49 from logilab.common.deprecation import deprecated

   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