CHIEFSOFT\ameye
1022 lines
50 KiB
Python
1022 lines
50 KiB
Python
from urllib import request
|
|
|
|
from flask import session, jsonify
|
|
|
|
from app.api.enums import SettingsItemsData, KafkaMessage
|
|
from app.api.schemas.myproduct_external_url import MyProductExternalUrlSchema
|
|
from app.api.schemas.myproduct_set_colorstyle import MyProductSetColorStyleSchema
|
|
from app.api.schemas.myproduct_set_template import MyProductSetTemplateSchema
|
|
from app.api.schemas.myproduct_template_image import MyProductTemplateImageSchema
|
|
# from app.api.services import GenerativesService
|
|
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, ProductsColorStyle, \
|
|
MembersWebfiles
|
|
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):
|
|
START_URL_PATTERN = Config.START_URL_PATTERN
|
|
MEDIA_SERVER = Config.MEDIA_SERVER
|
|
|
|
@staticmethod
|
|
def process_provision_actions(data):
|
|
pass
|
|
|
|
@staticmethod
|
|
def process_set_colorstyle(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductSetColorStyleSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
color_style_uid = validated_data.get('color_style_uid')
|
|
product_id = validated_data.get('product_id')
|
|
|
|
member_data = Members.get_member_by_uid(uid)
|
|
member_id = member_data.id
|
|
|
|
# is this a valid color scheme
|
|
colorStyle = ProductsColorStyle.get_colorstyle_by_product_id_and_uid(product_id, color_style_uid)
|
|
if colorStyle and colorStyle.color_style != '':
|
|
MembersProducts.set_member_product_colorstyle(member_id, product_id, color_style_uid)
|
|
|
|
response_data = {}
|
|
response_data = {
|
|
"product_id": product_id,
|
|
"color_style_uid": color_style_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 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')
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
|
|
MembersProducts.set_member_product_template(member_id, product_id, template_uid)
|
|
|
|
response_data = {
|
|
"subscription_uid": memberSubscription.uid,
|
|
"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,
|
|
"custom_template_name": memberSubscription.custom_template if memberSubscription else '',
|
|
"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 mpproduct_colostyles_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')
|
|
color_style_data = []
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
if memberSubscription:
|
|
colorStyles = ProductsColorStyle.get_colorstyle_by_product_id(product_id)
|
|
# templates = ProductsTemplates.get_template_by_product_id(product_id)
|
|
for t in colorStyles:
|
|
color_style_data.append({
|
|
'id': t.id,
|
|
'template_uid': t.uid,
|
|
'color_style_uid': t.uid,
|
|
'color_code': t.color_code,
|
|
'title': t.name,
|
|
'active': t.status,
|
|
'added': t.added.isoformat() if t.added else None
|
|
})
|
|
|
|
response_data = {
|
|
"product_id": product_id,
|
|
"current_colorstyle_uid": memberSubscription.colorstyle if memberSubscription else None,
|
|
"current_template_uid": memberSubscription.product_template if memberSubscription else None,
|
|
"custom_template_name": memberSubscription.custom_template if memberSubscription else '',
|
|
"color_styles": color_style_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)
|
|
percent_completed=0
|
|
provision_activities = ProvisionActions.get_provision_action_by_product_uid(subscription.uid, 4)
|
|
provision_activities_data = []
|
|
activity_counter = 0
|
|
if provision_activities:
|
|
for t in provision_activities:
|
|
if activity_counter == 0:
|
|
percent_completed = t.percent_completed
|
|
activity_counter += 1
|
|
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": percent_completed,
|
|
"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
|
|
|
|
# getting the url-name part
|
|
url_name_part = str(random.randint(100000, 999999)) # Starr with random numbers
|
|
member_profile_data = MembersProfile.get_member_profile_by_member_id(member_id)
|
|
if member_profile_data and member_profile_data.url_name != None:
|
|
url_name_part = member_profile_data.url_name
|
|
|
|
product_id = validated_data.get('product_id')
|
|
product_data = Products.get_product_by_product_id(product_id)
|
|
configured_start_url = product_data.start_url
|
|
|
|
if configured_start_url == '':
|
|
configured_start_url = MyProductsService.START_URL_PATTERN
|
|
|
|
internal_url = url_name_part + configured_start_url # ".devprov.mermsemr.com" =
|
|
internal_url = internal_url.lower()
|
|
|
|
# let us see if this is in USE
|
|
anybodyUsingUrl = MembersProducts.get_member_product_by_internal_url(internal_url)
|
|
if anybodyUsingUrl:
|
|
return {
|
|
"message": "Unable to create URL",
|
|
"error_message": "Error - Please try again latter",
|
|
"data": None,
|
|
"error": f"Unable to create URL for the Product."
|
|
}, 400
|
|
|
|
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."
|
|
}, 400
|
|
|
|
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)
|
|
|
|
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,
|
|
product_id, subscription_uid)
|
|
|
|
# thread AI Here
|
|
# GenerativesService.process_generatives_list(subscription)
|
|
|
|
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
|
|
|
|
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, KafkaMessage.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
|
|
|
|
product_template = ''
|
|
custom_template = ''
|
|
|
|
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
|
|
product_template = memberSubscription.product_template
|
|
custom_template = memberSubscription.custom_template
|
|
|
|
# "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,
|
|
'product_template': product_template,
|
|
'custom_template': custom_template,
|
|
"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:
|
|
custom_template = "" if (
|
|
memberSubscription.custom_template is None or len(memberSubscription.custom_template)
|
|
== 0) else memberSubscription.custom_template
|
|
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
product_subscription_uid = memberSubscription.uid
|
|
subscription_template = "" if len(custom_template) > 0 else memberSubscription.product_template
|
|
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()
|
|
blogConnectFields = SettingsItemsData.get_site_blog_connect_settings()
|
|
|
|
blogConnect = False
|
|
if product_data.blog_product_id != None and product_data.blog_product_id != '':
|
|
blogConnect = True
|
|
blog_product_data = Products.get_product_by_product_id(product_data.blog_product_id)
|
|
|
|
settings_items = {}
|
|
if product_id == "A000001":
|
|
settings_items = {
|
|
"url_config_tab": {"title": 'URL Configuration', "controls": 'url-config', "active": '',
|
|
"custom": True, "data": {}, "list_order": 0},
|
|
"settings": {"title": 'Settings', "controls": 'settings', "active": 'active show',
|
|
"custom": False, "data": settingsFields, "list_order": 1},
|
|
"home_tab": {"title": 'Home Page', "controls": 'home', "active": '', "custom": False,
|
|
"data": homeFields, "list_order": 2},
|
|
"footer_tab": {"title": 'Footer', "controls": 'footer', "active": '', "custom": False,
|
|
"data": footerFields, "list_order": 3},
|
|
"about_tab": {"title": 'About Page', "controls": 'about', "active": '', "custom": False,
|
|
"data": aboutFields, "list_order": 4},
|
|
"contact_tab": {"title": 'Contact Page', "controls": 'contact', "active": '',
|
|
"custom": False,
|
|
"data": contactFields, "list_order": 5},
|
|
"social_tab": {"title": 'Socials', "controls": 'social', "active": '', "custom": False,
|
|
"data": socialFields, "list_order": 6},
|
|
"template_tab": {"title": 'Select Template', "controls": 'template', "active": '',
|
|
"custom": True,
|
|
"data": templateData, "list_order": 17},
|
|
"color_scheme_tab": {"title": 'Color Scheme', "controls": 'color-scheme', "active": '',
|
|
"custom": True, "data": {}, "list_order": 18}
|
|
}
|
|
|
|
if product_id == "A000002":
|
|
settings_items = {
|
|
"url_config_tab": {"title": 'URL Configuration', "controls": 'url-config', "active": '',
|
|
"custom": True, "data": {}, "list_order": 0},
|
|
"settings": {"title": 'Settings', "controls": 'settings', "active": 'active show',
|
|
"custom": False, "data": settingsFields, "list_order": 1},
|
|
"home_tab": {"title": 'Home Page', "controls": 'home', "active": '', "custom": False,
|
|
"data": homeFields, "list_order": 2},
|
|
"footer_tab": {"title": 'Footer', "controls": 'footer', "active": '', "custom": False,
|
|
"data": footerFields, "list_order": 3},
|
|
"about_tab": {"title": 'About Page', "controls": 'about', "active": '', "custom": False,
|
|
"data": aboutFields, "list_order": 4},
|
|
"contact_tab": {"title": 'Contact Page', "controls": 'contact', "active": '',
|
|
"custom": False,
|
|
"data": contactFields, "list_order": 5},
|
|
"testimonial_tab": {"title": 'Testimonials', "controls": 'testimonial', "active": '',
|
|
"custom": False,
|
|
"data": testimonialFields, "list_order": 6},
|
|
"social_tab": {"title": 'Socials', "controls": 'social', "active": '', "custom": False,
|
|
"data": socialFields, "list_order": 7},
|
|
"template_tab": {"title": 'Template', "controls": 'template', "active": '', "custom": True,
|
|
"data": templateData, "list_order": 18},
|
|
"color_scheme_tab": {"title": 'Color Scheme', "controls": 'color-scheme', "active": '',
|
|
"custom": True, "data": {}, "list_order": 19}
|
|
}
|
|
|
|
if product_id == "A000006":
|
|
settings_items = {
|
|
"merms_emr_settings": {"title": 'EMR Settings', "controls": 'merms-emr-settings', "active": '',
|
|
"custom": True, "data": {}, "list_order": 1},
|
|
"merms_emr_users": {"title": 'Users Admin', "controls": 'merms-emr-users', "active": '',
|
|
"custom": True, "data": {}, "list_order": 19},
|
|
}
|
|
|
|
if blogConnect:
|
|
settings_items["blog_connect_tab"] = {"title": 'Blog Connect', "controls": 'blog-connect-scheme',
|
|
"active": '',
|
|
"custom": False, "data": blogConnectFields, "list_order": 9}
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"settings_items": settings_items,
|
|
"member_id": member_id,
|
|
"subscription_template": subscription_template,
|
|
"custom_template_name": custom_template,
|
|
"product_subscription_uid": product_subscription_uid,
|
|
"blog_connect": blogConnect
|
|
}
|
|
|
|
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 set_external_url(data):
|
|
try:
|
|
with db.session.begin():
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {data}")
|
|
validated_data = MyProductsService.validate_data(data, MyProductExternalUrlSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
subscription_uid = validated_data.get('subscription_uid')
|
|
external_url = validated_data.get('external_url')
|
|
|
|
member_data = Members.get_member_by_uid(uid)
|
|
if not member_data:
|
|
return {
|
|
"message": "Invalid User",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"User with UID {uid} does not exist."
|
|
}, 400
|
|
|
|
member_id = member_data.id
|
|
|
|
membersSubResult = MembersProducts.get_member_product_by_subscription_uid(subscription_uid)
|
|
if not membersSubResult:
|
|
return {
|
|
"message": "Invalid Subscription",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Subscription with UID {subscription_uid} does not exist."
|
|
}, 400
|
|
logger.info(f"External URL Member Data: {member_data}")
|
|
|
|
if int(membersSubResult.member_id) != member_id:
|
|
return {
|
|
"message": "Mismatch subscription and User",
|
|
"error_message": "Error - Please select a valid product to view",
|
|
"data": None,
|
|
"error": f"Mismatch subscription and User."
|
|
}, 400
|
|
|
|
setUrlResult = MembersProducts.set_member_product_external_url(member_id, membersSubResult.product_id,
|
|
external_url)
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"subscription_uid": subscription_uid,
|
|
"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 template_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)
|
|
template_images = []
|
|
template_name = ''
|
|
|
|
if memberSubscription is not None:
|
|
custom_template = "" if (
|
|
memberSubscription.custom_template is None or len(memberSubscription.custom_template)
|
|
== 0) else memberSubscription.custom_template
|
|
|
|
# logger.info(f"Incoming MyProduct data ==>>>> {memberSubscription}")
|
|
product_subscription_uid = memberSubscription.uid
|
|
subscription_template = "" if len(custom_template) > 0 else memberSubscription.product_template
|
|
|
|
selected_flavor = ''
|
|
if product_id == "A000001" or product_id == "A000002": ## should be config or data driven not hard coded
|
|
settings_items = {}
|
|
|
|
if memberSubscription.product_template:
|
|
selectedTemplate = ProductsTemplates.get_template_by_uid(
|
|
str(memberSubscription.product_template))
|
|
if selectedTemplate:
|
|
selected_flavor = selectedTemplate.flavor
|
|
template_name = selectedTemplate.name
|
|
|
|
template_images = BaseService.get_site_imges_data(memberSubscription.uid,
|
|
memberSubscription.primary_server,
|
|
memberSubscription.provision_port,
|
|
selected_flavor)
|
|
|
|
web_files_list = MembersProductsSettings.get_member_websettings_by_member_setting_type(
|
|
member_id, "WEBFILES")
|
|
if web_files_list and template_images:
|
|
web_files_items = []
|
|
for t in web_files_list:
|
|
web_files_items.append({
|
|
'setting_key': t.settings_key,
|
|
'setting_value': t.setting_value,
|
|
})
|
|
|
|
template_images = MyProductsService._process_webimage_entry(web_files_items,
|
|
template_images)
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"product_id": product_id,
|
|
"subscription_template": str(subscription_template),
|
|
"template_name": str(template_name),
|
|
"product_subscription_uid": str(product_subscription_uid),
|
|
"template_images": template_images
|
|
}
|
|
|
|
cacheId = str(product_subscription_uid).replace("-", "")
|
|
BaseService.write_cache_data("WEB_CONFIGURE", cacheId, response_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_webimage_entry(web_files_items, template_images):
|
|
# logger.error(f"_process_webimage_entry web_files_items : {web_files_items}")
|
|
# logger.error(f"_process_webimage_entry template_images : {template_images}")
|
|
|
|
def find_key_value(current_key, web_files_items):
|
|
for tv in web_files_items:
|
|
if tv['setting_key'] == current_key:
|
|
return tv['setting_value']
|
|
return None
|
|
|
|
logger.error(f"_process_webimage_entry template_images DATA : {template_images['data']}")
|
|
if template_images and template_images['data']:
|
|
indx = 0
|
|
for t in template_images['data']:
|
|
current_key = template_images['data'][indx]['id']
|
|
saved_value = find_key_value(current_key, web_files_items)
|
|
template_images['data'][indx]['curr_val'] = '' if saved_value is None else saved_value
|
|
if saved_value:
|
|
template_images['data'][indx]['default_val'] = saved_value
|
|
indx = indx + 1
|
|
|
|
return template_images
|
|
|
|
@staticmethod
|
|
def template_set_media(data):
|
|
try:
|
|
with db.session.begin():
|
|
validated_data = MyProductsService.validate_data(data, MyProductTemplateImageSchema())
|
|
token = validated_data.get('token')
|
|
uid = validated_data.get('uid')
|
|
file_uid = validated_data.get('file_uid')
|
|
image_id = validated_data.get('image_id')
|
|
|
|
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)
|
|
|
|
# Check if this media belong
|
|
selectedFile = MembersWebfiles.get_member_webfiles_by_member_file_uid(member_id, file_uid)
|
|
if not selectedFile:
|
|
return {
|
|
"message": "Please provide valid file_uid",
|
|
"error_message": "Error - Please select a valid file UID",
|
|
"data": None,
|
|
"error": f"File with ID {file_uid} does not exist."
|
|
}, 400
|
|
|
|
# Check if image key
|
|
if image_id is None or image_id == '':
|
|
return {
|
|
"message": "Please provide valid image_id",
|
|
"error_message": "Error - Please select a valid image_id",
|
|
"data": None,
|
|
"error": f"File with ID {image_id} does not exist."
|
|
}, 400
|
|
|
|
memberSubscription = MembersProducts.get_member_product_by_product_member_id(member_id, product_id)
|
|
if not memberSubscription:
|
|
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
|
|
|
|
# make this file
|
|
file_url = (
|
|
MyProductsService.MEDIA_SERVER + "/" + selectedFile.file_group + "/" + str(
|
|
selectedFile.uid) + "/" + selectedFile.filename).lower()
|
|
|
|
product_subscription_uid = memberSubscription.uid
|
|
|
|
setting_value = file_url
|
|
subscription_uid = memberSubscription.uid
|
|
# with db.session.begin():
|
|
MembersProductsSettings.save_update_product_settings(member_id, subscription_uid, product_id,
|
|
image_id,
|
|
'WEBFILES', setting_value)
|
|
|
|
# Simulate processing
|
|
response_data = {
|
|
"file_url": file_url,
|
|
"product_id": product_id,
|
|
"subscription_uid": str(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()
|