def count(self, model, **kwargs):
"""
:param model: model
:param kwargs: filter parameters
:return: number of row
"""
try:
return self.session.query(model).filter_by(**kwargs).count()
except Exception as e:
saas_logger.error(e)
raise HTTPInternalServerError(description=CRITICAL_ERROR_MESSAGE)
def send_to_chat_channel(self, body):
"""
we try to send data to chat channel
:param body:
:return:
"""
data_format = "```json\n{}\n```".format(json.dumps(body, indent=4))
data = {"text": data_format}
data = json.dumps(data).encode('utf8')
url = CHAT_CHANNEL_ENDPOINT
req = Request(url=url,
data=data,
headers={"Content-Type": "application/json"})
try:
urlopen(req, context=insecure_context)
except URLError as e:
saas_logger.error(e)
def get(self, model, **kwargs):
"""
Get data from database.
Args:
model: Which model class used to get data
**kwargs: Extra conditions for filtering data.
Returns:
model: Data. If data not found return None
"""
# params = self.append_default_params(**kwargs)
try:
q = self.session.query(model).filter_by(**kwargs)
return q.scalar()
except Exception as e:
saas_logger.error(e)
raise HTTPInternalServerError(description=CRITICAL_ERROR_MESSAGE)
def process_response(self, req, resp, resource, req_succeeded):
if req_succeeded:
try:
self.db.session.commit()
except IntegrityError as e:
self.db.session.rollback()
saas_logger.error(e)
raise HTTPConflict(
description="There is an conflict please change input value"
)
except Exception as e:
self.db.session.rollback()
saas_logger.error(e)
raise HTTPInternalServerError(
description=
"Critical error occurred. We handle this error as soon as "
"possible time")
else:
self.db.session.rollback()
Session.remove()
def send_mailgun(data, testing_mode=False):
"""
data format: {
"from": ADDRESS_FROM,
"to": "[email protected],
"subject": "Mail Subject,
"text": "Mail Text",
}
if you want to send additional header , add data "h:X-Example-Header": "example data"
:param data:
:param testing_mode:
:return:
"""
if testing_mode:
data['o:testmode'] = "true"
data = urlencode(data)
data = data.encode('ascii')
auth_handler = request.HTTPBasicAuthHandler()
auth_handler.add_password(realm='MG API',
user="******",
passwd=MAIL_GUN_API_KEY,
uri=MAIL_GUN_URL)
opener = request.build_opener(auth_handler)
request.install_opener(opener)
try:
response = request.urlopen(MAIL_GUN_URL, data)
except URLError as e:
saas_logger.error("Send MailGun Raise Error: {}".format(e))
raise HTTPFailedDependency(
description=
"An error occurred while interacting with an external service, please try again later."
)
response_body = response.read()
response_body = json.loads(response_body)
mail_id = response_body['id'][1:-1]
return mail_id
def filter(self, model, order_field=None, descending=True, **kwargs):
"""
:param model:
:param order_field:
:param descending:
:param kwargs:
:return:
"""
# params = self.append_default_params(**kwargs)
try:
q = self.session.query(model).filter_by(**kwargs)
if order_field:
order_field = getattr(model, order_field)
if descending:
q = q.order_by(desc(order_field))
else:
q = q.order_by(asc(order_field))
return q.all()
except Exception as e:
saas_logger.error(e)
raise HTTPInternalServerError(description=CRITICAL_ERROR_MESSAGE)
def paginated_filter(self, model, order_field, page_size, page, descending=True, **kwargs):
"""
Filter with page size, page, model, and order_field
If you want to take first 20 log row sorting with descending order and filtered with kwargs value
example: paginated_filter(Log,Log.creation_time, 20, 0, **kwargs)
paginated_filter
:param model: model
:param order_field: order field format model.field
:param page_size:
:param page:
:param descending: default true. if descending set false then sorted with ascending order
:param kwargs: filter parameters
"""
try:
order = desc(order_field) if descending else asc(order_field)
q = self.session.query(model).filter_by(**kwargs)
return q.order_by(order).limit(page_size).offset(page * page_size).all()
except Exception as e:
saas_logger.error(e)
raise HTTPInternalServerError(description=CRITICAL_ERROR_MESSAGE)