payment session

app/models/__init__.py

@@ -25,7 +25,7 @@ from .members_profile import  MembersProfile
 from .subscription_options import SubscriptionOptions
 from .subscription_options_items import SubscriptionOptionsItems
 from .products_templates import ProductsTemplates
-
+from .payments_session import PaymentsSession
 
 
 
@@ -34,7 +34,7 @@ __all__ = ['Members','Customer', 'Account', 'Products',
            'MembersProducts', 'MembersActions', 'MembersPending', 'ProductsDetails',
            'ProvisionActions', 'MembersProductsRefresh','MembersProductsSettings',
            'PasswordReset','MembersProfile','SubscriptionOptions','SubscriptionOptionsItems',
-           'ProductsTemplates',
+           'ProductsTemplates','PaymentsSession',
 
            'Loan', 'Transaction', 'Repayment',
            'LoanCharge', 'Offer', 'Charge', 'RACCheck', 'LoanRepaymentSchedule',

app/models/payments.py

@@ -3,75 +3,44 @@ from app.extensions import db
 from app.models.charge import Charge
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
+from sqlalchemy.exc import IntegrityError
 
 
-class Offer(db.Model):
+class Payments(db.Model):
     __tablename__ = 'payments'
 
-    id = db.Column(db.String, primary_key=True)
-    product_id = db.Column(db.String, nullable=False)
-    min_amount = db.Column(db.Float, nullable=False)
-    max_amount = db.Column(db.Float, nullable=False)
-    tenor = db.Column(db.Integer, nullable=False)
-    schedule = db.Column(db.Integer, nullable=True)
-    interest_rate = db.Column(db.Float, default=3.0)
-    management_rate = db.Column(db.Float, default=1.0)
-    insurance_rate = db.Column(db.Float, default=1.0)
-    vat_rate = db.Column(db.Float, default=7.5)
-    list_order = db.Column(db.Integer, nullable=True)
-    max_daily_loans = db.Column(db.Integer, nullable=True)
-    max_active_loans = db.Column(db.Integer, nullable=True)
-    max_life_loans = db.Column(db.Integer, nullable=True)
-    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
-    updated_at = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
-
-    charges = relationship(
-        "Charge",
-        primaryjoin="Offer.id == Charge.offer_id",
-        foreign_keys="Charge.offer_id",
-        back_populates="offer",
+    id = db.Column(
+        db.Integer,
+        primary_key=True,
+        autoincrement=True,
     )
+    uid = db.Column(db.String(150), nullable=True)
+    member_id = db.Column(db.Integer, nullable=False)
+    product_id = db.Column(db.String(25), nullable=False)
+    processor = db.Column(db.String(25), nullable=False)
+    status = db.Column(db.Integer, nullable=True, default=1)
+    added = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
 
     @classmethod
-    def get_all_offers(cls):
-        """
-        Return all offers in dictionary format.
-        """
-        offers = cls.query.all()
+    def add_payment(cls, customer_id, account_id, transaction_id, data=None):
 
-        if not offers:
-            raise ValueError(f"No available offers")
-        return offers
+        # Save the response
+        rac_check = cls(
+            customer_id=customer_id,
+            account_id=account_id,
+            transaction_id=transaction_id,
+            added=datetime.now(timezone.utc),
+            updated=datetime.now(timezone.utc)
+        )
 
-    @classmethod
-    def is_valid_offer(cls, offer_id):
-        offer = cls.query.filter_by(id=str(offer_id)).first()
+        try:
+            db.session.add(rac_check)
+        except IntegrityError as err:
+            raise ValueError(f"Database integrity error: {err}")
+        return rac_check
 
-        if not offer:
-            return False
-        return offer
 
-    @classmethod
-    def get_offer_by_id(cls, offer_id):
-        """
-        Return an offer by its ID.
-        """
-        offer = cls.query.filter_by(id=str(offer_id)).first()
-
-        if not offer:
-            raise ValueError(f"Offer with ID {offer_id} not found")
-        return offer
-
-    @classmethod
-    def get_offer_by_product_id(cls, product_id):
-        """
-        Return an offer by its product ID.
-        """
-        offer = cls.query.filter_by(product_id=str(product_id)).first()
-
-        if not offer:
-            raise ValueError(f"Offer with Product ID {product_id} not found")
-        return offer
 
     def to_dict(self):
         return {

app/models/payments_session.py

@@ -0,0 +1,60 @@
+from datetime import datetime, timezone
+from app.extensions import db
+from app.models.charge import Charge
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from sqlalchemy.exc import IntegrityError
+import uuid
+
+class PaymentsSession(db.Model):
+    __tablename__ = 'payments_session'
+
+    id = db.Column(
+        db.Integer,
+        primary_key=True,
+        autoincrement=True,
+    )
+    uid = db.Column(db.String(150), nullable=True)
+    member_id = db.Column(db.Integer, nullable=False)
+    option_name = db.Column(db.String(100), nullable=False)
+    processor = db.Column(db.String(25), nullable=False)
+    session_id = db.Column(db.String(150), nullable=False)
+    status = db.Column(db.Integer, nullable=True, default=1)
+    added = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+    @classmethod
+    def add_payment_session(cls, member_id, option_name, processor, session_id):
+
+        # save the response
+        session_data = cls(
+            uid=str(uuid.uuid4()),
+            member_id=member_id,
+            option_name=option_name,
+            processor=processor,
+            session_id=session_id,
+            added=datetime.now(timezone.utc),
+            updated=datetime.now(timezone.utc)
+        )
+
+        try:
+            db.session.add(session_data)
+        except IntegrityError as err:
+            raise ValueError(f"database integrity error: {err}")
+        return session_data
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "uid": self.uid,
+            "member_id": self.member_id,
+            "option_name": self.option_name,
+            "processor": self.processor,
+            "session_id": self.session_id,
+            "status": self.status,
+            "added": self.added,
+            "updated": self.updated
+        }
+
+    def __repr__(self):
+        return f'<PaymentsSession {self.id}>'