Added Transaction

app/api/routes/routes.py

@@ -8,6 +8,7 @@ from app.api.services import (
     CustomerConsentService,
     NotificationCallbackService,
     AuthorizationService,
+    TransactionService,
 )
 from app.utils.logger import logger
 from app.api.middlewares import enforce_json, require_auth
@@ -20,7 +21,6 @@ from flask_jwt_extended import (
     create_refresh_token,
 )
 
-
 api = Blueprint("api", __name__)
 
 
@@ -119,6 +119,24 @@ def health_check():
     return {"status": "ok"}, 200
 
 
+# Get All Transactions Endpoint
+@api.route("/transactions", methods=["GET"])
+@jwt_required()
+def get_transactions():
+    # Extract query parameters for filtering
+    filters = {
+        'account_id': request.args.get('account_id'),
+        'type': request.args.get('type'),
+        'channel': request.args.get('channel'),
+        'start_date': request.args.get('start_date'),
+        'end_date': request.args.get('end_date')
+    }
+
+    # logger.info(f"Get transactions request received with filters: {filters}")
+    response = TransactionService.process_request(filters)
+    return response
+
+
 # Authorize endpoint
 @api.route("/Authorize", methods=["POST"])
 def authorize():

app/api/services/__init__.py

@@ -6,3 +6,4 @@ from app.api.services.repayment import RepaymentService
 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.transaction import TransactionService

app/api/services/transaction.py

@@ -0,0 +1,75 @@
+from flask import jsonify
+from app.utils.logger import logger
+from app.api.services.base_service import BaseService
+from app.models.transaction import Transaction
+from datetime import datetime
+
+
+class TransactionService(BaseService):
+    @staticmethod
+    def process_request(filters=None):
+        """
+        Process the get transactions request.
+
+        Args:
+            filters (dict, optional): Filters for the transactions query.
+
+        Returns:
+            dict: A standardized response with transactions data.
+        """
+        try:
+            if filters is None:
+                filters = {}
+
+            # Extract filters
+            account_id = filters.get('account_id')
+            transaction_type = filters.get('type')
+            channel = filters.get('channel')
+            start_date = filters.get('start_date')
+            end_date = filters.get('end_date')
+
+            # Convert string dates to datetime objects if provided
+            if start_date and isinstance(start_date, str):
+                start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            if end_date and isinstance(end_date, str):
+                end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+
+            # Get transactions with optional filters
+            transactions = Transaction.get_all_transactions(
+                account_id=account_id,
+                transaction_type=transaction_type,
+                channel=channel,
+                start_date=start_date,
+                end_date=end_date
+            )
+
+            # Convert transactions to dictionary format
+            transactions_data = []
+            for transaction in transactions:
+                transactions_data.append({
+                    'id': transaction.id,
+                    'transaction_id': transaction.transaction_id,
+                    'account_id': transaction.account_id,
+                    'type': transaction.type,
+                    'channel': transaction.channel,
+                    'created_at': transaction.created_at.isoformat(),
+                    'updated_at': transaction.updated_at.isoformat()
+                })
+
+            response_data = {
+                'status': 'success',
+                'message': 'Transactions retrieved successfully',
+                'data': {
+                    'transactions': transactions_data,
+                    'count': len(transactions_data)
+                }
+            }
+
+            return jsonify(response_data), 200
+
+        except Exception as e:
+            logger.error(f"Error retrieving transactions: {str(e)}", exc_info=True)
+            return jsonify({
+                'status': 'error',
+                'message': f'Failed to retrieve transactions: {str(e)}'
+            }), 500

app/models/offer.py

@@ -1,16 +0,0 @@
-from datetime import datetime, timezone
-from app.extensions import db
-
-class Offer(db.Model):
-    __tablename__ = 'offers'
-
-    id = db.Column(db.Integer, 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)
-    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))
-
-    def __repr__(self):
-        return f'<LoanOffer {self.id}>'

app/models/transaction.py

@@ -3,6 +3,7 @@ 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(
@@ -10,7 +11,7 @@ class Transaction(db.Model):
         primary_key=True,
         autoincrement=True,
     )
-    #id = db.Column(db.Int, primary_key=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)
@@ -27,11 +28,9 @@ class Transaction(db.Model):
         # 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():
+        if cls.query.filter(and_(cls.transaction_id == transaction_id, cls.type == type)).first():
             raise ValueError("Duplicate Transaction")
 
-
-
         transaction = cls(
             transaction_id=transaction_id,
             account_id=account_id,
@@ -50,4 +49,42 @@ class Transaction(db.Model):
 
     @classmethod
     def get_transaction_by_id(cls, transaction_id):
-        return cls.query.get(transaction_id)
+        return cls.query.get(transaction_id)
+
+    @classmethod
+    def get_all_transactions(cls, account_id=None, transaction_type=None, channel=None, start_date=None, end_date=None):
+        """
+        Get all transactions with optional filtering
+
+        Args:
+            account_id (str, optional): Filter by account ID
+            transaction_type (str, optional): Filter by transaction type
+            channel (str, optional): Filter by channel
+            start_date (datetime, optional): Filter by start date
+            end_date (datetime, optional): Filter by end date
+
+        Returns:
+            list: List of Transaction objects
+        """
+        query = cls.query
+
+        # Apply filters if provided
+        if account_id:
+            query = query.filter(cls.account_id == account_id)
+
+        if transaction_type:
+            query = query.filter(cls.type == transaction_type)
+
+        if channel:
+            query = query.filter(cls.channel == channel)
+
+        if start_date:
+            query = query.filter(cls.created_at >= start_date)
+
+        if end_date:
+            query = query.filter(cls.created_at <= end_date)
+
+        # Order by created_at descending (newest first)
+        query = query.order_by(cls.created_at.desc())
+
+        return query.all()