959 return a score >= 0 |
958 return a score >= 0 |
960 """ |
959 """ |
961 def __init__(self, scorefunc, once_is_enough=False): |
960 def __init__(self, scorefunc, once_is_enough=False): |
962 super(score_entity, self).__init__(once_is_enough) |
961 super(score_entity, self).__init__(once_is_enough) |
963 self.score_entity = scorefunc |
962 self.score_entity = scorefunc |
964 |
|
965 |
|
966 # XXX DEPRECATED ############################################################## |
|
967 from cubicweb.vregistry import chainall |
|
968 |
|
969 yes_selector = deprecated()(yes) |
|
970 norset_selector = deprecated()(none_rset) |
|
971 rset_selector = deprecated()(any_rset) |
|
972 anyrset_selector = deprecated()(nonempty_rset) |
|
973 emptyrset_selector = deprecated()(empty_rset) |
|
974 onelinerset_selector = deprecated()(one_line_rset) |
|
975 twolinerset_selector = deprecated()(two_lines_rset) |
|
976 twocolrset_selector = deprecated()(two_cols_rset) |
|
977 largerset_selector = deprecated()(paginated_rset) |
|
978 sortedrset_selector = deprecated()(sorted_rset) |
|
979 oneetyperset_selector = deprecated()(one_etype_rset) |
|
980 multitype_selector = deprecated()(two_etypes_rset) |
|
981 anonymous_selector = deprecated()(anonymous_user) |
|
982 not_anonymous_selector = deprecated()(authenticated_user) |
|
983 primaryview_selector = deprecated()(primary_view) |
|
984 contextprop_selector = deprecated()(match_context_prop) |
|
985 |
|
986 @deprecated('use non_final_entity instead of %s') |
|
987 def nfentity_selector(cls, req, rset=None, row=None, col=0, **kwargs): |
|
988 return non_final_entity()(cls, req, rset, row, col) |
|
989 |
|
990 @deprecated('use implements instead of %s') |
|
991 def implement_interface(cls, req, rset=None, row=None, col=0, **kwargs): |
|
992 return implements(*cls.accepts_interfaces)(cls, req, rset, row, col) |
|
993 _interface_selector = deprecated()(implement_interface) |
|
994 interface_selector = deprecated()(implement_interface) |
|
995 |
|
996 @deprecated('use specified_etype_implements instead of %s') |
|
997 def accept_etype(cls, req, *args, **kwargs): |
|
998 """check etype presence in request form *and* accepts conformance""" |
|
999 return specified_etype_implements(*cls.accepts)(cls, req, *args) |
|
1000 etype_form_selector = accept_etype |
|
1001 |
|
1002 @deprecated('use match_search_state instead of %s') |
|
1003 def searchstate_selector(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1004 return match_search_state(cls.search_states)(cls, req, rset, row, col) |
|
1005 |
|
1006 @deprecated('use match_user_groups instead of %s') |
|
1007 def match_user_group(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1008 return match_user_groups(*cls.require_groups)(cls, req, rset, row, col, **kwargs) |
|
1009 in_group_selector = match_user_group |
|
1010 |
|
1011 @deprecated('use relation_possible instead of %s') |
|
1012 def has_relation(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1013 return relation_possible(cls.rtype, role(cls), cls.etype, |
|
1014 getattr(cls, 'require_permission', 'read'))(cls, req, rset, row, col, **kwargs) |
|
1015 |
|
1016 @deprecated('use relation_possible instead of %s') |
|
1017 def one_has_relation(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1018 return relation_possible(cls.rtype, role(cls), cls.etype, |
|
1019 getattr(cls, 'require_permission', 'read', |
|
1020 once_is_enough=True))(cls, req, rset, row, col, **kwargs) |
|
1021 |
|
1022 @deprecated('use implements instead of %s') |
|
1023 def accept_rset(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1024 """simply delegate to cls.accept_rset method""" |
|
1025 return implements(*cls.accepts)(cls, req, rset, row=row, col=col) |
|
1026 accept_rset_selector = accept_rset |
|
1027 |
|
1028 accept = chainall(non_final_entity(), accept_rset, name='accept') |
|
1029 accept = deprecated('use implements selector')(accept) |
|
1030 accept_selector = deprecated()(accept) |
|
1031 |
|
1032 accept_one = deprecated()(chainall(one_line_rset, accept, |
|
1033 name='accept_one')) |
|
1034 accept_one_selector = deprecated()(accept_one) |
|
1035 |
|
1036 |
|
1037 def _rql_condition(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1038 if cls.condition: |
|
1039 return rql_condition(cls.condition)(cls, req, rset, row, col) |
|
1040 return 1 |
|
1041 _rqlcondition_selector = deprecated()(_rql_condition) |
|
1042 |
|
1043 rqlcondition_selector = deprecated()(chainall(non_final_entity(), one_line_rset, _rql_condition, |
|
1044 name='rql_condition')) |
|
1045 |
|
1046 @deprecated('use but_etype instead of %s') |
|
1047 def but_etype_selector(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1048 return but_etype(cls.etype)(cls, req, rset, row, col) |
|
1049 |
|
1050 @lltrace |
|
1051 def etype_rtype_selector(cls, req, rset=None, row=None, col=0, **kwargs): |
|
1052 schema = cls.schema |
|
1053 perm = getattr(cls, 'require_permission', 'read') |
|
1054 if hasattr(cls, 'etype'): |
|
1055 eschema = schema.eschema(cls.etype) |
|
1056 if not (eschema.has_perm(req, perm) or eschema.has_local_role(perm)): |
|
1057 return 0 |
|
1058 if hasattr(cls, 'rtype'): |
|
1059 rschema = schema.rschema(cls.rtype) |
|
1060 if not (rschema.has_perm(req, perm) or rschema.has_local_role(perm)): |
|
1061 return 0 |
|
1062 return 1 |
|
1063 etype_rtype_selector = deprecated()(etype_rtype_selector) |
|
1064 |
|
1065 #req_form_params_selector = deprecated()(match_form_params) # form_params |
|
1066 #kwargs_selector = deprecated()(match_kwargs) # expected_kwargs |
|
1067 |
|
1068 # compound selectors ########################################################## |
|
1069 |
|
1070 searchstate_accept = chainall(nonempty_rset(), accept, |
|
1071 name='searchstate_accept') |
|
1072 searchstate_accept_selector = deprecated()(searchstate_accept) |
|
1073 |
|
1074 searchstate_accept_one = chainall(one_line_rset, accept, _rql_condition, |
|
1075 name='searchstate_accept_one') |
|
1076 searchstate_accept_one_selector = deprecated()(searchstate_accept_one) |
|
1077 |
|
1078 searchstate_accept = deprecated()(searchstate_accept) |
|
1079 searchstate_accept_one = deprecated()(searchstate_accept_one) |
|
1080 |
|
1081 # end of deprecation section ################################################## |
|
1082 |
|
1083 def unbind_method(selector): |
|
1084 def new_selector(registered): |
|
1085 # get the unbound method |
|
1086 if hasattr(registered, 'im_func'): |
|
1087 registered = registered.im_func |
|
1088 # don't rebind since it will be done automatically during |
|
1089 # the assignment, inside the destination class body |
|
1090 return selector(registered) |
|
1091 new_selector.__name__ = selector.__name__ |
|
1092 return new_selector |
|
1093 |
|
1094 |
|
1095 def deprecate(registered, msg): |
|
1096 # get the unbound method |
|
1097 if hasattr(registered, 'im_func'): |
|
1098 registered = registered.im_func |
|
1099 def _deprecate(cls, vreg): |
|
1100 warn(msg, DeprecationWarning) |
|
1101 return registered(cls, vreg) |
|
1102 return _deprecate |
|
1103 |
|
1104 @unbind_method |
|
1105 def require_group_compat(registered): |
|
1106 def plug_selector(cls, vreg): |
|
1107 cls = registered(cls, vreg) |
|
1108 if getattr(cls, 'require_groups', None): |
|
1109 warn('use "match_user_groups(group1, group2)" instead of using require_groups', |
|
1110 DeprecationWarning) |
|
1111 cls.__select__ &= match_user_groups(cls.require_groups) |
|
1112 return cls |
|
1113 return plug_selector |
|
1114 |
|
1115 @unbind_method |
|
1116 def accepts_compat(registered): |
|
1117 def plug_selector(cls, vreg): |
|
1118 cls = registered(cls, vreg) |
|
1119 if getattr(cls, 'accepts', None): |
|
1120 warn('use "implements("EntityType", IFace)" instead of using accepts on %s' |
|
1121 % cls, |
|
1122 DeprecationWarning) |
|
1123 cls.__select__ &= implements(*cls.accepts) |
|
1124 return cls |
|
1125 return plug_selector |
|
1126 |
|
1127 @unbind_method |
|
1128 def accepts_etype_compat(registered): |
|
1129 def plug_selector(cls, vreg): |
|
1130 cls = registered(cls, vreg) |
|
1131 if getattr(cls, 'accepts', None): |
|
1132 warn('use "specified_etype_implements("EntityType", IFace)" instead of using accepts', |
|
1133 DeprecationWarning) |
|
1134 cls.__select__ &= specified_etype_implements(*cls.accepts) |
|
1135 return cls |
|
1136 return plug_selector |
|
1137 |
|
1138 @unbind_method |
|
1139 def condition_compat(registered): |
|
1140 def plug_selector(cls, vreg): |
|
1141 cls = registered(cls, vreg) |
|
1142 if getattr(cls, 'condition', None): |
|
1143 warn('use "use rql_condition(expression)" instead of using condition', |
|
1144 DeprecationWarning) |
|
1145 cls.__select__ &= rql_condition(cls.condition) |
|
1146 return cls |
|
1147 return plug_selector |
|
1148 |
|
1149 @unbind_method |
|
1150 def has_relation_compat(registered): |
|
1151 def plug_selector(cls, vreg): |
|
1152 cls = registered(cls, vreg) |
|
1153 if getattr(cls, 'etype', None): |
|
1154 warn('use relation_possible selector instead of using etype_rtype', |
|
1155 DeprecationWarning) |
|
1156 cls.__select__ &= relation_possible(cls.rtype, role(cls), |
|
1157 getattr(cls, 'etype', None), |
|
1158 action=getattr(cls, 'require_permission', 'read')) |
|
1159 return cls |
|
1160 return plug_selector |
|