CHIEFSOFT\ameye
582 lines
28 KiB
Python
582 lines
28 KiB
Python
from urllib import request
|
|
|
|
from flask import session, jsonify
|
|
|
|
from app.api.enums import SettingsItemsData
|
|
from app.api.schemas.myproduct_set_template import MyProductSetTemplateSchema
|
|
from app.utils.logger import logger
|
|
from app.api.services.base_service import BaseService
|
|
from marshmallow import ValidationError
|
|
from app.extensions import db
|
|
from app.models import MembersProducts, Products, Members, ProductsDetails, ProductsDetails, ProvisionActions, \
|
|
MembersProductsSettings, ProductsTemplates, MembersProfile, SubscriptionGenerative
|
|
from app.api.helpers.response_helper import ResponseHelper
|
|
from app.api.schemas.myproduct import MyProductSchema
|
|
from app.api.schemas.provision import ProvisionSchema
|
|
from app.api.schemas.myproduct_settings import MyProductSettingsSchema
|
|
from threading import Thread
|
|
|
|
import datetime
|
|
import jwt
|
|
import random
|
|
from app.config import Config
|
|
|
|
|
|
class MyProductsService(BaseService):
|
|
|
|
@staticmethod
|
|
def process_provision_actions(data):
|
|
pass
|
|
|
|
@staticmethod
|
|
def process_set_template(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSetTemplateSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
template_uid = validated_data.get('template_uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
response_data = {}
|
|
product_id = validated_data.get('product_id')
|
|
|
|
MembersProducts.set_member_product_template(member_id, product_id, template_uid)
|
|
|
|
response_data = {
|
|
"product_id": product_id,
|
|
"new_template_uid": template_uid,
|
|
"last_update": datetime.datetime.utcnow(),
|
|
}
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def mpproduct_template_data(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
|
|
product_id = validated_data.get('product_id')
|
|
template_data = []
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
if memberSubscription:
|
|
templates = ProductsTemplates.get_template_by_product_id(product_id)
|
|
for t in templates:
|
|
template_data.append({
|
|
'id': t.id,
|
|
'template_uid': t.uid,
|
|
'title': t.name,
|
|
'active': 1,
|
|
'banner': 'https://qa-panel.mermsemr.com/static/media/',
|
|
'added': t.added.isoformat() if t.added else None
|
|
})
|
|
|
|
response_data = {
|
|
"product_id": product_id,
|
|
"current_template_uid": memberSubscription.product_template if memberSubscription else None,
|
|
"templates": template_data,
|
|
"last_update": datetime.datetime.utcnow(),
|
|
}
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def process_provision(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, ProvisionSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
|
|
product_id = validated_data.get('product_id')
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
# logger.error(f"Product with ID {product_id} does not exist.")
|
|
if not product_data:
|
|
return {
|
|
"message": "Please provide valid product_id",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Product with ID {product_id} does not exist."
|
|
}, 400
|
|
|
|
logger.info(f"GET HERE ******************************** : {data}", exc_info=True)
|
|
subscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
|
|
provision_activities = ProvisionActions.get_provision_action_by_product_uid(subscription.uid, 4)
|
|
provision_activities_data = []
|
|
if provision_activities:
|
|
for t in provision_activities:
|
|
provision_activities_data.append({
|
|
'id': t.id,
|
|
'uid': t.uid,
|
|
'action': t.action,
|
|
'added': t.added.isoformat() if t.added else None,
|
|
})
|
|
|
|
response_data = {
|
|
"subscription_uid": subscription.uid,
|
|
"subscription_id": subscription.id,
|
|
"last_update": datetime.datetime.utcnow(),
|
|
"percent_completed": random.randint(10, 99),
|
|
"activities": provision_activities_data
|
|
}
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def process_subscription(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
|
|
product_id = validated_data.get('product_id')
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
|
|
if not product_data:
|
|
if not product_data:
|
|
return {
|
|
"message": "Please provide valid product_id",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Product with ID {product_id} does not exist."
|
|
}, 4000
|
|
|
|
logger.info(f"GET HERE ******************************** : {data}", exc_info=True)
|
|
mumberSub = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
|
|
if mumberSub:
|
|
logger.error(f"Ready to add data to tables")
|
|
response_data = {
|
|
"subscription": mumberSub,
|
|
"member_id": member_id,
|
|
"error": "already_subscribed",
|
|
"uid": uid
|
|
}
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
internal_url = str(random.randint(100000, 999999)) + ".devprov.mermsemr.com"
|
|
# INSERT_NEW_PRODUCT = "INSERT INTO members_products (member_id ,product_id,status,internal_url) VALUES (%s, %s, %s, %s)"
|
|
# val_insert = (member_id, product_id,6,internal_url)
|
|
status = 6
|
|
subscription = MembersProducts.create_subscription(member_id, product_id, status, internal_url)
|
|
|
|
#-let prepare the flags for auto generated stuffs
|
|
profile_data = MembersProfile.get_member_profile_by_member_id(member_id)
|
|
if profile_data:
|
|
practice = profile_data.practice
|
|
specialization = profile_data.specialization
|
|
subscription_uid = subscription.uid
|
|
SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,subscription_uid)
|
|
|
|
response_data = {
|
|
"subscription_uid": subscription.uid,
|
|
"subscription_id": subscription.id,
|
|
"internal_url": subscription.internal_url,
|
|
"member_id": member_id,
|
|
"uid": uid
|
|
}
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def process_settings(data):
|
|
try:
|
|
with db.session.begin():
|
|
logger.info(f"Incoming MyProduct Settings Data ==>>>> {data}")
|
|
settings = data["settings"]
|
|
data.pop("settings")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSettingsSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
product_id = validated_data.get('product_id')
|
|
product_settings = validated_data.get('settings')
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
if memberSubscription is not None:
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
productDataStatus = memberSubscription.status
|
|
product_subscription_uid = memberSubscription.uid
|
|
# product_subscription_external_url = memberSubscription.external_url
|
|
# product_subscription_internal_url = memberSubscription.internal_url
|
|
|
|
# result_data = {
|
|
# "myproudct": {
|
|
# "result": "Reveived under development ",
|
|
# "message": "to be fixed"
|
|
# }
|
|
# }
|
|
|
|
for key in settings.keys():
|
|
setting_value = settings[key]
|
|
subscription_uid = memberSubscription.uid
|
|
MembersProductsSettings.save_update_product_settings(member_id, subscription_uid, product_id, key,
|
|
'TXT', setting_value)
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"member_id": member_id,
|
|
"subscription_uid": str(subscription_uid),
|
|
"uid": str(uid),
|
|
}
|
|
logger.error(f"Going for Thread ******************** ")
|
|
thread = Thread(target=MyProductsService.async_send_settings_refresh_to_kafka,
|
|
args=(response_data, subscription_uid, "REFRESH_PRODUCT_SETTINGS"))
|
|
thread.start()
|
|
logger.error(f"After the Thread ******************** ")
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def process_request(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
product_id = validated_data.get('product_id')
|
|
product_subscription_uid = ''
|
|
product_subscription_external_url = ''
|
|
product_subscription_internal_url = ''
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
if not product_data:
|
|
return {
|
|
"message": "Please provide valid product_id",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Product with ID {product_id} does not exist."
|
|
}, 400
|
|
|
|
product_description = ProductsDetails.get_product_details_with_product_id(product_id)
|
|
productDataStatus = product_data.status
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
if memberSubscription is not None:
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
productDataStatus = memberSubscription.status
|
|
product_subscription_uid = memberSubscription.uid
|
|
product_subscription_external_url = memberSubscription.external_url
|
|
product_subscription_internal_url = memberSubscription.internal_url
|
|
|
|
# "banner": "banner.jpg",
|
|
myproduct_data = {
|
|
"myproudct": {
|
|
"banner": product_data.banner,
|
|
"description": product_description.details,
|
|
"sale_text": product_description.sale_text,
|
|
"internal_url": product_subscription_internal_url,
|
|
"external_url": product_subscription_external_url,
|
|
"price_text": "90 days free and 3.95/Month",
|
|
"product_id": product_data.product_id,
|
|
"product_name": product_data.name,
|
|
"product_subscription_uid": product_subscription_uid,
|
|
"product_uid": product_data.uid,
|
|
"promotion_text": "Start Free Today !",
|
|
"subscription_uid": product_subscription_uid,
|
|
"status": productDataStatus,
|
|
"subscription_text": "Start with your goals in mind and then work possible.ith yand Goals. If the plan doesn\u2019t support the vision then change it!",
|
|
"title": "Your personal professional web presence"
|
|
}
|
|
}
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"myproduct": myproduct_data,
|
|
"member_id": member_id,
|
|
"uid": uid,
|
|
}
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def process_settings_values(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
product_id = validated_data.get('product_id')
|
|
|
|
product_subscription_uid = ''
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
if not product_data:
|
|
return {
|
|
"message": "Please provide valid product_id",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Product with ID {product_id} does not exist."
|
|
}, 400
|
|
|
|
product_description = ProductsDetails.get_product_details_with_product_id(product_id)
|
|
productDataStatus = product_data.status
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
settings_data = []
|
|
if memberSubscription is not None:
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
product_subscription_uid = memberSubscription.uid
|
|
settings_data_result = MembersProductsSettings.get_product_settings_by_product_id_and_member_id(
|
|
product_id, member_id)
|
|
if settings_data_result is not None:
|
|
for t in settings_data_result:
|
|
settings_data.append({
|
|
'setting_key': t.settings_key,
|
|
'setting_value': t.setting_value,
|
|
})
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"settings": settings_data,
|
|
"member_id": member_id,
|
|
"product_subscription_uid": product_subscription_uid,
|
|
}
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|
|
|
|
@staticmethod
|
|
def product_configuration(data):
|
|
try:
|
|
with db.session.begin():
|
|
validated_data = MyProductsService.validate_data(data, MyProductSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
product_id = validated_data.get('product_id')
|
|
|
|
product_subscription_uid = ''
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
if not product_data:
|
|
return {
|
|
"message": "Please provide valid product_id",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Product with ID {product_id} does not exist."
|
|
}, 400
|
|
|
|
product_description = ProductsDetails.get_product_details_with_product_id(product_id)
|
|
productDataStatus = product_data.status
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
|
|
if memberSubscription is not None:
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
product_subscription_uid = memberSubscription.uid
|
|
settingsFields = SettingsItemsData.get_site_settings_data()
|
|
templateData = []
|
|
homeFields = SettingsItemsData.get_site_home_settings()
|
|
footerFields = SettingsItemsData.get_site_footer_settings()
|
|
contactFields = SettingsItemsData.get_site_contact_items()
|
|
socialFields = SettingsItemsData.get_site_social_settings_data()
|
|
aboutFields = SettingsItemsData.get_site_about_items()
|
|
testimonialFields = SettingsItemsData.get_site_testimonial_settings()
|
|
|
|
settings_items = {}
|
|
if product_id == "A000001":
|
|
settings_items = {
|
|
"settings": {"title": 'Settings', "controls": 'settings', "active": 'active show',
|
|
"custom": False, "data": settingsFields, "list_order": 0},
|
|
"home_tab": {"title": 'Home Page', "controls": 'home', "active": '', "custom": False,
|
|
"data": homeFields, "list_order": 1},
|
|
"footer_tab": {"title": 'Footer', "controls": 'footer', "active": '', "custom": False,
|
|
"data": footerFields, "list_order": 2},
|
|
"about_tab": {"title": 'About Page', "controls": 'about', "active": '', "custom": False,
|
|
"data": aboutFields, "list_order": 3},
|
|
"contact_tab": {"title": 'Contact Page', "controls": 'contact', "active": '',
|
|
"custom": False,
|
|
"data": contactFields, "list_order": 4},
|
|
"social_tab": {"title": 'Socials', "controls": 'social', "active": '', "custom": False,
|
|
"data": socialFields, "list_order": 5},
|
|
"template_tab": {"title": 'Template', "controls": 'template', "active": '', "custom": True,
|
|
"data": templateData, "list_order": 6},
|
|
"color_scheme_tab": {"title": 'Color Scheme', "controls": 'color-scheme', "active": '',
|
|
"custom": True, "data": {}, "list_order": 7}
|
|
}
|
|
|
|
if product_id == "A000002":
|
|
settings_items = {
|
|
"settings": {"title": 'Settings', "controls": 'settings', "active": 'active show',
|
|
"custom": False, "data": settingsFields, "list_order": 0},
|
|
"home_tab": {"title": 'Home Page', "controls": 'home', "active": '', "custom": False,
|
|
"data": homeFields, "list_order": 1},
|
|
"footer_tab": {"title": 'Footer', "controls": 'footer', "active": '', "custom": False,
|
|
"data": footerFields, "list_order": 2},
|
|
"about_tab": {"title": 'About Page', "controls": 'about', "active": '', "custom": False,
|
|
"data": aboutFields, "list_order": 3},
|
|
"contact_tab": {"title": 'Contact Page', "controls": 'contact', "active": '',
|
|
"custom": False,
|
|
"data": contactFields, "list_order": 4},
|
|
"testimonial_tab": {"title": 'Testimonials', "controls": 'testimonial', "active": '',
|
|
"custom": False,
|
|
"data": testimonialFields, "list_order": 5},
|
|
"social_tab": {"title": 'Socials', "controls": 'social', "active": '', "custom": False,
|
|
"data": socialFields, "list_order": 6},
|
|
"template_tab": {"title": 'Template', "controls": 'template', "active": '', "custom": True,
|
|
"data": templateData, "list_order": 7},
|
|
"color_scheme_tab": {"title": 'Color Scheme', "controls": 'color-scheme', "active": '',
|
|
"custom": True, "data": {}, "list_order": 8}
|
|
}
|
|
#
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"settings_items": settings_items,
|
|
"member_id": member_id,
|
|
"product_subscription_uid": product_subscription_uid,
|
|
}
|
|
|
|
return ResponseHelper.success(data=response_data)
|
|
|
|
except ValidationError as err:
|
|
|
|
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.unprocessable_entity(result_description="Validation exception")
|
|
|
|
except ValueError as err:
|
|
logger.error(f"{getattr(err, 'messages', str(err))}")
|
|
db.session.rollback()
|
|
return ResponseHelper.error(result_description=str(err))
|
|
|
|
except Exception as e:
|
|
logger.error(f"An error occurred: {str(e)}", exc_info=True)
|
|
db.session.rollback()
|
|
return ResponseHelper.internal_server_error()
|