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 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 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 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 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 change_pending_status(): if Security.is_login(SK): callback = request.form['callback'] try: Invoice.change_pending_status(request.form['pending_id']) except Exception as e: print(e) return 'Failed' return redirect(url_for(callback)) return redirect(url_for('login', callback=stack()[0][3]))
def make_invoices(self): #Function to make invoices with no arguments for invoice in self.policy.invoices: invoice.delete() billing_schedules = {'Annual': None, 'Semi-Annual': 3, 'Quarterly': 4, 'Monthly': 12} #Creating a dictionary that specifies the definitions of each word invoices = [] #Creating a list names invoices first_invoice = Invoice(self.policy.id, #Creating the first invoice from using Invoice() from models.py self.policy.effective_date, #bill_date self.policy.effective_date + relativedelta(months=1), #due date self.policy.effective_date + relativedelta(months=1, days=14), #cancel date two weeks after self.policy.annual_premium) #Amount due invoices.append(first_invoice) #Placing first invoice into the list named invoices if self.policy.billing_schedule == "Annual": #If the billing schedule is equal to Annual then pass pass elif self.policy.billing_schedule == "Two-Pay": #Else if the billing schedule is equto to Two-Pay first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(self.policy.billing_schedule) #Figuring out amount due from first invoice for i in range(1, billing_schedules.get(self.policy.billing_schedule)): #For every object in the range(starting at one,stopping at billing schedule) months_after_eff_date = i*6 #Multiplies by 6 to split 12 months into two payments bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date) invoice = Invoice(self.policy.id, #Create an invoice for this specification 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": #Else if billing schedule is 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 #Multiplies by 3 to split 12 months into 4 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(self.policy.billing_schedule)) invoices.append(invoice) elif self.policy.billing_schedule == "Monthly": #Else if billing schedule is Monthly 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*1 #Changing variable i to be multiplied by 1 so we have 12 monthly invoices 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) else: print "You have chosen a bad billing schedule." #If all the if and elif statements are False then print a bad billing schedule for invoice in invoices: #For every invoice add the invoice and commit to database db.session.add(invoice) db.session.commit()
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 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 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 set_data_for(self, value): if value: try: invoices = Invoice.select().where(Invoice.number == int(value)) except Exception as e: Config.logging.error(e) invoices = Invoice.select().where(Invoice.location.contains(value) | Invoice.client.contains(value)) else: invoices = Invoice.select().order_by(Invoice.number.asc()) self.data = [(invoice.owner, invoice.number, show_date(invoice.date), invoice.client, "") for invoice in invoices]
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 email_invoices_timer_callback(): logger.info("email_invoices_timer_callback()..") with app.app_context(): invoices = Invoice.all_with_email_and_not_terminated(db.session) for invoice in invoices: order = bronze_order_status(invoice) if order: if invoice.status != order["status"]: invoice_url = url_for("invoice", token=invoice.token) hostname = urllib.parse.urlparse(invoice_url).hostname sender = "no-reply@" + hostname formatted_amount = '{0:0.2f}'.format(invoice.amount / 100.0) # send email msg = Message('ZAP bill payment status updated', sender=sender, recipients=[invoice.email]) msg.html = 'Invoice <a href="{}">{}</a> has updated the {} invoice with the amount of ${} to status "{}"'.format( invoice_url, invoice.token, invoice.utility_name, formatted_amount, order["status"]) msg.body = 'Invoice {} has updated the {} invoice with the amount of ${} to status {}'.format( invoice_url, invoice.utility_name, formatted_amount, order["status"]) mail.send(msg) # update invoice object invoice.status = order["status"] db.session.commit()
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 index(): db = connect_db() seed_db(db) invoice = Invoice.objects().first() results = process_invoice(invoice=invoice, return_dict=True) labels = [ 'Date', 'Ending Def Rev', 'Cumulative Revenue', 'CR Sales Revenue', 'DR Deferred Revenue', 'DR Reserve Refunds', 'DR Contra-Revenue', 'CR Refunds Payable', 'DR Reserve Grace Period', 'CR Contra-Revenue' ] data = [] for (date, v) in sorted(results['revrec_schedule'].iteritems(), key=lambda (k, v): (k, v)): row = [ pretty_date(date), v['ending_defrev'], v['cumul_rev'], v['cr_rev'], v['dr_defrev'], v['dr_reserve_ref'], v['dr_contra_rev'], v['cr_ref_payable'], v['dr_reserve_graceperiod'], v['cr_contra_rev'] ] data.append(row) return render_template('base.html', labels=labels, data=data, invoice=invoice, payment=results['payment'], invoice_items=results['invoice_items'], refunds=results['refunds'], gp_notes=results['gp_notes'])
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 post(self): data = flatten_arguments(self.request.arguments) from models import Transaction, Invoice from pprint import pformat invoice_id = data.get('invoice') if invoice_id: invoice = Invoice.get_by_id(int(invoice_id, 10)) txn = Transaction(invoice=invoice) txn.identifier = data.get('txn_id') txn.subscription_id = data.get("subscr_id") txn.transaction_type = data.get('txn_type') txn.currency = data.get('mc_currency') txn.amount = data.get('mc_gross', data.get('mc_amount3')) txn.data = pformat(data) txn.put() if self.verify(data): r = self.process(data, txn=txn, invoice=invoice) else: r = self.process_invalid(data, txn=txn, invoice=invoice) if r: self.write(r) else: self.write('Nothing to see here.') else: # error. invoice id was not found. pass
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 index(): db = connect_db() seed_db(db) invoice = Invoice.objects().first() results = process_invoice(invoice=invoice, return_dict=True) labels = ['Date', 'Ending Def Rev', 'Cumulative Revenue', 'CR Sales Revenue', 'DR Deferred Revenue', 'DR Reserve Refunds', 'DR Contra-Revenue', 'CR Refunds Payable', 'DR Reserve Grace Period', 'CR Contra-Revenue'] data = [] for (date, v) in sorted(results['revrec_schedule'].iteritems(), key=lambda (k, v): (k, v)): row = [pretty_date(date), v['ending_defrev'], v['cumul_rev'], v['cr_rev'], v['dr_defrev'], v['dr_reserve_ref'], v['dr_contra_rev'], v['cr_ref_payable'], v['dr_reserve_graceperiod'], v['cr_contra_rev']] data.append(row) return render_template('base.html', labels=labels, data=data, invoice=invoice, payment=results['payment'], invoice_items=results['invoice_items'], refunds=results['refunds'], gp_notes=results['gp_notes'])
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 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()
def create_invoice(self, recipient_user, recipient_email, recipient_name, recipient_address, title, invoicedate, duedate, invoicerows, processor = None, processorid = None, autopaymentoptions = True, bankinfo = True, accounting_account = None, accounting_object = None): invoice = Invoice( recipient_email=recipient_email, recipient_name=recipient_name, recipient_address=recipient_address, title=title, invoicedate=invoicedate, duedate=duedate, total_amount=-1, bankinfo=bankinfo, accounting_account=accounting_account, accounting_object=accounting_object) if recipient_user: invoice.recipient_user = recipient_user if processor: invoice.processor = processor if processorid: invoice.processorid = processorid # Add our rows. Need to save the invoice first so it has an id. # But we expect to be in a transaction anyway. invoice.save() for r in invoicerows: invoice.invoicerow_set.add(InvoiceRow(invoice=invoice, rowtext = r[0], rowcount = r[1], rowamount = r[2])) if autopaymentoptions: invoice.allowedmethods = InvoicePaymentMethod.objects.filter(auto=True) invoice.save() # That should be it. Finalize so we get a PDF, and then # return whatever we have. wrapper = InvoiceWrapper(invoice) wrapper.finalizeInvoice() return invoice
def ws_invoices_timer_callback(): #logger.info("ws_invoices_timer_callback()..") for token in ws_invoices.keys(): #logger.info("ws_invoices_timer_callback: token: {}".format(token)) invoice = Invoice.from_token(db.session, token) if invoice: order = bronze_order_status(invoice) if order: socketio.emit("order_status", order["status"], room=token)
def click_item(self, row, column, *args): last_column = self.hheaders.__len__() - 1 if column != last_column: return try: self.parent.change_main_context(ShowInvoiceViewWidget, invoice=Invoice.get(number=(self.data[row][1]))) except IndexError: pass
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 set_data_for(self, value): if value: value = str(value) if is_int(value): qs = ((Invoice.number == int(value))) invoices = Invoice.select().where(qs) else: invoices = [] for clt in ProviderOrClient.select().where( ProviderOrClient.name.contains(value)).iterator(): for invoice in clt.invoices().iterator(): invoices.append(invoice) else: invoices = Invoice.select()[:100] try: self.data = [(invoice.number, invoice.date, invoice.client, "") for invoice in invoices] except Exception as e: print("Exception ", e)
def test_invoice(token): if not app.config["DEBUG"]: return abort(404) invoice = Invoice.from_token(db.session, token) if token in ws_invoices: logger.info("sending invoice update %s" % token) socketio.emit("info", invoice.to_json(), json=True, room=token) if invoice: return jsonify(invoice.to_json()) return abort(404)
def search_invoice(): invoice_id = request.args.get('invoice_id') inv = Invoice() inv.invoice_id = invoice_id invoice = inv.get_invoice_by_id() if invoice: id = invoice[0][1] costumer = invoice[0][2] date = str(datetime.strftime(invoice[0][3], '%Y-%m-%d')) seller = invoice[0][4] items = invoice[0][5] total = invoice[0][6] pending = invoice[0][7] return redirect(url_for('print_invoice', id=id, costumer=costumer, date=date, seller=seller, items=items, total=total, pending=pending)) else: return redirect(url_for('select_invoice', nfy="No found"))
def check_auth(token, nonce, sig, body): invoice = Invoice.from_token(db.session, token) if not invoice: return False, "not found", None res, reason = check_hmac_auth(invoice, nonce, sig, body) if not res: return False, reason, None # update invoice nonce db.session.commit() return True, "", invoice
def delete_invoice(): invoice = request.form['invoice-1'] vali_invoice = request.form['invoice-2'] if invoice == '' or vali_invoice == '': flash("Please complete all the fields.") return redirect(url_for('settings')) if invoice == vali_invoice: inv = Invoice() inv.invoice_id = invoice if inv.delete_invoice(): flash("Invoice deleted successfully.") return redirect(url_for('settings')) else: flash("ERROR.") return redirect(url_for('settings')) else: flash("Invoice number didn't match.") return redirect(url_for('settings'))
def get(self, **kwargs): re = db.get(self.get_realestate_key()) invoices = [] invoices.extend( Invoice.all().filter('realestate', re.key()).filter('state', Invoice._INPROCESS).order('date') ) invoices.extend( Invoice.all().filter('realestate', re.key()).filter('state', Invoice._NOT_PAID).filter('date <= ', datetime.now()).order('date') ) total_debt = reduce(lambda x,i: x + (i.amount if i.state == Invoice._NOT_PAID else 0), invoices, 0) params = { 're' :re, 'invoices' :invoices, 'total_debt':total_debt, 'mnutop' :'cuenta', 'plan' :re.plan, 'Invoice' :Invoice, } return self.render_response('backend/account.html', **params)
def set_data_for(self, date_, provid_clt_id=None, search=None): self.provid_clt_id = provid_clt_id qs = Invoice.select().order_by(Invoice.number.asc()) if isinstance(self.provid_clt_id, int): self.provider_clt = ProviderOrClient.get(id=self.provid_clt_id) qs = qs.select().where(Invoice.client == self.provider_clt) else: self.provider_clt = "Tous" self.data = [(vl.date, vl.number, vl.client.name, vl.amount_ivoice, "") for vl in qs if (vl.date > date_[0] and vl.date < date_[1])]
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 get(self, **kwargs): re = get_or_404(kwargs['key']) blobs = [] imgs = [] props = [] for img in ImageFile.all().filter('realestate', re.key()): blobs.append(img.file.key()) imgs.append(img.key()) blobstore.delete(blobs) db.delete(imgs) props = [] for prop in Property.all().filter('realestate', re.key()): props.append(prop.key()) db.delete(props) pis = [] for pi in PropertyIndex.all().filter('realestate', re.key()): pis.append(pi.key()) db.delete(pis) invs = [] pays = [] for inv in Invoice.all().filter('realestate', re.key()): invs.append(inv) if inv.payment: pays.append(inv.payment.key()) db.delete(invs) db.delete(pays) usrs = [] for usr in User.all().filter('realestate', re.key()): usrs.append(usr) db.delete(usrs) mRealEstateFriendship = [] for fr in RealEstateFriendship.all().filter('realestates', str(re.key())): mRealEstateFriendship.append(fr) db.delete(mRealEstateFriendship) re.delete() self.response.write('borrado %s' % kwargs['key'])
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 invoices(invoice_type=CONST.INVOICE_TYPE[CONST.INVOICE_IN]): form = InvoiceForm() form_elem = ElemForm() if invoice_type == CONST.INVOICE_TYPE[CONST.INVOICE_IN]: inv_type = CONST.INVOICE_IN elif invoice_type == CONST.INVOICE_TYPE[CONST.INVOICE_OUT]: inv_type = CONST.INVOICE_OUT del form.ninvoice if request.method == "POST": if form.validate(current_user): if inv_type == CONST.INVOICE_OUT: ninvoice = Invoice.make_unique_num(form.dinvoice.data, form.org_uid.data) flash(u"Счет-фактуре присвоен номер "+ninvoice, "alert-success") else: ninvoice = form.ninvoice.data newinvoice = Invoice(inv_type, form.org_uid.data, form.agent_uid.data, ninvoice, form.dinvoice.data, form.sum_snds.data, form.sum_no_nds18.data, form.sum_nds18.data, form.sum_no_nds10.data, form.sum_nds10.data, current_user.uid) db.session.add(newinvoice) db.session.commit() flash(u"Добавлена новая счет-фактура", "alert-success") # clean fields lst_fields = ['dinvoice', 'sum_snds', 'sum_no_nds18', 'sum_nds18', 'sum_no_nds10', 'sum_nds10'] if inv_type == CONST.INVOICE_IN: lst_fields.append('ninvoice') for fld in lst_fields: form[fld].raw_data = None form[fld].data = None invoices = current_user.available_invoices(inv_type=inv_type) sums = invoices.with_entities(func.sum(Invoice.sum_snds), func.sum(Invoice.sum_no_nds18), func.sum(Invoice.sum_nds18), func.sum(Invoice.sum_no_nds10), func.sum(Invoice.sum_nds10), func.sum(Invoice.commission)).first() return render_template('invoices.html', form=form, form_elem=form_elem, invoices=invoices.all(), invoice_type=invoice_type, sums=sums, edit=0)
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 save_model(self,request,obj,form,change): #import pdb #pdb.set_trace() if form.is_valid(): invo = form.save(commit=False) if change: if invo.auditstate == 3: invosa = Invoice.objects.get(id = obj.id) if invosa.auditstate != 3: invosa.auditer = request.user.id invosa.auditstate = 3 invosa.save() else: orderidindex = datetime.datetime.now().strftime('%Y%m%d%H%M%S') record = Invoice.objects.filter(orderid__contains=orderidindex).order_by('-id') if record.count()>0: last = int(record[0].orderid[14:]) last += 1 orderid = orderidindex+str(last).zfill(4) else: orderid = orderidindex+'0001' invosa = Invoice(orderformtype = invo.orderformtype, orderid = orderid, buyerid = invo.buyerid, buyername = invo.buyername, buyercontactmethod = invo.buyercontactmethod, buyeraddress = invo.buyeraddress, buytype = invo.buytype, paymoney = invo.paymoney, terminalcount = invo.terminalcount, paystate = invo.paystate, former = request.user.id, producetime = datetime.datetime.now(), auditstate = 1, auditer = '', ) invosa.save()
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 map(self, payment): # Traemos la factura que este pago cancela el pago (payment) invoice = Invoice.all().filter('Trx_id', payment.trx_id).get() if not invoice: logging.error('No encontre factura para el pago %s' % str(payment.key())) return ([], []) # Obtenemos el realestate en funcion del trx_id id_or_name = payment.trx_id[7:] #YYYYMM[NI]ddddddd re = None if payment.trx_id[6] == 'I': re = RealEstate.get_by_id(int(id_or_name)) else: re = RealEstate.get_by_key_name(id_or_name) if re is None: logging.error('No encontre el realestate para %s' % payment.trx_id) return ([], []) invoice.realestate = re # Ponemos la factura en estado pagada invoice.state = Invoice._PAID invoice.payment = payment invoice.save() # Acabamos de asignar un pago, deberiamos automaticamente # poner en ENABLED a la inmo si es que no estaba en ese estado # Si esta volviendo a ENABLE desde NO_PAYMENT debemos comunicarle que 'las props estan publicadas nuevamente' oldst = re.status # payment_received if re.status == RealEstate._ENABLED: send_mail('payment_received', re) else: re.status = RealEstate._ENABLED re.save() if oldst == RealEstate._NO_PAYMENT: send_mail('enabled_again', re, invoice) payment.assigned = 1 return ([payment], []) # update/delete
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 __init__(self, table_p, invoice_num, parent=0, *args, **kwargs): # super(ShowInvoiceViewWidget, self).__init__( # parent=parent, *args, **kwargs) QDialog.__init__(self, parent, *args, **kwargs) self.invoice = Invoice.get(number=invoice_num) self.parentWidget().setWindowTitle( "{} {}".format(Config.APP_NAME, "CONSULTATION DE FACTURE")) self.parent = parent self.table_p = table_p vbox = QVBoxLayout() self.title = self.invoice.type_ self.table_show = ShowOrderTableWidget(parent=self) editbox = QGridLayout() xls_bicon = QIcon.fromTheme( 'document-del', QIcon(u"{}xls.png".format(Config.img_cmedia))) pdf_icon = QIcon.fromTheme( 'document-del', QIcon(u"{}pdf.png".format(Config.img_cmedia))) self.button_pdf = QPushButton(pdf_icon, u"") self.button_pdf.setFixedWidth(30) self.button_pdf.setFixedHeight(30) self.button_xls = QPushButton(xls_bicon, u"") self.button_xls.setFixedWidth(30) self.button_xls.setFixedHeight(30) self.button_pdf.released.connect(self.printer_pdf) self.button_xls.released.connect(self.export_xls) self.button_dl = DeletedBtt(u"Annuler la facture") self.button_dl.released.connect(self.cancellation) editbox.addWidget(FLabel(u"{typ} N°: {num}".format( num=self.invoice.number, typ=self.invoice.type_)), 0, 0) editbox.addWidget(FLabel(u"%s le %s" % ( self.invoice.location, show_date(self.invoice.date))), 1, 4) editbox.addWidget(FLabel(u"Doit: %s " % self.invoice.client), 1, 0) editbox.addWidget(self.button_pdf, 1, 5) editbox.addWidget(self.button_dl, 0, 4) editbox.addWidget(self.button_xls, 1, 6) vbox.addLayout(editbox) vbox.addWidget(self.table_show) self.setLayout(vbox)
def __init__(self, invoice_num, parent=0, *args, **kwargs): super(ShowInvoiceViewWidget, self).__init__( parent=parent, *args, **kwargs) self.invoice = Invoice.get(number=invoice_num) self.parentWidget().setWindowTitle(Config.NAME_ORGA + u" CONSULTATION DE FACTURE") self.parent = parent vbox = QVBoxLayout() self.title = self.invoice.type_ self.table_show = ShowOrderTableWidget(parent=self) editbox = QGridLayout() xls_bicon = QIcon.fromTheme( 'document-del', QIcon(u"{}xls.png".format(Config.img_cmedia))) pdf_icon = QIcon.fromTheme( 'document-del', QIcon(u"{}pdf.png".format(Config.img_cmedia))) self.button_pdf = QPushButton(pdf_icon, u"") self.button_pdf.setFixedWidth(30) self.button_pdf.setFixedHeight(30) self.button_xls = QPushButton(xls_bicon, u"") self.button_xls.setFixedWidth(30) self.button_xls.setFixedHeight(30) self.button_pdf.released.connect(self.printer_pdf) self.button_xls.released.connect(self.export_xls) self.button_dl = Deleted_btt(u"Annuler la facture") self.button_dl.released.connect(self.cancellation) editbox.addWidget(FLabel(u"{typ} N°: {num}".format( num=self.invoice.number, typ=self.invoice.type_)), 0, 0) editbox.addWidget(FLabel(u"%s le %s" % (self.invoice.location, show_date(self.invoice.date))), 1, 4) editbox.addWidget(FLabel(u"Doit: %s " % self.invoice.client), 1, 0) # editbox.addWidget(self.button_pdf, 1, 5) editbox.addWidget(self.button_dl, 0, 4) editbox.addWidget(self.button_xls, 1, 6) vbox.addLayout(editbox) vbox.addWidget(self.table_show) self.setLayout(vbox)
def set_data_for(self, value): # if not value: # print("is value") invoices = Invoice.select().order_by(Invoice.number.desc()) if value: # return qs = ( Invoice.location.contains(value) | # Invoice.date.contains(value) | Invoice.client.contains(value) ) try: qs = qs | (Invoice.number.contains(int(value))) except Exception as e: print(e) # invoices = invoices.where(qs).execute() invoices = qs try: self.data = [(invoice.number, show_date(invoice.date), invoice.client, "") for invoice in invoices] except Exception as e: print(e)
def confirm_purchase(invoice_id): import datetime user = g.user if invoice_id is None: i = Invoice() i.paid = False i.datecreated = datetime.datetime.utcnow() i.user_id = user.id db.session.add(i) db.session.commit() try: callback_url = url_for('pay_invoice', _external=True)+'?secret='+SECRET_KEY+'%26invoice_id='+str(i.id) url = BLOCKCHAIN_URL+'?method=create&address='+STASH_WALLET+'&callback='+callback_url xhr = urllib2.Request(url) data = json.load(urllib2.build_opener().open(xhr)) price_data = json.load(urllib2.build_opener().open(urllib2.Request("http://blockchain.info/tobtc?currency=USD&value="+str(PRICE_OF_SERVICE)))) exchange_data = json.load(urllib2.build_opener().open(urllib2.Request("http://blockchain.info/ticker"))) app.logger.info("Sent to blockchain api: " + url) except urllib2.URLError as e: app.logger.error('Unable to access the blockchain.info api: ' + url) flash('There was an error creating a new invoice. Please try again later.') return redirect('/dashboard') i.address = data['input_address'] i.total_btc = price_data i.exchange_rate_when_paid = exchange_data['USD']['last'] db.session.commit() # TODO: Generate a QR code and/or other e-z payment options for BTC services return redirect(url_for('confirm_purchase', invoice_id=i.id)) else: i = Invoice.query.get(invoice_id) if request.method == 'POST': flash('Invoice ('+i.address+') was deleted succesfully.') db.session.delete(i) db.session.commit() return redirect(url_for('dashboard')) return render_template('confirm_purchase.html', user=user, invoice=i, min_confirm=CONFIRMATION_CAP)
def save_b(self): ''' add operation ''' # entete de la facture print("save") if not self.is_valide(): return invoice_date = unicode(self.invoice_date.text()) num_invoice = int(self.num_invoice.text()) invoice_type = self.liste_type_invoice[ self.box_type_inv.currentIndex()] lis_error = [] invoice = Invoice() try: self.owner = Owner.get(Owner.islog == True) except: lis_error.append("Aucun utilisateur est connecté <br/>") paid_amount = int(self.table_invoice.paid_amount_field.text()) try: clt = ProviderOrClient.get_or_create( self.name_client, int(self.phone.replace(" ", "")), ProviderOrClient.CLT) except ValueError: field_error( self.name_client_field, "Nom, numéro de téléphone du client") invoice.number = num_invoice invoice.owner = self.owner invoice.client = clt invoice.location = "Bamako" invoice.type_ = invoice_type invoice.subject = "" invoice.paid_amount = paid_amount invoice.tax = False try: invoice.save() if int(paid_amount) != 0 or invoice_type == Invoice.TYPE_BON: Refund(type_=Refund.DT, owner=self.owner, amount=paid_amount, date=date_to_datetime(invoice_date), provider_client=clt, invoice=Invoice.get(number=num_invoice)).save() except Exception as e: invoice.deletes_data() lis_error.append( "Erreur sur l'enregistrement d'entête de facture<br/>") return False # Save invoiceitems invoice = Invoice.get(Invoice.number == num_invoice) for name, qty, price in self.table_invoice.get_table_items(): rep = Report() product = Product.get(Product.name == name) rep.store = 1 rep.product = product rep.invoice = invoice rep.type_ = Report.S rep.cost_buying = int(product.last_report.cost_buying) rep.date = date_to_datetime(invoice_date) rep.qty = int(qty) rep.selling_price = int(price) try: rep.save() except Exception as e: lis_error.append(e) if lis_error != []: invoice.delete_instance() self.parent.Notify(lis_error, "error") return False else: self.parent.Notify("Facture Enregistrée avec succès", "success") self.change_main_context(ShowInvoiceViewWidget, invoice_num=invoice.number)
def save_b(self): ''' add operation ''' # entete de la facture if not self.table_invoice.isvalid: return False try: num_invoice = int(self.num_invoice.text()) self.num_invoice_error.setText(u"") except: self.pixmap = QPixmap(u"{img_media}{img}".format(img_media=Config.img_media, img="warning.png")) self.num_invoice.setStyleSheet("background-color: rgb(255, 235, 235);") self.num_invoice_error.setToolTip(u"Le numero de facture est obligatoire.") self.num_invoice_error.setPixmap(self.pixmap) invoice_date = str(self.invoice_date.text()) name_client = str(self.name_client.text()) datetime_ = date_to_datetime(invoice_date) values_t = self.table_invoice.get_table_items() if name_client == "": self.name_client.setStyleSheet("background-color: rgb(255, 235, 235);") self.pixmap = QPixmap(u"{img_media}{img}".format(img_media=Config.img_media, img="decline.png")) self.name_client_error.setToolTip(u"Nom du client est obligatoire.") self.name_client_error.setPixmap(self.pixmap) return False # if num_invoice > Config.credit: # raise_error(("Avertisement"), u"<h2>Veuillez payer la reste de la licence</h2>") # return False invoice = Invoice() try: invoice.owner = Owner.get(islog=True) except: if Config.DEBUG: invoice.owner = Owner.get(username='******') else: return False invoice.number = num_invoice invoice.date_ord = datetime_ invoice.client = name_client.capitalize() invoice.location = "Bamako" invoice.type_ = "Facture" invoice.subject = "" invoice.tax = False invoice.otax_rate = 18 try: invoice.save() except: raise_error("Erreur", u"Impossible d'enregistrer l'entête de la facture") return False # Save orderitems try: order = Invoice.get(number=num_invoice) except: return False for i in values_t: qty, name, price = i description = Product.filter(name=name).get() item = InvoiceItem() item.invoices = invoice.id item.quantity = int(i[0]) item.description = description item.price = int(i[2]) try: item.save() self.name_client.clear() self.num_invoice.clear() except Exception as e: print(e) invoice.delete_instance() raise_error("Erreur", u"Ce mouvement n'a pas pu etre " u"enregistré dans les rapports") return False self.change_main_context(ShowInvoiceViewWidget, invoice=invoice)
def __init__(self, product="", parent=0, *args, **kwargs): super(InvoiceViewWidget, self).__init__(parent=parent, *args, **kwargs) self.parentWidget().setWindowTitle(Config.NAME_ORGA + u" FACTURATION") self.parent = parent vbox = QVBoxLayout(self) hbox = QHBoxLayout(self) editbox = QGridLayout() self.num_invoice = IntLineEdit("%d" % (Invoice.select().count() + 1)) self.num_invoice.setToolTip(u"Le numéro de la facture") self.num_invoice.setMaximumSize(40, self.num_invoice.maximumSize().height()) self.num_invoice_error = ErrorLabel("") self.invoice_date = FormatDate(QDate.currentDate()) self.name_client = QLineEdit() self.name_client.setMaximumSize(200, self.name_client.maximumSize().height()) self.name_client.setToolTip("Taper le nom du client") self.name_client_error = ErrorLabel("") self.search_field = QLineEdit() self.search_field.setMaximumSize(200, self.search_field.maximumSize().height()) self.search_field.textChanged.connect(self.finder) self.vline = QFrame() self.vline.setFrameShape(QFrame.VLine) self.vline.setFrameShadow(QFrame.Sunken) self.table_invoice = OrderTableWidget(parent=self) self.table_resultat = ResultatTableWidget(parent=self) self.table_info = InfoTableWidget(parent=self) self.table_resultat.refresh_("") editbox.addWidget(FormLabel(u"Recherche:"), 0, 0) editbox.addWidget(self.search_field, 1, 0) editbox.addWidget(self.vline, 0, 1, 2, 5) editbox.addWidget(FormLabel(u"Facture N°:"), 0, 2) editbox.addWidget(self.num_invoice, 0, 3) editbox.addWidget(self.num_invoice_error, 0, 4) editbox.addWidget(FormLabel(u"Doit:"), 1, 2) editbox.addWidget(self.name_client, 1, 3) editbox.addWidget(self.name_client_error, 1, 4) editbox.addWidget(FormLabel(u"Date:"), 0, 5) editbox.addWidget(self.invoice_date, 0, 6) splitter = QSplitter(Qt.Horizontal) splitter_left = QSplitter(Qt.Vertical) splitter_down = QSplitter(Qt.Vertical) splitter_left.addWidget(FBoxTitle(u"Les resultats")) splitter_left.addWidget(self.table_resultat) splitter_down.resize(15, 20) splitter_down.addWidget(self.table_info) splitter_rigth = QSplitter(Qt.Vertical) splitter_rigth.addWidget(FBoxTitle(u"Les produits vendus")) splitter_rigth.addWidget(self.table_invoice) splitter_rigth.resize(500, 900) splitter_left.addWidget(splitter_down) splitter.addWidget(splitter_left) splitter.addWidget(splitter_rigth) hbox.addWidget(splitter) vbox.addLayout(editbox) vbox.addLayout(hbox) self.setLayout(vbox)
def post(self): # Get customer and create an invoice. customer = Customer.get_by_key_name(self.get_current_username()) invoice = Invoice(customer=customer) invoice.put() # Now start processing subscription data. subscription_data = self.session['subscription-data'] products = db.get([db.Key(key) for key in subscription_data.get('products')]) period = subscription_data.get('period') subscription_period = SubscriptionPeriod.get_by_period(period) units = [product for product in products if 'product_keys' not in product.properties()] baskets = [product for product in products if 'product_keys' in product.properties()] activation_credentials_list = [] orders = [] for unit in units: subscription = Subscription.get_by_product_and_period(unit, period) order = Order(customer=customer, invoice=invoice, subscription=subscription) order.subscription_price = subscription.price order.subscription_general_sales_tax = subscription.general_sales_tax order.subscription_period_in_months = subscription.period_in_months order.subscription_free_period_in_months = subscription_period.free_period_in_months order.price = subscription.price + subscription.general_sales_tax order.subscription_currency = subscription.currency orders.append(order) order.put() unit_id = unit.key().id() activation_credentials = ActivationCredentials() activation_credentials.serial_number = self.get_argument('u_%d_serial_number' % unit_id) activation_credentials.machine_id = self.get_argument('u_%d_machine_id' % unit_id) activation_credentials.order = order activation_credentials.product = unit activation_credentials.customer = customer logging.info(activation_credentials) activation_credentials_list.append(activation_credentials) for basket in baskets: subscription = Subscription.get_by_product_and_period(basket, period) order = Order(customer=customer, invoice=invoice, subscription=subscription) order.subscription_price = subscription.price order.subscription_general_sales_tax = subscription.general_sales_tax order.subscription_period_in_months = subscription.period_in_months order.subscription_free_period_in_months = subscription_period.free_period_in_months order.price = subscription.price + subscription.general_sales_tax order.subscription_currency = subscription.currency orders.append(order) order.put() for unit in basket.products: basket_id = basket.key().id() unit_id = unit.key().id() activation_credentials = ActivationCredentials() activation_credentials.serial_number = self.get_argument('b_%d_u_%d_serial_number' % (basket_id, unit_id,)) activation_credentials.machine_id = self.get_argument('b_%d_u_%d_machine_id' % (basket_id, unit_id,)) activation_credentials.order = order activation_credentials.product = unit activation_credentials.customer = customer logging.info(activation_credentials) activation_credentials_list.append(activation_credentials) db.put(activation_credentials_list) invoice.total_price = sum([order.price for order in orders]) invoice.currency = orders[0].subscription_currency invoice.put() self.session['activation-invoice-key'] = str(invoice.key()) self.redirect('/activate/overview')
def select_invoice(): if Security.is_login(SK): return render_template('invoice/select_invoice.html', title='Select Invoice', invoices=Invoice.get_ten_invoices(), boxes_sold=Invoice.number_of_boxes_sold()) return redirect(url_for('login', callback=stack()[0][3]))
def view_pending(): if Security.is_login(SK): return render_template('pending/select_pending.html', callback='view_pending', title='View Pending', pending=Invoice.get_pending_invoices()) return redirect(url_for('login', callback=stack()[0][3]))
def make_invoices(self, end_date_cursor = None): """Produces next year's worth of invoices.""" invoices = [] if not end_date_cursor: if self.policy: end_date_cursor = self.policy.effective_date + relativedelta(days=365) else: end_date_cursor = datetime.now().date + relativedelta(days=365) for invoice in self.policy.invoices: if not invoice.deleted: db.session.delete(invoice) else: invoices.append(invoice) logger.log("New invoices are being made, invoices for this policy will be have a different invoice_id", "Info", self.policy.id); billing_schedules = {'Annual': None, 'Two-Pay': 2, 'Semi-Annual': 3, 'Quarterly': 4, 'Monthly': 12} billing_to_months = {'Annual': 12, 'Two-Pay': 6, 'Quarterly': 3, 'Monthly': 1} # create the first invoice 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) # find the months in the billing period if billing_to_months.has_key(self.policy.billing_schedule): months_in_billing_period = billing_to_months.get(self.policy.billing_schedule) else: logger.log("Client tried using %s billing schedule" % (self.policy.billing_schedule), "Info", self.policy.id) print "You have chosen a bad billing schedule." del billing_schedules["Annual"] # leave out annual from here to simplify if self.policy.billing_schedule in billing_schedules.keys(): # find amount of months between end_date_cursor and self.policy.effective_date months_left = (end_date_cursor - self.policy.effective_date).days / 30 invoices_needed = int(months_left / billing_to_months.get(self.policy.billing_schedule)) first_invoice.amount_due = first_invoice.amount_due / invoices_needed # create the correct amount of invoices based on variables above for i in range(1, invoices_needed): months_after_eff_date = i * months_in_billing_period 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 / invoices_needed) invoices.append(invoice) for invoice in invoices: db.session.add(invoice) db.session.commit() self.policy.invoices = invoices
def make_invoices(self): """ Populates self.policy.invoices based on the selected billing schedule. Should have 1 if Annual, 2 if 2-Pay, 4 if quarterly, and 12 if Monthly. """ # Clear what may currently be in the list of invoices to make sure there are no duplicates. for invoice in self.policy.invoices: invoice.delete() billing_schedules = {'Annual': None, 'Semi-Annual': 3, 'Quarterly': 4, 'Monthly': 12} invoices = [] # First record to declare the overall premium of the policy 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 billing schedule is Annual, no other invoices are needed if self.policy.billing_schedule == "Annual": pass elif self.policy.billing_schedule == "Two-Pay": # Put value in a variable to save hash table look-ups frequency = billing_schedules.get(self.policy.billing_schedule) # Alter first invoice's amount to reflect a 6-month payment first_invoice.amount_due = first_invoice.amount_due / frequency for i in range(1, frequency): # number of months to add to the invoices' bill_date months_after_eff_date = i*6 # multiply by 6 for Two-Pay bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date) invoice = Invoice(self.policy.id, bill_date, # bill date bill_date + relativedelta(months=1), # due date bill_date + relativedelta(months=1, days=14), # cancel date self.policy.annual_premium / frequency) # amount due invoices.append(invoice) elif self.policy.billing_schedule == "Quarterly": # Put value into variable to save hash table look-ups frequency = billing_schedules.get(self.policy.billing_schedule) # Alter first invoice's amount due to reflect a 3-month payment first_invoice.amount_due = first_invoice.amount_due / frequency for i in range(1, frequency): # number of months to add to invoices' bill_date months_after_eff_date = i*3 # multiply by 3 for Quarterly bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date) invoice = Invoice(self.policy.id, bill_date, # bill date bill_date + relativedelta(months=1), # due date bill_date + relativedelta(months=1, days=14), # cancel date self.policy.annual_premium / frequency) # amount due invoices.append(invoice) elif self.policy.billing_schedule == "Monthly": # put value into variable to save hash table look-ups frequency = billing_schedules.get(self.policy.billing_schedule) # Alter the first invoice's amount due to reflect a monthly payment first_invoice.amount_due = first_invoice.amount_due / frequency for i in range(1, frequency): months_after_eff_date = i # no multiple here for Monthly. "frequency" should be 1 bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date) invoice = Invoice(self.policy.id, bill_date, # bill date bill_date + relativedelta(months=1), # due date bill_date + relativedelta(months=1, days=14), # cancel date self.policy.annual_premium / frequency) # amount due invoices.append(invoice) else: print "You have chosen a bad billing schedule." for invoice in invoices: db.session.add(invoice) db.session.commit()
def __init__(self, product="", parent=0, *args, **kwargs): super(InvoiceViewWidget, self).__init__(parent=parent, *args, **kwargs) self.parentWidget().setWindowTitle( Config.APP_NAME + u" Ventes") self.parent = parent vbox = QVBoxLayout(self) # hbox = QHBoxLayout(self) editbox = QGridLayout(self) try: next_number = int( Invoice.select().order_by(Invoice.number.desc()).get().number) + 1 except: next_number = 1 self.num_invoice = IntLineEdit(str(next_number)) self.num_invoice.setToolTip(u"Le numéro") self.num_invoice.setMaximumSize( 40, self.num_invoice.maximumSize().height()) self.invoice_date = FormatDate(QDate.currentDate()) # self.name_client_field = LineEdit() self.string_list = [""] + ["{},{}".format(clt.name, clt.phone) for clt in ProviderOrClient.select().where( ProviderOrClient.type_ == ProviderOrClient.CLT).order_by(ProviderOrClient.name.desc())] # self.name_client_field_new = "" self.name_client_field = ExtendedComboBox() self.name_client_field.addItems(self.string_list) self.name_client_field.setMaximumSize( 200, self.name_client_field.maximumSize().height()) self.name_client_field.setToolTip("Nom, numero du client") self.add_clt_btt = BttSmall(u"+") self.add_clt_btt.clicked.connect(self.add_clt) self.add_clt_btt.setFixedWidth(50) # Combobox widget for add store self.liste_type_invoice = [Invoice.TYPE_FACT, Invoice.TYPE_BON] self.box_type_inv = QComboBox() for index in range(0, len(self.liste_type_invoice)): op = self.liste_type_invoice[index] sentence = u"%(name)s" % {'name': op} self.box_type_inv.addItem(sentence, op) self.search_field = LineEdit() self.search_field.setPlaceholderText("Rechercher un article") self.search_field.textChanged.connect(self.finder) # self.search_field.setFixedWidth(250) self.table_invoice = InvoiceTableWidget(parent=self) self.table_resultat = ResultatTableWidget(parent=self) self.table_info = InfoTableWidget(parent=self) self.table_resultat.refresh_("") editbox.addWidget(self.box_type_inv, 0, 2) editbox.addWidget(self.num_invoice, 0, 3) editbox.addWidget(FLabel(u"Doit :"), 1, 2) editbox.addWidget(self.name_client_field, 1, 3) # editbox.addWidget(self.add_clt_btt, 1, 4) editbox.addWidget(self.invoice_date, 0, 6) editbox.setColumnStretch(0, 1) editbox.setColumnStretch(5, 1) splitter = QSplitter(Qt.Horizontal) splitter_left = QSplitter(Qt.Vertical) splitter_left.addWidget(self.search_field) splitter_left.addWidget(self.table_resultat) # splitter_down.resize(15, 20) splitter_down = QSplitter(Qt.Vertical) splitter_down.addWidget(self.table_info) splitter_rigth = QSplitter(Qt.Vertical) # splitter_rigth.setLayout(editbox) splitter_rigth.addWidget(self.table_invoice) splitter_rigth.resize(800, 900) splitter_left.addWidget(splitter_down) splitter.addWidget(splitter_left) splitter.addWidget(splitter_rigth) vbox.addLayout(editbox) vbox.addWidget(splitter) self.setLayout(vbox)
def create_invoice_process(): inv = Invoice() try: inv.info = request.form['costumer'] inv.date = datetime.strptime(request.form['date'], '%d %B, %Y') # CONVERT STRING TO DATETIME category = request.form['category'] inv.seller = request.form['seller'] inv.invoice_id = request.form['invoice_id'] except Exception as e: raise e try: inv.pending = request.form['pending'] except Exception as e: inv.pending = 0 items_list_id_quantity = [] for x in range(1, 6): try: items_list_id_quantity.append((request.form['id'+str(x)], request.form['quantity'+str(x)])) except Exception as e: print(e) items_full = [] for item in items_list_id_quantity: if item[0]: # LIST OF TUPLES WITH (ID, PRICE, QUANTITY ) items_full.append((item[0], inv.get_price_category(item[0], category), item[1])) total = 0 invoice = [] for item in items_full: subtotal = 0 quantity = int(item[2]) price = int(item[1]) subtotal = quantity * price total += subtotal # TODO: THIS IS STATIC. FIND A DYNAMIC SOLUTION CODE: 508 if item[0][0] == '1': invoice.append((quantity, inv.get_item_description_by_id(1), price, subtotal)) elif item[0][0] == '2': invoice.append((quantity, inv.get_item_description_by_id(2), price, subtotal)) elif item[0][0] == '3': invoice.append((quantity, inv.get_item_description_by_id(3), price, subtotal)) elif item[0][0] == '4': invoice.append((quantity, inv.get_item_description_by_id(3), price, subtotal)) elif item[0][0] == '5': invoice.append((quantity, inv.get_item_description_by_id(3), price, subtotal)) elif item[0][0] == '6': invoice.append((quantity, inv.get_item_description_by_id(3), price, subtotal)) else: invoice.append((quantity, "Unidentified item. CODE: 580", price, subtotal)) invoice_list = "" for k in invoice: invoice_list += str(k) inv.items = invoice_list.replace("'", "") inv.total = total try: inv.create_invoice() except Exception as e: print(e) return redirect(url_for('create_invoice', flash="Invoice couldn't been created.")) return redirect(url_for('create_invoice', flash='Invoice created successfully.'))