774 lines
35 KiB
Python
774 lines
35 KiB
Python
import arrow
|
|
import time
|
|
|
|
from decimal import Decimal
|
|
from datetime import datetime, timedelta
|
|
from Schemas import BuildDecisionBookPayments, AccountRecords, ApiEnumDropdown
|
|
|
|
from time import perf_counter
|
|
from sqlalchemy import select, func, distinct, cast, Date, String, literal, desc, and_, or_
|
|
from Controllers.Postgres.engine import get_session_factory
|
|
#from ServicesApi.Schemas.account.account import AccountRecords
|
|
#from ServicesApi.Schemas.building.decision_book import BuildDecisionBookPayments
|
|
|
|
|
|
class BuildDuesTypes:
|
|
|
|
def __init__(self):
|
|
self.debit: ApiEnumDropdownShallowCopy = None
|
|
self.add_debit: ApiEnumDropdownShallowCopy = None
|
|
self.renovation: ApiEnumDropdownShallowCopy = None
|
|
self.lawyer_expence: ApiEnumDropdownShallowCopy = None
|
|
self.service_fee: ApiEnumDropdownShallowCopy = None
|
|
self.information: ApiEnumDropdownShallowCopy = None
|
|
|
|
|
|
class ApiEnumDropdownShallowCopy:
|
|
id: int
|
|
uuid: str
|
|
enum_class: str
|
|
key: str
|
|
value: str
|
|
|
|
def __init__(self, id: int, uuid: str, enum_class: str, key: str, value: str):
|
|
self.id = id
|
|
self.uuid = uuid
|
|
self.enum_class = enum_class
|
|
self.key = key
|
|
self.value = value
|
|
|
|
|
|
def get_enums_from_database():
|
|
build_dues_types = BuildDuesTypes()
|
|
with ApiEnumDropdown.new_session() as session:
|
|
|
|
ApiEnumDropdown.set_session(session)
|
|
|
|
debit_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-D").first() # Debit
|
|
add_debit_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-A").first() # Add Debit
|
|
renovation_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-R").first() # Renovation
|
|
late_payment_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-L").first() # Lawyer expence
|
|
service_fee_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-S").first() # Service fee
|
|
information_enum_shallow = ApiEnumDropdown.query.filter_by(enum_class="BuildDuesTypes", key="BDT-I").first() # Information
|
|
|
|
build_dues_types.debit = ApiEnumDropdownShallowCopy(
|
|
debit_enum_shallow.id, str(debit_enum_shallow.uu_id), debit_enum_shallow.enum_class, debit_enum_shallow.key, debit_enum_shallow.value
|
|
)
|
|
build_dues_types.add_debit = ApiEnumDropdownShallowCopy(
|
|
add_debit_enum_shallow.id, str(add_debit_enum_shallow.uu_id), add_debit_enum_shallow.enum_class, add_debit_enum_shallow.key, add_debit_enum_shallow.value
|
|
)
|
|
build_dues_types.renovation = ApiEnumDropdownShallowCopy(
|
|
renovation_enum_shallow.id, str(renovation_enum_shallow.uu_id), renovation_enum_shallow.enum_class, renovation_enum_shallow.key, renovation_enum_shallow.value
|
|
)
|
|
build_dues_types.lawyer_expence = ApiEnumDropdownShallowCopy(
|
|
late_payment_enum_shallow.id, str(late_payment_enum_shallow.uu_id), late_payment_enum_shallow.enum_class, late_payment_enum_shallow.key, late_payment_enum_shallow.value
|
|
)
|
|
build_dues_types.service_fee = ApiEnumDropdownShallowCopy(
|
|
service_fee_enum_shallow.id, str(service_fee_enum_shallow.uu_id), service_fee_enum_shallow.enum_class, service_fee_enum_shallow.key, service_fee_enum_shallow.value
|
|
)
|
|
build_dues_types.information = ApiEnumDropdownShallowCopy(
|
|
information_enum_shallow.id, str(information_enum_shallow.uu_id), information_enum_shallow.enum_class, information_enum_shallow.key, information_enum_shallow.value
|
|
)
|
|
return [build_dues_types.debit, build_dues_types.lawyer_expence, build_dues_types.add_debit, build_dues_types.renovation, build_dues_types.service_fee, build_dues_types.information]
|
|
|
|
|
|
def generate_total_paid_amount_for_spesific_build_part_id(build_parts_id: int, session):
|
|
"""
|
|
Calculate the total amount paid for a specific build part ID.
|
|
|
|
Args:
|
|
build_parts_id: The build part ID to calculate payments for
|
|
session: Database session
|
|
|
|
Returns:
|
|
float: The total amount paid (absolute value)
|
|
"""
|
|
payment_query = session.query(func.sum(BuildDecisionBookPayments.payment_amount)).filter(
|
|
BuildDecisionBookPayments.build_parts_id == build_parts_id,
|
|
BuildDecisionBookPayments.account_is_debit == False,
|
|
cast(BuildDecisionBookPayments.process_date, Date) >= '2022-01-01'
|
|
).scalar()
|
|
return payment_query if payment_query is not None else 0
|
|
|
|
|
|
def generate_total_debt_amount_for_spesific_build_part_id(build_parts_id: int, session):
|
|
|
|
# Use SQLAlchemy's func.sum to calculate the total debts
|
|
# For total debt, we want to include ALL debts, both processed and unprocessed
|
|
result = session.query(
|
|
func.sum(BuildDecisionBookPayments.payment_amount)
|
|
).filter(
|
|
BuildDecisionBookPayments.build_parts_id == build_parts_id,
|
|
BuildDecisionBookPayments.account_is_debit == True,
|
|
cast(BuildDecisionBookPayments.process_date, Date) >= '2022-01-01'
|
|
).scalar()
|
|
|
|
# Return 0 if no debts found, otherwise return the absolute value of the sum
|
|
return abs(result) if result is not None else 0
|
|
|
|
|
|
def generate_total_amount_that_user_has_in_account(account_record: AccountRecords, session):
|
|
# Get total amount that user has in account
|
|
result = session.query(
|
|
func.sum(AccountRecords.currency_value)
|
|
).filter(
|
|
AccountRecords.build_parts_id == account_record.build_parts_id,
|
|
AccountRecords.currency_value > 0,
|
|
cast(AccountRecords.bank_date, Date) >= '2022-01-01'
|
|
).scalar()
|
|
|
|
# Return 0 if no payments found, otherwise return the absolute value of the sum
|
|
return abs(result)
|
|
|
|
|
|
def get_unpaid_debts(build_parts_id: int, session, debit_type, date_query: tuple):
|
|
"""Find BuildDecisionBookPayments entries where the debt has NOT been fully paid for a specific debit type.
|
|
|
|
This function identifies payments where the sum of payments is less than the debit amount,
|
|
meaning the debt has not been fully closed.
|
|
|
|
Args:
|
|
build_parts_id: The build part ID to check
|
|
session: Database session
|
|
debit_type: The specific debit type to check
|
|
date_query: Tuple of date filters to apply
|
|
|
|
Returns:
|
|
list: List of unpaid debt entries (full BuildDecisionBookPayments objects)
|
|
|
|
query:
|
|
SELECT
|
|
bpf.ref_id,
|
|
bpf.process_date,
|
|
ABS(COALESCE(SUM(bpf.payment_amount), 0)) AS total_payments
|
|
FROM public.build_decision_book_payments AS bpf
|
|
GROUP BY
|
|
bpf.ref_id,
|
|
bpf.process_date
|
|
HAVING ABS(COALESCE(SUM(bpf.payment_amount), 0)) > 0
|
|
order by bpf.process_date
|
|
"""
|
|
# Create a subquery for the payment sums without executing it separately
|
|
payment_sums_subquery = select(
|
|
BuildDecisionBookPayments.ref_id,
|
|
BuildDecisionBookPayments.process_date,
|
|
func.abs(func.coalesce(func.sum(BuildDecisionBookPayments.payment_amount), 0)).label("total_payments")
|
|
).filter(
|
|
BuildDecisionBookPayments.build_parts_id == build_parts_id,
|
|
BuildDecisionBookPayments.payment_types_id == debit_type.id,
|
|
*date_query
|
|
).group_by(
|
|
BuildDecisionBookPayments.ref_id, BuildDecisionBookPayments.process_date
|
|
).having(
|
|
func.abs(func.coalesce(func.sum(BuildDecisionBookPayments.payment_amount), 0)) > 0
|
|
).order_by(BuildDecisionBookPayments.process_date.desc())
|
|
|
|
# Use the subquery directly in the main query
|
|
# query_results = session.query(BuildDecisionBookPayments).filter(
|
|
# BuildDecisionBookPayments.ref_id.in_(payment_sums_subquery),
|
|
# BuildDecisionBookPayments.build_parts_id == build_parts_id,
|
|
# BuildDecisionBookPayments.payment_types_id == debit_type.id,
|
|
# ).order_by(BuildDecisionBookPayments.process_date.desc())
|
|
payment_sums = session.execute(payment_sums_subquery).all()
|
|
payment_sums_list = []
|
|
for item in payment_sums:
|
|
payment_sums_list.append({"ref_id": item[0], "process_date": item[1], "total_payments": item[2]})
|
|
return payment_sums
|
|
|
|
|
|
def _print_debt_details(debt, session):
|
|
"""Helper function to print detailed information about an unpaid debt.
|
|
|
|
Args:
|
|
debt: The BuildDecisionBookPayments object representing the debt
|
|
session: Database session
|
|
"""
|
|
# Get the sum of payments for this debt
|
|
payments_sum = session.query(
|
|
func.sum(BuildDecisionBookPayments.payment_amount)
|
|
).filter(
|
|
BuildDecisionBookPayments.ref_id == debt.ref_id,
|
|
BuildDecisionBookPayments.account_is_debit == False
|
|
).scalar() or 0
|
|
|
|
# Calculate remaining amount
|
|
debit_amount = abs(debt.payment_amount)
|
|
remaining = debit_amount - abs(payments_sum)
|
|
payment_percentage = (abs(payments_sum) / debit_amount) * 100 if debit_amount > 0 else 0
|
|
|
|
# Format the date for display
|
|
date_str = debt.process_date.strftime('%Y-%m-%d') if debt.process_date else 'Unknown date'
|
|
|
|
|
|
def analyze_payment_function():
|
|
session_factory = get_session_factory()
|
|
session = session_factory()
|
|
# Set session for all models
|
|
AccountRecords.set_session(session)
|
|
BuildDecisionBookPayments.set_session(session)
|
|
|
|
order_pay = get_enums_from_database()
|
|
# Get distinct build_parts_id values from account records with positive currency_value
|
|
# This avoids redundant processing of the same build_parts_id
|
|
distinct_build_parts = session.query(
|
|
distinct(AccountRecords.build_parts_id)
|
|
).filter(
|
|
AccountRecords.build_parts_id.isnot(None),
|
|
AccountRecords.currency_value > 0,
|
|
AccountRecords.bank_date >= '2022-01-01'
|
|
).order_by(AccountRecords.build_parts_id.desc()).all()
|
|
|
|
start_time = time.time()
|
|
|
|
for build_part_id_tuple in distinct_build_parts:
|
|
build_part_id = build_part_id_tuple[0] # Extract the ID from the tuple
|
|
process_date = datetime.now()
|
|
last_date_of_process_date = datetime(process_date.year, process_date.month, 1) - timedelta(days=1)
|
|
first_date_of_process_date = datetime(process_date.year, process_date.month, 1)
|
|
|
|
print(f"\n{'=' * 50}")
|
|
print(f"ACCOUNT ANALYSIS FOR BUILD PART ID: {build_part_id}")
|
|
print(f"{'=' * 50}")
|
|
|
|
# Calculate total paid amount for this build_part_id
|
|
total_amount_paid = generate_total_paid_amount_for_spesific_build_part_id(build_part_id, session)
|
|
|
|
# Calculate total debt amount for this build_part_id
|
|
total_debt_amount = generate_total_debt_amount_for_spesific_build_part_id(build_part_id, session)
|
|
|
|
# Get total amount in account for this build_part_id
|
|
account_record = AccountRecords()
|
|
account_record.build_parts_id = build_part_id
|
|
total_amount_in_account = generate_total_amount_that_user_has_in_account(account_record, session)
|
|
|
|
# Calculate remaining amount to be paid
|
|
amount_need_to_paid = total_debt_amount - total_amount_paid
|
|
total_amount_that_user_need_to_transfer = abs(amount_need_to_paid) - abs(total_amount_in_account)
|
|
|
|
# Print summary with clear descriptions
|
|
print(f"PAYMENT SUMMARY:")
|
|
print(f" • Total debt amount: {total_debt_amount:,.2f} TL")
|
|
print(f" • Amount already paid: {total_amount_paid:,.2f} TL")
|
|
print(f" • Remaining debt to be collected: {amount_need_to_paid:,.2f} TL")
|
|
print(f" • Current account balance: {total_amount_in_account:,.2f} TL")
|
|
|
|
if total_amount_that_user_need_to_transfer > 0:
|
|
print(f" • Additional funds needed: {total_amount_that_user_need_to_transfer:,.2f} TL")
|
|
elif amount_need_to_paid <= 0:
|
|
print(f" • Account is fully paid with no outstanding debt")
|
|
else:
|
|
print(f" • Sufficient funds available to close all debt")
|
|
# Show debt coverage percentage
|
|
if total_debt_amount > 0:
|
|
# Calculate current coverage (already paid)
|
|
current_coverage_percentage = (total_amount_paid / total_debt_amount) * 100
|
|
|
|
# Calculate potential coverage (including available funds)
|
|
potential_coverage = min(100, ((total_amount_paid + total_amount_in_account) / total_debt_amount) * 100)
|
|
|
|
# Display both percentages
|
|
print(f" • Current debt coverage: {current_coverage_percentage:.2f}%")
|
|
print(f" • Potential debt coverage with available funds: {potential_coverage:.2f}%")
|
|
|
|
# Analyze unpaid debts for each payment type
|
|
print("\nUNPAID DEBTS ANALYSIS BY PAYMENT TYPE:")
|
|
for payment_type in order_pay:
|
|
# Get unpaid debts for current month
|
|
date_query_current = (
|
|
BuildDecisionBookPayments.process_date >= first_date_of_process_date,
|
|
BuildDecisionBookPayments.process_date <= process_date
|
|
)
|
|
date_query_previous = (
|
|
BuildDecisionBookPayments.process_date < first_date_of_process_date,
|
|
)
|
|
|
|
current_unpaid_debts = get_unpaid_debts(build_parts_id=build_part_id, session=session, debit_type=payment_type, date_query=date_query_current)
|
|
|
|
# Get unpaid debts from previous months
|
|
previous_unpaid_debts = get_unpaid_debts(build_parts_id=build_part_id, session=session, debit_type=payment_type, date_query=date_query_previous)
|
|
|
|
# Calculate totals
|
|
current_total = sum(abs(debt[2]) for debt in current_unpaid_debts)
|
|
previous_total = sum(abs(debt[2]) for debt in previous_unpaid_debts)
|
|
grand_total = current_total + previous_total
|
|
|
|
# Print summary for this payment type
|
|
if current_unpaid_debts or previous_unpaid_debts:
|
|
print(f" • {payment_type.key}: Total unpaid: {grand_total:,.2f} TL")
|
|
|
|
# Current month details
|
|
if current_unpaid_debts:
|
|
print(f" - Current month: {len(current_unpaid_debts)} debts, {current_total:,.2f} TL")
|
|
# Show details of each unpaid debt if there aren't too many
|
|
# if len(current_unpaid_debts) <= 3:
|
|
# for debt in current_unpaid_debts:
|
|
# _print_debt_details(debt, session)
|
|
|
|
# Previous months details
|
|
if previous_unpaid_debts:
|
|
print(f" - Previous months: {len(previous_unpaid_debts)} debts, {previous_total:,.2f} TL")
|
|
# Show details of each unpaid debt if there aren't too many
|
|
# if len(previous_unpaid_debts) <= 3:
|
|
# for debt in previous_unpaid_debts:
|
|
# _print_debt_details(debt, session)
|
|
else:
|
|
print(f" • {payment_type.key}: All debts paid")
|
|
print(f"{'=' * 50}\n")
|
|
|
|
|
|
def close_payment_book(payment_row_book, account_record, value, session):
|
|
"""Create a credit entry in BuildDecisionBookPayments to close a debt.
|
|
|
|
Args:
|
|
payment_row_book: The debit entry to be paid
|
|
account_record: The account record containing the funds
|
|
value: The amount to pay
|
|
session: Database session
|
|
|
|
Returns:
|
|
The newly created payment record
|
|
"""
|
|
BuildDecisionBookPayments.set_session(session)
|
|
|
|
# Create a new credit entry (payment)
|
|
new_row = BuildDecisionBookPayments.create(
|
|
ref_id=str(payment_row_book.uu_id),
|
|
payment_plan_time_periods=payment_row_book.payment_plan_time_periods,
|
|
period_time=payment_row_book.period_time,
|
|
currency=payment_row_book.currency,
|
|
account_records_id=account_record.id,
|
|
account_records_uu_id=str(account_record.uu_id),
|
|
build_parts_id=payment_row_book.build_parts_id,
|
|
build_parts_uu_id=str(payment_row_book.build_parts_uu_id),
|
|
payment_amount=abs(value), # Negative for credit entries
|
|
payment_types_id=payment_row_book.payment_types_id,
|
|
payment_types_uu_id=str(payment_row_book.payment_types_uu_id),
|
|
process_date_m=payment_row_book.process_date.month,
|
|
process_date_y=payment_row_book.process_date.year,
|
|
process_date=payment_row_book.process_date,
|
|
build_decision_book_item_id=payment_row_book.build_decision_book_item_id if payment_row_book.build_decision_book_item_id else None,
|
|
build_decision_book_item_uu_id=str(payment_row_book.build_decision_book_item_uu_id) if payment_row_book.build_decision_book_item_uu_id else None,
|
|
decision_book_project_id=payment_row_book.decision_book_project_id if payment_row_book.decision_book_project_id else None,
|
|
decision_book_project_uu_id=str(payment_row_book.decision_book_project_uu_id) if payment_row_book.decision_book_project_uu_id else None,
|
|
is_confirmed=True,
|
|
account_is_debit=False,
|
|
)
|
|
|
|
# Save the new payment record
|
|
saved_row = new_row.save()
|
|
# Update the original debt record to mark it as processed
|
|
# payment_row_book.account_records_id = account_record.id
|
|
# payment_row_book.account_records_uu_id = str(account_record.uu_id)
|
|
# payment_row_book.save()
|
|
# # Flush to ensure both records are saved to the database
|
|
# session.flush()
|
|
return saved_row
|
|
|
|
|
|
def update_account_remainder_if_spent(account_record, ref_id: str, session):
|
|
"""Update the remainder_balance of an account after spending money.
|
|
|
|
Args:
|
|
account_record: The account record to update
|
|
amount_spent: The amount spent in this transaction
|
|
session: Database session
|
|
|
|
Returns:
|
|
bool: True if all money is spent, False otherwise
|
|
"""
|
|
AccountRecords.set_session(session)
|
|
BuildDecisionBookPayments.set_session(session)
|
|
sum_of_paid = session.query(func.sum(func.abs(BuildDecisionBookPayments.payment_amount))).filter(
|
|
BuildDecisionBookPayments.account_records_id == account_record.id,
|
|
BuildDecisionBookPayments.account_is_debit == False
|
|
).scalar()
|
|
|
|
debit_row = BuildDecisionBookPayments.query.filter_by(ref_id=ref_id).first()
|
|
account_record_to_update = AccountRecords.query.filter_by(id=account_record.id).first()
|
|
account_record_to_update.remainder_balance = sum_of_paid
|
|
account_record_to_update.save()
|
|
# Get the current remainder balance
|
|
if abs(sum_of_paid) == abs(account_record.currency_value):
|
|
return True
|
|
return False
|
|
|
|
|
|
def update_all_spent_accounts(session):
|
|
"""Update remainder_balance for all accounts with payments.
|
|
|
|
This function finds account records in BuildDecisionBookPayments and updates
|
|
their remainder_balance based on the sum of payments made, regardless of whether
|
|
all funds have been spent or not.
|
|
|
|
Args:
|
|
session: Database session
|
|
"""
|
|
with AccountRecords.new_session() as session:
|
|
# Set sessions for models
|
|
AccountRecords.set_session(session)
|
|
BuildDecisionBookPayments.set_session(session)
|
|
|
|
# Get distinct account_records_id values from BuildDecisionBookPayments
|
|
distinct_account_ids = session.query(BuildDecisionBookPayments.account_records_id).filter(
|
|
BuildDecisionBookPayments.account_records_id.isnot(None),
|
|
BuildDecisionBookPayments.account_is_debit == False # Credit entries (payments)
|
|
).distinct().all()
|
|
|
|
updated_count = 0
|
|
|
|
for account_id_tuple in distinct_account_ids:
|
|
account_id = account_id_tuple[0]
|
|
|
|
# Get the account record
|
|
account = AccountRecords.query.filter_by(id=account_id).first()
|
|
if not account or not account.build_parts_id or account.currency_value <= 0:
|
|
continue
|
|
|
|
# Calculate the sum of payments made using this account
|
|
# Note: payment_amount is negative for credit entries, so we need to use abs() to get the positive amount
|
|
payment_query = session.query(func.sum(func.abs(BuildDecisionBookPayments.payment_amount))).filter(
|
|
BuildDecisionBookPayments.account_records_id == account_id,
|
|
BuildDecisionBookPayments.account_is_debit == False # Credit entries (payments)
|
|
)
|
|
|
|
payment_sum = payment_query.scalar() or 0
|
|
|
|
# Update remainder_balance for ALL accounts, regardless of payment_sum value
|
|
threshold = Decimal('0.01')
|
|
fully_spent = payment_sum >= abs(account.currency_value) - threshold
|
|
status = "All funds spent" if fully_spent else "Partial payment"
|
|
|
|
# Store the positive value in remainder_balance
|
|
account.remainder_balance = payment_sum
|
|
account.save()
|
|
updated_count += 1
|
|
|
|
print(f"\nTotal accounts updated: {updated_count}")
|
|
|
|
|
|
# def find_amount_to_pay_by_ref_id(ref_id, session):
|
|
# """Calculate the remaining amount to pay for a specific debt reference ID.
|
|
|
|
# Args:
|
|
# ref_id: The reference ID of the debt (this is the uu_id of the debt record)
|
|
# session: Database session
|
|
|
|
# Returns:
|
|
# float: The remaining amount to pay
|
|
# """
|
|
# # Get the original debt amount - the debt is identified by its uu_id which is passed as ref_id
|
|
# debit = BuildDecisionBookPayments.query.filter(
|
|
# BuildDecisionBookPayments.uu_id == ref_id,
|
|
# BuildDecisionBookPayments.account_is_debit == True
|
|
# ).first()
|
|
# if not debit:
|
|
# return 0 # No debit found, nothing to pay
|
|
|
|
# debit_amount = abs(debit.payment_amount) # Ensure positive value for debit amount
|
|
|
|
# # Get the sum of payments already made for this debt
|
|
# # The ref_id in credit records points to the uu_id of the original debit
|
|
# # Note: payment_amount is negative for credit entries, so we use abs() to get positive values
|
|
# credit_amount = session.query(
|
|
# func.sum(func.abs(BuildDecisionBookPayments.payment_amount))
|
|
# ).filter(
|
|
# BuildDecisionBookPayments.ref_id == str(ref_id),
|
|
# BuildDecisionBookPayments.account_is_debit == False
|
|
# ).scalar() or 0
|
|
# # Calculate remaining amount to pay
|
|
# remaining = abs(debit_amount) - abs(credit_amount)
|
|
# # Ensure we don't return negative values
|
|
# if remaining < 0:
|
|
# return 0
|
|
|
|
# return remaining
|
|
|
|
|
|
def do_payments_of_this_month():
|
|
"""Process payments for the current month's unpaid debts.
|
|
This function retrieves account records with available funds and processes
|
|
payments for current month's unpaid debts in order of payment type priority.
|
|
"""
|
|
session_factory = get_session_factory()
|
|
session = session_factory()
|
|
|
|
# Set session for all models
|
|
AccountRecords.set_session(session)
|
|
BuildDecisionBookPayments.set_session(session)
|
|
|
|
# Get payment types in priority order
|
|
payment_type_list = get_enums_from_database()
|
|
|
|
# Get account records with positive currency_value and available funds
|
|
account_records = AccountRecords.query.filter(
|
|
AccountRecords.build_parts_id.isnot(None),
|
|
AccountRecords.currency_value > 0,
|
|
or_(
|
|
AccountRecords.remainder_balance.is_(None),
|
|
AccountRecords.remainder_balance < AccountRecords.currency_value
|
|
),
|
|
AccountRecords.bank_date >= '2022-01-01'
|
|
).order_by(AccountRecords.build_parts_id.desc()).all()
|
|
|
|
payments_made = 0
|
|
total_amount_paid = 0
|
|
process_date = datetime.now()
|
|
first_date_of_process_date = datetime(process_date.year, process_date.month, 1)
|
|
last_date_of_process_date_ = datetime(process_date.year, process_date.month, 1) + timedelta(days=31)
|
|
last_date_of_process_date = datetime(last_date_of_process_date_.year, last_date_of_process_date_.month, 1) - timedelta(days=1)
|
|
|
|
# Current month date filter
|
|
date_query_tuple = (
|
|
BuildDecisionBookPayments.process_date >= first_date_of_process_date,
|
|
BuildDecisionBookPayments.process_date <= last_date_of_process_date
|
|
)
|
|
|
|
fund_finished = lambda money_spend, money_in_account: money_spend == money_in_account
|
|
# Update all accounts with spent funds but zero remainder_balance
|
|
update_all_spent_accounts(session)
|
|
|
|
for account_record in account_records:
|
|
# Initialize variables for this account
|
|
money_in_account = abs(account_record.currency_value) - abs(account_record.remainder_balance)
|
|
money_paid = 0
|
|
build_parts_id = account_record.build_parts_id
|
|
# Process each payment type in priority order
|
|
for payment_type in payment_type_list:
|
|
# Check if all money is spent and update remainder balance if needed
|
|
if fund_finished(money_paid, money_in_account):
|
|
break
|
|
# Get unpaid debts for this payment type
|
|
unpaid_debts = get_unpaid_debts(build_parts_id=build_parts_id, session=session, debit_type=payment_type, date_query=date_query_tuple)
|
|
# Process each unpaid debt
|
|
for debt in unpaid_debts:
|
|
if not money_in_account > 0:
|
|
update_account_remainder_if_spent(account_record, debt[0], session)
|
|
break
|
|
# Check if all money is spent and update remainder balance if needed
|
|
# if fund_finished(money_paid, money_in_account):
|
|
# break
|
|
# Calculate remaining amount to pay
|
|
# Use debt.uu_id as the ref_id, not debt.ref_id
|
|
debt_to_pay = debt[2]
|
|
# Skip if nothing to pay
|
|
if debt_to_pay <= 0:
|
|
continue
|
|
# Determine amount to pay based on available funds
|
|
payment_amount = min(debt_to_pay, money_in_account)
|
|
# Make payment
|
|
debt_to_copy = BuildDecisionBookPayments.query.filter_by(ref_id=debt[0]).first()
|
|
close_payment_book(debt_to_copy, account_record, payment_amount, session)
|
|
# Update counters
|
|
money_in_account -= payment_amount
|
|
money_paid += payment_amount
|
|
payments_made += 1
|
|
total_amount_paid += payment_amount
|
|
if not money_in_account > 0:
|
|
update_account_remainder_if_spent(account_record, debt[0], session)
|
|
break
|
|
|
|
# if money_paid > 0:
|
|
# update_account_remainder_if_spent(account_record, money_paid, session)
|
|
|
|
# Update all accounts with spent funds but zero remainder_balance
|
|
update_all_spent_accounts(session)
|
|
|
|
# Commit all changes to the database
|
|
session.commit()
|
|
|
|
# Print summary
|
|
print("\nCURRENT MONTH PAYMENT SUMMARY:")
|
|
print(f"Total payments made: {payments_made}")
|
|
print(f"Total amount paid: {total_amount_paid:,.2f} TL")
|
|
|
|
|
|
def do_payments_of_previos_months():
|
|
"""Process payments for previous months' unpaid debts.
|
|
|
|
This function retrieves account records with available funds and processes
|
|
payments for previous months' unpaid debts in order of payment type priority.
|
|
"""
|
|
session_factory = get_session_factory()
|
|
session = session_factory()
|
|
|
|
# Set session for all models
|
|
AccountRecords.set_session(session)
|
|
BuildDecisionBookPayments.set_session(session)
|
|
|
|
# Get payment types in priority order
|
|
payment_type_list = get_enums_from_database()
|
|
|
|
# Get account records with positive currency_value and available funds
|
|
account_query = AccountRecords.query.filter(
|
|
AccountRecords.build_parts_id.isnot(None),
|
|
AccountRecords.currency_value > 0,
|
|
AccountRecords.remainder_balance < AccountRecords.currency_value,
|
|
AccountRecords.bank_date >= '2022-01-01'
|
|
).order_by(AccountRecords.bank_date.desc())
|
|
|
|
account_records = account_query.all()
|
|
|
|
payments_made = 0
|
|
total_amount_paid = 0
|
|
# process_date = datetime.now()
|
|
# first_date_of_process_date = datetime(process_date.year, process_date.month, 1)
|
|
|
|
# Previous months date filter
|
|
# date_query_tuple = (BuildDecisionBookPayments.process_date < first_date_of_process_date, )
|
|
fund_finished = lambda money_spend, money_in_account: money_spend >= money_in_account
|
|
|
|
# Update all accounts with spent funds but zero remainder_balance
|
|
update_all_spent_accounts(session)
|
|
|
|
for account_record in account_records:
|
|
# Initialize variables for this account
|
|
process_date_begins = datetime(account_record.bank_date.year, account_record.bank_date.month, 1)
|
|
process_date_ends_ = datetime(account_record.bank_date.year, account_record.bank_date.month, 1)+ timedelta(days=31)
|
|
process_date_ends = datetime(process_date_ends_.year, process_date_ends_.month, 1)- timedelta(days=1)
|
|
|
|
date_query_tuple = (BuildDecisionBookPayments.process_date >= process_date_begins, BuildDecisionBookPayments.process_date <= process_date_ends)
|
|
|
|
money_in_account = abs(account_record.currency_value) - abs(account_record.remainder_balance)
|
|
money_paid = 0
|
|
build_parts_id = account_record.build_parts_id
|
|
# Process each payment type in priority order
|
|
for payment_type in payment_type_list:
|
|
# Check if all money is spent and update remainder balance if needed
|
|
if fund_finished(money_paid, money_in_account):
|
|
break
|
|
# Get unpaid debts for this payment type
|
|
unpaid_debts = get_unpaid_debts(build_parts_id=build_parts_id, session=session, debit_type=payment_type, date_query=date_query_tuple)
|
|
if not len(unpaid_debts) > 0:
|
|
process_date = datetime.now()
|
|
process_date_ends = datetime(process_date.year, process_date.month, 1)
|
|
date_query_tuple = (BuildDecisionBookPayments.process_date < process_date_ends, )
|
|
unpaid_debts = get_unpaid_debts(build_parts_id=build_parts_id, session=session, debit_type=payment_type, date_query=date_query_tuple)
|
|
|
|
# Process each unpaid debt
|
|
for debt in unpaid_debts:
|
|
if not money_in_account > 0:
|
|
update_account_remainder_if_spent(account_record, debt[0], session)
|
|
break
|
|
# Check if all money is spent and update remainder balance if needed
|
|
if fund_finished(money_paid, money_in_account):
|
|
break
|
|
# Calculate remaining amount to pay
|
|
debt_to_pay = debt[2]
|
|
# Skip if nothing to pay
|
|
if debt_to_pay <= 0:
|
|
continue
|
|
# Determine amount to pay based on available funds
|
|
payment_amount = min(debt_to_pay, money_in_account)
|
|
# Make payment
|
|
try:
|
|
# Create payment record and update original debt
|
|
debt_to_copy = BuildDecisionBookPayments.query.filter_by(ref_id=debt[0]).first()
|
|
new_payment = close_payment_book(debt_to_copy, account_record, payment_amount, session)
|
|
# Verify the payment was created
|
|
if new_payment and new_payment.id:
|
|
# Update counters
|
|
money_in_account -= payment_amount
|
|
money_paid += payment_amount
|
|
payments_made += 1
|
|
total_amount_paid += payment_amount
|
|
# Flush changes to ensure they are visible in subsequent queries
|
|
session.flush()
|
|
else:
|
|
session.rollback()
|
|
continue
|
|
except Exception as e:
|
|
print(f"Debt : {debt[0]} -> Exception: {e}")
|
|
session.rollback()
|
|
continue
|
|
if not money_in_account > 0:
|
|
update_account_remainder_if_spent(account_record, debt[0], session)
|
|
break
|
|
# Update all accounts with spent funds but zero remainder_balance
|
|
update_all_spent_accounts(session)
|
|
|
|
# Commit all changes to the database
|
|
session.commit()
|
|
|
|
# Print summary
|
|
print("\nPREVIOUS MONTHS PAYMENT SUMMARY:")
|
|
print(f"Total payments made: {payments_made}")
|
|
print(f"Total amount paid: {total_amount_paid:,.2f} TL")
|
|
|
|
|
|
# /draft/draft-first-work.py
|
|
if __name__ == "__main__":
|
|
start_time = perf_counter()
|
|
|
|
print("\n===== PROCESSING PAYMENTS =====\n")
|
|
print("Starting payment processing at:", datetime.now())
|
|
|
|
# Process payments for current month first
|
|
print("\n1. Processing current month payments...")
|
|
do_payments_of_this_month()
|
|
|
|
# Then process payments for previous months with remaining funds
|
|
print("\n2. Processing previous months payments...")
|
|
attempt = 4
|
|
while True:
|
|
total_debit = BuildDecisionBookPayments.query.filter(BuildDecisionBookPayments.account_is_debit == True).count()
|
|
total_credit = BuildDecisionBookPayments.query.filter(BuildDecisionBookPayments.account_is_debit == False).count()
|
|
if total_debit != total_credit:
|
|
do_payments_of_previos_months()
|
|
attempt -= 1
|
|
if attempt == 0:
|
|
break
|
|
else:
|
|
break
|
|
|
|
print("\n===== PAYMENT PROCESSING COMPLETE =====\n")
|
|
print("Payment processing completed at:", datetime.now())
|
|
|
|
# Analyze the payment situation after processing payments
|
|
print("\n===== ANALYZING PAYMENT SITUATION AFTER PROCESSING =====\n")
|
|
analyze_payment_function()
|
|
|
|
end_time = perf_counter()
|
|
print(f"\n{end_time - start_time:.3f} : seconds")
|
|
|
|
|
|
# # Create a subquery to get the sum of payments for each debit's uu_id
|
|
# # For credit entries, ref_id points to the original debit's uu_id
|
|
# payment_sums = session.query(
|
|
# BuildDecisionBookPayments.ref_id.label('original_debt_id'),
|
|
# func.sum(func.abs(BuildDecisionBookPayments.payment_amount)).label('payment_sum')
|
|
# ).filter(
|
|
# BuildDecisionBookPayments.account_is_debit == False # Credit entries only
|
|
# ).group_by(BuildDecisionBookPayments.ref_id).subquery()
|
|
|
|
# # Main query to find debits with their payment sums
|
|
# query = session.query(BuildDecisionBookPayments)
|
|
|
|
# # Join with payment sums - cast uu_id to string to match ref_id type
|
|
# query = query.outerjoin(
|
|
# payment_sums,
|
|
# func.cast(BuildDecisionBookPayments.uu_id, String) == payment_sums.c.original_debt_id
|
|
# )
|
|
|
|
# # Filter for debits of the specified build part and payment type
|
|
# query = query.filter(
|
|
# BuildDecisionBookPayments.build_parts_id == build_parts_id,
|
|
# BuildDecisionBookPayments.payment_types_id == debit_type.id,
|
|
# BuildDecisionBookPayments.account_is_debit == True, # Debit entries only
|
|
# )
|
|
|
|
# # Apply date filters if provided
|
|
# if date_query:
|
|
# for date_filter in date_query:
|
|
# query = query.filter(date_filter)
|
|
|
|
# # Filter for debits that are not fully paid
|
|
# # (payment_sum < debit_amount or payment_sum is NULL)
|
|
# query = query.filter(
|
|
# or_(
|
|
# payment_sums.c.payment_sum.is_(None),
|
|
# func.coalesce(payment_sums.c.payment_sum, 0) < func.abs(BuildDecisionBookPayments.payment_amount)
|
|
# )
|
|
# )
|
|
|
|
# # Execute the query and return the results
|
|
# results = query.order_by(BuildDecisionBookPayments.process_date).all()s |