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

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 isVirtual: Optional[bool] 

11 """The field is not stored in the DB. (added in 8.1)""" 

12 

13 

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

15 pass 

16 

17 

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

19 isVirtual: bool 

20 

21 def configure(self): 

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

23 

24 def before_select(self, mc): 

25 if self.isVirtual: 

26 return 

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

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

29 

30 def after_select(self, features, mc): 

31 for feature in features: 

32 self.from_record(feature, mc) 

33 

34 def before_create(self, feature, mc): 

35 if self.isAuto: 

36 return 

37 if self.isVirtual: 

38 return 

39 self.to_record(feature, mc) 

40 

41 def before_update(self, feature, mc): 

42 if self.isAuto: 

43 return 

44 if self.isVirtual: 

45 return 

46 self.to_record(feature, mc) 

47 

48 ## 

49 

50 def from_props(self, feature, mc): 

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

52 if value is not None: 

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

54 if value is not None: 

55 feature.set(self.name, value) 

56 

57 def to_props(self, feature, mc): 

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

59 return 

60 value = feature.get(self.name) 

61 if value is not None: 

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

63 if value is not None: 

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

65 

66 ## 

67 

68 def do_init(self, feature, mc): 

69 value = self.get_value( 

70 feature, 

71 {}, 

72 mc.user.can_read(self), 

73 self.prop_to_python, 

74 mc 

75 ) 

76 if value is not None: 

77 feature.set(self.name, value) 

78 

79 ## 

80 

81 def from_record(self, feature, mc): 

82 value = self.get_value( 

83 feature, 

84 feature.record.attributes, 

85 mc.user.can_read(self), 

86 self.raw_to_python, 

87 mc 

88 ) 

89 if value is not None: 

90 feature.set(self.name, value) 

91 

92 def to_record(self, feature, mc): 

93 value = self.get_value( 

94 feature, 

95 feature.attributes, 

96 mc.user.can_write(self), 

97 self.python_to_raw, 

98 mc 

99 ) 

100 if value is not None: 

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

102 

103 def get_value( 

104 self, 

105 feature: gws.Feature, 

106 source: dict, 

107 has_access: bool, 

108 convert_fn: Callable, 

109 mc: gws.ModelContext 

110 ): 

111 mv = self.model_value(mc) 

112 

113 if mv and not mv.isDefault: 

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

115 

116 if has_access and self.name in source: 

117 value = source.get(self.name) 

118 if value is not None: 

119 return convert_fn(feature, value, mc) 

120 

121 if mv: 

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

123 

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

125 for mv in self.values: 

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

127 return mv