Untitled

 avatar
unknown
plain_text
5 months ago
59 kB
5
Indexable
import os
import pandas as pd
import datetime as dt
import numpy as np
from openpyxl import Workbook
from openpyxl.styles import PatternFill

dirreport = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

ltmp = os.listdir(dirreport)
l = [k for k in ltmp if "Lista" in k]
Euronet1 = pd.DataFrame()

for i in range(0, len(l)):
    print("Plik:", l[i])
    print(dt.datetime.now())
    tableResults = pd.read_excel(dirreport + l[i], sheet_name='Rozliczenie PayU', usecols='B:F', skiprows=2)
    Euronet1 = pd.concat([pd.DataFrame(tableResults), Euronet1], axis=0, ignore_index=True)
Euronet1.columns = ['Magazyn', 'LoanNo', 'LoanDate', 'LoanRepDate', 'LoanAmount']

indexNames = Euronet1[(pd.isnull(Euronet1['LoanNo']) == True)].index
Euronet1.drop(indexNames, inplace=True)

l = [k for k in ltmp if "EURONET_" in k]
Payu1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResults = pd.read_csv(dirreport + l[i], sep=";")
    Payu1 = pd.concat([pd.DataFrame(tableResults), Payu1], axis=0, ignore_index=True)
Payu1.columns = ['VARIANT','PROVIDER_ID','FIRM_ID','CRO_AMOUNT','INSTALLMENTS_NUMBER','SHOP_ID','AGREEMENT','TRANS_DATE',\
                 'TRANS_ID','TRANS_DESC','FSU_URL']
Payu1['CRO_AMOUNT'] = Payu1['CRO_AMOUNT'] / 100

Diff = pd.merge(left=Euronet1, right=Payu1, how='outer', left_on='LoanNo', right_on='TRANS_DESC')


Diff['DiffAmount'] = Diff['LoanAmount'] - Diff['CRO_AMOUNT']

print(Diff)

Smartney = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

Smartlista = os.listdir(dirreport)
l = [k for k in Smartlista if "Loan_T" in k]

Smartney1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsS = pd.read_excel(Smartney + l[i], sheet_name='rozliczenie', usecols='A:L', skiprows=0)
    Smartney1 = pd.concat([pd.DataFrame(tableResultsS), Smartney1], axis=0, ignore_index=True)
Smartney1.columns = ['loan_no', 'product_type', 'transaction_id', 'parter_id', 'loan_start_date',
                   'loan_amount_gross', 'loan_duration_months', 'loan_installments', 'percentage_commission',
                   'commission_payable_to_payu', 'subsidy_fee_rate','total_subsidy']

DiffS = pd.merge(left=Diff, right=Smartney1, how='inner', left_on='AGREEMENT', right_on='loan_no')

Inbank = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

Inbanklista = os.listdir(dirreport)
l = [k for k in Inbanklista if "Loan_N" in k]

Inbank1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsI = pd.read_excel(Inbank + l[i], sheet_name='PayU_Loan_NewTransactions', usecols='B:P', skiprows=1)
    Inbank1 = pd.concat([pd.DataFrame(tableResultsI), Inbank1], axis=0, ignore_index=True)
Inbank1.columns = ['loan_no', 'product_type', 'transaction_id', 'parter_id', 'acc_no', 'loan_start_date',
                   'loan_amount_gross', 'loan_amount_net', 'loan_duration_months', 'loan_installments','customer_type','percentage_commission',
                   'commission_payable_to_payu', 'subsidy_fee_rate','total_subsidy']
del Inbank1['acc_no']
del Inbank1['loan_amount_net']
del Inbank1['customer_type']


DiffI = pd.merge(left=Diff, right=Inbank1, how='inner', left_on='AGREEMENT', right_on='loan_no')

DiffComplete = pd.concat([DiffS,DiffI], axis=0,ignore_index=True)

stawki = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

stawkilista = os.listdir(dirreport)
l = [k for k in stawkilista if "Stawki1" in k]

stawki1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsU = pd.read_excel(stawki + l[i], sheet_name='Sheet1', usecols='A:C', skiprows=0)
    stawki1 = pd.concat([pd.DataFrame(tableResultsU), stawki1], axis=0, ignore_index=True)
stawki1.columns = ['VARIANT', 'wynagrodzenie dla Euronet', 'wynagrodzenie dla Euronet2']

print(stawki1)
stawki2 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsY = pd.read_excel(stawki + l[i], sheet_name='Sheet2', usecols='A:D', skiprows=0)
    stawki2 = pd.concat([pd.DataFrame(tableResultsY), stawki1], axis=0, ignore_index=True)

euronet_standard = 'EURONET1_STANDARD_1'
euronet_standard25 = 'EURONET1_STANDARD_1_25'
standard1250 = 'STANDARD_12_50'
standard1250LOOP='EURONET1_STANDARD_1_25_LOOP'
euronet_standard2 = 'EURONET2_STANDARD_1_25_LOOP'
euronet_standard225 = 'EURONET2_STANDARD_1_25'
euronet_zero = 'EURONET1_ZERO'
euronet_zero2 = 'EURONET2_ZERO'
zero336 = 'ZERO_3_36'
euronet_zero_loop = 'EURONET1_ZERO_LOOP'
euronet_standard_loop = 'EURONET1_STANDARD_1_LOOP'
euronet_zero_loop2 = 'EURONET2_ZERO_LOOP'
euronet_standard_loop2 = 'EURONET2_STANDARD_1_LOOP'

