def test_update_statement_daily_to_daily(session):
"""Assert that going from daily to daily creates a new record."""
bcol_account = factory_premium_payment_account()
bcol_account.save()
payment = factory_payment()
payment.save()
i = factory_invoice(payment_account=bcol_account)
i.save()
factory_invoice_reference(i.id).save()
factory_statement_settings(payment_account_id=bcol_account.id,
frequency=StatementFrequency.DAILY.value)
# update to weekly
payment_account = PaymentAccount.find_by_id(bcol_account.id)
statement_settings = StatementSettingsService.update_statement_settings(payment_account.auth_account_id,
StatementFrequency.DAILY.value)
assert statement_settings is not None
assert statement_settings.get('frequency') == StatementFrequency.DAILY.value
assert statement_settings.get('to_date') is None
# daily to daily - assert daily should start by tomorow
assert statement_settings.get('from_date') == (datetime.today() + timedelta(days=1)).strftime('%Y-%m-%d')
# daily to daily - assert current active one is stil daily ending today
current_statement_settings = StatementSettingsModel.find_active_settings(payment_account.auth_account_id,
datetime.today())
assert current_statement_settings is not None
assert current_statement_settings.frequency == StatementFrequency.DAILY.value
assert current_statement_settings.to_date == datetime.today().date()
def find_by_account_id(auth_account_id: str):
"""Find statements by account id."""
current_app.logger.debug(f'<find_by_account_id {auth_account_id}')
statements_settings = StatementSettingsModel.find_latest_settings(
auth_account_id)
if statements_settings is None:
return None
all_settings = []
# iterate and find the next start date to all frequencies
for freq in StatementFrequency:
max_frequency = StatementSettings._find_longest_frequency(
statements_settings.frequency, freq.value)
last_date = StatementSettings._get_end_of(max_frequency)
all_settings.append({
'frequency': freq.name,
'start_date': last_date + timedelta(days=1)
})
statements_settings_schema = StatementSettingsModelSchema()
settings_details = {
'current_frequency':
statements_settings_schema.dump(statements_settings),
'frequencies':
all_settings
}
current_app.logger.debug('>statements_find_by_account_id')
return settings_details
def find_by_account_id(auth_account_id: str):
"""Find statements by account id."""
current_app.logger.debug(f'<find_by_account_id {auth_account_id}')
statements_settings = StatementSettingsModel.find_latest_settings(
auth_account_id)
statements_settings_schema = StatementSettingsModelSchema()
current_app.logger.debug('>statements_find_by_account_id')
return statements_settings_schema.dump(statements_settings)
def factory_statement_settings(frequency: str = 'WEEKLY',
payment_account_id: str = None,
from_date: datetime = datetime.now(),
to_date: datetime = None):
"""Return Factory."""
return StatementSettings(frequency=frequency,
payment_account_id=payment_account_id,
from_date=from_date,
to_date=to_date).save()
def factory_statement_settings(pay_account_id: str,
frequency='DAILY',
from_date=datetime.now(),
to_date=None) -> StatementSettings:
"""Return Factory."""
return StatementSettings(frequency=frequency,
payment_account_id=pay_account_id,
from_date=from_date,
to_date=to_date).save()
def test_update_statement_monthly(session):
"""Assert that the statement settings by id works."""
bcol_account = factory_premium_payment_account()
bcol_account.save()
payment = factory_payment()
payment.save()
i = factory_invoice(payment_account=bcol_account)
i.save()
factory_invoice_reference(i.id).save()
factory_statement_settings(payment_account_id=bcol_account.id,
frequency=StatementFrequency.MONTHLY.value)
# update to weekly
payment_account = PaymentAccount.find_by_id(bcol_account.id)
statement_settings = StatementSettingsService.update_statement_settings(
payment_account.auth_account_id, StatementFrequency.WEEKLY.value)
assert statement_settings is not None
assert statement_settings.get(
'frequency') == StatementFrequency.WEEKLY.value
assert statement_settings.get('to_date') is None
# monthly to weekly - assert weekly should start by next week first day
end_of_month_date = get_first_and_last_dates_of_month(
datetime.today().month,
datetime.today().year)[1]
assert statement_settings.get('from_date') == (
end_of_month_date + timedelta(days=1)).strftime(DT_SHORT_FORMAT)
# monthly to weekly - assert current active one is stil monthly ending end of the week
current_statement_settings = StatementSettingsModel.find_active_settings(
payment_account.auth_account_id, datetime.today())
assert current_statement_settings is not None
assert current_statement_settings.frequency == StatementFrequency.MONTHLY.value
assert current_statement_settings.to_date == end_of_month_date.date()
# travel to next week and see whats active
with freeze_time(end_of_month_date + timedelta(days=2)):
next_week_statement_settings = StatementSettingsModel.find_active_settings(
payment_account.auth_account_id, datetime.today())
assert next_week_statement_settings is not None
assert next_week_statement_settings.frequency == StatementFrequency.WEEKLY.value
assert next_week_statement_settings.to_date is None
def update_statement_settings(auth_account_id: str, frequency: str):
"""Update statements by account id.
rather than checking frequency changes by individual if , it just applies the following logic.
find the maximum frequency of current one and new one ;and calculate the date which it will keep on going.
"""
statements_settings_schema = StatementSettingsModelSchema()
today = datetime.today()
current_statements_settings = StatementSettingsModel.find_active_settings(
auth_account_id, today)
payment_account: PaymentAccountModel = PaymentAccountModel.find_by_auth_account_id(
auth_account_id)
if current_statements_settings is None:
# no frequency yet.first time accessing the statement settings.so create a new record
statements_settings = StatementSettingsModel(
frequency=frequency, payment_account_id=payment_account.id)
statements_settings.save()
return statements_settings_schema.dump(statements_settings)
# check if the latest one is the active one.. if not , inactivate the latest one.
# this handles the case of quickly changing of frequencies..
# changed from daily to monthly but then changed back to weekly..
# the monthly didn't get applied ,but even before that its being changed to weekly
future_statements_settings = StatementSettingsModel.find_latest_settings(
auth_account_id)
if future_statements_settings is not None and current_statements_settings.id != future_statements_settings.id:
future_statements_settings.to_date = today
future_statements_settings.save()
max_frequency = StatementSettings._find_longest_frequency(
current_statements_settings.frequency, frequency)
last_date = StatementSettings._get_end_of(max_frequency)
current_statements_settings.to_date = last_date
current_statements_settings.save()
new_statements_settings = StatementSettingsModel(
frequency=frequency,
payment_account_id=payment_account.id,
from_date=last_date + timedelta(days=1))
new_statements_settings.save()
return statements_settings_schema.dump(new_statements_settings)
def _persist_default_statement_frequency(payment_account_id):
statement_settings_model = StatementSettingsModel(
frequency=StatementFrequency.default_frequency().value,
payment_account_id=payment_account_id)
statement_settings_model.save()
