def test03(self):
luc = Contact.objects.get(id=2)
i1 = Invoice(number=2000, customer=luc, creation_date="2009-04-14")
i1.save()
i2 = Invoice(customer=luc, creation_date="2009-04-14")
i2.save()
self.assertEquals(i2.number, 2001)
def setUpClass(cls):
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
db.session.add(cls.policy)
db.session.commit()
cls.invoice_1 = Invoice(cls.policy.id, date(2015, 1, 1), date(2015, 1, 15), date(2015, 2, 1), 50)
cls.invoice_2 = Invoice(cls.policy.id, date(2015, 3, 1), date(2015, 3, 1), date(2015, 2, 1), 20)
db.session.add(cls.invoice_1)
db.session.add(cls.invoice_2)
db.session.commit()
def make_invoices(self):
"""
Creates invoices depending on policy's billing_schedule.
"""
billing_schedules = {
"Annual": 1,
"Two-Pay": 2,
"Quarterly": 4,
"Monthly": 12
}
months_after_eff_date_dict = {
"Annual": 12,
"Two-Pay": 6,
"Quarterly": 3,
"Monthly": 1,
}
invoices = []
first_invoice = Invoice(
self.policy.id,
self.policy.effective_date, # bill_date
self.policy.effective_date + relativedelta(months=1), # due
self.policy.effective_date +
relativedelta(months=1, days=14), # cancel
self.policy.annual_premium,
)
invoices.append(first_invoice)
if self.policy.billing_schedule in billing_schedules:
invoices_quantity = billing_schedules.get(
self.policy.billing_schedule)
first_invoice.amount_due = first_invoice.amount_due / invoices_quantity
months_between_invoices = months_after_eff_date_dict.get(
self.policy.billing_schedule)
for i in range(1, invoices_quantity):
a = i * months_between_invoices
bill_date = self.policy.effective_date + relativedelta(
months=a)
invoice = Invoice(
self.policy.id,
bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium /
billing_schedules.get(self.policy.billing_schedule),
)
invoices.append(invoice)
else:
print "You have chosen a bad billing schedule."
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def generate_monthly_invoices(policy_id):
# query the database to get the policy with the id
policy = Policy.query.filter_by(id=policy_id).one()
# check if the policy has an initial invoice generated by PolicyAccounting
if policy.invoices:
# check if the policy is a Policy Three plan
if policy.policy_number == "Policy Three":
# delete any pre-generated invoice for the policy
for invoice in policy.invoices:
db.session.delete(invoice)
# set the billing schedule to 12 i.e monthly
billing_schedule = 12
# create an empty list to store all invoices generated for the policy
invoices = []
# create an instance of invoice
first_invoice = Invoice(
policy.id,
policy.effective_date, # bill_date
policy.effective_date + relativedelta(months=1), # due
policy.effective_date +
relativedelta(months=1, days=14), # cancel
policy.annual_premium)
invoices.append(first_invoice)
first_invoice.amount_due = first_invoice.amount_due / billing_schedule
for i in range(1, billing_schedule):
months_after_eff_date = i * 1
bill_date = policy.effective_date + relativedelta(
months=months_after_eff_date)
# create an instance of invoice
invoice = Invoice(policy.id, bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
policy.annual_premium / billing_schedule)
# add the generated invoice to invoice list
invoices.append(invoice)
# save all the generated invoices to the database
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
print "Invoices generated for Policy Three (Monthly Schedule)"
else:
print(
"This not a Policy Three. Get the appropriate representation of Policy Three"
)
else:
print("Policy not found")
def make_invoices(self):
billing_schedules = {
'Annual': 1,
'Two-Pay': 2,
'Quarterly': 4,
'Monthly': 12
}
invoices = []
# Create an Invoice.
first_invoice = Invoice(
self.policy.id,
self.policy.effective_date, # bill_date
self.policy.effective_date + relativedelta(months=1), # due date
self.policy.effective_date +
relativedelta(months=1, days=14), # cancellation date
self.policy.annual_premium)
# Add invoice to array.
invoices.append(first_invoice)
# Get number of payments from billing_schedules
num_of_payments = billing_schedules.get(
self.policy.billing_schedule) or None
if not num_of_payments:
print "You have chosen a bad billing schedule."
# Calculate first invoice amount due by dividing total by number of payments
first_invoice.amount_due = first_invoice.amount_due / num_of_payments
for i in range(1, num_of_payments):
# Calculate months after effective date
months_after_eff_date = i * (12 / num_of_payments)
# Add months to effective date to get bill date
bill_date = self.policy.effective_date + relativedelta(
months=months_after_eff_date)
invoice = Invoice(
self.policy.id, bill_date, bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium /
billing_schedules.get(self.policy.billing_schedule))
invoices.append(invoice)
# Add new invoices to db
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def invoices(id=None):
if request.method == 'GET':
if id is not None:
invoice = Invoice.query.get(id)
if invoice:
return jsonify(invoice.serialize()), 200
return jsonify({"msg": "This invoice not found!"}), 404
else:
invoices = Invoice.query.all()
invoices = list(map(lambda invoice: invoice.serialize(), invoices))
return jsonify(invoices), 200
elif request.method == 'PUT':
invoice = Invoice.query.get(id)
invoice.email_paypal = request.json.get("email_paypal", "")
invoice.payment = request.json.get("payment", "")
invoice.date = request.json.get("date", "")
invoice.validity = request.json.get("validity", "")
invoice.update()
return jsonify('Actualizado correctamente'), 200
elif request.method == 'DELETE':
invoice = Invoice.query.get(id)
invoice.delete()
return jsonify('Borrado'), 200
elif request.method == "POST":
invoice = Invoice()
invoice.email_paypal = request.json.get("email_paypal", "")
invoice.payment = request.json.get("payment", "")
invoice.date = request.json.get("date", "")
invoice.validity = request.json.get("validity", "")
invoice.premium = request.json.get("premium", "")
invoice.save()
return jsonify(invoice.serialize()), 201
def handle_request_invoice(user_id, params):
plan = params.get('plan', None)
plan_from_db = db_session_users.query(Plan).filter_by(
stripe_id=plan).first()
if not plan_from_db:
return 'Invalid plan'
plan_name = plan_from_db.name
plan_id = plan_from_db.id
current_user = db_session_users.query(User).filter_by(id=user_id).first()
message = current_user.first_name + ' ' + current_user.last_name + ' is requesting to pay by invoice for the ' + plan_name + ' subscription. ' + current_user.first_name + ', the team at Compliance.ai will respond to your request soon!'
try:
email_helper.send_email(
'*****@*****.**',
current_user.email,
'Invoice request from ' + current_user.first_name,
template='feedback-inline',
vars={
'feedback': message,
'User_first_name': current_user.first_name,
'User_last_name': current_user.last_name,
},
)
except SMTPException as e:
return error_response('Could not send invoice email.', code=500)
invoice_for_db = {
'user_id': user_id,
'plan_id': plan_id,
'status': 'requested'
}
invoice_for_db = Invoice(invoice_for_db)
db_session_users.add(invoice_for_db)
db_session_users.commit()
db_session_users.refresh(invoice_for_db)
return {'invoice': 'invoice request sent'}
def make_invoices(self):
"""
Create invoices for new Policy's instances
"""
for invoice in self.policy.invoices:
invoice.delete()
invoices = []
first_invoice = Invoice(
self.policy.id,
self.policy.effective_date, #bill_date
self.policy.effective_date + relativedelta(months=1), #due
self.policy.effective_date +
relativedelta(months=1, days=14), #cancel
self.policy.annual_premium)
invoices.append(first_invoice)
if self.policy.billing_schedule == "Annual":
invoices += self.create_invoice(first_invoice, 12)
elif self.policy.billing_schedule == "Two-Pay":
invoices += self.create_invoice(first_invoice, 6)
elif self.policy.billing_schedule == "Quarterly":
invoices += self.create_invoice(first_invoice, 3)
elif self.policy.billing_schedule == "Monthly":
invoices += self.create_invoice(first_invoice, 1)
else:
print "You have chosen a bad billing schedule."
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def test04(self):
luc = Contact.objects.get(id=2)
table = Product.objects.get(id=1)
chair = Product.objects.get(id=2)
i = Invoice(customer=luc, creation_date="2009-04-14")
i.save()
i.docitem_set.create(pos=1, product=table, qty=1)
def invoices(request):
args = {}
args['user'] = auth.get_user(request)
if request.method == 'POST' and request.FILES['myfile']:
myfile = request.FILES['myfile']
fs = FileSystemStorage()
filename = fs.save(myfile.name, myfile)
uploaded_file_url = fs.url(filename)
invoice = Invoice(Photo=uploaded_file_url,
DateTime=datetime.datetime.now(),
User=auth.get_user(request))
invoice.save()
args['uploaded_file_url'] = uploaded_file_url
invoices_list = Invoice.objects.all()
paginator = Paginator(invoices_list, 9) # Show 25 contacts per page
page = request.GET.get('page')
try:
invoices = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
invoices = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
invoices = paginator.page(paginator.num_pages)
args['invoices'] = invoices
return render(request, 'invoices.html', args)
def create_invoice(self, first_invoice, period):
"""
:param first_invoice: Invoice instance
:param billing_schedules: dict with the schedules available
:param period: int with the number of periods (number of invoices)
:return: list with Invoice instances
"""
invoices = []
first_invoice.amount_due = first_invoice.amount_due / self.billing_schedules.get(
self.policy.billing_schedule)
for i in range(
1, self.billing_schedules.get(self.policy.billing_schedule)):
months_after_eff_date = i * period
bill_date = self.policy.effective_date + relativedelta(
months=months_after_eff_date)
amount = self.policy.annual_premium / self.billing_schedules.get(
self.policy.billing_schedule)
invoice = Invoice(
self.policy.id,
bill_date,
bill_date + relativedelta(months=1), #due date
bill_date + relativedelta(months=1, days=14), #cancel date
amount)
invoices.append(invoice)
return invoices
def invoice_create(utility, details, email, amount, utility_name):
# init bank recipient params
bank_account = details["bank_account"]
reference = details["reference"] if "reference" in details else ""
code = details["code"] if "code" in details else ""
particulars = details["particulars"] if "particulars" in details else ""
# request params
recipient_params = dict(reference=reference,
code=code,
particulars=particulars)
params = dict(market="ZAPNZD",
side="sell",
amount=str(amount),
amountasquotecurrency=True,
recipient=bank_account,
customrecipientparams=recipient_params)
# create request
r, err = bronze_request("BrokerCreate", params)
if not r:
return None, err
# extract token and create invoice
body = r.json()
broker_token = body["token"]
amount_cents_zap = int(decimal.Decimal(body["amountSend"]) * 100)
amount_cents_nzd = int(decimal.Decimal(body["amountReceive"]) * 100)
status = body["status"]
invoice = Invoice(email, amount_cents_nzd, amount_cents_zap, broker_token,
status, utility_name)
db.session.add(invoice)
db.session.commit()
return invoice, None
def make_invoices(self):
for invoice in self.policy.invoices:
invoice.deleted = True
billing_schedules = {
'Annual': None,
'Two-Pay': 2,
'Quarterly': 4,
'Monthly': 12
}
invoices = []
first_invoice = Invoice(
self.policy.id,
self.policy.effective_date, # bill_date
self.policy.effective_date + relativedelta(months=1), # due
self.policy.effective_date +
relativedelta(months=1, days=14), # cancel
self.policy.annual_premium)
invoices.append(first_invoice)
schedule = self.policy.billing_schedule
if schedule == "Annual":
pass
elif schedule in billing_schedules:
num_payments = billing_schedules.get(schedule)
# desire full-dollar bill amounts, but not always divisible, so add remainder to first installment
first_invoice.amount_due = first_invoice.amount_due / num_payments + first_invoice.amount_due % num_payments
for i in range(1, billing_schedules.get(schedule)):
months_after_eff_date = i * 12 / num_payments
bill_date = self.policy.effective_date + relativedelta(
months=months_after_eff_date)
invoice = Invoice(
self.policy.id, bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium /
billing_schedules.get(schedule))
invoices.append(invoice)
else:
print "You have chosen a bad billing schedule."
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def setUpClass(cls):
print("Setting up")
conn = mongoengine.connect(db=DB_NAME, host=DB_HOST)
for n in range(1, 11):
invoice = Invoice(x=n, invoice_number=2)
position = Position(**POSITION).save()
#invoice.positions = [InvoiceItem(position_id=str(position.id))]
invoice.positions = [InvoiceItem(position=position)]
invoice.save()
def no_payment(self, params):
re = db.get(params['rekey'])
invoices_count = len(Invoice().all(keys_only=True).filter('realestate', re.key()).filter('state', Invoice._NOT_PAID).fetch(10))
plural = 's' if invoices_count>1 else ''
context_ex = self.common_context()
context_ex = dict({'invoices_count':invoices_count, 'plural':plural}, **context_ex)
self.send_email('no_payment', re.email, u'Aviso de factura%s impaga%s' % (plural, plural), **context_ex)
def build(self):
if self.__provider is None:
raise Exception('Provider is required')
if self.__items is None:
raise Exception('No items')
return Invoice(company=self.__provider,
issued_at=self.__issued_at,
items=self.__items,
remarks=self.__remarks)
def process():
form = ServiceForm()
if form.validate_on_submit():
currency = int(form.currency.data)
if currency == 978:
invoice = Invoice(form.description.data, form.amount.data,
currency, 'payeer_usd', 'invoice')
invoice.save()
data = invoice.get_invoice_form_params()
return render_template('invoice.html', data=data, title='Invoice')
if currency == 840:
invoice = Invoice(form.description.data, form.amount.data,
currency, 'payeer_usd', 'tip')
invoice.save()
return render_template('tip.html',
invoice=invoice,
form_url=app.config['PS_TIP_URL'],
shop_id=app.config['PS_SHOP_ID'],
title='TIP')
return redirect(url_for('index'))
def post(self):
new_invoice = Invoice(client_name=request.json['client_name'])
db.session.add(new_invoice)
for item in request.json['invoice_items']:
new_invoice_item = InvoiceItem(
units = item['units'],
description = item['description'],
amount = item['amount'],
invoice = new_invoice
)
db.session.add(new_invoice_item)
db.session.commit()
return '', 204
def check():
form = InvoiceForm()
if form.validate_on_submit():
invoice = Invoice(
form.data['amount'],
form.data['currency'],
form.data['description']
)
db.session.add(invoice)
db.session.commit()
app.logger.info(u"invoice created: {}".format(invoice))
# hack for passing signature check
amount = int(invoice.amount) if (
int(invoice.amount) == float(invoice.amount)) else invoice.amount
payload = {
"shop_id": SHOP_ID,
"amount": amount,
"currency": invoice.currency,
'shop_invoice_id': invoice.id,
"description": invoice.description
}
if invoice.currency == '980':
payload["payway"] = 'w1_uah'
sign = _get_sign(payload, INVOICE_KEYS)
payload['sign'] = sign
resp = requests.post(UAH_INVOICE_URL, json=payload)
data = json.loads(resp.content)['data']
app.logger.info("data: {}".format(data))
if not data:
return jsonify(json.loads(resp.content))
url = data['source']
data = data['data']
elif invoice.currency == '643':
sign = _get_sign(payload, TIP_KEYS)
payload['sign'] = sign
data = payload
url = TIP_URL
else:
return jsonify({'result': 'error', 'message': 'Wrong currency'})
app.logger.info("data sent: {}".format(data))
return jsonify({'result': 'ok', 'data': data, 'url': url})
return jsonify({'result': 'error', 'message': 'Form validation error'})
def make_invoices(self, changing=False, proration=0):
if not changing:
for invoice in self.policy.invoices:
invoice.delete()
invoices = []
invoices_to_create = self.billing_schedules.get(self.policy.billing_schedule)
if changing:
if proration == 0:
logger.error("can't change policy with no invoices emitted")
db.session.rollback()
return
invoices_to_create = proration
if self.policy.billing_schedule in self.scheduling_interval:
for i in range(0, invoices_to_create):
months_after_eff_date = i * self.scheduling_interval[self.policy.billing_schedule]
bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date)
logger.debug(
"Creating [%s] Invoice => policy_id: %s / bill_date: %s / due_date: %s / cancel_date: %s / amount_due: %s",
self.policy.billing_schedule,
self.policy.id,
bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium / self.billing_schedules.get(self.policy.billing_schedule))
invoice = Invoice(self.policy.id,
bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium / self.billing_schedules.get(self.policy.billing_schedule))
invoices.append(invoice)
elif self.policy.billing_schedule == "Annual":
pass
else:
logger.info("You have chosen a bad billing schedule.")
db.session.rollback()
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def invoices(id=None):
if request.method == 'GET':
if id is not None:
invoice = Invoice.query.get(
id) # None por defecto si no consigue el registro
if invoice:
return jsonify(invoice.serialize()), 200
return jsonify({"msg": "Invoice not found"}), 404
else:
invoice = Invoice.query.all()
invoice = list(map(lambda invoice: invoice.serialize(), invoice))
return jsonify(invoice), 200
if request.method == 'POST':
urlPDF = request.json.get("urlPDF", None)
date = request.json.get("data", None)
amount = request.json.get("amount", None)
rut = request.json.get("rut", None)
if not urlPDF:
return jsonify({"msg": "URL is required"}), 400
if not date:
return jsonify({"msg": "Date is required"}), 400
if not amount:
return jsonify({"msg": "Amount is required"}), 400
if not rut:
return jsonify({"msg": "RUT is required"}), 400
invoice = Invoice.query.filter_by(id=id).first()
if invoice:
return jsonify({"msg": "Invoice already exists"}), 400
invoice = Invoice()
invoice.urlPDF = urlPDF
invoice.date = date
invoice.amount = amount
invoice.rut = rut
invoice.save()
return jsonify({"success": "Invoice Register Successfully"}), 200
def checkTime():
timelist = []
routedata = Booking.query.filter_by(user=g.id)
ctime = datetime.now()
ct = datetime.timestamp(ctime)
for i in routedata:
bt = datetime.timestamp(i.date)
rt = bt - ct
timelist.append(rt)
for data, rmt in zip(routedata, timelist):
if rmt <= 0:
entry = Invoice(user=data.user,
date=data.date,
fare=20,
route=data.route,
bussClass=data.bussClass)
db.session.add(entry)
Booking.query.filter_by(id=data.id).delete()
db.session.commit()
def invoice_frequency(months_next_invoice):
"""helper function to determine number of invoices"""
next_invoice.amount_due = remaining_balance / \
(billing_schedules.get(
self.policy.billing_schedule))
for i in range(1,
billing_schedules.get(
self.policy.billing_schedule)):
months_after_eff_date = (i * months_next_invoice)
bill_date = next_payment_date + \
relativedelta(months=months_after_eff_date)
invoice = Invoice(
self.policy.id, bill_date + relativedelta(months=1),
bill_date + relativedelta(months=2),
bill_date + relativedelta(months=2, days=14),
remaining_balance /
billing_schedules.get(self.policy.billing_schedule))
invoices.append(invoice)
def zarinpal( sale_plan_id, course_id = 0):
user_id = int(session_f['user_id'])
s = Session()
ZARINPAL_WEBSERVICE = 'https://www.zarinpal.com/pg/services/WebGate/wsdl'
MMERCHANT_ID = '46c993a0-9bed-11ea-8c18-000c295eb8fc'
invoice_date= datetime.now().strftime('%Y/%m/%d %H:%M:%S')
client = Client(ZARINPAL_WEBSERVICE)
sale_plan = s.query(Sale_plan).filter(Sale_plan.id == sale_plan_id).first()
user = s.query(User).filter(User.id == user_id).first()
if not (sale_plan or user):
result = {"result":"user or sale plane id not found"}
status_code = 401
else:
callback_url = f'{BASE_URL}/zarinpal-callback'
result_zarinpal = client.service.PaymentRequest(MMERCHANT_ID,
sale_plan.price,
sale_plan.title,
user.mobile,
'*****@*****.**',
callback_url)
if result_zarinpal.Status == 100:
if sale_plan_id == '3' :
lesson_ids = s.query(Lesson.id).filter(Lesson.course_id == course_id).all()
str_lesson = ''
for lesson_id in lesson_ids:
if str(lesson_id[0]) not in ['1','9','16','20','32','42']:
str_lesson = str_lesson +str(lesson_id[0]) + ","
lessons = str_lesson[:-1]
else:
lessons = sale_plan.lessons
invoice = Invoice( invoice_no = result_zarinpal.Authority, datetime = invoice_date , sale_plan_id = sale_plan_id, user_id = user_id, lessons = lessons, verify= -1)
s.add(invoice)
s.commit()
s.close()
zarinpal_url = f'https://www.zarinpal.com/pg/StartPay/{result_zarinpal.Authority}'
s.commit()
s.close()
return redirect(zarinpal_url)
else:
flash('با عرض پوزش در هنگام اتصال به درگاه بانک خطایی رخ داده است!','danger')
return redirect(url_for("confirm_purchase_information"))
def add_invoice():
product = Product(name=f'Produkt testowy {random.randint(1, 1000)}')
for _ in range(3):
product.stocks.append(
ProductStock(quantity=random.randint(1, 10), purchase_price=1))
invoice = Invoice(account=random.choice(accounts),
invoice_amount=10,
invoice_number=str(
random.randint(1, 9) * 100 +
random.randint(0, 9) * 10 + random.randint(0, 9)),
invoice_date=datetime.datetime.today())
for _ in range(5):
invoice_item = InvoiceItem(product=product,
name=product.name,
quantity=1,
price=2,
discount=0)
invoice.invoice_items.append(invoice_item)
session.add(invoice)
session.commit()
def new_invoice_excel():
excel_file = request.get_dict(field_name='invoice_file')
samsung_keys = (
'Shipped Parts',
'Qty',
'Amount',
'Delivery No',
'P/O No',
'Description',
'Tracking No',
)
# Check for valid Samsung invoice format
if all(k in excel_file for k in samsung_keys):
invoice_number = excel_file['Delivery No'][0]
if Invoice.query.get(invoice_number):
flash('This invoice already exists', 'alert-danger')
return redirect(url_for('invoices'))
invoice = Invoice(invoice_number=invoice_number)
for idx, part_number in enumerate(excel_file['Shipped Parts']):
qty = int(excel_file['Qty'][idx])
purchase_order_number = excel_file['P/O No'][idx]
description = excel_file['Description'][idx].strip()
price = float(excel_file['Amount'][idx]) / qty
part = Part.get_or_create(part_number, db.session)
part.description = description
part.price = price
for _ in range(qty):
invoice_detail = InvoiceDetail(
invoice_number=invoice_number,
purchase_order_number=purchase_order_number,
)
invoice_detail.part = part
invoice.parts.append(invoice_detail)
db.session.add(invoice)
db.session.commit()
flash('Imported excel file successfully', 'alert-success')
else:
flash('Invalid file, try again', 'alert-danger')
return redirect(url_for('invoices'))
def add_invoice():
account = session.query(Account).first()
product = Product(name='Produkt testowy')
for _ in range(3):
product.stocks.append(
ProductStock(quantity=random.randint(1, 10), purchase_price=1))
invoice = Invoice(account=account,
invoice_amount=2,
invoice_number='123',
invoice_date=datetime.datetime.today())
for _ in range(5):
invoice_item = InvoiceItem(product=product,
name='Zakup: ' + product.name,
quantity=1,
price=2,
discount=0)
invoice.invoice_items.append(invoice_item)
session.add(invoice)
session.commit()
def create_new_invoices(self,
invoices_left=None,
start_date=None,
due_now=None):
billing_schedules = {
'Annual': 1,
'Two-Pay': 2,
'Quarterly': 4,
'Monthly': 12
}
if not invoices_left:
invoices_left = billing_schedules.get(self.policy.billing_schedule)
if not start_date:
start_date = self.policy.effective_date
if not due_now:
due_now = self.policy.annual_premium
invoices = []
if self.policy.billing_schedule in billing_schedules:
for i in range(0, invoices_left):
months_after_eff_date = i * 12 / billing_schedules.get(
self.policy.billing_schedule)
bill_date = start_date + relativedelta(
months=months_after_eff_date)
invoice = Invoice(self.policy.id, bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
due_now / invoices_left)
invoices.append(invoice)
else:
print "You have chosen a bad billing schedule."
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
def new_invoice_post():
invoice_number = request.form['invoice_number']
received_date = us_to_sql_date(request.form['date_received']),
part_numbers = filter(None, request.form.getlist('part_numbers[]'))
part_numbers = [x.upper() for x in part_numbers]
assoc_pos = request.form.getlist('assoc_pos[]')
shelf_locations = request.form.getlist('shelf_locations[]')
if Invoice.query.get(invoice_number):
flash("The invoice number has already existed", 'alert-danger')
return redirect(url_for('new_invoice'))
invoice = Invoice(invoice_number=invoice_number,
received_date=received_date)
for idx, x in enumerate(part_numbers):
invoice_detail = InvoiceDetail(
purchase_order_number=assoc_pos[idx],
shelf_location=shelf_locations[idx],
)
part = Part.get_or_create(x, db.session)
invoice_detail.part = part
invoice.parts.append(invoice_detail)
db.session.add(invoice)
db.session.commit()
flash('Invoice created successfully', 'alert-success')
return redirect(url_for('invoices'))
def make_invoices(self):
for invoice in self.policy.invoices:
invoice.delete()
billing_schedules = {
'Annual': None,
'Semi-Annual': 3,
'Quarterly': 4,
'Monthly': 12
}
invoices = []
first_invoice = Invoice(
self.policy.id,
self.policy.effective_date, #bill_date
self.policy.effective_date + relativedelta(months=1), #due
self.policy.effective_date +
relativedelta(months=1, days=14), #cancel
self.policy.annual_premium)
invoices.append(first_invoice)
if self.policy.billing_schedule == "Annual":
pass
elif self.policy.billing_schedule == "Two-Pay":
first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(
self.policy.billing_schedule)
for i in range(1,
billing_schedules.get(
self.policy.billing_schedule)):
months_after_eff_date = i * 6
bill_date = self.policy.effective_date + relativedelta(
months=months_after_eff_date)
invoice = Invoice(
self.policy.id, bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium /
billing_schedules.get(self.policy.billing_schedule))
invoices.append(invoice)
elif self.policy.billing_schedule == "Quarterly":
first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(
self.policy.billing_schedule)
for i in range(1,
billing_schedules.get(
self.policy.billing_schedule)):
months_after_eff_date = i * 3
bill_date = self.policy.effective_date + relativedelta(
months=months_after_eff_date)
invoice = Invoice(
self.policy.id, bill_date,
bill_date + relativedelta(months=1),
bill_date + relativedelta(months=1, days=14),
self.policy.annual_premium /
billing_schedules.get(self.policy.billing_schedule))
invoices.append(invoice)
elif self.policy.billing_schedule == "Monthly":
pass
else:
print "You have chosen a bad billing schedule."
for invoice in invoices:
db.session.add(invoice)
db.session.commit()