value_to_assign = stawki1.loc[stawki1['VARIANT'] == euronet_standard, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign2 = stawki1.loc[stawki1['VARIANT'] == euronet_standard25, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign3 = stawki1.loc[stawki1['VARIANT'] == standard1250, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign4 = stawki1.loc[stawki1['VARIANT'] == standard1250LOOP, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign5 = stawki1.loc[stawki1['VARIANT'] == euronet_standard2, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign6 = stawki1.loc[stawki1['VARIANT'] == euronet_standard225, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign7 = stawki1.loc[stawki1['VARIANT'] == euronet_zero, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign8 = stawki1.loc[stawki1['VARIANT'] == euronet_zero2, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign9 = stawki1.loc[stawki1['VARIANT'] == zero336, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign10 = stawki1.loc[stawki1['VARIANT'] == euronet_zero_loop, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign11 = stawki1.loc[stawki1['VARIANT'] == euronet_standard_loop, 'wynagrodzenie dla Euronet'].values[0]
value_to_assign12 = stawki1.loc[stawki1['VARIANT'] == euronet_zero_loop2, 'wynagrodzenie dla Euronet'].values[0]



#określenie stawki za płatność
wynagrodzenie_euronet_standard = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign
wynagrodzenie_euronet_standard25 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO (%) raty regularne'] =value_to_assign2
wynagrodzenie_standard1250 = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign3
wynagrodzenie_standard1250LOOP = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign4
wynagrodzenie_euronet_standard2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign5
wynagrodzenie_euronet_standard225 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign6
wynagrodzenie_euronet_zero = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign7
wynagrodzenie_euronet_zero2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign8
wynagrodzenie_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign9
wynagrodzenie_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign10
wynagrodzenie_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign11
wynagrodzenie_euronet_zero_loop2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO (%) raty regularne'] = value_to_assign12
#Przeliczanie prowizji dla euronetu
wngrfin_euronet_standard = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_standard

wngrfin_euronet_standard25 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_standard25

wngrfin_standard1250 = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_standard1250

wngrfin_standard1250LOOP = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_standard1250LOOP

wngrfin_euronet_standard2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_standard2

wngrfin_euronet_standard225 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_standard225

wngrfin_euronet_zero = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_zero

wngrfin_euronet_zero2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_zero2

wngrfin_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_zero336

wngrfin_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_zero_loop

wngrfin_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_standard_loop

wngrfin_euronet_zero_loop2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO Value'] \
    = DiffComplete['LoanAmount'].astype(float) * wynagrodzenie_euronet_zero_loop2



mask1 = ((DiffComplete['loan_installments'] >= 1) & (DiffComplete['loan_installments'] <=4)) \
        & ((DiffComplete['VARIANT'] == 'EURONET1_ZERO'))

mask2 = ((DiffComplete['loan_installments'] >= 5) & (DiffComplete['loan_installments'] <=9)) \
        & (DiffComplete['VARIANT'] == 'EURONET1_ZERO')

mask3 = ((DiffComplete['loan_installments'] >= 10) & (DiffComplete['loan_installments'] <= 14)) \
        & ((DiffComplete['VARIANT'] == 'EURONET1_ZERO'))

mask4 = ((DiffComplete['loan_installments'] >= 15) & (DiffComplete['loan_installments'] <= 19)) \
        & ((DiffComplete['VARIANT'] == 'EURONET1_ZERO'))

mask5 = ((DiffComplete['loan_installments'] >= 20) & (DiffComplete['loan_installments'] <= 24)) \
        & ((DiffComplete['VARIANT'] == 'EURONET1_ZERO'))

mask6 = ((DiffComplete['loan_installments'] >= 25) & (DiffComplete['loan_installments'] <= 100)) \
        & ((DiffComplete['VARIANT'] == 'EURONET1_ZERO'))

mask7 = ((DiffComplete['loan_installments'] >= 1) & (DiffComplete['loan_installments'] <=9)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

mask8 = ((DiffComplete['loan_installments'] >= 10) & (DiffComplete['loan_installments'] <=14)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

mask9 = ((DiffComplete['loan_installments'] >= 15) & (DiffComplete['loan_installments'] <= 19)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

mask10 = ((DiffComplete['loan_installments'] >= 20) & (DiffComplete['loan_installments'] <= 25)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

mask11 = ((DiffComplete['loan_installments'] >= 26) & (DiffComplete['loan_installments'] <= 30)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

mask12 = ((DiffComplete['loan_installments'] >= 30) & (DiffComplete['loan_installments'] <= 100)) \
        & ((DiffComplete['VARIANT'] == 'EURONET2_ZERO'))

value_to_assignZERO = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO5-15', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO3 = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO15-20', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO4 = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO20-24', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO5 = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO24-30', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO6 = stawki2.loc[stawki2['VARIANT'] == 'EURONET1_ZERO30', 'wynagrodzenie dla PayU'].values[0]

value_to_assignZEROT2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO2T2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO5-15', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO3T2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO15-20', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO4T2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO20-24', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO5T2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO24-30', 'wynagrodzenie dla PayU'].values[0]
value_to_assignZERO6T2 = stawki2.loc[stawki2['VARIANT'] == 'EURONET2_ZERO30', 'wynagrodzenie dla PayU'].values[0]

DiffComplete.loc[mask1, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO

DiffComplete.loc[mask2, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO2

DiffComplete.loc[mask3, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO3

DiffComplete.loc[mask4, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO4

DiffComplete.loc[mask5, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO5

DiffComplete.loc[mask6, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO6

DiffComplete.loc[mask7, 'wynagrodzenie_euronet_zero'] = value_to_assignZEROT2

DiffComplete.loc[mask8, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO2T2

DiffComplete.loc[mask9, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO3T2

DiffComplete.loc[mask10, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO4T2

DiffComplete.loc[mask11, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO5T2

DiffComplete.loc[mask12, 'wynagrodzenie_euronet_zero'] = value_to_assignZERO6T2


DiffComplete.loc[(DiffComplete['VARIANT'] == 'EURONET1_ZERO') | (DiffComplete['VARIANT'] == 'EURONET2_ZERO'), 'Wynagrodzenie PayU (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * DiffComplete['wynagrodzenie_euronet_zero']

DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero2, 'Wynagrodzenie PayU (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * DiffComplete['wynagrodzenie_euronet_zero']

value_to_assignZEROPayU = stawki2.loc[stawki2['VARIANT'] == 'ZERO_3_36', 'wynagrodzenie dla PayU'].values[0]

wngrpayu0_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'wynagrodzenie_euronet_zero'] = value_to_assignZEROPayU
wngrpayu0_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'wynagrodzenie_euronet_zero'] = 0.0
wngrpayu0_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'wynagrodzenie_euronet_zero'] = value_to_assignZEROPayU

wngrpayufin_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'Wynagrodzenie PayU (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu0_zero336

wngrpayufin_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie PayU (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu0_euronet_zero_loop

wngrpayufin_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie PayU (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu0_euronet_standard_loop
#wynagrodzenie za raty 0% euronet
wngrpayu_euronet_standard = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_euronet_standard25 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_standard1250 = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_standard1250LOOP = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_euronet_standard2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_euronet_standard225 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_euronet_zero = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%) raty0%'] = 0.006
wngrpayu_euronet_zero2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%) raty0%'] = 0.006
wngrpayu_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'Wynagrodzenie EURO (%) raty0%'] = 0.006
wngrpayu_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%) raty0%'] = 0
wngrpayu_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%) raty0%'] = 0

#wynagrodzenie za raty 0% euronet
wngrfinPayU_euronet_standard = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_standard

wngrfinPayU_euronet_standard25 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_standard25

wngrfinPayU_standard1250 = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_standard1250

wngrfinPayU_standard1250LOOP = DiffComplete.loc[DiffComplete['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_standard1250LOOP

wngrfinPayU_euronet_standard2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_standard2

wngrfinPayU_euronet_standard225 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_standard225

wngrfinPayU_euronet_zero = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_zero

wngrfinPayU_euronet_zero2 = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_zero2

wngrfinPayU_zero336 = DiffComplete.loc[DiffComplete['VARIANT'] == zero336, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_zero336

wngrfinPayU_euronet_zero_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_zero_loop

wngrfinPayU_euronet_standard_loop = DiffComplete.loc[DiffComplete['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%)'] \
    = DiffComplete['LoanAmount'].astype(float) * wngrpayu_euronet_standard_loop

DiffCompleteFinal = DiffComplete[(DiffComplete['DiffAmount'] != 0)]
DiffComplete['Wynagrodzenie EURO (%)'] = DiffComplete['Wynagrodzenie EURO (%)'].round(2)
DiffComplete['Wynagrodzenie PayU (%)'] = DiffComplete['Wynagrodzenie PayU (%)'].round(2)
DiffComplete['Wynagrodzenie EURO Value'] = DiffComplete['Wynagrodzenie EURO Value'].round(2)
arkuszglowny = DiffComplete
print(len(arkuszglowny))

del arkuszglowny['PROVIDER_ID']
del arkuszglowny['FIRM_ID']
del arkuszglowny['SHOP_ID']
del arkuszglowny['AGREEMENT']
del arkuszglowny['TRANS_DATE']
del arkuszglowny['TRANS_DESC']
del arkuszglowny['loan_no']
del arkuszglowny['product_type']
del arkuszglowny['parter_id']
del arkuszglowny['loan_start_date']
del arkuszglowny['loan_amount_gross']
del arkuszglowny['Magazyn']
del arkuszglowny['LoanRepDate']
del DiffComplete['TRANS_ID']
del DiffComplete['transaction_id']
del DiffComplete['loan_duration_months']
del DiffComplete['loan_installments']
del DiffComplete['subsidy_fee_rate']
del DiffComplete['total_subsidy']
del DiffComplete['percentage_commission']
del DiffComplete['commission_payable_to_payu']
del DiffComplete['CRO_AMOUNT']
del DiffComplete['DiffAmount']

DiffComplete.columns = ['Numer Zamówienia', 'Data Zamówienia', 'Wartość zamówienia (brutto)', 'Opcja pożyczki', 'Liczba rat',\
                        'Serwis','Wynagrodzenie EURO (%) raty regularne','Wynagrodzenie EURO (netto PLN)raty regularne','Wynagrodzenie PayU (%)', \
                        'Wynagrodzenie PayU','Wynagrodzenie EURO (%) raty0%', 'Wynagrodzenie EURO raty 0%']
DiffComplete['Pożyczkodawca'] = np.where(DiffComplete.index < len(DiffS), 'Raty Smartney (insm)', 'Raty InBank (inb)')
DiffComplete.drop_duplicates(subset=['Numer Zamówienia'], keep='first')

columnDiff = DiffComplete.pop('Pożyczkodawca')
DiffComplete.insert(6, 'Pożyczkodawca', columnDiff)

prevmonlist = os.listdir(dirreport)

l = [k for k in ltmp if "PREVIOUS" in k]
prevmon1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsP = pd.read_csv(dirreport + l[i], sep=";")
    prevmon1 = pd.concat([pd.DataFrame(tableResultsP), prevmon1], axis=0, ignore_index=True)
prevmon1.columns = ['VARIANT', 'PROVIDER', 'trans_firm_id', 'kwota_gr','INSTALLMENTS_NUMBER','TRANS_SHOP_ID', \
                    'agreement', 'data','TRANS_ID','TRANS_DESC','FSU_URL']

prevmonlist2 = os.listdir(dirreport)

l = [k for k in ltmp if "PREVIOUS2" in k]
prevmon2 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsP2 = pd.read_csv(dirreport + l[i], sep=";")
    prevmon2 = pd.concat([pd.DataFrame(tableResultsP2), prevmon2], axis=0, ignore_index=True)
prevmon2.columns = ['VARIANT', 'PROVIDER', 'trans_firm_id', 'kwota_gr','INSTALLMENTS_NUMBER','TRANS_SHOP_ID', \
                    'agreement', 'data','TRANS_ID','TRANS_DESC','FSU_URL']

prevmonlist2 = os.listdir(dirreport)

l = [k for k in ltmp if "PREVIOUS3" in k]
prevmon3 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsP3 = pd.read_csv(dirreport + l[i], sep=";")
    prevmon3 = pd.concat([pd.DataFrame(tableResultsP3), prevmon3], axis=0, ignore_index=True)
prevmon3.columns = ['VARIANT', 'PROVIDER', 'trans_firm_id', 'kwota_gr','INSTALLMENTS_NUMBER','TRANS_SHOP_ID', \
                    'agreement', 'data','TRANS_ID','TRANS_DESC','FSU_URL']

prevmon= pd.concat([prevmon1, prevmon2, prevmon3])

canctrans = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

canctranslist = os.listdir(dirreport)
l = [k for k in canctranslist if "Loan_C" in k]

canctrans1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsI = pd.read_excel(canctrans + l[i], sheet_name='PayU_Loan_CanceledTransactions', usecols='A:K', skiprows=0)
    canctrans1 = pd.concat([pd.DataFrame(tableResultsI), canctrans1], axis=0, ignore_index=True)
canctrans1.columns = ['loan_no','product_type','parter_id', 'acc_no', 'loan_start_date', 'loan_amount_net',
                      'loan_installments', 'loan_cancel', 'cancel_date', 'commission_payable_to_payu', 'decr_subsidy']

del canctrans1['product_type']
del canctrans1['acc_no']
del canctrans1['loan_cancel']
del canctrans1['decr_subsidy']
del canctrans1['commission_payable_to_payu']


stawkilista1 = os.listdir(dirreport)
l = [k for k in stawkilista1 if "Stawki3" in k]

stawki3 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsXYZ = pd.read_excel(stawki + l[i], sheet_name='Sheet1', usecols='A:C', skiprows=0)
    stawki3 = pd.concat([pd.DataFrame(tableResultsXYZ), stawki3], axis=0, ignore_index=True)
stawki3.columns = ['VARIANT', 'wynagrodzenie dla Euronet', 'wynagrodzenie dla Euronet2']

prevvalue_to_assign = stawki3.loc[stawki3['VARIANT'] == euronet_standard, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign2 = stawki3.loc[stawki3['VARIANT'] == euronet_standard25, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign3 = stawki3.loc[stawki3['VARIANT'] == standard1250, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign4 = stawki3.loc[stawki3['VARIANT'] == standard1250LOOP, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign5 = stawki3.loc[stawki3['VARIANT'] == euronet_standard2, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign6 = stawki3.loc[stawki3['VARIANT'] == euronet_standard225, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign7 = stawki3.loc[stawki3['VARIANT'] == euronet_zero, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign8 = stawki3.loc[stawki3['VARIANT'] == euronet_zero2, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign9 = stawki3.loc[stawki3['VARIANT'] == zero336, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign10 = stawki3.loc[stawki3['VARIANT'] == euronet_zero_loop, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign11 = stawki3.loc[stawki3['VARIANT'] == euronet_standard_loop, 'wynagrodzenie dla Euronet'].values[0]
prevvalue_to_assign12 = stawki3.loc[stawki3['VARIANT'] == euronet_zero_loop2, 'wynagrodzenie dla Euronet'].values[0]


prevwynagrodzenie_euronet_standard = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign
prevwynagrodzenie_euronet_standard25 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign2
prevwynagrodzenie_standard1250 = canctrans1.loc[prevmon1['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign3
prevwynagrodzenie_standard1250LOOP = canctrans1.loc[prevmon1['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign4
prevwynagrodzenie_euronet_standard2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign5
prevwynagrodzenie_euronet_standard225 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign6
prevwynagrodzenie_euronet_zero = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign7
prevwynagrodzenie_euronet_zero2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign8
prevwynagrodzenie_zero336 = canctrans1.loc[prevmon1['VARIANT'] == zero336, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign9
prevwynagrodzenie_euronet_zero_loop = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign10
prevwynagrodzenie_euronet_standard_loop = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign11
prevwynagrodzenie_euronet_zero_loop2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign12

wngrfin_euronet_standard = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_standard

wngrfin_euronet_standard25 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_standard25

wngrfin_standard1250 = canctrans1.loc[prevmon1['VARIANT'] == standard1250, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_standard1250

wngrfin_standard1250LOOP = canctrans1.loc[prevmon1['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_standard1250LOOP

wngrfin_euronet_standard2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_standard2

wngrfin_euronet_standard225 = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_standard225

wngrfin_euronet_zero = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_zero

wngrfin_euronet_zero2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevvalue_to_assign7

wngrfin_zero336 = canctrans1.loc[prevmon1['VARIANT'] == zero336, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevvalue_to_assign8

wngrfin_euronet_zero_loop = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevvalue_to_assign9

wngrfin_euronet_standard_loop = canctrans1.loc[prevmon1['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevvalue_to_assign10

wngrfin_euronet_zero_loop2 = canctrans1.loc[prevmon1['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO Value'] \
    = canctrans1['loan_amount_net'].astype(float) * prevwynagrodzenie_euronet_zero_loop2


stawki4 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsXY = pd.read_excel(stawki + l[i], sheet_name='Sheet2', usecols='A:D', skiprows=0)
    stawki4 = pd.concat([pd.DataFrame(tableResultsXY), stawki4], axis=0, ignore_index=True)
stawki4.columns = ['VARIANT', 'liczba rat', 'pomocnicza', 'wynagrodzenie dla PayU' ]


svalue_to_assignZERO = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO5-15', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO3 = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO15-20', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO4 = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO20-24', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO5 = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO24-30', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO6 = stawki4.loc[stawki4['VARIANT'] == 'EURONET1_ZERO30', 'wynagrodzenie dla PayU'].values[0]

svalue_to_assignZEROT2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO2T2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO5-15', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO3T2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO15-20', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO4T2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO20-24', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO5T2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO24-30', 'wynagrodzenie dla PayU'].values[0]
svalue_to_assignZERO6T2 = stawki4.loc[stawki4['VARIANT'] == 'EURONET2_ZERO30', 'wynagrodzenie dla PayU'].values[0]



odstinb = pd.merge(left=canctrans1, right=prevmon1, how='inner', left_on='loan_no', right_on='agreement')
print(odstinb)
inbwngrfin_euronet_standard = odstinb.loc[odstinb['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign

inbwngrfin_euronet_standard25 = odstinb.loc[odstinb['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign2

inbwngrfin_standard1250 = odstinb.loc[odstinb['VARIANT'] == standard1250, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign3

inbwngrfin_standard1250LOOP = odstinb.loc[odstinb['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign4

inbwngrfin_euronet_standard2 = odstinb.loc[odstinb['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign5

inbwngrfin_euronet_standard225 = odstinb.loc[odstinb['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign6

inbwngrfin_euronet_zero = odstinb.loc[odstinb['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign7

inbwngrfin_euronet_zero2 = odstinb.loc[odstinb['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign8

inbwngrfin_zero336 = odstinb.loc[odstinb['VARIANT'] == zero336, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign9

inbwngrfin_euronet_zero_loop = odstinb.loc[odstinb['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign10

inbwngrfin_euronet_standard_loop = odstinb.loc[odstinb['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign11

inbwngrfin_euronet_zero_loop2 = odstinb.loc[odstinb['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign12

smask1 = ((odstinb['loan_installments'] >= 1) & (odstinb['loan_installments'] <=4)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

smask2 = ((odstinb['loan_installments'] >= 5) & (odstinb['loan_installments'] <=9)) \
        & (prevmon1['VARIANT'] == 'EURONET1_ZERO')

smask3 = ((odstinb['loan_installments'] >= 10) & (odstinb['loan_installments'] <= 14)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

smask4 = ((odstinb['loan_installments'] >= 15) & (odstinb['loan_installments'] <= 19)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

smask5 = ((odstinb['loan_installments'] >= 20) & (odstinb['loan_installments'] <= 24)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

smask6 = ((odstinb['loan_installments'] >= 25) & (odstinb['loan_installments'] <= 100)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

smask7 = ((odstinb['loan_installments'] >= 1) & (odstinb['loan_installments'] <=9)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

smask8 = ((odstinb['loan_installments'] >= 10) & (odstinb['loan_installments'] <=14)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

smask9 = ((odstinb['loan_installments'] >= 15) & (odstinb['loan_installments'] <= 19)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

smask10 = ((odstinb['loan_installments'] >= 20) & (odstinb['loan_installments'] <= 25)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

smask11 = ((odstinb['loan_installments'] >= 26) & (odstinb['loan_installments'] <= 30)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

smask12 = ((odstinb['loan_installments'] >= 30) & (odstinb['loan_installments'] <= 100)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

if not odstinb.empty:

    odstinb.loc[smask1, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO

    odstinb.loc[smask2, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO2

    odstinb.loc[smask3, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO3

    odstinb.loc[smask4, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO4

    odstinb.loc[smask5, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO5

    odstinb.loc[smask6, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO6

    odstinb.loc[smask7, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZEROT2

    odstinb.loc[smask8, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO2T2

    odstinb.loc[smask9, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO3T2

    odstinb.loc[smask10, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO4T2

    odstinb.loc[smask11, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO5T2

    odstinb.loc[smask12, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO6T2

    odstinb.loc[odstinb['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO Value3'] \
    = odstinb['loan_amount_net'].astype(float) * prevvalue_to_assign10

    odstinb.loc[(prevmon1['VARIANT'] == 'EURONET1_ZERO') | (prevmon1['VARIANT'] == 'EURONET2_ZERO'), 'Wynagrodzenie PayU (%)'] \
    = odstinb['loan_amount_net'].astype(float) * odstinb['wynagrodzenie_euronet_zero']

    odstinb.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie PayU (%)'] \
    = odstinb['loan_amount_net'].astype(float) * odstinb['wynagrodzenie_euronet_zero']

    odstinb.loc[odstinb['parter_id'] == 89762, 'Pożyczkodawca'] = 'Raty Smartney'
    odstinb.loc[odstinb['parter_id'] == 75438, 'Pożyczkodawca'] = 'Raty InBank'


    prevwynagrodzenie_euronet_standard = odstinb.loc[odstinb['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign
    prevwynagrodzenie_euronet_standard25 = odstinb.loc[odstinb['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign2
    prevwynagrodzenie_standard1250 = odstinb.loc[odstinb['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign3
    prevwynagrodzenie_standard1250LOOP = odstinb.loc[odstinb['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign4
    prevwynagrodzenie_euronet_standard2 = odstinb.loc[odstinb['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign5
    prevwynagrodzenie_euronet_standard225 = odstinb.loc[odstinb['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign6
    prevwynagrodzenie_euronet_zero = odstinb.loc[odstinb['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign7
    prevwynagrodzenie_euronet_zero2 = odstinb.loc[odstinb['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign8
    prevwynagrodzenie_zero336 = odstinb.loc[odstinb['VARIANT'] == zero336, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign9
    prevwynagrodzenie_euronet_zero_loop = odstinb.loc[odstinb['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign10
    prevwynagrodzenie_euronet_standard_loop = odstinb.loc[odstinb['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign11
    prevwynagrodzenie_euronet_zero_loop2 = odstinb.loc[odstinb['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO (%) raty regularne'] = prevvalue_to_assign12


    del odstinb['Wynagrodzenie EURO Value']
    del odstinb['PROVIDER']
    del odstinb['trans_firm_id']
    del odstinb['kwota_gr']
    del odstinb['INSTALLMENTS_NUMBER']
    del odstinb['TRANS_SHOP_ID']
    del odstinb['TRANS_ID']
    del odstinb['TRANS_DESC']
    del odstinb['parter_id']
    del odstinb['agreement']

    column = odstinb.pop('data')
    odstinb.insert(2, 'data', column)
    column2 = odstinb.pop('Wynagrodzenie EURO (%) raty regularne')
    odstinb.insert(9,'Wynagrodzenie EURO (%) raty regularne', column2)
    column3 = odstinb.pop('cancel_date')
    odstinb.insert(12,'cancel_date',column3)
    column4 = odstinb.pop('FSU_URL')
    odstinb.insert(8,'FSU_URL',column4)
    warunek = ~odstinb['VARIANT'].isin(['EURONET1_ZERO', 'EURONET2_ZERO'])
    odstinb.loc[warunek,'wynagrodzenie_euronet_zero'] = 0
    odstinb.loc[odstinb['wynagrodzenie_euronet_zero'] == 0,'Wynagrodzenie PayU (%)'] = 0

    odstinb = odstinb[['loan_no','loan_start_date','data','loan_amount_net','loan_installments','VARIANT','Wynagrodzenie EURO (%) raty regularne'
                   ,'Wynagrodzenie EURO Value3','FSU_URL','Pożyczkodawca','wynagrodzenie_euronet_zero','Wynagrodzenie PayU (%)',
                   'cancel_date']]
    odstinb.columns = ['Numer zamówienia','Data Zamówienia','Data zapłaty za zamówienie','Wartość zamówienia (brutto)','Liczba rat',
                   'Opcja pożyczki','Wynagrodzenie EURO (%) raty regularne','Wynagrodzenie EURO (netto PLN)raty regularne',
                   'Serwis', 'Pożyczkodawca','Wynagrodzenie EURO (%) raty0%','Wynagrodzenie EURO raty 0%(netto PLN)',
                   'Data odstąpienia']
else:
    print("DataFrame is empty. No operation performed.")

odstsmrt = "C:\\Users\\RafalBukowski\\OneDrive - PayU\\Desktop\pyautomat3\\"

odstsmrtlist = os.listdir(dirreport)
l = [k for k in odstsmrtlist if "Smartney" in k]

odstsmrt1 = pd.DataFrame()
for i in range(0, len(l)):
    tableResultsI = pd.read_excel(odstsmrt + l[i], sheet_name='dane', usecols='A:P', skiprows=0)
    odstsmrt1 = pd.concat([pd.DataFrame(tableResultsI), odstsmrt1], axis=0, ignore_index=True)

wngrfinPayU_zero336odst = odstsmrt1.loc[odstsmrt1['id sklepu'] == 89762, 'Wynagrodzenie EURO (%)'] \
    = odstsmrt1['kwota brutto pozyczki'].astype(float) * 0.006

wngrfinPayU_euronet_zero_loopodst = odstsmrt1.loc[odstsmrt1['id sklepu'] == 75438, 'Wynagrodzenie EURO (%)'] \
    = odstsmrt1['kwota brutto pozyczki'].astype(float) * 0.006

odstsmrt1['Wynagrodzenie EURO (%)'] = odstsmrt1['Wynagrodzenie EURO (%)'].round(2)
odstsmrt1['Pożyczkodawca'] = 'Raty Smartney(insm)'
masksmrt = (odstsmrt1['id sklepu'] != 89762) & (odstsmrt1['id sklepu'] != 75438)
odstsmrt1 = odstsmrt1[~masksmrt]

del odstsmrt1['app_product_type']
del odstsmrt1['nazwa produktu']
del odstsmrt1['id wniosku']
del odstsmrt1['id sklepu']
del odstsmrt1['liczba rat']
del odstsmrt1['loan_status']

odstsmrt1.columns = ['Numer zamówienia', 'Data Zamówienia','Wartość zamównienia (brutto)','kwota netto pozyczki', 'Liczba rat', \
                     'Wynagrodzenie EURO (%) raty regularne', 'Wynagrodzenie EURO (netto PLN) raty regularne', \
                     'Wynagrodzenie EURO (%) raty0%', 'Wynagrodzenie EURO raty 0% (netto PLN)','Data odstąpienia', \
                     'Wynagrodzenie PayU (%)','Pożyczkodawca']

odstsmrtcomb= pd.merge(left=odstsmrt1, right=prevmon1, how='inner', left_on='Numer zamówienia', right_on='agreement')
odstsmrtcomb2= pd.merge(left=odstsmrt1, right=prevmon2, how='inner', left_on='Numer zamówienia', right_on='agreement')
odstsmrtcomb3= pd.merge(left=odstsmrt1, right=prevmon3, how='inner', left_on='Numer zamówienia', right_on='agreement')

umask1 = ((odstsmrtcomb['Liczba rat'] >= 1) & (odstsmrtcomb['Liczba rat'] <=4)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

umask2 = ((odstsmrtcomb['Liczba rat'] >= 5) & (odstsmrtcomb['Liczba rat'] <=9)) \
        & (prevmon1['VARIANT'] == 'EURONET1_ZERO')

umask3 = ((odstsmrtcomb['Liczba rat'] >= 10) & (odstsmrtcomb['Liczba rat'] <= 14)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

umask4 = ((odstsmrtcomb['Liczba rat'] >= 15) & (odstsmrtcomb['Liczba rat'] <= 19)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

umask5 = ((odstsmrtcomb['Liczba rat'] >= 20) & (odstsmrtcomb['Liczba rat'] <= 24)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

umask6 = ((odstsmrtcomb['Liczba rat'] >= 25) & (odstsmrtcomb['Liczba rat'] <= 100)) \
        & ((prevmon1['VARIANT'] == 'EURONET1_ZERO'))

umask7 = ((odstsmrtcomb['Liczba rat'] >= 1) & (odstsmrtcomb['Liczba rat'] <=9)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

umask8 = ((odstsmrtcomb['Liczba rat'] >= 10) & (odstsmrtcomb['Liczba rat'] <=14)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

umask9 = ((odstsmrtcomb['Liczba rat'] >= 15) & (odstsmrtcomb['Liczba rat'] <= 19)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

umask10 = ((odstsmrtcomb['Liczba rat'] >= 20) & (odstsmrtcomb['Liczba rat'] <= 21)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

umask11 = ((odstsmrtcomb['Liczba rat'] >= 22) & (odstsmrtcomb['Liczba rat'] <= 24)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))

umask12 = ((odstsmrtcomb['Liczba rat'] >= 25) & (odstsmrtcomb['Liczba rat'] <= 100)) \
        & ((prevmon1['VARIANT'] == 'EURONET2_ZERO'))


swngrfin_euronet_standard = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_standard

swngrfin_euronet_standard25 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard25, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_standard25

swngrfin_standard1250 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == standard1250, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_standard1250

swngrfin_standard1250LOOP = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_standard1250LOOP

swngrfin_euronet_standard2 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_standard2

swngrfin_euronet_standard225 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_standard225

swngrfin_euronet_zero = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_zero

swngrfin_euronet_zero2 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_zero2

swngrfin_zero336 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == zero336, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_zero336

swngrfin_euronet_zero_loop = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_zero_loop

swngrfin_euronet_standard_loop = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_standard_loop

swngrfin_euronet_zero_loop2 = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO Value'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * prevwynagrodzenie_euronet_zero_loop2

#### TEST #######

swngrfin_euronet_standardodst = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_standard

swngrfin_euronet_standard25odst = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard25, 'WWynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_standard25

swngrfin_standard1250odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == standard1250, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_standard1250

swngrfin_standard1250LOOPodst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == standard1250LOOP, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_standard1250LOOP

swngrfin_euronet_standard2odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard2, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_standard2

swngrfin_euronet_standard225odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard225, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_standard225

swngrfin_euronet_zeroodst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_zero

swngrfin_euronet_zero2odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_zero2

swngrfin_zero336odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == zero336, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_zero336

swngrfin_euronet_zero_loopodst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero_loop, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_zero_loop

swngrfin_euronet_standard_loopodst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_standard_loop, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_standard_loop

swngrfin_euronet_zero_loop2odst  = odstsmrtcomb.loc[odstsmrtcomb['VARIANT'] == euronet_zero_loop2, 'Wynagrodzenie EURO (%)'] \
    = odstsmrtcomb['Wartość zamównienia (brutto)'].astype(float) * prevwynagrodzenie_euronet_zero_loop2

### TEST ### ^


odstsmrtcomb.loc[umask1, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO

odstsmrtcomb.loc[umask2, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO2

odstsmrtcomb.loc[umask3, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO3

odstsmrtcomb.loc[umask4, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO4

odstsmrtcomb.loc[umask5, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO5

odstsmrtcomb.loc[umask6, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO6

odstsmrtcomb.loc[umask7, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZEROT2

odstsmrtcomb.loc[umask8, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO2T2

odstsmrtcomb.loc[umask9, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO3T2

odstsmrtcomb.loc[umask10, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO4T2

odstsmrtcomb.loc[umask11, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO5T2

odstsmrtcomb.loc[umask12, 'wynagrodzenie_euronet_zero'] = svalue_to_assignZERO6T2

odstsmrtcomb.loc[(prevmon1['VARIANT'] == 'EURONET1_ZERO') | (prevmon1['VARIANT'] == 'EURONET2_ZERO'), 'Wynagrodzenie PayU (%)'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * odstsmrtcomb['wynagrodzenie_euronet_zero']

odstsmrtcomb.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie PayU (%)'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * odstsmrtcomb['wynagrodzenie_euronet_zero']

wngrpayu_euronet_zero = odstsmrtcomb.loc[prevmon1['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%) raty0%'] = 0.006
wngrpayu_euronet_zero2 = odstsmrtcomb.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%) raty0%'] = 0.006
wngrpayu_zero336 = odstsmrtcomb.loc[prevmon1['VARIANT'] == zero336, 'Wynagrodzenie EURO (%) raty0%'] = 0.006

wngrfinPayU_euronet_zero = odstsmrtcomb.loc[prevmon1['VARIANT'] == euronet_zero, 'Wynagrodzenie EURO (%)2'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * wngrpayu_euronet_zero

wngrfinPayU_euronet_zero2 = odstsmrtcomb.loc[prevmon1['VARIANT'] == euronet_zero2, 'Wynagrodzenie EURO (%)2'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * wngrpayu_euronet_zero2

wngrfinPayU_zero336 = odstsmrtcomb.loc[prevmon1['VARIANT'] == zero336, 'Wynagrodzenie EURO (%)2'] \
    = odstsmrtcomb['kwota netto pozyczki'].astype(float) * wngrpayu_zero336




del odstsmrtcomb['PROVIDER']
del odstsmrtcomb['trans_firm_id']
del odstsmrtcomb['Wynagrodzenie EURO raty 0% (netto PLN)']
del odstsmrtcomb['kwota_gr']
del odstsmrtcomb['Wynagrodzenie EURO (%)2']
del odstsmrtcomb['INSTALLMENTS_NUMBER']
del odstsmrtcomb['TRANS_SHOP_ID']
del odstsmrtcomb['agreement']
del odstsmrtcomb['TRANS_ID']
del odstsmrtcomb['TRANS_DESC']

odstsmrtcomb = odstsmrtcomb[['Numer zamówienia','Data Zamówienia','data','Wartość zamównienia (brutto)','Liczba rat',
                            'VARIANT','Wynagrodzenie EURO (%) raty regularne','Wynagrodzenie EURO (netto PLN) raty regularne',
                            'FSU_URL','Pożyczkodawca','Wynagrodzenie EURO (%) raty0%','Wynagrodzenie EURO Value',
                            'wynagrodzenie_euronet_zero','Wynagrodzenie PayU (%)','Data odstąpienia', 'kwota netto pozyczki', 'Wynagrodzenie EURO (%)']]
odstsmrtcomb.columns =['Numer zamówienia','Data Zamówienia','Data zapłaty za zamówienie','Wartość zamówienia (brutto)','Liczba rat',
                            'Opcja pożyczki','Wynagrodzenie EURO (%) raty regularne','Wynagrodzenie EURO (netto PLN) raty regularne',
                            'Serwis','Pożyczkodawca','Wynagrodzenie EURO (%) raty0%','Wynagrodzenie EURO raty 0%',
                            'Wynagrodzenie PayU (%)','Wynagrodzenie EURO (netto PLN)','Data odstąpienia','kwota netto pozyczki','Wynagrodzenie EURO (%)']

#sumy kolumn
arkuszglowny = DiffComplete
cols_to_sum = ['Wartość zamówienia (brutto)', 'Wynagrodzenie EURO (netto PLN)raty regularne', 'Wynagrodzenie EURO raty 0%', 'Wynagrodzenie PayU']
DiffComplete.loc['Total'] = DiffComplete[cols_to_sum].sum()
cols_to_sum = ['Wartość zamówienia (brutto)', 'Wynagrodzenie EURO (netto PLN)raty regularne', 'Wynagrodzenie EURO raty 0%', 'Wynagrodzenie PayU']

new_index = ['Total'] + DiffComplete.index[:-1].tolist()
DiffComplete = DiffComplete.reindex(new_index)

arkuszglowny.loc['Total'] = arkuszglowny[cols_to_sum].sum()
kolumny_do_sumy = ['Wartość zamówienia (brutto)','Wynagrodzenie EURO (netto PLN)raty regularne','Wynagrodzenie EURO (%) raty0%','Wynagrodzenie EURO raty 0%(netto PLN)']
kolumny_do_sumy2 = ['Wartość zamówienia (brutto)','Wynagrodzenie EURO (netto PLN) raty regularne','Wynagrodzenie EURO raty 0%','Wynagrodzenie EURO (netto PLN)']

if not odstinb.empty:
    odstinb.loc['Total'] = odstinb[kolumny_do_sumy].sum()
odstsmrtcomb.loc['Total'] = odstsmrtcomb[kolumny_do_sumy2].sum()
print(prevvalue_to_assign12)


diffcomplete_sum = DiffComplete.loc['Total']['Wartość zamówienia (brutto)']
if not odstinb.empty:
    odstinb_sum = odstinb.loc['Total']['Wartość zamówienia (brutto)']
odstsmrtcomb_sum = odstsmrtcomb.loc['Total']['Wartość zamówienia (brutto)']

diffcomplete_sum2 = DiffComplete.loc['Total']['Wynagrodzenie EURO (netto PLN)raty regularne']
if not odstinb.empty:
    odstinb_sum2 = odstinb.loc['Total']['Wynagrodzenie EURO (netto PLN)raty regularne']
odstsmrtcomb_sum2 = odstsmrtcomb.loc['Total']['Wynagrodzenie EURO (netto PLN) raty regularne']

diffcomplete_sum3 = DiffComplete.loc['Total']['Wynagrodzenie EURO raty 0%']
if not odstinb.empty:
    odstinb_sum3 = odstinb.loc['Total']['Wynagrodzenie EURO (%) raty0%']
odstsmrtcomb_sum3 = odstsmrtcomb.loc['Total']['Wynagrodzenie EURO raty 0%']

diffcomplete_sum4 = DiffComplete.loc['Total']['Wynagrodzenie PayU']
if not odstinb.empty:
    odstinb_sum4 = odstinb.loc['Total']['Wynagrodzenie EURO raty 0%(netto PLN)']
odstsmrtcomb_sum4 = odstsmrtcomb.loc['Total']['Wynagrodzenie EURO (netto PLN)']


if not odstinb.empty:
    difference = diffcomplete_sum - (odstinb_sum)
    difference2 = diffcomplete_sum2 - (odstinb_sum2 + odstsmrtcomb_sum2)
    difference3 = diffcomplete_sum3 - (odstinb_sum3 + odstsmrtcomb_sum3)
    difference4 = diffcomplete_sum4 - (odstinb_sum4 + odstsmrtcomb_sum4)
    difference5 = diffcomplete_sum - (odstsmrtcomb_sum)

if not odstinb.empty:
    result_df = pd.DataFrame({
    'Wynik brutto - Inbank brutto': [difference],
    'Wynik brutto - Smartney brutto': [difference5],
    'Wynik Wynagrodzenie Euro raty regularne - (Inb + Smart)': [difference2],
    'Wynik Wynagrodzenie EURO raty 0% - (Inb + Smart)': [difference3],
    'Wynik Wynagrodzenie PayU - (Inb + Smart)': [difference4]
})


condition = (DiffComplete['Opcja pożyczki'] == "EURONET1_ZERO") | (DiffComplete['Opcja pożyczki'] == "EURONET2_ZERO")
condition2 = (DiffComplete['Opcja pożyczki'] != "EURONET1_ZERO") | (DiffComplete['Opcja pożyczki'] != "EURONET2_ZERO") | (DiffComplete['Opcja pożyczki'] == "")


filtered_df = DiffComplete[condition]
filtered_df2 = DiffComplete[condition2]


sum_value = filtered_df['Wartość zamówienia (brutto)'].sum()

sum_value2 = diffcomplete_sum - sum_value

sum_value3 = filtered_df['Wartość zamówienia (brutto)'].sum()

# Create a new DataFrame with the sum value
new_df = pd.DataFrame({"TPV od udzielonych pożyczek": [sum_value, sum_value2, sum_value3]})
new_df['Rodzaj pożyczki'] = ['Pożyczka typu REVE SHARE','Pożyczka typu typu REVE SHARE2', 'Pożyczka 0%']
new_df['Wynagrodzenie'] = [diffcomplete_sum3, diffcomplete_sum2, diffcomplete_sum4]
if not odstinb.empty:
    new_df['TPV od odstąpień'] = [odstsmrtcomb_sum, odstinb_sum, odstsmrtcomb_sum]
    new_df['Umniejszenie wynagrodzenia'] = [odstsmrtcomb_sum3, odstinb_sum2, odstsmrtcomb_sum4]
    new_df['Suma wynagrodzenia dla merchanta'] = [diffcomplete_sum3 - odstsmrtcomb_sum3, diffcomplete_sum2 - odstinb_sum2, diffcomplete_sum4 - odstsmrtcomb_sum4]
else:
    new_df['TPV od odstąpień'] = [odstsmrtcomb_sum, 0, odstsmrtcomb_sum]
    new_df['Umniejszenie wynagrodzenia'] = [odstsmrtcomb_sum3, 0, odstsmrtcomb_sum4]
    new_df['Suma wynagrodzenia dla merchanta'] = [diffcomplete_sum3 - odstsmrtcomb_sum3,
                                                  diffcomplete_sum2 - 0,
                                                  diffcomplete_sum4 - odstsmrtcomb_sum4]
new_df['TPV od udzielonych pożyczek'], new_df['Rodzaj pożyczki'] = new_df['Rodzaj pożyczki'], new_df['TPV od udzielonych pożyczek']
new_df = new_df.round(2)

writer = pd.ExcelWriter('Euronet.xlsx', engine='xlsxwriter')
Payu1.to_excel(writer, sheet_name='PayU', index=True, header=True)
Euronet1.to_excel(writer, sheet_name='EuroNet', index=True, header=True)
Diff.to_excel(writer, sheet_name='Diff', index=True, header=True)
DiffS.to_excel(writer, sheet_name='DiffSMART', index=False, header=True)
DiffI.to_excel(writer, sheet_name='DiffSMARTinb', index=False, header=True)
DiffComplete.to_excel(writer, sheet_name='Final', index=False, header=True)
DiffCompleteFinal.to_excel(writer, sheet_name='Rejects', index=False, header=True)
canctrans1.to_excel(writer, sheet_name='CancelledTransactions', index=False, header=True)
odstinb.to_excel(writer, sheet_name='odstinb', index=False, header=True)
odstsmrtcomb.to_excel(writer, sheet_name='odstsmrt', index=False, header=True)
if not odstinb.empty:
    result_df.to_excel(writer, sheet_name='wyniki', index=False, header=True)
new_df.to_excel(writer, sheet_name='rozliczenie', index=False, header=True)
writer.save()
exit()


Editor is loading...
Leave a Comment