Coverage for gws-app/gws/base/model/scalar_field.py: 83%

1"""Generic scalar field.""" 

2 

3from typing import Optional, Callable, cast 

4 

5import gws 

6import gws.base.model.field 

7 

8 

9class Config(gws.base.model.field.Config): 

10 """Configuration for the scalar field.""" 

11 

12 isVirtual: Optional[bool] 

13 """The field is not stored in the DB.""" 

14 

15 

16class Props(gws.base.model.field.Props): 

17 pass 

18 

19 

20class Object(gws.base.model.field.Object): 

21 isVirtual: bool 

22 

23 def configure(self): 

24 self.isVirtual = self.cfg('isVirtual', default=False) 

25 

26 def before_select(self, mc): 

27 if self.isVirtual: 

28 return 

29 model = cast(gws.DatabaseModel, self.model) 

30 mc.dbSelect.columns.append(model.column(self.name)) 

31 

32 def after_select(self, features, mc): 

33 for feature in features: 

34 self.from_record(feature, mc) 

35 

36 def before_create(self, feature, mc): 

37 if self.isAuto: 

38 return 

39 if self.isVirtual: 

40 return 

41 self.to_record(feature, mc) 

42 

43 def before_update(self, feature, mc): 

44 if self.isAuto: 

45 return 

46 if self.isVirtual: 

47 return 

48 self.to_record(feature, mc) 

49 

50 ## 

51 

52 def from_props(self, feature, mc): 

53 value = feature.props.attributes.get(self.name) 

54 if value is not None: 

55 value = self.prop_to_python(feature, value, mc) 

56 if value is not None: 

57 feature.set(self.name, value) 

58 

59 def to_props(self, feature, mc): 

60 if not mc.user.can_read(self): 

61 return 

62 value = feature.get(self.name) 

63 if value is not None: 

64 value = self.python_to_prop(feature, value, mc) 

65 if value is not None: 

66 feature.props.attributes[self.name] = value 

67 

68 ## 

69 

70 def do_init(self, feature, mc): 

71 value = self.get_value( 

72 feature, 

73 {}, 

74 mc.user.can_read(self), 

75 self.prop_to_python, 

76 mc, 

77 ) 

78 if value is not None: 

79 feature.set(self.name, value) 

80 

81 ## 

82 

83 def from_record(self, feature, mc): 

84 value = self.get_value( 

85 feature, 

86 feature.record.attributes, 

87 mc.user.can_read(self), 

88 self.raw_to_python, 

89 mc, 

90 ) 

91 if value is not None: 

92 feature.set(self.name, value) 

93 

94 def to_record(self, feature, mc): 

95 value = self.get_value( 

96 feature, 

97 feature.attributes, 

98 mc.user.can_write(self), 

99 self.python_to_raw, 

100 mc, 

101 ) 

102 if value is not None: 

103 feature.record.attributes[self.name] = value 

104 

105 def get_value( 

106 self, 

107 feature: gws.Feature, 

108 source: dict, 

109 has_access: bool, 

110 convert_fn: Callable, 

111 mc: gws.ModelContext, 

112 ): 

113 mv = self.model_value(mc) 

114 

115 if mv and not mv.isDefault: 

116 return mv.compute(self, feature, mc) 

117 

118 if has_access and self.name in source: 

119 value = source.get(self.name) 

120 if value is not None: 

121 return convert_fn(feature, value, mc) 

122 

123 if mv: 

124 return mv.compute(self, feature, mc) 

125 

126 def model_value(self, mc: gws.ModelContext): 

127 for mv in self.values: 

128 if mc.op in mv.ops and mc.user.can_use(mv): 

129 return mv