mercore starter

app/api/enums/loan_status.py

@@ -3,5 +3,6 @@ from enum import Enum
 class LoanStatus(str, Enum):
     PENDING = "pending"
     ACTIVE = "active"
+    ACTIVE_PARTIAL = "active_partial"
     START_REPAY = "start_repay"
     REPAID = "repaid"

app/api/helpers/response_helper.py

@@ -26,7 +26,7 @@ class ResponseHelper:
     @staticmethod
     def success(
         result_description: str = "Successful",
-        result_code: str = "00",
+        result_code: str = "0",
         data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         return ResponseHelper.build_response(result_code, result_description, data)

app/api/routes/routes.py

@@ -1,5 +1,6 @@
 from flask import Blueprint, request, jsonify, send_from_directory
 from app.api.services import (
+    LoginService,
     EligibilityCheckService,
     SelectOfferService,
     ProvideLoanService,
@@ -42,6 +43,15 @@ def serve_paths(filename):
     swagger_dir = os.path.join("swagger")
     return send_from_directory(swagger_dir, filename)
 
+# EligibilityCheck Endpoint
+@api.route("/Login", methods=["POST"])
+@jwt_required()
+def merms_login():
+    data = request.get_json()
+    # logger.info(f"EligibilityCheck request received: {data}")
+    response = LoginService.process_request(data)
+    return response
+
 
 # EligibilityCheck Endpoint
 @api.route("/EligibilityCheck", methods=["POST"])

app/api/schemas/login.py

@@ -0,0 +1,5 @@
+from marshmallow import Schema, fields
+
+class LoginSchema(Schema):
+    username = fields.Str(required=True)
+    password = fields.Str(required=True)

app/api/services/__init__.py

@@ -7,3 +7,4 @@ from app.api.services.customer_consent import CustomerConsentService
 from app.api.services.notification_callback import NotificationCallbackService
 from app.api.services.authorization import AuthorizationService
 from app.api.services.offer_analysis import OfferAnalysis
+from app.api.services.login import LoginService

app/api/services/login.py

@@ -0,0 +1,137 @@
+from flask import session, jsonify
+from app.models.loan import Loan
+from app.utils.logger import logger
+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 SimbrellaIntegration
+from app.extensions import db
+from app.models import Offer, RACCheck, Members
+from app.api.services.offer_analysis import OfferAnalysis
+from app.api.helpers.response_helper import ResponseHelper
+from werkzeug.security import generate_password_hash, check_password_hash
+from app.api.schemas.login import LoginSchema
+import datetime
+import jwt
+import random
+from app.config import Config
+
+
+class LoginService(BaseService):
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the Login request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            with db.session.begin():
+
+                validated_data = LoginService.validate_data(data, LoginSchema())
+                username = validated_data.get('username')
+                password = validated_data.get('password')
+
+                member = Members.get_member_by_username(username)
+                # pass22 = generate_password_hash(password)
+                # logger.info("Password generated = >  {}".format(pass22) )
+
+                pass_check =  check_password_hash(member.password, password)
+                logger.info("Password check: {}".format(pass_check))
+                if not member or not pass_check:
+                    invalid_data = {
+                        "error_message": "invalid username or password",
+                        "message_key": "invalid_username_or_password",
+                    }
+                    return ResponseHelper.success(data=invalid_data)
+
+                user_data = {}
+                user_data["id"] = member.id,
+                user_data["member_id"]= member.id,
+                user_data["uid"] = str(member.uid),
+
+                user_token = jwt.encode(
+                        {"user": user_data, 'exp' : datetime.datetime.utcnow() + datetime.timedelta(minutes=3330)},
+                        Config.JWT_SECRET_KEY,
+                        algorithm="HS256"
+                    )
+
+                # Simulate processing
+                response_data = {
+                    "member_id": member.id,
+                    "uid":  str(member.uid),
+                    "username": member.username,
+                    "account_name": member.account_name,
+                    "firstname":member.firstname,
+                    "lastname": member.lastname,
+                    "room":  member.uid,
+                    "token": user_token
+                }
+
+                # user = {}
+                # user_data = {}
+                # user_data["id"] = result_data["member_id"]
+                # user_data["member_id"] =result_data["member_id"]
+                # user_data["uid"] = result_data["uid"]
+
+                # token should expire after 24 hrs
+                # user["token"] = jwt.encode(
+                #     {"user": user_data, 'exp' : datetime.datetime.utcnow() + datetime.timedelta(minutes=3330)},
+                #     Config.JWT_SECRET_KEY,
+                #     algorithm="HS256"
+                # )
+                # user["room"] = result_data["uid"]
+                # response_data = {
+                #     "message": "Successfully fetched auth token",
+                #     "data": user_data
+                # }
+
+                return ResponseHelper.success(data=response_data)
+
+        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()
+
+    @staticmethod
+    def check_loan_limits(customer_id):
+        """
+        Checks if a customer has exceeded the loan limits for given offer.
+        """
+        loan = Loan.get_customer_last_loan(customer_id)
+
+        if not loan:
+            return True
+
+        offer_id = loan.offer_id[:5]
+
+        offer = Offer.get_offer_by_id(offer_id)
+        if not offer:
+            logger.error(f"Offer not found for offer_id: {offer_id} (customer_id: {customer_id})")
+            return False
+
+        daily_count = Loan.get_daily_loan_count(customer_id, offer.product_id)
+
+        logger.info(f"daily_count: {daily_count}, Max: {offer.max_daily_loans}")
+
+        if offer.max_daily_loans is not None and daily_count >= offer.max_daily_loans:
+            return False
+
+        return True