generative data

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;
 
 
 

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_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 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 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 website.', "active": True},
+                    {"name": 'about_description', "prompt": 'Write three paragraphs about a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True},
                 ]
         return data

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, \
+from app.models import SubscriptionGenerative, GenerativeResults
-    MembersProductsSettings, ProductsTemplates
 
 from app.api.enums import GenerativesList
 
@@ -13,23 +12,71 @@ class GenerativesService(BaseService):
 
     @staticmethod
     def process_generatives_list(data):
-        logger.info("ENTER GENERATIVE")
+        logger.info("SELECT GENERATIVE")
-        generate_list = GenerativesList.get_generative_list()
+        planed_generate_list = SubscriptionGenerative.get_subscription_generative_list_by_status(0)
-        practice_type = "Dentist"
+
-        subscription_uid =" a42dbcc2-7466-4bea-aa67-8357c2c33925"
+        if planed_generate_list:
-        product_id ="A000001"
+            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}")
 

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,

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']
 

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'<GenerativeResults {self.id}>'
+

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=#
-    '''

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"

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):
+    def get_subscription_generative_list_by_status(cls, status):
-        subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).all()
+        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
+        logger.info(
-        subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
+            f"UPDATE SubscriptionGenerative::status   subscription_uid = {subscription_uid} status = {status} ")
-
+        subscription_generative_data = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
-        if not subscription_generative:
+        # member_product = cls.query.filter_by(member_id=str(member_id), product_id=str(product_id)).first()
-            raise ValueError(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
+        if not subscription_generative_data:
-
+            logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
-        subscription_generative.status =status
+            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