def get_query_filter(self, req, resp, model_class, **kwargs):
filtering = dict(parse_qsl(req.query_string))
qs = model_class.query()
filtering, qs = self.modify_query(filtering, qs, req, resp,
model_class, **kwargs)
query_fields = self.scheme_class.Meta.query_fields if hasattr(
self.scheme_class.Meta, 'query_fields') else []
cols = inspect(self.model_class).columns
if filtering:
for k, v in filtering.items():
if query_fields and k in query_fields:
fop = List.parse_query_field(k, self.model_class)[0]
qs = qs.filter(text_(fop.format(v)))
continue
if k in cols and hasattr(cols[k].type, 'choices'):
if not v in tuple(cols[k].type.choices.values()):
log.error('Bad value for filtering! {}={}'.format(
k, v))
raise Exception(
'Bad value for filtering! "{}"="{}" must be one of [{}]'
.format(
k, v,
','.join(list(cols[k].type.choices.values()))))
continue
if '*' in v: # pragma: no cover
qs = qs.filter(
getattr(model_class, k).like(v.replace('*', '%')))
else:
qs = qs.filter(getattr(model_class, k) == v)
return qs
def _apply_mail(self, template_name, var_name):
template = EmailTemplate.get(template_name)
if not template:
return 'no such template'
from_addr = template.email_from
from_addr = settings.MAILING['username']
try:
mail = settings_get_mailer()
mail.set_variables({var_name: self})
mail.set_content(template.subject, template.content_text,
template.content_html)
except Exception as e:
import traceback
log.error('cannot render {}:{}:{}'.format(template.content_html, e,
traceback.format_exc()))
return 'Bad email template "{}" syntax. error {}'.format(
template_name, str(e))
email = None
if hasattr(self, 'email') and hasattr(self, 'user_uuid'):
email = self.email
user_uuid = self.user_uuid
if hasattr(self, 'user'):
email = self.user.email
user_uuid = self.user.user_uuid
status = mail.send(from_addr, email, template.email_cc)
EmailLog.log(user_uuid, template.name, mail.subject, from_addr, email,
mail.get_content(), status, template.email_cc)
return status
def _on_get(self, req, resp, **kwargs):
if (not hasattr(self, 'no_auth_needed') or self.no_auth_needed
== False) and not check_permission(self, req, 'list'):
self.set_response(
resp,
responses.ForbiddenErrorResponse(
data=errors.AuthErrors.Forbidden))
return
try:
objects_list, total, page, per_page = self.get_objects_list(
req, self.model_class, **kwargs)
self.set_response(
resp,
responses.SuccessResponse(data={
'items':
self.scheme_class().dump(objects_list, many=True).data,
'total':
total,
'page':
page,
'per_page':
per_page
},
scheme=schemes.ObjectScheme))
except AttributeError as e:
self.set_response(
resp,
responses.AttributeNotExitsErrorResponse(
data=ATTRIBUTE_ERROR_RE.search(str(e)).group(1)))
except Exception as e:
log.error(e)
#self.set_response(resp, responses.OperationErrorResponse(data=errors.CommonErrors.DataError))
self.set_response(resp, OperationalError(e))
def on_post(self, req, resp, **kwargs):
try:
token_data = jwt.decode(kwargs['token'], settings.JWT_SIGNATURE)
kwargs['user_uuid'] = token_data['user_uuid']
return self.proceed(req, resp, **kwargs)
except Exception as e:
log.error('user confirm register error {}'.format(str(e)))
self.set_response(resp, responses.ObjectNotFoundErrorResponse())
def on_patch(self, req, resp, **kwargs):
self.init_req(req)
kwargs = user_context(self, req, resp, **kwargs)
if not self.has_modify_operation: # pragma: no cover
return self.method_not_allowed_response(resp, 'PATCH')
if not check_permission(
self, req, 'modify',
self.get_object(resp, self.model_class, **kwargs)):
self.set_response(
resp,
responses.ForbiddenErrorResponse(
data=errors.AuthErrors.Forbidden))
return
try:
scheme = self.scheme_class_modify(
) if self.scheme_class_modify else self.scheme_class()
if self.check_request_data(req, resp, scheme):
if self.update_object(
req, resp, self.model_class, self.scheme_class_modify
if self.scheme_class_modify else self.scheme_class,
**kwargs):
data = self.get_object_data(resp, self.model_class,
self.scheme_class_get,
**kwargs)
if data:
self.set_response(
resp,
responses.SuccessResponseObjectInfo(data=data))
else:
self.set_response(resp,
responses.SuccessResponseJustOk())
except IntegrityError as e:
try:
msg = str(e).split('\n')[1].split(':')[1]
except:
msg = str(e)
self.set_response(resp, AlreadyExistsResponse(self.entity, msg))
except FkConstraintViolation as e:
self.set_response(
resp,
responses.FkConstraintViolationResponse(
data=errors.CommonErrors.get_fk_violation_error(
e.table_name, e.column_name, e.value)))
except ValidationError as e:
self.set_response(
resp, responses.ValidationErrorResponse(data=e.messages))
except NoResultFound:
self.set_response(resp, responses.ObjectNotFoundErrorResponse())
except Exception as e:
log.error(e)
#self.set_response(resp, responses.OperationErrorResponse(data=errors.CommonErrors.DataError))
self.set_response(resp, OperationalError(e))
def apply(self, obj, req, resp, **kwargs):
try:
if obj:
obj.confirmed_on = datetime.now(UTC)
obj.is_active = True
obj.save()
self.set_response(resp, responses.SuccessResponseJustOk())
return True
except Exception as e:
log.error('user confirm register error {}'.format(str(e)))
pass
self.set_response(resp, responses.ObjectNotFoundErrorResponse())
def delete_object(self, req, resp, model_class, **kwargs):
try:
query = self.get_query_filter(req, resp, model_class, **kwargs)
result = query.delete(synchronize_session='fetch')
model_class.session().commit()
self.set_response(
resp,
responses.SuccessResponseObjectInfo(data={'deleted': result}))
except Exception as e:
model_class.query().session.rollback()
log.error('Mass delete error:{}'.format(str(e)))
return False
def on_post(self, req, resp, **kwargs):
self.init_req(req)
kwargs = user_context(self, req, resp, **kwargs)
self.apply_restrict_rules(req, kwargs)
scheme = self.scheme_class()
if not check_permission(self, req, 'create'):
self.set_response(
resp,
responses.ForbiddenErrorResponse(
data=errors.AuthErrors.Forbidden))
return
if self.check_request_data(req, resp, scheme):
try:
data = self.create_object(req, scheme, **kwargs)
self.set_response(
resp,
self.scheme_class.get_object_created_response(data=data))
self.after_create(data, req, resp, **kwargs)
except IntegrityError as e:
#self.set_response(resp, responses.AlreadyExistsResponse(
# data=errors.CommonErrors.get_already_exists_error(self.entity, self.unique_field))
#)
try:
msg = str(e).split('\n')[1].split(':')[1]
except:
msg = str(e)
self.set_response(resp,
AlreadyExistsResponse(self.entity, msg))
except FkConstraintViolation as e:
self.set_response(
resp,
responses.FkConstraintViolationResponse(
data=errors.CommonErrors.get_fk_violation_error(
e.table_name, e.fk_column_name, e.column_name,
e.value)))
except schemes.validate.ValidationError as e:
self.set_response(
resp, responses.ValidationErrorResponse(data=e.messages))
except DataError as e:
log.error(e)
#self.set_response(resp, responses.OperationErrorResponse(data=errors.CommonErrors.DataError))
self.set_response(resp, OperationalError(e))
except Exception as e:
log.error(e)
# self.set_response(resp, responses.OperationErrorResponse(data=errors.CommonErrors.DataError))
self.set_response(resp, OperationalError(e))
def modify_query_from_filtering_for_list(self, filtering, **kwargs):
if 'start_query' in kwargs:
ret = kwargs['start_query']
else:
ret = self.model_class.query()
filt = {}
query_fields = self.scheme_class.Meta.query_fields if hasattr(
self.scheme_class.Meta, 'query_fields') else []
cols = inspect(self.model_class).columns
syns = inspect(self.model_class).synonyms
if filtering:
for k, v in filtering.items():
if hasattr(self, 'on_filtering'):
ret = getattr(self, 'on_filtering')(ret, k, v, kwargs)
continue
if hasattr(self, 'on_filter_' + k):
ret = getattr(self, 'on_filter_' + k)(ret, v, kwargs)
continue
if query_fields and k in query_fields:
fop, dbfield = List.parse_query_field(k, self.model_class)
if dbfield in cols:
col = cols[dbfield]
elif dbfield in syns:
col = cols[syns[dbfield].name]
else:
raise Exception(
'Bad value for filtering! field "{}" not found!'.
format(dbfield))
if ' in ({})' in fop:
lst = v.split(',')
v1 = []
for i in lst:
t = 'unknown'
try:
if isinstance(col.type, Integer):
t = 'int'
x = int(i)
elif isinstance(col.type, Numeric):
t = 'numeric'
x = float(i)
x = "'" + i + "'"
elif isinstance(col.type,
DateTime) or isinstance(
cols[dbfield].type, Date):
t = 'datetime'
x = parse_datetime(i)
x = "'" + i + "'"
else:
t = 'string'
x = "'" + i + "'"
v1.append(i)
except Exception as e:
raise Exception(
'Bad value for filtering list! "{}" "{}" {}'
.format(v, i, str(e)))
v = ','.join(v1)
ret = ret.filter(text_(fop.format(v)))
continue
if k in cols and hasattr(cols[k].type, 'choices'):
if not v in tuple(cols[k].type.choices.values()):
log.error('Bad value for filtering! {}={}'.format(
k, v))
raise Exception(
'Bad value for filtering! "{}"="{}" must be one of [{}]'
.format(
k, v,
','.join(list(cols[k].type.choices.values()))))
continue
filt[k] = v
return (filt, ret)