def vorschau(von='Kein von',
fuer='Kein für',
widmung='Keine Widmung',
betrag=0,
motiv=''):
gutschein = frappe.get_doc("Gutschein", 'Gutschein-000001')
gutschein.text_from = von
gutschein.text_to = fuer
gutschein.inscription = widmung.replace("\n", "<br>")
gutschein.amount = betrag
gutschein.selling_date = nowdate()
gutschein.valid_date = add_years(nowdate(), 5)
if motiv == 'Herz':
motiv = 'Wintergruss'
if motiv == 'Blumen':
motiv = 'Herbstblüte'
if motiv == 'Blumen2':
motiv = 'Glücksbringer'
if motiv == 'Hortensien':
motiv = 'Sommergarten'
if motiv == 'Tulpenstrauss':
motiv = 'Frühlingsstrauss'
gutschein.motiv = motiv
gutschein.save(ignore_permissions=True)
return
def process_for_active(self):
"""
Called by `process` if the status of the `Subscription` is 'Active'.
The possible outcomes of this method are:
1. Generate a new invoice
2. Change the `Subscription` status to 'Past Due Date'
3. Change the `Subscription` status to 'Cancelled'
"""
if not self.is_current_invoice_generated() and not self.is_current_invoice_paid() and \
(self.is_postpaid_to_invoice() or self.is_prepaid_to_invoice()):
self.generate_invoice()
if self.current_invoice_is_past_due():
self.status = 'Past Due Date'
if self.current_invoice_is_past_due() and getdate(nowdate()) > getdate(
self.current_invoice_end):
self.status = 'Past Due Date'
if self.cancel_at_period_end and getdate(nowdate()) > getdate(
self.current_invoice_end):
self.cancel_subscription_at_period_end()
if self.is_current_invoice_generated() and getdate() > getdate(
self.current_invoice_end):
self.update_subscription_period(
add_days(self.current_invoice_end, 1))
def handle_timesheet(user,
doctype,
reference,
time,
bemerkung='',
date=nowdate()):
_date = getdate(date)
latest_date = getdate(add_days(nowdate(), -7))
if _date < latest_date:
frappe.throw(
"Sie können maximal 7 Tage in die Vergangenheit buchungen vornehmen."
)
user = frappe.db.sql(
"""SELECT `name` FROM `tabEmployee` WHERE `user_id` = '{user}'""".
format(user=user),
as_list=True)
if not user:
frappe.throw("Es wurde kein Mitarbeiterstamm gefunden!")
else:
user = user[0][0]
if not time:
time = 0.000
else:
time = float(time)
ts = check_if_timesheet_exist(user, date)
if ts == 'gebucht':
frappe.throw("Das Timesheet vom {datum} ist bereits verbucht.".format(
date=date))
elif ts == 'neuanlage':
create_timesheet(user, doctype, reference, time, bemerkung, date)
else:
update_timesheet(ts, time, doctype, reference, user, bemerkung, date)
def process_for_active(self):
"""
Called by `process` if the status of the `Subscription` is 'Active'.
The possible outcomes of this method are:
1. Generate a new invoice
2. Change the `Subscription` status to 'Past Due Date'
3. Change the `Subscription` status to 'Cancelled'
"""
if getdate(nowdate()) > getdate(self.current_invoice_end) or (
getdate(nowdate()) >= getdate(self.current_invoice_end)
and getdate(self.current_invoice_end) == getdate(
self.current_invoice_start)
) and not self.has_outstanding_invoice():
self.generate_invoice()
if self.current_invoice_is_past_due():
self.status = 'Past Due Date'
if self.current_invoice_is_past_due() and getdate(nowdate()) > getdate(
self.current_invoice_end):
self.status = 'Past Due Date'
if self.cancel_at_period_end and getdate(
nowdate()) > self.current_invoice_end:
self.cancel_subscription_at_period_end()
def set_plan_details_status(self):
for plan in self.plans:
if getdate(plan.from_date or "1900-01-01") <= getdate(
nowdate()) and getdate(
plan.to_date or "3000-12-31") >= getdate(nowdate()):
plan.status = "Active"
else:
plan.status = "Inactive"
def test_create_subscription_trial_with_wrong_dates(self):
subscription = frappe.new_doc('Subscription')
subscription.subscriber = '_Test Customer'
subscription.trial_period_end = nowdate()
subscription.trial_period_start = add_days(nowdate(), 30)
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
self.assertRaises(frappe.ValidationError, subscription.save)
subscription.delete()
def is_prepaid_to_invoice(self): if not self.generate_invoice_at_period_start: return False if self.is_new_subscription() and getdate(nowdate()) >= getdate(self.current_invoice_start): return True # Check invoice dates and make sure it doesn't have outstanding invoices return getdate(nowdate()) >= getdate(self.current_invoice_start)
def test_create_subscription_trial_with_wrong_dates(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.trial_period_end = nowdate()
subscription.trial_period_start = add_days(nowdate(), 30)
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
self.assertRaises(frappe.ValidationError, subscription.save)
subscription.delete()
def make_membership(self):
doc = frappe.new_doc("Library Membership")
doc.set('library_member', self.name)
doc.set('member_first_name', self.first_name)
doc.set('member_last_name', self.last_name)
doc.set('from_date', nowdate())
doc.set('to_date', add_years(nowdate(), 1))
doc.save()
def test_create_subscription_trial_with_wrong_dates(self):
subscription = frappe.new_doc("Subscription")
subscription.party_type = "Customer"
subscription.party = "_Test Customer"
subscription.trial_period_end = nowdate()
subscription.trial_period_start = add_days(nowdate(), 30)
subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
self.assertRaises(frappe.ValidationError, subscription.save)
subscription.delete()
def test_create_subscription_multi_with_different_billing_fails(self):
subscription = frappe.new_doc('Subscription')
subscription.subscriber = '_Test Customer'
subscription.trial_period_end = nowdate()
subscription.trial_period_start = add_days(nowdate(), 30)
subscription.append('plans', {'plan': '_Test Plan Name'})
subscription.append('plans', {'plan': '_Test Plan Name 3'})
self.assertRaises(frappe.ValidationError, subscription.save)
subscription.delete()
def _set_status(renting):
status = None
if renting.docstatus == 0:
status = "Draft"
elif renting.docstatus == 2:
status = "Cancelled"
elif renting.docstatus == 1:
status = get_status({
"Active": [renting.contract_end_date > nowdate()],
"Expired": [renting.contract_end_date < nowdate()],
})
renting.db_set("status", status, update_modified=True)
def restart_subscription(self):
"""
This sets the subscription as active. The subscription will be made to be like a new
subscription and the `Subscription` will lose all the history of generated invoices
it has.
"""
if self.status == 'Cancelled':
self.status = 'Active'
self.db_set('start', nowdate())
self.update_subscription_period(nowdate())
self.invoices = []
self.save()
else:
frappe.throw(_('You cannot restart a Subscription that is not cancelled.'))
def restart_subscription(self):
"""
This sets the subscription as active. The subscription will be made to be like a new
subscription and the `Subscription` will lose all the history of generated invoices
it has.
"""
if self.status == 'Cancelled':
self.status = 'Active'
self.db_set('start', nowdate())
self.update_subscription_period(nowdate())
self.invoices = []
self.save()
else:
frappe.throw(_('You cannot restart a Subscription that is not cancelled.'))
def validate(self):
if not self.last_calibration:
self.last_calibration = nowdate()
self.next_calibration = add_months(getdate(self.last_calibration),
self.calibration_interval)
if self.status == 'Calibrated':
if getdate(self.next_calibration) < getdate(nowdate()):
self.status = 'To Calibrate'
if self.status == 'To Calibrate':
if getdate(self.next_calibration) >= getdate(nowdate()):
self.status = 'Calibrated'
def test_create_subscription_without_trial_with_correct_period(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, None)
self.assertEqual(subscription.trial_period_end, None)
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
# No invoice is created
self.assertEqual(len(subscription.invoices), 0)
self.assertEqual(subscription.status, 'Active')
subscription.delete()
def test_create_subscription_without_trial_with_correct_period(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, None)
self.assertEqual(subscription.trial_period_end, None)
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
# No invoice is created
self.assertEqual(len(subscription.invoices), 0)
self.assertEqual(subscription.status, 'Active')
subscription.delete()
def test_subscription_is_past_due_doesnt_change_within_grace_period(self):
settings = frappe.get_single("Subscription Settings")
grace_period = settings.grace_period
settings.grace_period = 1000
settings.save()
subscription = frappe.new_doc("Subscription")
subscription.party_type = "Customer"
subscription.party = "_Test Customer"
subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
subscription.start_date = add_days(nowdate(), -1000)
subscription.insert()
subscription.process() # generate first invoice
self.assertEqual(subscription.status, "Past Due Date")
subscription.process()
# Grace period is 1000 days so status should remain as Past Due Date
self.assertEqual(subscription.status, "Past Due Date")
subscription.process()
self.assertEqual(subscription.status, "Past Due Date")
subscription.process()
self.assertEqual(subscription.status, "Past Due Date")
settings.grace_period = grace_period
settings.save()
subscription.delete()
def test_subscription_cancellation_invoices_with_prorata_true(self):
settings = frappe.get_single("Subscription Settings")
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc("Subscription")
subscription.party_type = "Customer"
subscription.party = "_Test Customer"
subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
subscription.save()
subscription.cancel_subscription()
invoice = subscription.get_current_invoice()
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(
date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1
)
prorate_factor = flt(diff / plan_days)
self.assertEqual(flt(invoice.grand_total, 2), flt(prorate_factor * 900, 2))
settings.prorate = to_prorate
settings.save()
subscription.delete()
def cancel_subscription_at_period_end(self): """ Called when `Subscription.cancel_at_period_end` is truthy """ self.status = 'Cancelled' if not self.cancelation_date: self.cancelation_date = nowdate()
def test_create_subscription_with_trial_with_correct_period(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.trial_period_start = nowdate()
subscription.trial_period_end = add_days(nowdate(), 30)
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, nowdate())
self.assertEqual(subscription.trial_period_end, add_days(nowdate(), 30))
self.assertEqual(subscription.trial_period_start, subscription.current_invoice_start)
self.assertEqual(subscription.trial_period_end, subscription.current_invoice_end)
self.assertEqual(subscription.invoices, [])
self.assertEqual(subscription.status, 'Trialling')
subscription.delete()
def test_invoice_is_generated_at_end_of_billing_period(self):
start_date = add_to_date(nowdate(), months=-1)
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.start = start_date
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.insert()
self.assertEqual(subscription.status, 'Active')
self.assertEqual(subscription.current_invoice_start, start_date)
self.assertEqual(subscription.current_invoice_end, add_days(nowdate(), -1))
subscription.process()
self.assertEqual(len(subscription.invoices), 1)
self.assertEqual(subscription.status, 'Past Due Date')
subscription.delete()
def test_create_subscription_without_trial_with_correct_period(self):
subscription = frappe.new_doc("Subscription")
subscription.party_type = "Customer"
subscription.party = "_Test Customer"
subscription.append("plans", {"plan": "_Test Plan Name", "qty": 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, None)
self.assertEqual(subscription.trial_period_end, None)
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
# No invoice is created
self.assertEqual(len(subscription.invoices), 0)
self.assertEqual(subscription.status, "Active")
subscription.delete()
def cancel_subscription_at_period_end(self): """ Called when `Subscription.cancel_at_period_end` is truthy """ self.status = 'Cancelled' if not self.cancelation_date: self.cancelation_date = nowdate()
def calculate_gross_gratuity():
"""
Calculate gratuity / indemnity on Employee
:return:
"""
employees = frappe.db.sql("""
SELECT name, employee_name, date_of_joining, nationality, ashbee_gratuity_paid_till_date
FROM `tabEmployee`
WHERE status = 'Active'
""",
as_dict=1)
filtered_employees = list(
filter(lambda x: x['nationality'] != 'Bahraini', employees))
salaries = _get_salaries()
now = nowdate()
for employee in filtered_employees:
name = employee.get('name')
date_of_joining = employee.get('date_of_joining')
working_years, last_working_year_days = year_diff(now, date_of_joining)
salary = salaries.get(name, 0.00)
total_gratuity = sum([
_get_gross_gratuity(working_years, salary),
_get_per_day_gratuity(working_years, last_working_year_days,
salary),
-employee.get('ashbee_gratuity_paid_till_date', 0)
])
frappe.db.set_value('Employee', name, 'ashbee_gratuity_till_date',
total_gratuity)
def test_prepaid_subscriptions_with_prorate_true(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.party_type = 'Customer'
subscription.party = '_Test Customer'
subscription.generate_invoice_at_period_start = True
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
subscription.process()
subscription.cancel_subscription()
self.assertEqual(len(subscription.invoices), 1)
current_inv = subscription.get_current_invoice()
self.assertEqual(current_inv.status, "Unpaid")
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1)
prorate_factor = flt(diff / plan_days)
self.assertEqual(flt(current_inv.grand_total, 2), flt(prorate_factor * 900, 2))
settings.prorate = to_prorate
settings.save()
subscription.delete()
def get_context(context):
if frappe.session.user == 'Guest':
frappe.throw(_("You need to be logged in to access this page"),
frappe.PermissionError)
if "TeamPlaner Spieler" not in frappe.get_roles(frappe.session.user):
frappe.throw(
_("Du benötigst eine Spieler Rolle für den Zugriff auf diese Seite"
), frappe.PermissionError)
context.show_sidebar = True
context['trainings'] = frappe.client.get_list(
'TeamPlaner Spiel',
fields=[
'name', 'von', 'bis', 'ort', 'aufgebot_status',
'zwei_aufgebot_status', 'beschriftung', 'gegner', 'zweiter_gegner'
],
filters=[['datum', '>=', nowdate()]],
order_by='name',
limit_page_length=1000)
context['teilnehmer'] = {}
context['spieler'] = {}
i = 1
context['trainings_kurz'] = []
for training in context['trainings']:
if i <= 5:
context['trainings_kurz'].append(training)
i += 1
teiln = count_teilnehmer(training.name, 'TeamPlaner Spiel')
total = count_total_teilnehmer(training.name, 'TeamPlaner Spiel')
context['teilnehmer'][training.name] = '{teiln} von {total}'.format(
teiln=teiln, total=total)
context['spieler'][training.name] = teilnehmer_details(
training.name, 'TeamPlaner Spiel')
return context
def test_subscription_is_past_due_doesnt_change_within_grace_period(self):
settings = frappe.get_single('Subscription Settings')
grace_period = settings.grace_period
settings.grace_period = 1000
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.party_type = 'Customer'
subscription.party = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.start_date = add_days(nowdate(), -1000)
subscription.insert()
subscription.process() # generate first invoice
self.assertEqual(subscription.status, 'Past Due Date')
subscription.process()
# Grace period is 1000 days so status should remain as Past Due Date
self.assertEqual(subscription.status, 'Past Due Date')
subscription.process()
self.assertEqual(subscription.status, 'Past Due Date')
subscription.process()
self.assertEqual(subscription.status, 'Past Due Date')
settings.grace_period = grace_period
settings.save()
subscription.delete()
def test_subscription_cancellation_invoices(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.party_type = 'Customer'
subscription.party = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.status, 'Active')
subscription.cancel_subscription()
# Invoice must have been generated
self.assertEqual(len(subscription.invoices), 1)
invoice = subscription.get_current_invoice()
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1)
prorate_factor = flt(diff/plan_days)
self.assertEqual(
flt(
get_prorata_factor(subscription.current_invoice_end, subscription.current_invoice_start),
2),
flt(prorate_factor, 2)
)
self.assertEqual(flt(invoice.grand_total, 2), flt(prorate_factor * 900, 2))
self.assertEqual(subscription.status, 'Cancelled')
subscription.delete()
settings.prorate = to_prorate
settings.save()
def test_subscription_cancellation_invoices_with_prorata_true(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.subscriber = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
subscription.cancel_subscription()
invoice = subscription.get_current_invoice()
diff = flt(
date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(
date_diff(subscription.current_invoice_end,
subscription.current_invoice_start) + 1)
prorate_factor = flt(diff / plan_days)
self.assertEqual(flt(invoice.grand_total, 2),
flt(prorate_factor * 900, 2))
settings.prorate = to_prorate
settings.save()
subscription.delete()
def test_prepaid_subscriptions_with_prorate_true(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.generate_invoice_at_period_start = True
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
subscription.cancel_subscription()
self.assertEqual(len(subscription.invoices), 1)
current_inv = subscription.get_current_invoice()
self.assertEqual(current_inv.status, "Unpaid")
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1)
prorate_factor = flt(diff / plan_days)
self.assertEqual(flt(current_inv.grand_total, 2), flt(prorate_factor * 900, 2))
settings.prorate = to_prorate
settings.save()
subscription.delete()
def make_meebership(self):
doc=frappe.new_doc("Membership")
doc.set('member_name',self.name)
doc.set('member_frist_name',self.frist_name)
doc.set('member_last_name',self.last_name)
doc.set('status','Active')
doc.set('email',self.email)
doc.set('phone',self.phone)
doc.set('form_date',nowdate())
doc.set('to_date',add_years(nowdate(),1))
doc.save()
doc.submit()
frappe.msgprint("Libray Membership Are Generate For 1 Year")
def test_create_subscription_with_trial_with_correct_period(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.trial_period_start = nowdate()
subscription.trial_period_end = add_days(nowdate(), 30)
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, nowdate())
self.assertEqual(subscription.trial_period_end, add_days(nowdate(), 30))
self.assertEqual(subscription.trial_period_start, subscription.current_invoice_start)
self.assertEqual(subscription.trial_period_end, subscription.current_invoice_end)
self.assertEqual(subscription.invoices, [])
self.assertEqual(subscription.status, 'Trialling')
subscription.delete()
def test_subscription_cancellation_invoices(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.status, 'Active')
subscription.cancel_subscription()
# Invoice must have been generated
self.assertEqual(len(subscription.invoices), 1)
invoice = subscription.get_current_invoice()
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1)
prorate_factor = flt(diff/plan_days)
self.assertEqual(
flt(
get_prorata_factor(subscription.current_invoice_end, subscription.current_invoice_start),
2),
flt(prorate_factor, 2)
)
self.assertEqual(flt(invoice.grand_total, 2), flt(prorate_factor * 900, 2))
self.assertEqual(subscription.status, 'Cancelled')
subscription.delete()
settings.prorate = to_prorate
settings.save()
def set_current_invoice_start(self, date=None):
if self.trial_period_start and self.is_trial():
self.current_invoice_start = self.trial_period_start
elif date:
self.current_invoice_start = date
else:
self.current_invoice_start = nowdate()
def create_payment(self):
from erpnext.accounts.party import get_party_account
from erpnext.accounts.utils import get_account_currency
payment_entry = frappe.new_doc("Payment Entry")
bank_account_name = frappe.db.get_value(
"Bank Account", {
"is_default": 1,
"is_company_account": 1,
"company": erpnext.get_default_company()
}, "name")
bank_account = frappe.get_doc("Bank Account", bank_account_name)
payment_entry.posting_date = nowdate()
payment_entry.company = self.company
payment_entry.paid_amount = self.grand_total
payment_entry.party = self.customer
payment_entry.paid_from = get_party_account("Customer", self.customer,
self.company)
payment_entry.paid_from_account_currency = get_account_currency(
payment_entry.paid_from)
payment_entry.bank_account = bank_account_name
payment_entry.paid_to = bank_account.account
payment_entry.received_amount = self.grand_total
payment_entry.reference_no = f"{self.customer}-{self.name}"
payment_entry.reference_date = self.current_invoice_start if self.generate_invoice_at_period_start else self.current_invoice_end
payment_entry.payment_type = "Receive"
payment_entry.party_type = "Customer"
payment_entry.paid_to_account_currency = self.currency
return payment_entry
def test_create_subscription_with_trial_with_correct_period(self):
subscription = frappe.new_doc('Subscription')
subscription.party_type = 'Customer'
subscription.party = '_Test Customer'
subscription.trial_period_start = nowdate()
subscription.trial_period_end = add_months(nowdate(), 1)
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
self.assertEqual(subscription.trial_period_start, nowdate())
self.assertEqual(subscription.trial_period_end, add_months(nowdate(), 1))
self.assertEqual(add_days(subscription.trial_period_end, 1), get_date_str(subscription.current_invoice_start))
self.assertEqual(add_to_date(subscription.current_invoice_start, months=1, days=-1), get_date_str(subscription.current_invoice_end))
self.assertEqual(subscription.invoices, [])
self.assertEqual(subscription.status, 'Trialling')
subscription.delete()
def is_prepaid_to_invoice(self): if not self.generate_invoice_at_period_start: return False if self.is_new_subscription(): return True # Check invoice dates and make sure it doesn't have outstanding invoices return getdate(nowdate()) >= getdate(self.current_invoice_start) and not self.has_outstanding_invoice()
def is_past_grace_period(self):
"""
Returns `True` if the grace period for the `Subscription` has passed
"""
current_invoice = self.get_current_invoice()
if self.current_invoice_is_past_due(current_invoice):
subscription_settings = frappe.get_single('Subscription Settings')
grace_period = cint(subscription_settings.grace_period)
return getdate(nowdate()) > add_days(current_invoice.due_date, grace_period)
def period_has_passed(end_date): """ Returns true if the given `end_date` has passed """ # todo: test for illegal time if not end_date: return True end_date = getdate(end_date) return getdate(nowdate()) > getdate(end_date)
def process_for_active(self): """ Called by `process` if the status of the `Subscription` is 'Active'. The possible outcomes of this method are: 1. Generate a new invoice 2. Change the `Subscription` status to 'Past Due Date' 3. Change the `Subscription` status to 'Cancelled' """ if self.is_postpaid_to_invoice or self.is_prepaid_to_invoice: self.generate_invoice() if self.current_invoice_is_past_due(): self.status = 'Past Due Date' if self.current_invoice_is_past_due() and getdate(nowdate()) > getdate(self.current_invoice_end): self.status = 'Past Due Date' if self.cancel_at_period_end and getdate(nowdate()) > getdate(self.current_invoice_end): self.cancel_subscription_at_period_end()
def current_invoice_is_past_due(self, current_invoice=None): """ Returns `True` if the current generated invoice is overdue """ if not current_invoice: current_invoice = self.get_current_invoice() if not current_invoice: return False else: return getdate(nowdate()) > getdate(current_invoice.due_date)
def get_cheque_info(name=None):
res = []
if name:
ref_doc = frappe.get_doc("Cheque Lot", name)
cheque_no = ref_doc.next_no
cheque_date = nowdate()
res.append({"reference_no": cheque_no})
res.append({"reference_date": cheque_date})
update_cheque_lot(ref_doc)
return res
def test_subscription_invoice_days_until_due(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.days_until_due = 10
subscription.start = add_months(nowdate(), -1)
subscription.insert()
subscription.process() # generate first invoice
self.assertEqual(len(subscription.invoices), 1)
self.assertEqual(subscription.status, 'Active')
subscription.delete()
def set_current_invoice_start(self, date=None): """ This sets the date of the beginning of the current billing period. If the `date` parameter is not given , it will be automatically set as today's date. """ if self.trial_period_start and self.is_trialling(): self.current_invoice_start = self.trial_period_start elif date: self.current_invoice_start = date else: self.current_invoice_start = nowdate()
def test_subscription_remains_active_during_invoice_period(self):
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
subscription.process() # no changes expected
self.assertEqual(subscription.status, 'Active')
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
self.assertEqual(len(subscription.invoices), 0)
subscription.process() # no changes expected still
self.assertEqual(subscription.status, 'Active')
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
self.assertEqual(len(subscription.invoices), 0)
subscription.process() # no changes expected yet still
self.assertEqual(subscription.status, 'Active')
self.assertEqual(subscription.current_invoice_start, nowdate())
self.assertEqual(subscription.current_invoice_end, add_to_date(nowdate(), months=1, days=-1))
self.assertEqual(len(subscription.invoices), 0)
subscription.delete()
def cancel_subscription(self):
"""
This sets the subscription as cancelled. It will stop invoices from being generated
but it will not affect already created invoices.
"""
if self.status != 'Cancelled':
to_generate_invoice = True if self.status == 'Active' else False
to_prorate = frappe.db.get_single_value('Subscription Settings', 'prorate')
self.status = 'Cancelled'
self.cancelation_date = nowdate()
if to_generate_invoice:
self.generate_invoice(prorate=to_prorate)
self.save()
def supplement(to_cc=None, to_acc=None, amount=None, fiscal_year=None):
to_account = get_cc_acc_budget(to_cc, to_acc, fiscal_year)
if to_account:
#Add in the To Account and Cost Center
to_budget_account = frappe.get_doc("Budget Account", to_account[0].name)
supplement = flt(to_budget_account.supplementary_budget) + flt(amount)
total = flt(to_budget_account.budget_amount) + flt(amount)
to_budget_account.db_set("supplementary_budget", supplement)
to_budget_account.db_set("budget_amount", total)
#Add the reappropriation details for record
supp_details = frappe.new_doc("Supplementary Details")
supp_details.to_cc = to_cc
supp_details.to_acc = to_acc
supp_details.amount = amount
supp_details.posted_date = nowdate()
supp_details.submit()
return "DONE"
else:
return "The budget head you specified doesn't exist. Please try again"
def test_subscription_cancellation_invoices_with_prorata_true(self):
settings = frappe.get_single('Subscription Settings')
to_prorate = settings.prorate
settings.prorate = 1
settings.save()
subscription = frappe.new_doc('Subscription')
subscription.customer = '_Test Customer'
subscription.append('plans', {'plan': '_Test Plan Name', 'qty': 1})
subscription.save()
subscription.cancel_subscription()
invoice = subscription.get_current_invoice()
diff = flt(date_diff(nowdate(), subscription.current_invoice_start) + 1)
plan_days = flt(date_diff(subscription.current_invoice_end, subscription.current_invoice_start) + 1)
prorate_factor = flt(diff / plan_days)
self.assertEqual(flt(invoice.grand_total, 2), flt(prorate_factor * 900, 2))
settings.prorate = to_prorate
settings.save()
subscription.delete()
def is_postpaid_to_invoice(self): return getdate(nowdate()) > getdate(self.current_invoice_end) or \ (getdate(nowdate()) >= getdate(self.current_invoice_end) and getdate(self.current_invoice_end) == getdate(self.current_invoice_start)) and \ not self.has_outstanding_invoice()
def get_prorata_factor(period_end, period_start): diff = flt(date_diff(nowdate(), period_start) + 1) plan_days = flt(date_diff(period_end, period_start) + 1) prorate_factor = diff / plan_days return prorate_factor
