subscription generative

SQL/site_data.sql

@@ -583,6 +583,23 @@ INSERT INTO subscription_options_items (option_name,description,list_order)
 
 
 
+CREATE TABLE subscription_generative(
+	id SERIAL,
+	uid uuid DEFAULT  uuid_generate_v4(),
+	member_id INT REFERENCES members(id) UNIQUE  NOT NULL,
+	practice VARCHAR(100)  NOT NULL,
+	specialization VARCHAR(100)  NOT NULL,
+    subscription_uid VARCHAR(100)  NOT NULL,
+    status INT DEFAULT 0,
+	added timestamp without time zone DEFAULT now()
+);
+
+ALTER TABLE ONLY subscription_generative
+    ADD CONSTRAINT subscription_generative_id_key UNIQUE (id);
+
+ALTER TABLE subscription_generative OWNER TO merms_panel
+
+
 
 
 

app/api/services/myproduct.py

@@ -9,7 +9,7 @@ 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
+    MembersProductsSettings, ProductsTemplates, MembersProfile, SubscriptionGenerative
 from app.api.helpers.response_helper import ResponseHelper
 from app.api.schemas.myproduct import MyProductSchema
 from app.api.schemas.provision import ProvisionSchema
@@ -148,13 +148,14 @@ class MyProductsService(BaseService):
 
                 provision_activities = ProvisionActions.get_provision_action_by_product_uid(subscription.uid, 4)
                 provision_activities_data = []
-                for t in provision_activities:
+                if provision_activities:
-                    provision_activities_data.append({
+                    for t in provision_activities:
-                        'id': t.id,
+                        provision_activities_data.append({
-                        'uid': t.uid,
+                            'id': t.id,
-                        'action': t.action,
+                            'uid': t.uid,
-                        'added': t.added.isoformat() if t.added else None,
+                            'action': t.action,
-                    })
+                            'added': t.added.isoformat() if t.added else None,
+                        })
 
                 response_data = {
                     "subscription_uid": subscription.uid,
@@ -224,6 +225,14 @@ class MyProductsService(BaseService):
                 status = 6
                 subscription = MembersProducts.create_subscription(member_id, product_id, status, internal_url)
 
+                #-let prepare the flags for auto generated stuffs
+                profile_data = MembersProfile.get_member_profile_by_member_id(member_id)
+                if profile_data:
+                    practice = profile_data.practice
+                    specialization =  profile_data.specialization
+                    subscription_uid = subscription.uid
+                    SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,subscription_uid)
+
                 response_data = {
                     "subscription_uid": subscription.uid,
                     "subscription_id": subscription.id,

app/models/__init__.py

@@ -1,16 +1,4 @@
-# from .customer import Customer
 from .account import Account
-# from .loan import Loan
-# from .transaction import Transaction
-# from .repayment import Repayment
-# from .loan_charge import LoanCharge
-# from .offer import Offer
-# from .charge import Charge
-# from .rac_checks import RACCheck
-# from .loan_repayment_schedule import LoanRepaymentSchedule
-# from .transaction_offers import TransactionOffer
-# from .repayments_data import RepaymentsData
-# from .salary import Salary
 from .members import Members
 from .products import Products
 from .members_products import MembersProducts
@@ -27,17 +15,12 @@ from .subscription_options_items import SubscriptionOptionsItems
 from .products_templates import ProductsTemplates
 from .payments_session import PaymentsSession
 from .payments import Payments
-
+from .subscription_generative import SubscriptionGenerative
-
-
 
 
 __all__ = ['Members', 'Account', 'Products',
            'MembersProducts', 'MembersActions', 'MembersPending', 'ProductsDetails',
            'ProvisionActions', 'MembersProductsRefresh','MembersProductsSettings',
            'PasswordReset','MembersProfile','SubscriptionOptions','SubscriptionOptionsItems',
-           'ProductsTemplates','Payments','PaymentsSession']
+           'ProductsTemplates','Payments','PaymentsSession','SubscriptionGenerative']
 
-# 'Loan', 'Transaction', 'Repayment', 'Customer',
-# 'LoanCharge', 'Offer', 'Charge', 'RACCheck', 'LoanRepaymentSchedule',
-# 'TransactionOffer', 'RepaymentsData', 'Salary'

app/models/subscription_generative.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 SubscriptionGenerative(db.Model):
+    __tablename__ = 'subscription_generative'
+
+    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)
+    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)
+    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,  subscription_uid, status):
+        subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).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
+
+
+    @classmethod
+    def create_subscription_generative(cls, member_id ,practice,specialization,subscription_uid):
+
+        logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization}, {subscription_uid} ")
+        subscription_generative_data = cls(
+            uid=str(uuid.uuid4()),
+            member_id=member_id,
+            practice=practice,
+            specialization=specialization,
+            subscription_uid=subscription_uid,
+            added=datetime.now(timezone.utc)
+        )
+        try:
+            logger.info(f" About to Insert Subscription_Generative Data {subscription_generative_data.member_id} ")
+            db.session.add(subscription_generative_data)
+            db.session.flush()
+        except IntegrityError as err:
+            logger.error(f" Error inserting Subscription_Generative data {err}  -- ")
+            raise ValueError(f"Database integrity error: {err}")
+        return subscription_generative_data
+
+    def to_dict(self):
+        """
+        Convert the Loan object to a dictionary format for JSON serialization.
+        """
+        return {
+            'id': self.id,
+            'uid': self.uid,
+            'member_id': self.member_id,
+            'practice': self.practice,
+            'specialization': self.specialization,
+            'subscription_uid': self.subscription_uid,
+            'added': self.added,
+            'status': self.status
+        }
+
+    def __repr__(self):
+        return f'<SubscriptionGenerative {self.id}>'
+