[fix]: Loan id

.gitignore

@@ -4,4 +4,5 @@ app.log
 .DS_Store
 migrations/__pycache__/
 migrations/*.pycg
-./vscode
+./vscode
+.vscode/settings.json

.vscode/settings.json

@@ -1,24 +1,24 @@
-{
-  "editor.lineNumbers": "off",
-  "editor.padding.top": 3,
-  "editor.padding.bottom": 3,
-  "editor.formatOnSave": true,
-  "editor.formatOnPaste": true,
-  "editor.fontSize": 14,
-  "editor.lineHeight": 4.5,
-  "editor.suggestFontSize": 15,
-  // "editor.suggestLineHeight": 4,
-  "breadcrumbs.enabled": false,
-  "workbench.tips.enabled": false,
-  "workbench.statusBar.visible": false,
-  // "workbench.editor.showTabs": "single",
-  "git.enableSmartCommit": true,
-  "workbench.editor.editorActionsLocation": "hidden",
-  // "workbench.activityBar.location": "hidden",
-  "workbench.editor.enablePreviewFromQuickOpen": false,
-  "editor.lightbulb.enabled": "off",
-  "editor.selectionHighlight": false,
-  "editor.overviewRulerBorder": false,
-  "editor.renderLineHighlight": "none",
-  "editor.occurrencesHighlight": "off"
-}
+// {
+//   "editor.lineNumbers": "off",
+//   "editor.padding.top": 3,
+//   "editor.padding.bottom": 3,
+//   "editor.formatOnSave": true,
+//   "editor.formatOnPaste": true,
+//   "editor.fontSize": 14,
+//   "editor.lineHeight": 4.5,
+//   "editor.suggestFontSize": 15,
+//   // "editor.suggestLineHeight": 4,
+//   "breadcrumbs.enabled": false,
+//   "workbench.tips.enabled": false,
+//   "workbench.statusBar.visible": false,
+//   // "workbench.editor.showTabs": "single",
+//   "git.enableSmartCommit": true,
+//   "workbench.editor.editorActionsLocation": "hidden",
+//   // "workbench.activityBar.location": "hidden",
+//   "workbench.editor.enablePreviewFromQuickOpen": false,
+//   "editor.lightbulb.enabled": "off",
+//   "editor.selectionHighlight": false,
+//   "editor.overviewRulerBorder": false,
+//   "editor.renderLineHighlight": "none",
+//   "editor.occurrencesHighlight": "off"
+// }

SQL/site_data.sql

@@ -0,0 +1,14 @@
+
+CREATE TABLE transactions (
+        id SERIAL,
+        transaction_id VARCHAR(50) NOT NULL,
+        account_id VARCHAR(50) NOT NULL,
+        type VARCHAR(50) NOT NULL,
+        channel VARCHAR(8) NOT NULL,
+        created_at timestamp with time zone DEFAULT now(),
+        updated_at timestamp with time zone DEFAULT now()
+);
+ALTER TABLE ONLY transactions
+    ADD CONSTRAINT transactions_id_key UNIQUE (id);
+
+

app/__init__.py

@@ -26,6 +26,7 @@ def create_app():
     CORS(app)
 
     JWTManager(app)
+    CORS(app, supports_credentials=True) 
 
     # Swagger Doc
     SWAGGER_URL = app.config.get("SWAGGER_URL")

app/api/integrations/__init__.py

@@ -1 +1,2 @@
-from .simbrella import SimbrellaClient
+from .simbrella import SimbrellaIntegration
+from .kafka import KafkaIntegration

app/api/integrations/kafka.py

@@ -0,0 +1,82 @@
+from confluent_kafka import Producer
+import json
+import logging
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class KafkaIntegration:
+    _producer = None
+    _config = {
+        "bootstrap.servers": settings.KAFKA_BROKER,
+        "client.id": "loan-service-producer",
+        "acks": "all",
+        "retries": 3,
+        "debug": "broker,topic,msg",
+    }
+
+    @staticmethod
+    def _get_producer():
+        """Kafka producer"""
+        if not KafkaIntegration._producer:
+            KafkaIntegration._producer = Producer(KafkaIntegration._config)
+
+            logger.info(
+                f"Connected to Kafka broker at {KafkaIntegration._config['bootstrap.servers']}"
+            )
+
+        return KafkaIntegration._producer
+
+
+    @staticmethod
+    def delivery_report(err, msg):
+        """Called once for each message produced"""
+        if err is not None:
+
+            logger.error(f'Message delivery failed: {err}')
+            raise RuntimeError(f"Message delivery failed: {err}")
+        
+        else:
+            logger.debug(f'Message delivered to {msg.topic()} [{msg.partition()}] @ offset {msg.offset()}')
+
+
+
+    @staticmethod
+    def send_loan_request(loan_data, request_id):
+        """
+        Send loan request to PROCESS_PAYMENT topic
+
+        Args:
+            loan_data: Loan request payload as dict
+            request_id: Unique request identifier (used as Kafka key)
+        """
+        try:
+
+            # Proceed to send loan request to Kafka
+            producer = KafkaIntegration._get_producer()
+
+            # Sending loan request message to Kafka
+            producer.produce(
+                topic="PROCESS_PAYMENT",
+                key=str(request_id),
+                value=json.dumps(loan_data).encode("utf-8"),
+                callback=KafkaIntegration.delivery_report,
+
+            )
+
+            producer.poll(0)
+
+            logger.info(f"Loan request {request_id} queued for processing")
+
+        except Exception as e:
+            logger.error(
+                f"Failed to send loan request to Kafka: {str(e)}", exc_info=True
+            )
+            raise Exception(f"Failed to send loan request to Kafka: {str(e)}")
+
+    @staticmethod
+    def flush():
+        """Shutdown"""
+        producer = KafkaIntegration._get_producer()
+        producer.flush()

app/api/integrations/simbrella.py

@@ -1,8 +1,10 @@
 import requests
+import json
+from requests.auth import HTTPBasicAuth
 from app.utils.logger import logger
 from app.config import settings
 
-class SimbrellaClient:
+class SimbrellaIntegration:
     BASE_URL = settings.SIMBRELLA_BASE_URL
 
     @staticmethod
@@ -10,7 +12,7 @@ class SimbrellaClient:
         """
         Calls the RACCheck endpoit
         """
-        url = f"{SimbrellaClient.BASE_URL}/RACCheck"
+        url = f"{SimbrellaIntegration.BASE_URL}/RACCheck"
         
         payload = {
             "customerId": customer_id,
@@ -33,14 +35,21 @@ class SimbrellaClient:
             ]
         }
 
+        logger.error(f"This is PayLoad: {str(payload)}",exc_info=True)
+        headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': f'{settings.VALID_API_KEY}',
+            'App-Id': f'{settings.VALID_APP_ID}'
+        }
+
         try:
-            response = requests.post(url, json=payload, timeout=10)
-
+            response = requests.post(url, json=payload, timeout=10, headers=headers)
+            logger.error(f"This is Response: {str(response)}", exc_info=True)
             # Raise an error for non-200 responses
-            # response.raise_for_status()  
-
+            if response.status_code != 200:
+                response.raise_for_status()
 
             return response.json()
         except requests.exceptions.RequestException as err:
             logger.error(f"RACCheck API call failed: {str(err)}", exc_info=True)
-            return {"error": "RACCheck API error", "details": str(err)}
+            return {"error": "RACCheck API error"}

app/api/middlewares/app_id_checker.py

@@ -15,12 +15,12 @@ def require_app_id(f):
 
         if not app_id:
             logger.error("Unauthorized access: Missing App-ID.")
-            return jsonify({"message": "Invalid request parameters"}), 400
+            return jsonify({"message": "Invalid request"}), 400
 
 
         if app_id != VALID_APP_ID:
             logger.error(f"Unauthorized access: Invalid App-ID {app_id}.")
-            return jsonify({"message": "Invalid request parameters"}), 400
+            return jsonify({"message": "Invalid request"}), 400
 
         return f(*args, **kwargs)
 

app/api/middlewares/basic_auth.py

@@ -11,7 +11,7 @@ def require_auth(f):
     def decorated(*args, **kwargs):
         auth = request.headers.get('Authorization')
         if not auth or not check_auth(auth):
-            return jsonify({"message": "Invalid request parameters"}), 401
+            return jsonify({"message": "Invalid request"}), 401
         return f(*args, **kwargs)
     return decorated
 

app/api/middlewares/cors.py

@@ -4,4 +4,4 @@ from flask import request, jsonify
 def enforce_json():
     """Middleware to enforce JSON Content-Type for incoming requests"""
     if request.method in ["POST", "PUT", "PATCH"] and request.content_type != "application/json":
-        return jsonify({"message": "Invalid request parameters"}), 400
+        return jsonify({"message": "Invalid request"}), 400

app/api/middlewares/verify_api_key.py

@@ -14,11 +14,11 @@ def require_api_key(f):
 
         if not api_key:
             logger.error("Unauthorized access: Missing API key.")
-            return jsonify({"message": "Invalid request parameters"}), 400
+            return jsonify({"message": "Invalid request"}), 400
 
         if api_key != VALID_API_KEY:
             logger.error("Unauthorized access: Invalid API key.")
-            return jsonify({"message": "Invalid request parameters"}), 400
+            return jsonify({"message": "Invalid request"}), 400
 
         return f(*args, **kwargs)
 

app/api/schemas/provide_loan.py

@@ -8,8 +8,8 @@ class ProvideLoanSchema(Schema):
     customerId = fields.Str(required=True)
     accountId = fields.Str(required=True)
     msisdn = fields.Str(required=False)
-    productId = fields.Str(required=True)
-    lienAmount = fields.Float(required=True)
+    # productId = fields.Str(required=True)
+    # lienAmount = fields.Float(required=True)
     requestedAmount = fields.Float(required=True)
     collectionType = fields.Int(required=True)
     offerId = fields.Int(required=True)

app/api/services/base_service.py

@@ -48,7 +48,7 @@ class BaseService:
         Create a new transaction.
         """
         return Transaction.create_transaction(
-            id=validated_data.get("transactionId"),
+            transaction_id =validated_data.get("transactionId"),
             account_id=validated_data.get("accountId"),
             type=cls.TRANSACTION_TYPE,
             channel=validated_data.get("channel"),

app/api/services/eligibility_check.py

@@ -4,7 +4,7 @@ from app.api.services.base_service import BaseService
 from app.api.schemas.eligibility_check import EligibilityCheckSchema
 from marshmallow import ValidationError
 from app.api.enums import TransactionType
-from app.api.integrations import SimbrellaClient
+from app.api.integrations import SimbrellaIntegration
 
 class EligibilityCheckService(BaseService):
     TRANSACTION_TYPE = TransactionType.ELIGIBILITY_CHECK 
@@ -25,6 +25,8 @@ class EligibilityCheckService(BaseService):
             validated_data = EligibilityCheckService.validate_data(data, EligibilityCheckSchema())
             account_id = validated_data.get('accountId')
             customer_id =  validated_data.get('customerId')
+            transactionId = validated_data.get('transactionId')
+            msisdn = validated_data.get('msisdn')
 
             customer = EligibilityCheckService.get_or_create_customer(validated_data = validated_data)
 
@@ -42,44 +44,45 @@ class EligibilityCheckService(BaseService):
                     }), 400
             
              # Call RACCheck
-            response = SimbrellaClient.rac_check(
+            response = SimbrellaIntegration.rac_check(
                 customer_id = customer_id,
                 account_id = account_id,
                 transaction_id = transaction.id,
             )
+            logger.error(f"This is Response Returned ****** : {str(response)}")
 
-            if "error" in response or response.get("status") != 200:
-                return jsonify({"message": "RACCheck failed", "error": response.get("message", response)}), 400
-
-            
+            # this chck for error is not valid
+            logger.error(f"Check for ERROR is not valid  ****** FIX THIS !!!!!")
+            #if "error" in response or response.get("status") != 200:
+            #    return jsonify({"message": "RACCheck failed"}), 400
 
             offers = [
                 {
-                "offerId": "Offer1",
-                "productId": "Product1",
-                "minAamount": 100,
-                "maxAamount": 1000,
-                "tenor": 12
+                    "offerId": "SAL90",
+                    "productId": "2030",
+                    "minAmount": 5000,
+                    "maxAmount": 100000,
+                    "tenor": 30
                 },
                 {
-                "offerId": "Offer2",
-                "productId": "Product2",
-                "minAamount": 200,
-                "maxAamount": 2000,
-                "tenor": 24
+                    "offerId": "SAL30",
+                    "productId": "2090",
+                    "minAmount": 3000,
+                    "maxAmount": 500000,
+                    "tenor": 90
                 }
             ]
 
             # Simulate processing
             response_data = {
-                "customerId": "CN621868",
-                "transactionId": "TX12345",
+                "customerId": customer_id,
+                "transactionId": transactionId,
                 "countryCode": "NG",
-                "msisdn": "3451342",
+                "msisdn": msisdn,
                 "eligibleOffers": offers,
                 "resultDescription": "Successful",
                 "resultCode": "00",
-                "accountId": "ACN8263457"
+                "accountId": account_id
                 }
 
             return response_data

app/api/services/loan_status.py

@@ -22,10 +22,11 @@ class LoanStatusService(BaseService):
         """
         try:
             validated_data = LoanStatusService.validate_data(data, LoanStatusSchema())
-            account_id = validated_data.get('accountId')
             customer_id =  validated_data.get('customerId')
+            customer = LoanStatusService.get_or_create_customer(validated_data)
+            account = customer.accounts[0]
 
-            if (LoanStatusService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
+            if (LoanStatusService.validate_account_ownership(account_id = account.id, customer_id = customer_id)):
                 transaction = LoanStatusService.log_transaction(validated_data = validated_data)
 
                 if not transaction:

app/api/services/provide_loan.py

@@ -1,9 +1,14 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
+from app.api.integrations.kafka import KafkaIntegration
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
 from app.utils.logger import logger
-from app.api.schemas.provide_loan import ProvideLoanSchema   
+from app.api.schemas.provide_loan import ProvideLoanSchema
+from app.api.integrations import KafkaIntegration
+from threading import Thread
+from app.models.loan import Loan
+
 
 class ProvideLoanService(BaseService):
     TRANSACTION_TYPE = TransactionType.PROVIDE_LOAN 
@@ -24,8 +29,11 @@ class ProvideLoanService(BaseService):
             validated_data = ProvideLoanService.validate_data(data, ProvideLoanSchema())
             account_id = validated_data.get('accountId')
             customer_id =  validated_data.get('customerId')
+            request_id =  validated_data.get('requestId')
+            transaction_id = validated_data.get('transactionId')
 
             if (ProvideLoanService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
+
                 transaction = ProvideLoanService.log_transaction(validated_data = validated_data)
 
                 if not transaction:
@@ -33,6 +41,25 @@ class ProvideLoanService(BaseService):
                     return jsonify({
                         "message": "Failed to log transaction."
                     }), 400
+
+                # Save the loan details
+                loan_id = f"loan_{transaction_id}"
+                
+                loan = Loan.create_loan(
+                    customer_id=customer_id,
+                    account_id=account_id,
+                    offer_id=validated_data.get('offerId'),
+                    principal_amount=validated_data.get('requestedAmount'),
+                    status="active"
+                )
+
+                if not loan:
+                    logger.error(f"Failed to save loan details")
+                    return jsonify({
+                        "message": "Failed to save loan details."
+                    }), 400
+            
+                
             else: 
                 return jsonify({
                         "message": "Invalid Customer or Account"
@@ -40,16 +67,20 @@ class ProvideLoanService(BaseService):
            
            
             response_data = {
-                "requestId": "202111170001371256908",
-                "transactionId": "Tr201712RK9232P115",
-                "customerId": "CN621868",
-                "accountId": "ACN8263457",
+                "requestId": request_id,
+                "transactionId": transaction_id,
+                "customerId": customer_id,
+                "accountId": account_id,
                 "msisdn": "3451342",
                 "resultCode": "00",
                 "resultDescription": "Successful"
                 }
 
 
+            # KafkaIntegration.send_loan_request(loan_data = response_data, request_id = request_id)
+            # Call Kafka in a background thread
+            thread = Thread(target=ProvideLoanService.async_send_to_kafka, args=(response_data, request_id))
+            thread.start()
 
             return response_data
 
@@ -72,4 +103,10 @@ class ProvideLoanService(BaseService):
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
                 "message": "Internal Server Error"
-                }) , 500
+                }) , 500
+        
+    
+    def async_send_to_kafka(loan_data, request_id):
+        KafkaIntegration.send_loan_request(loan_data = loan_data, request_id = request_id)
+        KafkaIntegration.flush()
+

app/api/services/repayment.py

@@ -21,10 +21,13 @@ class RepaymentService(BaseService):
         """
         try:
             validated_data = RepaymentService.validate_data(data, RepaymentSchema())
-            account_id = validated_data.get('accountId')
             customer_id =  validated_data.get('customerId')
+            customer = RepaymentService.get_or_create_customer(validated_data)
+            account = customer.accounts[0]
+            validated_data['accountId'] = account.id
 
-            if (RepaymentService.validate_account_ownership(account_id = account_id, customer_id = customer_id)):
+
+            if (RepaymentService.validate_account_ownership(account_id = account.id, customer_id = customer_id)):
                 transaction = RepaymentService.log_transaction(validated_data = validated_data)
 
                 if not transaction:

app/api/services/select_offer.py

@@ -3,7 +3,7 @@ from marshmallow import ValidationError
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
 from app.utils.logger import logger
-from app.api.schemas.select_offer import SelectOfferSchema   
+from app.api.schemas.select_offer import SelectOfferSchema
 
 class SelectOfferService(BaseService):
     TRANSACTION_TYPE = TransactionType.SELECT_OFFER 
@@ -60,9 +60,9 @@ class SelectOfferService(BaseService):
             response_data = {
                 "outstandingDebtAmount": 0,
                 "requestId": "202111170001371256908",
-                "transactionId": "1231231321232",
-                "customerId": "1256907",
-                "accountId": "5948306019",
+                "transactionId": transaction.id,
+                "customerId": customer_id,
+                "accountId": account_id,
                 "loan": offers,
                 "resultCode": "00",
                 "resultDescription": "Successful"

app/config.py

@@ -24,11 +24,15 @@ class Config:
     SQLALCHEMY_TRACK_MODIFICATIONS = False
     SIMBRELLA_BASE_URL = os.getenv("SIMBRELLA_BASE_URL", "http://127.0.0.1:6337")
 
+
     JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", "secret-key")
     JWT_ACCESS_TOKEN_EXPIRES = os.getenv("JWT_ACCESS_TOKEN_EXPIRES", timedelta(hours=1))
     JWT_REFRESH_TOKEN_EXPIRES = os.getenv(
         "JWT_REFRESH_TOKEN_EXPIRES", timedelta(days=30)
     )
 
+    KAFKA_BROKER = 'dev-events.simbrellang.net:9085'
+    KAFKA_PAYMENT_TOPIC = 'PROCESS_PAYMENT'
+
 
 settings = Config()

app/models/account.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from sqlalchemy.orm import relationship
 from app.extensions import db
 
 class Account(db.Model):
@@ -12,6 +13,13 @@ class Account(db.Model):
     created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
     updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
 
+    customer = relationship(
+        "Customer",
+        primaryjoin="Customer.id == Account.customer_id",
+        foreign_keys=[customer_id],
+        back_populates="accounts",
+    )
+
     @classmethod
     def create_account(cls, id, customer_id, account_type, status='active'):
         account = cls(

app/models/customer.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from sqlalchemy.orm import relationship
 from app.extensions import db
 from app.models.account import Account
 
@@ -11,12 +12,19 @@ class Customer(db.Model):
     created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
     updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
 
+    accounts = relationship(
+        "Account",
+        primaryjoin="Customer.id == Account.customer_id",
+        foreign_keys="Account.customer_id",
+        back_populates="customer",
+    )
+
     @classmethod
-    def is_eligible(cls, customer_id):
+    def is_valid_customer(cls, customer_id):
         customer = cls.query.filter_by(id=customer_id).first()
         if not customer:
-            return False, "Customer not found"
-        return True, "Customer is eligible"
+            return False
+        return True
 
     @classmethod
     def create_customer(cls, id, msisdn, country_code, account_id, account_type='savings'):

app/models/loan.py

@@ -1,20 +1,54 @@
 from datetime import datetime, timezone
 from app.extensions import db
+from app.models.customer import Customer
+from app.models.account import Account
 
 
 class Loan(db.Model):
     __tablename__ = 'loans'
 
-    id = db.Column(db.String(50), primary_key=True) 
+    id = db.Column(
+        db.Integer,
+        primary_key=True,
+        autoincrement=True,
+    )
     customer_id = db.Column(db.String(50), nullable=False)
     account_id = db.Column(db.String(50), nullable=False)
-    product_id = db.Column(db.String(20), nullable=False)
+    offer_id = db.Column(db.String(20), nullable=False)
     principal_amount = db.Column(db.Float, nullable=False)
     status = db.Column(db.String(20), default='pending')
     created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
     updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
 
 
+    @classmethod
+    def create_loan(cls, customer_id, account_id, offer_id, principal_amount, status='pending'):
+
+        # Check if customer exists
+        is_valid = Customer.is_valid_customer(customer_id)
+        if not is_valid:
+            raise ValueError("Customer does not exist")
+        
+        # # Check for active loans
+        # has_active_loans = cls.has_active_loans(customer_id)
+        # if has_active_loans:
+        #     raise ValueError("Customer has active loans")
+
+
+        # Create and save the loan
+        loan = cls(
+            customer_id=customer_id,
+            account_id=account_id,
+            offer_id=offer_id,
+            principal_amount=principal_amount,
+            status=status
+        )
+
+        db.session.add(loan)
+        db.session.commit()
+        return loan
+
+
     @classmethod
     def has_active_loans(cls, customer_id):
         active_loans = cls.query.filter_by(
@@ -23,8 +57,8 @@ class Loan(db.Model):
         ).count()
 
         if active_loans > 0:
-            return False, "Customer has active loans"
-        return True, "No active loans"
+            return False
+        return True
     
     
     def __repr__(self):

app/models/transaction.py

@@ -1,11 +1,17 @@
 from datetime import datetime, timezone
 from app.extensions import db
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy import and_, or_, not_
 
 class Transaction(db.Model):
     __tablename__ = 'transactions'
-
-    id = db.Column(db.String(50), primary_key=True)
+    id = db.Column(
+        db.Integer,
+        primary_key=True,
+        autoincrement=True,
+    )
+    #id = db.Column(db.Int, primary_key=True)
+    transaction_id = db.Column(db.String(50), nullable=False)
     account_id = db.Column(db.String(50), nullable=False)
     type = db.Column(db.String(50), nullable=False)
     channel = db.Column(db.String(50), nullable=False)
@@ -16,12 +22,18 @@ class Transaction(db.Model):
         return f'<Transaction {self.id}>'
 
     @classmethod
-    def create_transaction(cls, id, account_id, type, channel):
-        if cls.query.filter_by(id=id).first():
+    def create_transaction(cls, transaction_id, account_id, type, channel):
+
+        # if cls.query.filter_by(transaction_id=transaction_id).first():
+        #     raise ValueError("Duplicate Transaction")
+
+        if cls.query.filter( and_( cls.transaction_id ==transaction_id, cls.type==type) ).first():
             raise ValueError("Duplicate Transaction")
 
+
+
         transaction = cls(
-            id=id,
+            transaction_id=transaction_id,
             account_id=account_id,
             type=type,
             channel=channel

app/swagger/digifi_swagger.json

@@ -19,9 +19,28 @@
     },
     {
       "url": "http://api.dev.simbrellang.net:4500"
+    },
+        {
+      "url": "https://api.dev.simbrellang.net"
     }
   ],
   "tags": [
+      {
+      "name": "Authorize",
+      "description": "This feature will be used for authorizing customers.",
+      "externalDocs": {
+        "description": "Find out more",
+        "url": "https://www.simbrellang.net"
+      }
+    },
+    {
+      "name": "AuthorizeRefresh",
+      "description": "This feature will be used for refreshing authorized customers.",
+      "externalDocs": {
+        "description": "Find out more",
+        "url": "https://www.simbrellang.net"
+      }
+    },
     {
       "name": "EligibilityCheck",
       "description": "Eligibility Check Request",
@@ -61,41 +80,15 @@
         "description": "Find out more",
         "url": "https://www.simbrellang.net"
       }
-    },
-    {
-      "name": "CustomerConsent",
-      "description": "CustomerConsent Request.",
-      "externalDocs": {
-        "description": "Find out more",
-        "url": "https://www.simbrellang.net"
-      }
-    },
-    {
-      "name": "NotificationCallback",
-      "description": "This new feature will be used for informing Simbrella about status of the transactions that FBN have processed.",
-      "externalDocs": {
-        "description": "Find out more",
-        "url": "https://www.simbrellang.net"
-      }
-    },
-    {
-      "name": "Authorize",
-      "description": "This feature will be used for authorizing customers.",
-      "externalDocs": {
-        "description": "Find out more",
-        "url": "https://www.simbrellang.net"
-      }
-    },
-    {
-      "name": "AuthorizeRefresh",
-      "description": "This feature will be used for refreshing authorized customers.",
-      "externalDocs": {
-        "description": "Find out more",
-        "url": "https://www.simbrellang.net"
-      }
     }
   ],
   "paths": {
+    "/Authorize": {
+      "$ref": "swagger/paths/Authorize.json"
+    },
+    "/AuthorizeRefresh": {
+      "$ref": "swagger/paths/AuthorizeRefresh.json"
+    },
     "/EligibilityCheck": {
       "$ref": "swagger/paths/EligibilityCheck.json"
     },
@@ -110,18 +103,6 @@
     },
     "/Repayment": {
       "$ref": "swagger/paths/Repayment.json"
-    },
-    "/CustomerConsent": {
-      "$ref": "swagger/paths/CustomerConsent.json"
-    },
-    "/NotificationCallback": {
-      "$ref": "swagger/paths/NotificationCallback.json"
-    },
-    "/Authorize": {
-      "$ref": "swagger/paths/Authorize.json"
-    },
-    "/AuthorizeRefresh": {
-      "$ref": "swagger/paths/AuthorizeRefresh.json"
     }
   },
   "components": {

app/swagger/paths/CustomerConsent.json

@@ -43,7 +43,7 @@
           }
         },
         "400": {
-          "description": "Invalid request parameters"
+          "description": "Invalid request"
         },
         "422": {
           "description": "Validation exception"

app/swagger/paths/EligibilityCheck.json

@@ -44,7 +44,7 @@
                 }
             },
             "400": {
-                "description": "Invalid request parameters"
+                "description": "Invalid request"
             },
             "422": {
                 "description": "Validation exception"

app/swagger/paths/LoanStatus.json

@@ -44,7 +44,7 @@
           }
         },
         "400": {
-          "description": "Invalid request parameters"
+          "description": "Invalid request"
         },
         "422": {
           "description": "Validation exception"

app/swagger/paths/NotificationCallback.json

@@ -44,7 +44,7 @@
           }
         },
        "400": {
-          "description": "Invalid request parameters"
+          "description": "Invalid request"
         },
         "422": {
           "description": "Validation exception"

app/swagger/paths/ProvideLoan.json

@@ -44,7 +44,7 @@
           }
         },
         "400": {
-          "description": "Invalid request parameters"
+          "description": "Invalid request"
         },
         "422": {
           "description": "Validation exception"

app/swagger/paths/Repayment.json

@@ -43,7 +43,7 @@
                 }
             },
             "400": {
-                "description": "Invalid request parameters"
+                "description": "Invalid request"
             },
             "422": {
                 "description": "Validation exception"

app/swagger/paths/SelectOffer.json

@@ -44,7 +44,7 @@
                 }
             },
             "400": {
-                "description": "Invalid request parameters"
+                "description": "Invalid request"
             },
             "422": {
                 "description": "Validation exception"

app/swagger/schemas/ProvideLoanRequest.json

@@ -21,15 +21,6 @@
             "type": "string",
             "example": "3451342"
         },
-        "productId": {
-            "type": "string",
-            "example": "101"
-        },
-        "lienAmount": {
-            "type": "number",
-            "format": "decimal",
-            "example": 400
-        },
         "requestedAmount": {
             "type": "number",
             "format": "decimal",

requirements.txt

@@ -30,3 +30,7 @@ requests
 # JWT
 flask-jwt-extended
 
+
+# Kafka 
+confluent-kafka==1.9.2
+