From ff3ff1c6ba75a5cb91ec4b18e52785763b489c57 Mon Sep 17 00:00:00 2001 From: "CHIEFSOFT\\ameye" Date: Sat, 6 Sep 2025 11:48:37 -0400 Subject: [PATCH] generative data --- SQL/site_data.sql | 20 +++++- app/api/enums/generatives_list.py | 8 +-- app/api/services/genaratives.py | 87 ++++++++++++++++++------ app/api/services/myproduct.py | 2 +- app/models/__init__.py | 3 +- app/models/generative_results.py | 95 +++++++++++++++++++++++++++ app/models/members_pending.py | 29 -------- app/models/members_products.py | 1 - app/models/subscription_generative.py | 31 +++++---- 9 files changed, 206 insertions(+), 70 deletions(-) create mode 100644 app/models/generative_results.py diff --git a/SQL/site_data.sql b/SQL/site_data.sql index f068103..73fab33 100644 --- a/SQL/site_data.sql +++ b/SQL/site_data.sql @@ -589,6 +589,7 @@ CREATE TABLE subscription_generative( member_id INT REFERENCES members(id) UNIQUE NOT NULL, practice VARCHAR(100) NOT NULL, specialization VARCHAR(100) NOT NULL, + product_id VARCHAR(25) NOT NULL, subscription_uid VARCHAR(100) NOT NULL, status INT DEFAULT 0, added timestamp without time zone DEFAULT now() @@ -597,7 +598,24 @@ CREATE TABLE subscription_generative( ALTER TABLE ONLY subscription_generative ADD CONSTRAINT subscription_generative_id_key UNIQUE (id); -ALTER TABLE subscription_generative OWNER TO merms_panel +ALTER TABLE subscription_generative OWNER TO merms_panel; + +CREATE TABLE generative_results( + id SERIAL, + uid uuid DEFAULT uuid_generate_v4(), + member_id INT REFERENCES members(id) NOT NULL, + product_id VARCHAR(25) NOT NULL, + var_name VARCHAR(100) NOT NULL, + subscription_uid VARCHAR(100) NOT NULL, + text_result TEXT, + status INT DEFAULT 0, + added timestamp without time zone DEFAULT now() +); + +ALTER TABLE ONLY generative_results + ADD CONSTRAINT generative_results_id_key UNIQUE (id); + +ALTER TABLE generative_results OWNER TO merms_panel; diff --git a/app/api/enums/generatives_list.py b/app/api/enums/generatives_list.py index 1d85ba0..267eb7c 100644 --- a/app/api/enums/generatives_list.py +++ b/app/api/enums/generatives_list.py @@ -3,9 +3,9 @@ class GenerativesList: @staticmethod def get_generative_list(): data = [ - {"name": 'site_title', "prompt": 'Write about a 30-character title text for a REPLACE_THIS website.', "active": True}, - {"name": 'site_description', "prompt": 'Write a short introduction text about 100 characters for a REPLACE_THIS website.', "active": True}, - {"name": 'about_title', "prompt": 'Write about a 30-character about page title text for a REPLACE_THIS website.', "active": True}, - {"name": 'about_description', "prompt": 'Write three paragraphs about a REPLACE_THIS website.', "active": True}, + {"name": 'site_title', "prompt": 'Write about a 30-character title text for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True}, + {"name": 'site_description', "prompt": 'Write a short introduction text about 100 characters for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True}, + {"name": 'about_title', "prompt": 'Write about a 30-character about page title text for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True}, + {"name": 'about_description', "prompt": 'Write three paragraphs about a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True}, ] return data \ No newline at end of file diff --git a/app/api/services/genaratives.py b/app/api/services/genaratives.py index 7a225c9..4c3c3b8 100644 --- a/app/api/services/genaratives.py +++ b/app/api/services/genaratives.py @@ -4,8 +4,7 @@ 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 +from app.models import SubscriptionGenerative, GenerativeResults from app.api.enums import GenerativesList @@ -13,23 +12,71 @@ class GenerativesService(BaseService): @staticmethod def process_generatives_list(data): - logger.info("ENTER GENERATIVE") - generate_list = GenerativesList.get_generative_list() - practice_type = "Dentist" - subscription_uid =" a42dbcc2-7466-4bea-aa67-8357c2c33925" - product_id ="A000001" + logger.info("SELECT GENERATIVE") + planed_generate_list = SubscriptionGenerative.get_subscription_generative_list_by_status(0) + + if planed_generate_list: + for t in planed_generate_list: + logger.info(f"SELECT GENERATIVE {t}") + practice_type = t.practice + specialization = t.specialization + subscription_uid = t.subscription_uid + product_id = t.product_id + member_id = t.member_id + status = t.status + # logger.info(f"GenerativesService ****** *****: {member_id} {practice_type} {product_id} {subscription_uid}") + SubscriptionGenerative.update_subscription_generative_status(subscription_uid,status+1) # move the status up + GenerativesService.process_generatives_action(member_id, practice_type,specialization,subscription_uid,product_id) + + @staticmethod + def process_generatives_action(member_id, practice_type,specialization,subscription_uid,product_id): + try: + + logger.info("ENTER GENERATIVE") + generate_list = GenerativesList.get_generative_list() + GenerativeResults.create_generative_result(71, 'A000001', 'about_title', + '35e2d3ba-b5a6-4c1b-b962-05661d55b6f4', + 'Expert Neurologist: Brain & Nerve Care') + + # with db.session.begin(): + + for t in generate_list: + prompt_string = str(t["prompt"]).replace("REPLACE_THIS", practice_type).replace("REPLACE_ANOTHER", + specialization) + var_name = t["name"] + logger.info(f"GenerativesService ****** *****: {t['name']} {prompt_string}") + json_response = None + # json_response = GenerativeEngineIntegration.ask_generative(prompt_string) + # INFO - INSERT *****:71 A000001 about_title 35e2d3ba-b5a6-4c1b-b962-05661d55b6f4 Expert Neurologist: Brain & Nerve Care + GenerativeResults.create_generative_result(71, 'A000001', 'about_title', + '35e2d3ba-b5a6-4c1b-b962-05661d55b6f4', + 'Expert Neurologist: Brain & Nerve Care') + if json_response is not None: + logger.info(json_response) + # logger.info(json_response["output"]) + # logger.info(json_response["output"][0]) + # logger.info(json_response["output"][0]["content"][0]["text"]) + text_result = json_response["output"][0]["content"][0]["text"] + logger.info( + f"INSERT *****:{member_id} {product_id} {var_name} {subscription_uid} {text_result}") + GenerativeResults.create_generative_result(member_id, product_id, var_name, subscription_uid, + text_result) + + 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() + - for t in generate_list: - prompt_string = str(t["prompt"]).replace("REPLACE_THIS", practice_type) - var_name = t["name"] - logger.info(f"GenerativesService ****** *****: {t['name']} {prompt_string}") - json_response = [] - # json_response = GenerativeEngineIntegration.ask_generative(prompt_string) - if json_response is not None: - logger.info(json_response) - logger.info(json_response["output"]) - logger.info(json_response["output"][0]) - logger.info(json_response["output"][0]["content"][0]["text"]) - text_result= json_response["output"][0]["content"][0]["text"] - logger.info(f"INSERT *****: {product_id} {var_name} {subscription_uid} {text_result}") diff --git a/app/api/services/myproduct.py b/app/api/services/myproduct.py index 21f0f5d..1749743 100644 --- a/app/api/services/myproduct.py +++ b/app/api/services/myproduct.py @@ -231,7 +231,7 @@ class MyProductsService(BaseService): practice = profile_data.practice specialization = profile_data.specialization subscription_uid = subscription.uid - SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,subscription_uid) + SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,product_id, subscription_uid) response_data = { "subscription_uid": subscription.uid, diff --git a/app/models/__init__.py b/app/models/__init__.py index 83d34b6..ade46e4 100644 --- a/app/models/__init__.py +++ b/app/models/__init__.py @@ -16,11 +16,12 @@ from .products_templates import ProductsTemplates from .payments_session import PaymentsSession from .payments import Payments from .subscription_generative import SubscriptionGenerative +from .generative_results import GenerativeResults __all__ = ['Members', 'Account', 'Products', 'MembersProducts', 'MembersActions', 'MembersPending', 'ProductsDetails', 'ProvisionActions', 'MembersProductsRefresh','MembersProductsSettings', 'PasswordReset','MembersProfile','SubscriptionOptions','SubscriptionOptionsItems', - 'ProductsTemplates','Payments','PaymentsSession','SubscriptionGenerative'] + 'ProductsTemplates','Payments','PaymentsSession','SubscriptionGenerative','GenerativeResults'] diff --git a/app/models/generative_results.py b/app/models/generative_results.py new file mode 100644 index 0000000..fd93e1d --- /dev/null +++ b/app/models/generative_results.py @@ -0,0 +1,95 @@ +from datetime import datetime, timezone, timedelta +from itertools import product +from app.extensions import db +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import relationship +from dateutil.relativedelta import relativedelta +from datetime import timedelta +import logging +from sqlalchemy import and_, or_, not_ +from sqlalchemy.sql import func +import uuid + +logger = logging.getLogger(__name__) + + +class GenerativeResults(db.Model): + __tablename__ = 'generative_results' + + id = db.Column( + db.Integer, + primary_key=True, + autoincrement=True, + ) + + uid = db.Column(db.String(150), nullable=False) + member_id = db.Column(db.Integer, nullable=False) + product_id = db.Column(db.String(25), nullable=False) + var_name = db.Column(db.String(100), nullable=False) + subscription_uid = db.Column(db.String(100), nullable=False) + text_result = db.Column(db.String(14000), nullable=False) + status = db.Column(db.Integer, nullable=True, default=0) + added = db.Column(db.DateTime(timezone=True), server_default=func.now()) + + @classmethod + def get_subscription_generative_by_subscription_uid(cls, subscription_uid): + subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first() + if not subscription_generative: + return None + return subscription_generative + + @classmethod + def get_subscription_generative_list_by_status(cls, status): + subscription_generative = cls.query.filter_by(status=status).all() + if not subscription_generative: + return None + return subscription_generative + + @classmethod + def update_subscription_generative_status(cls, subscription_uid, status): + subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first() + if not subscription_generative: + logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.") + return None + subscription_generative.status =status + return status + + @classmethod + def create_generative_result(cls, member_id,product_id,var_name,subscription_uid,text_result): + # create_generative_result(member_id,product_id,var_name,subscription_uid,text_result) + logger.info(f"GenerativeResults Create::Data {member_id} ,{product_id} ,{var_name} , {subscription_uid},{text_result} ") + subscription_generative_data = cls( + uid=str(uuid.uuid4()), + member_id=member_id, + var_name=var_name, + text_result=text_result, + product_id=product_id, + subscription_uid=subscription_uid, + added=datetime.now(timezone.utc) + ) + try: + logger.info(f" About to Insert GenerativeResults Data {subscription_generative_data.member_id} ") + db.session.add(subscription_generative_data) + db.session.flush() + except IntegrityError as err: + logger.error(f" Error inserting GenerativeResults data {err} -- ") + raise ValueError(f"Database integrity error: {err}") + return subscription_generative_data + + def to_dict(self): + + return { + 'id': self.id, + 'uid': self.uid, + 'member_id': self.member_id, + 'product_id': self.product_id, + 'var_name': self.var_name, + 'subscription_uid': self.subscription_uid, + 'text_result': self.text_result, + 'status': self.status, + 'added': self.added + } + + def __repr__(self): + return f'' + diff --git a/app/models/members_pending.py b/app/models/members_pending.py index 01409c7..b252b61 100644 --- a/app/models/members_pending.py +++ b/app/models/members_pending.py @@ -55,38 +55,9 @@ class MembersPending(db.Model): @classmethod def get_member_by_username(cls, username): - """ - Return an offer by its ID. - """ member = cls.query.filter_by(username=str(username)).first() if not member: raise ValueError(f"Username = {username} not found") return member - # { - # "email": "ameye@chiefsoft.com", - # "firstname": "Olusesan", - # "lastname": "Ameye", - # "isChecked": true - # } - - ''' - merms_panel=# \d members_pending - Table "public.members_pending" - Column | Type | Collation | Nullable | Default ------------+-----------------------------+-----------+----------+--------------------------------------------- - id | integer | | not null | nextval('members_pending_id_seq'::regclass) - uid | uuid | | | uuid_generate_v4() - firstname | character varying(35) | | not null | - lastname | character varying(35) | | not null | - email | character varying(35) | | not null | - status | integer | | | 0 - added | timestamp without time zone | | | now() - updated | timestamp without time zone | | | now() -Indexes: - "members_pending_id_key" UNIQUE CONSTRAINT, btree (id) - - -merms_panel=# - ''' \ No newline at end of file diff --git a/app/models/members_products.py b/app/models/members_products.py index f0dbb12..db232b5 100644 --- a/app/models/members_products.py +++ b/app/models/members_products.py @@ -78,7 +78,6 @@ class MembersProducts(db.Model): member_product.product_template = product_template return product_template - @classmethod def create_subscription(cls, member_id ,product_id,status,internal_url): dns_group = "DNS_G01" diff --git a/app/models/subscription_generative.py b/app/models/subscription_generative.py index 3024021..230ae18 100644 --- a/app/models/subscription_generative.py +++ b/app/models/subscription_generative.py @@ -25,7 +25,8 @@ class SubscriptionGenerative(db.Model): member_id = db.Column(db.Integer, nullable=False) practice = db.Column(db.String(100), nullable=False) specialization = db.Column(db.String(100), nullable=False) - subscription_uid = db.Column(db.String(3500), nullable=True) + product_id = db.Column(db.String(25), nullable=False) + subscription_uid = db.Column(db.String(100), nullable=True) status = db.Column(db.Integer, nullable=True, default=0) added = db.Column(db.DateTime(timezone=True), server_default=func.now()) @@ -37,32 +38,35 @@ class SubscriptionGenerative(db.Model): return subscription_generative @classmethod - def get_subscription_generative_list_by_status(cls, subscription_uid, status): - subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).all() + def get_subscription_generative_list_by_status(cls, status): + subscription_generative = cls.query.filter_by(status=status).all() if not subscription_generative: return None return subscription_generative @classmethod def update_subscription_generative_status(cls, subscription_uid, status): - # Retrieve Reset - subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first() - - if not subscription_generative: - raise ValueError(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.") - - subscription_generative.status =status - + logger.info( + f"UPDATE SubscriptionGenerative::status subscription_uid = {subscription_uid} status = {status} ") + subscription_generative_data = cls.query.filter_by(subscription_uid=str(subscription_uid)).first() + # member_product = cls.query.filter_by(member_id=str(member_id), product_id=str(product_id)).first() + if not subscription_generative_data: + logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.") + return None + logger.info("INSERT::Point-->") + subscription_generative_data.status = status + return subscription_generative_data.status @classmethod - def create_subscription_generative(cls, member_id ,practice,specialization,subscription_uid): + def create_subscription_generative(cls, member_id ,practice,specialization,product_id, subscription_uid): - logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization}, {subscription_uid} ") + logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization},{product_id}, {subscription_uid} ") subscription_generative_data = cls( uid=str(uuid.uuid4()), member_id=member_id, practice=practice, specialization=specialization, + product_id=product_id, subscription_uid=subscription_uid, added=datetime.now(timezone.utc) ) @@ -85,6 +89,7 @@ class SubscriptionGenerative(db.Model): 'member_id': self.member_id, 'practice': self.practice, 'specialization': self.specialization, + 'product_id': self.product_id, 'subscription_uid': self.subscription_uid, 'added': self.added, 'status': self.status