pyMt940/pymt940/CSV2MentorBtrl.py

'''Created 15 Jun 2023 Levi'''

from datetime import date
import pandas as pd
from pymt940.languages import LANG
from pymt940.utils import (get_partners, re_check, dig_it, get_last_month, find_line_number)

class PaymentsProcessorBtrl:
    def __init__(self, csv_path, partner_data, account_name=None, account_number=None,
                 currency=None, account_location=None, account_agency=None, account_symbol=None):
        self.csv_path = csv_path
        self.partner_data = partner_data
        self._account_name = account_name
        self._account_number = account_number
        self._currency = currency
        self._account_location = account_location
        self._account_agency = account_agency
        self._account_symbol = account_symbol
        self.trans_dict = None
        self.names_dict = None
        self.obs_dict = None
        self.counts = None
        self.doc_list = None
        self.unique_count = None
        self.fiscal_code_dict = None
        self.days = None

    @property
    def account_name(self):
        return self._account_name

    @account_name.setter
    def account_name(self, value):
        self._account_name = value

    @property
    def account_number(self):
        return self._account_number

    @account_number.setter
    def account_number(self, value):
        self._account_number = value

    @property
    def currency(self):
        return self._currency

    @currency.setter
    def currency(self, value):
        self._currency = value

    @property
    def account_location(self):
        return self._account_location

    @account_location.setter
    def account_location(self, value):
        self._account_location = value

    @property
    def account_agency(self):
        return self._account_agency

    @account_agency.setter
    def account_agency(self, value):
        self._account_agency = value

    @property
    def account_symbol(self):
        return self._account_symbol

    @account_symbol.setter
    def account_symbol(self, value):
        self._account_symbol = value

    def process_payment_data(self, lang=LANG.RO, day_slice=(0, 2)):
        df_dict = get_partners(self.partner_data)
        fiscal_codes = df_dict['CodFiscal']
        mentor_names = df_dict['Denumire']
        self.fiscal_code_dict = {k: v for k, v in zip(mentor_names, fiscal_codes)}

        skip_r = find_line_number(self.csv_path, 'Rezultat cautare')
        payments_df = pd.read_csv(self.csv_path, skiprows=skip_r, keep_default_na=False).astype({lang['Balance']: 'object'})
        payments_df[lang['Credit']].replace(' ', '', regex=True, inplace=True)
        payments_df[lang['Debit']].replace(' ', '', regex=True, inplace=True)

        payments_df = payments_df.loc[payments_df[lang['Debit']] != '']
        payments_df['Amount'] = payments_df[lang['Debit']].map(str).apply(dig_it).map(abs)

        self._calculate_payment_attributes(payments_df, mentor_names=mentor_names, lang=LANG.RO, day_slice=day_slice)
        return payments_df

    def process_income_data(self, lang=LANG.RO, day_slice=(0, 2)):
        df_dict = get_partners(self.partner_data)
        fiscal_codes = df_dict['CodFiscal']
        mentor_names = df_dict['Denumire']
        self.fiscal_code_dict = {k: v for k, v in zip(mentor_names, fiscal_codes)}

        skip_r = find_line_number(self.csv_path, 'Rezultat cautare')
        income_df = pd.read_csv(self.csv_path, skiprows=skip_r, keep_default_na=False).astype({lang['Balance']: 'object'})
        income_df[lang['Credit']].replace(' ', '', regex=True, inplace=True)
        income_df[lang['Debit']].replace(' ', '', regex=True, inplace=True)

        income_df = income_df.loc[income_df[lang['Credit']] != '']
        income_df['Amount'] = income_df[lang['Credit']].map(str).apply(dig_it)

        self._calculate_payment_attributes(income_df, mentor_names, lang=LANG.RO, day_slice=day_slice)
        return income_df

    def _calculate_payment_attributes(self, df, mentor_names, lang=LANG.RO, day_slice=(0, 2)):
        # df['Amount'] = df['Credit'].map(str).apply(dig_it).map(abs)
        df['Name'] = df[lang['Description']].apply(re_check)
        names = [name for name in df['Name'] if name != '']

        for name2 in names:
            index_ = name2.count(' ')
            # nname =  name2 # ' '.join(name2.split()[:index_]).upper()
            # print(name2)
            for name in mentor_names:
                # index_ = name.count(' ')
                if len(' '.join(name.split()[:index_]).upper()) < 3:
                    index_ = 2
                elif len(' '.join(name.split()[:index_]).upper()) < 2:
                    index_ = 1
                if ' '.join(name2.split()[:index_]).upper() in name.upper():
                    # print(name)
                    for index, row in df.iterrows():
                        if row['Name'] == name2:
                            df.loc[index, 'Name'] = name
        df['Transaction details'] = df[lang['Description']]
        df['day'] = df[lang['Transaction date']].str.slice(*day_slice)

        unique_count = df['day'].nunique()
        self.doc_list = list(range(1, unique_count + 1))
        days = df['day'].unique().tolist()
        self.days = days
        trans = []
        cl_names = []
        obs = []
        counts = []

        for day in days:
            values = df.loc[df['day'] == day, 'Amount'].tolist()
            trans.append(values)
        self.trans_dict = {k: v for k, v in zip(days, trans)}

        for day in days:
            values = df.loc[df['day'] == day, 'Name'].tolist()
            for ind in range(len(mentor_names)):
                index_ = mentor_names[ind].count(' ')
                mentor_names[ind] = ' '.join(mentor_names[ind].split()[:index_]).upper()
                # print(mentor_names[ind])
            for i in range(len(values)):
                # print(values[i])
                if values[i] not in mentor_names:
                    values[i] = ''
            cl_names.append(values)
        self.names_dict = {k: v for k, v in zip(days, cl_names)}
        # print(self.names_dict)

        for day in days:
            values = df.loc[df['day'] == day, 'Transaction details'].tolist()
            obs.append(values)
        self.obs_dict = {k: v for k, v in zip(days, obs)}

        for day in days:
            value_counts = df['day'].value_counts()
            count_of_value = value_counts[day]
            counts.append(count_of_value)
        self.counts = counts
        self.unique_count = unique_count

    def to_dict(self, kind: str, month_back: int, std_client: str, acc_symbol: int):
        kinds = ['TotalIncasari', 'TotalPlati']
        if kind not in kinds:
            raise TypeError(f'type not in {kinds}')
        else:
            data = {'AnLucru': date.today().year,
                    'LunaLucru': get_last_month(month_back),
                    'TotalDocumente': self.unique_count,
                    'documents': self.doc_list,
                    'AccountName': self.account_name,
                    'AccountSymbol': self.account_symbol,
                    'AccountNumber': self.account_number,
                    'AccountLocation': self.account_location,
                    'AccountAgencyLocation': self.account_agency,
                    'Currency': self.currency,
                    'days': self.days,
                    kind: self.counts,
                    'incasari': self.counts,
                    'clients': self.names_dict,
                    'cods': self.fiscal_code_dict,
                    'amount': self.trans_dict,
                    'cont': acc_symbol,
                    'std_client': std_client,
                    'obs': self.obs_dict
                    }
            return data