def _get_old_value_of_scalar_attr(self, org_request, attr_name):
deleted_or_unchanged = sqla_inspect(
org_request).attrs[attr_name].history.non_added()
if deleted_or_unchanged:
[old_value] = deleted_or_unchanged
return old_value
return None
def _verify_org_group_specified(self, org_request):
assert isinstance(org_request, models.RegistrationRequest)
if org_request.org_group is None:
raise ValueError('Acceptation of a registration request cannot be '
'done when its `Org Group` field is unspecified.')
assert isinstance(org_request.org_group, models.OrgGroup)
assert sqla_inspect(org_request.org_group).persistent
def column_cache(table_class):
fsm_fields = [
col for col in sqla_inspect(table_class).columns
if isinstance(col.type, FSMField)
]
if len(fsm_fields) == 0:
raise exc.SetupError("No FSMField found in model")
elif len(fsm_fields) > 1:
raise exc.SetupError(
"More than one FSMField found in model ({})".format(fsm_fields))
return fsm_fields[0]
def addValidators(self):
if self.obj is None:
return
ormMapper = sqla_inspect(self.obj.__class__, raiseerr=False)
if ormMapper is None:
return
self._obj = self.obj # needed for Unique
for name, field in self._fields.items():
if not getattr(field, 'disabled', False):
ormProp = ormMapper.attrs.get(name)
extra = self.extvtors.setdefault(name, [])
if len(getattr(ormProp, 'columns', [])) == 1:
addValidators(field, ormProp.columns[0], extra, DBSession,
self.obj.__class__)
def COLUMN_CACHE(table_class):
fsm_fields = [
col
for col in sqla_inspect(table_class).columns
if isinstance(col.type, FSMField)
]
if len(fsm_fields) == 0:
raise exc.SetupError('No FSMField found in model')
elif len(fsm_fields) > 1:
raise exc.SetupError(
'More than one FSMField found in model ({})'.format(
fsm_fields
)
)
return fsm_fields[0]
def _s_expunge(self):
"""
expunge an object from its session
"""
session = sqla_inspect(self).session
session.expunge(self)
def _s_expunge(self):
session = sqla_inspect(self).session
session.expunge(self)
def _get_sqla_session(self, org_request):
return sqla_inspect(org_request).session
def save(self):
ormObj = sqla_inspect(self.obj, raiseerr=False)
if ormObj and ormObj.transient:
self.obj.insert()
def get_filters(self, cls):
"""
Parse search fields and values to filters.
"""
from .exp_format import raise_args_exception
filters = []
relationships = sqla_inspect(cls).mapper.relationships
all_field_items = self.array_field.items() + \
self.equal_field.items() + \
self.like_field.items()
for key, value in all_field_items:
if '.' in key:
# set children attribute filters
father_field, child_field = key.split(".", 1)
if father_field not in relationships:
raise_args_exception(key)
child_cls = relationships[father_field].mapper.class_
if child_field == '_match':
# set children _match filters
fc = self._get_match_filter(child_cls, value)
elif key in self.array_field:
fc = getattr(child_cls, child_field).in_(value)
elif key in self.like_field:
fc = getattr(child_cls, child_field).like(value,
escape='/')
else:
fc = getattr(child_cls, child_field) == value
# 这里到底是子资源过滤还是条件过滤
if not relationships[father_field].uselist:
# uselist = false
obj = get_session().query(child_cls).filter(fc).first()
_filter = getattr(cls, father_field) == obj
filters.append(_filter)
continue
if relationships[father_field].uselist:
_filter = getattr(cls, father_field).any(fc)
else:
_filter = getattr(cls, father_field).has(fc)
else:
# set attribute filters
if not hasattr(cls, key):
raise_args_exception(key)
if key in self.array_field:
_filter = getattr(cls, key).in_(value)
elif key in self.like_field:
_filter = getattr(cls, key).like(value, escape='/')
else:
_filter = getattr(cls, key) == value
filters.append(_filter)
# set match filters
args = request.args
match_keywords = args.get('_match')
if match_keywords:
filters.append(self._get_match_filter(cls, match_keywords))
return filters
