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()