MermsCoreFlask/app/api/services/reports.py

from flask import session, jsonify

from app.api.schemas.report import ReportSchema
# 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 MembersProducts, Products, Members, Payments, MembersActions

# 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.register import RegisterSchema
from app.api.schemas.products import ProductsSchema
from app.api.schemas.user import UserSchema

import datetime
import jwt
import random
from app.config import Config


class ReportService(BaseService):

    @staticmethod
    def process_report_topic_request(data):
        try:
            with db.session.begin():
                logger.info(f"Incoming ReportService data  ==>>>>  {data}")
                validated_data = ReportService.validate_data(data, UserSchema())
                token = validated_data.get('token')
                uid = validated_data.get('uid')
                member_data = Members.get_member_by_uid(uid)
                member_id = member_data.id

                topics_data = ReportService.configured_report_types()
                response_data = {
                    "last_update": datetime.datetime.utcnow(),
                    "member_id": member_id,
                    "topics": topics_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 configured_report_types():
        data = {
            "topics": [
                {"name": 'Payments', "url": 'payment', "active": True, "list_order": 0},
                {"name": 'Product', "url": 'product', "active": True, "list_order": 1},
                {"name": 'System', "url": 'system', "active": True, "list_order": 2},
            ]

        }
        return data

    @staticmethod
    def process_report_topic_item(report_type, data):
        try:
            with db.session.begin():
                logger.info(f"Incoming ReportService Item Data  ==>>>>  {data}")
                validated_data = ReportService.validate_data(data, ReportSchema())
                token = validated_data.get('token')
                uid = validated_data.get('uid')
                page = validated_data.get('page')


                member_data = Members.get_member_by_uid(uid)
                member_id = member_data.id
                response_data =[]

                if report_type == "PAYMENT":
                    member_payments = Payments.get_member_payments_by_member_id(member_id)

                    member_payments_data = []

                    for t in member_payments:
                        member_payments_data.append({
                            'id': t.id,
                            'uid': t.uid,
                            'option_name': t.option_name,
                            'option_type': t.option_type,
                            'payment_uid': t.payment_uid,
                            'amount': round(t.amount * 0.01, 2),
                            'currency': '$',
                            'status': t.status,
                            'added': t.added
                        })

                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "payment": member_payments_data,
                    }

                if report_type == "PRODUCT":
                    sub_status = []

                    member_subs = MembersProducts.get_member_productlist_by_member_id(member_id)
                    for tt in member_subs:
                        sub_status.append({
                            'product_id': tt.product_id,
                            'product_name': "Name for - " + tt.product_id,
                            'added': tt.added,
                            'subscription_uid': tt.uid,
                            'status': tt.status,
                            'internal_url': tt.internal_url,
                            'dns_group': tt.dns_group,
                        })
                    logger.info(f"Member Product Sub Data ****** *****: {sub_status}")


                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "product": sub_status,
                    }

                if report_type == "SYSTEM":
                    member_actions = MembersActions.get_recent_member_actions(member_id)
                    member_actions_data = []
                    if member_actions:
                        for t in member_actions:
                            member_actions_data.append({
                                'id': t.id,
                                'uid': t.uid,
                                'member_id': t.member_id,
                                'member_uid': t.member_uid,
                                'action_label': t.action_label,
                                'action_name': t.action_name,
                                'status_description': t.status_description,
                                'status': t.status,
                                'added': t.added,
                                'updated': t.updated
                            })
                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "system": member_actions_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()