def generate_credit_note(self, request, queryset): last_credite_note_created = None for invoice in queryset.all(): if invoice.is_credit_note: messages.add_message(request, messages.ERROR, _(u"You cannot create a credit note for " u"a credit note! (%s)" % invoice.invoice_id)) continue try: invoice.credit_note messages.add_message(request, messages.ERROR, _(u"This invoice has already a credit " u"note a credit note! (%s)" % invoice.invoice_id)) continue except: pass credit_note = Invoice(recipient=invoice.recipient, is_credit_note=True, invoice_related=invoice, invoice_cost_code=invoice.invoice_cost_code) credit_note.save() last_credite_note_created = credit_note for invoice_item in invoice.items.all(): item = InvoiceItem(invoice=credit_note, description=invoice_item.description, unit_price=invoice_item.unit_price, quantity=invoice_item.quantity) item.save() if last_credite_note_created: change_url = urlresolvers.reverse( 'admin:invoice_invoice_change', args=(last_credite_note_created.pk,)) return redirect(change_url)
def generate_credit_note(self, request, queryset): last_credite_note_created = None for invoice in queryset.all(): if invoice.is_credit_note: messages.add_message( request, messages.ERROR, _(u"You cannot create a credit note for " u"a credit note! (%s)" % invoice.invoice_id)) continue try: invoice.credit_note messages.add_message( request, messages.ERROR, _(u"This invoice has already a credit " u"note a credit note! (%s)" % invoice.invoice_id)) continue except: pass credit_note = Invoice(recipient=invoice.recipient, is_credit_note=True, invoice_related=invoice, invoice_cost_code=invoice.invoice_cost_code) credit_note.save() last_credite_note_created = credit_note for invoice_item in invoice.items.all(): item = InvoiceItem(invoice=credit_note, description=invoice_item.description, unit_price=invoice_item.unit_price, quantity=invoice_item.quantity) item.save() if last_credite_note_created: change_url = urlresolvers.reverse( 'admin:invoice_invoice_change', args=(last_credite_note_created.pk, )) return redirect(change_url)
def create(self, validated_data): items = validated_data.pop('items') invoice = Invoice(**validated_data) invoice.save() for item in items: ProductInvoice.objects.create(invoice=invoice, **item) return invoice
def post(self, customer_id): """ bills the customers current open cart --Bills the current open cart for customer --Create Invoice Record and Invoice Line Item Records --Automatically applies giftcard and credits --closes cart as 'billed' --store.credit_order_preference: determines if credits are giftcards are applied first """ customer = Customer.get_customer(customer_id=customer_id, request=request) store = Store.objects.filter(app_id=request.headers.get('APP-ID'), deleted_at=None).first() if customer is None: return jsonify({"error": CUSTOMER_NOT_FOUND}), 404 cart = Cart.objects.filter(customer_id=customer_id, invoice_created_at=None, closed_at=None).first() if cart is None: return jsonify({"error": NO_OPEN_CART}), 404 invoice = Invoice( invoice_id=str(uuid.uuid4().int), customer=customer, cart=cart ).save() invoice.create_invoice_line_items() if "coupon" in request.args: coupon = CouponCode.objects.filter(code=request.args.get("coupon"), store=store).first() if coupon is None: return jsonify({"error": "coupon code not found"}), 404 redemption = coupon.redeem(invoice=invoice) if redemption is None: return jsonify({"error": "coupon code not found"}), 404 if store.credit_order_preference == "credit": self.apply_credits(customer, invoice) self.apply_gift_cards(customer, invoice) else: self.apply_gift_cards(customer, invoice) self.apply_credits(customer, invoice) cart.state = "billed" cart.invoice_created_at = datetime.now() cart.save() response = { "result": "ok", "invoice": invoice_obj(invoice) } return jsonify(response), 201
def view_save_invoice(request, lu): reservation = lu['reservation'] invoice_no = lu['invoice_no'] datestring = reservation.start_datetime.strftime("%Y%m%d_%H%M") filename = "%s_%s.pdf" % (datestring, reservation.user.get_user_initials()) html = render_to_string('reservation_history/view_download_pdf.html', lu, context_instance=RequestContext(request)) invoice = Invoice(reservation=reservation, invoice_no=invoice_no, filename=filename, html=html) invoice.save() return download_invoice(request, filename, lu)
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): cd = form.cleaned_data my_loan = form.save() total_period = cd['total_periods'] period = cd['payment_period'] cost = cd['cost'] initial_fee = cd['initial_fee'] taxes = cd['taxes'] debt = (cost - initial_fee) my_loan.company = request.user.company my_loan.expiration_date = get_expiration_date( cd['date'], total_period, period) my_loan.save() initial_invoice = Invoice( loan=my_loan, payment_date=cd['date'], subtotal=initial_fee, tax=0, ) initial_invoice.save() initial_detail_invoice = DetailInvoice( invoice=initial_invoice, description="Pago inicial", value=initial_fee, ) initial_detail_invoice.save() for i in range(int(total_period)): subtotal = (cost - initial_fee) / total_period tax = debt * (taxes / 100) * (1 / period.value) new_invoice = Invoice( loan=my_loan, payment_date=get_expiration_date(cd['date'], i + 1, period), subtotal=subtotal, tax=tax, ) new_invoice.save() new_detail_invoice = DetailInvoice( invoice=new_invoice, description="Pago por compra", value=subtotal, ) debt = debt - ((cost - initial_fee) / total_period) new_detail_invoice.save() new_invoice.save() return HttpResponseRedirect(self.get_success_url())
def make_invoice(user, invoice_date, contact): return clean_and_save( Invoice( user=user, invoice_date=invoice_date, contact=contact, ))
def get(self, invoice_id=None): """ returns an invoice number or list of invoice numbers params: closed: true if want to include closed invoices startdate: date range filter enddate: date range filter """ if invoice_id: invoice = Invoice.objects.filter(invoice_id=invoice_id).first() store = Store.objects.filter(app_id=request.headers.get('APP-ID'), deleted_at=None).first() if invoice is None: return jsonify({"error": INVOICE_NOT_FOUND}), 404 if invoice.customer.store_id != store: return jsonify({"error": CUSTOMER_NOT_FOUND}), 404 response = { "result": "ok", "invoice": invoice_obj(invoice) } return jsonify(response), 200 else: try: invoices = Invoice.get_all_invoices(request=request) except IncorrectDateFormat: return jsonify({"error": INCORRECT_TIME_FORMAT}) return paginated_results(objects=invoices, collection_name='invoice', request=request , per_page=self.PER_PAGE, serialization_func=invoice_objs), 200
def fetch_data(request): if request.method == 'GET' : invoice_obj = Invoice.objects.all() print(invoice_obj) invoice_json = serializers.serialize('json', invoice_obj) return JsonResponse(invoice_json,safe=False) #return HttpResponse(invoice_json, content_type='application/json') if request.method == 'POST' : print(request.POST['']) # request_dict = r.json() try : if Invoice.objects.filter(customer = request.POST['customer']).exists(): invoice_obj = Invoice.objects.get(customer = request.POST['customer']) else : invoice_obj = Invoice(customer = request.POST['customer']) invoice_line_obj = Invoice_Line.objects.get(product = request.POST['product'],quantity=request.POST['quantity'] ,price_without_tax = float(request.POST['price_without_tax']), tax_name=request.POST['tax_name'],tax_amount=request.POST['tax_amount'], line_total=request.POST['line_total'],invoice=invoice_obj) invoice_line_obj.save() invoice_obj.total_quantity = Invoice_Line.objects.aggregate(Sum('quantity'))['quantity__sum'] invoice_obj.total_amount = Invoice_Line.objects.aggregate(Sum('line_total'))['line_total'] invoice_obj.date = datetime.datetime.now() invoice_obj.save() return JsonResponse(invoice_obj,safe=False) except : error={'error' : 'invoice cannot be saved'} return JsonResponse(error,safe=False)
def post(self, request, format=None): # client = self.get_object(request.user) serializer = InvoiceCreateSerializer(data=request.data, many=True) if serializer.is_valid(): new_crt_ids = [] for invoice_data in serializer.validated_data: new_invoice = Invoice(**invoice_data) new_invoice.save() new_crt_ids.append(new_invoice.id) new_invoices = Invoice.objects.all().filter(id__in=new_crt_ids) new_serializer = InvoiceSerializer(new_invoices, many=True) return Response(new_serializer.data, status=status.HTTP_201_CREATED) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def createInvoice(request, username): if username == request.session['username']: user = UserDetail.objects.get(username=username) if user.user_type == 'NORMAL': if request.method == 'POST': invoice = Invoice() invoice.name = request.POST['invoice_name'] invoice.date = request.POST['date'] invoice.amount = request.POST['amount'] invoice.image = request.POST['invoice_image'] invoice.user = user invoice.save() return render(request, 'create_invoice.html', {'username': username}) return render(request, 'create_invoice.html', {'username': '******'})
def create(request): if request.method == 'POST': invoice_form = InvoiceForm(request.POST) item_formset = ItemFormSet(request.POST) if invoice_form.is_valid() and item_formset.is_valid(): invoice_form.clean() item_formset.clean() new_invoice = Invoice(bill_to=invoice_form['bill_to'].data, date=invoice_form['date'].data, user=request.user) new_invoice.save() for form in item_formset: print form.cleaned_data print form['item_price'].data new_item = Item(name=form['item_name'].data, price=form['item_price'].data, user=request.user) new_item.save() print type(new_item.price) new_invoice_item = InvoiceItem(count=form['item_count'].data, item=new_item, user=request.user) new_invoice_item.save() new_invoice.items.add(new_invoice_item) new_invoice.save() return redirect('/dashboard/') else: invoice_form = InvoiceForm() item_formset = ItemFormSet() return render(request, 'invoice/create.html', {'invoice_form': invoice_form, 'item_formset': item_formset, 'form_counter': len(item_formset.forms) - 1,})
def handle(self, *args, **options): for run_date in options['run_date']: self.stdout.write( self.style.SUCCESS('Date: "%s"' % datetime.strptime(run_date, "%Y-%m-%d"))) scn_products = subscription_product.objects.filter( expiration_date__lte=datetime.strptime(run_date, "%Y-%m-%d")) for scn_item in scn_products: now = datetime.now() inv_num = now.strftime("%d%m%Y%S%M%H%f") inv = Invoice(invoice_number=inv_num, title=scn_item.title, due_date=scn_item.expiration_date, customer=scn_item.customer, subscription=scn_item, description=scn_item.title, status=True) inv.save() self.stdout.write(self.style.SUCCESS('Invoice: "%s"' % inv_num)) self.stdout.write( self.style.SUCCESS('Subscription: "%s"' % scn_item.title))
def get(self, customer_id): """ returns extended customer object :return: customer snapshot object """ customer = Customer.get_customer(customer_id=customer_id, request=request) if customer is None: return jsonify({"error": CUSTOMER_NOT_FOUND}), 404 obj = customer_obj(customer=customer) cart = Cart.objects.filter(customer_id=customer.customer_id, closed_at=None).first() if cart: obj['cart'] = cart_obj(cart) invoices = Invoice.objects.filter( customer=customer).order_by("-created_at").paginate(page=1, per_page=10) if invoices: obj["last_10_invoices"] = invoice_objs(invoices) orders = Order.get_orders(request=request, customer_id=customer_id).order_by("-created_at")\ .paginate(page=1, per_page=10) if orders: obj["last_10_orders"] = order_objs(orders) gift_cards = GiftCard.objects.filter(recipient_customer=customer, current_balance_in_cents__gt=0)\ .order_by("-created_at").paginate(page=1, per_page=10) if gift_cards: obj["active_giftcards"] = gift_card_objs(gift_cards) credits = Credit.objects.filter(customer=customer, current_balance_in_cents__gt=0) \ .order_by("-created_at").paginate(page=1, per_page=10) if credits: obj["active_credits"] = credit_objs(credits) products = Invoice.get_top_N_products(customer=customer, num_items=10, request=request) if products: obj["top_10_ordered_products"] = products response = {"result": "ok", "customer": obj} return jsonify(response), 200
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) with transaction.manager: # Create one item and one invoice item = InvoiceItem(units=1, description='car', amount=2) invoice = Invoice(date=date.today()) invoice.items.append(item) DBSession.add(item) DBSession.add(invoice)
def create_invoice(): form = InvoiceForm() if form.validate_on_submit(): invoice = Invoice(title=form.title.data, recipient=form.recipient.data, amount=form.amount.data, user_id=current_user.id, id=randint(100000000000, 999999999999)) # TODO: Ensure no chance override of invoice id db.session.add(invoice) db.session.commit() flash('Your invoice has been created', 'success') return redirect(url_for('home')) return render_template('create_invoice.html', title='New Invoice', form=form)
def get(self, customer_id): """ return a list of invoice for customer params: closed: true if want to include closed invoices startdate: date range filter enddate: date range filter """ try: invoices = Invoice.get_all_invoices(request=request) except IncorrectDateFormat: return jsonify({"error": INCORRECT_TIME_FORMAT}) customer = Customer.get_customer(customer_id=customer_id, request=request) if customer is None: return jsonify({"error": CUSTOMER_NOT_FOUND}), 404 invoices = invoices.filter(customer=customer_id) return paginated_results(objects=invoices, collection_name='invoice', request=request , per_page=self.PER_PAGE, serialization_func=invoice_objs), 200
def uploadFile(request): if request.method == 'POST': form = FileForm(request.POST, request.FILES) if form.is_valid(): if 'user' in request.session: user_session = request.session["user"] user = User.objects.get(username=user_session) pdf_name = form.cleaned_data["pdf_copy"] initial_obj = form.save() invoice = Invoice() invoice.pdf_copy = initial_obj.pdf_copy invoice.date = initial_obj.created_at invoice.agent = user invoice.save() return redirect("/create_invoice/" + str(invoice.id) + "/" + str(pdf_name)) else: form = FileForm() return render(request, 'file_upload.html', {"form": form}) else: form = FileForm() return render(request, "file_upload.html", {"form": form})
def test_get_info(self): i = Invoice() assert i.get_info() is None
def test_get_footer(self): i = Invoice() assert i.get_footer() is None
def register_invoice_enter(request): from participants.models import Participant from bookings.models import BookingLine from browsersessions.models import BrowserSession from invoice.models import Invoice from countries_plus.models import Country import decimal dbsession = BrowserSession.objects.get_session(request.session.session_key) entered_bookinglines = BookingLine.objects.filter( browser_session__name=request.session.session_key) stages = RegistrationStages() stages.set_active(RegistrationStages.STAGE_BILLING) first_bookingline = entered_bookinglines.first() try: invoice = first_bookingline.invoice except: # if the above fails, we might be here because of a inconsistent # session state, so we delete the entry, that brought us here del request.session['payment_id'] bounce_target = reverse('register_participants') return HttpResponseRedirect(bounce_target) invoice_address = None if invoice: invoice_address = invoice.address if request.method == 'GET': form = InvoiceAddressForm(instance=invoice_address) if request.method == 'POST': form = InvoiceAddressForm(request.POST,instance=invoice_address) if form.is_valid(): invoice_address = form.save(commit=False) if not invoice: invoice = Invoice() if invoice_address.vat_number[0:3] == 'ATU': invoice_address.country = Country.objects.get(iso='AT') invoice_address.save() invoice.address = invoice_address invoice.save() entered_bookinglines.update(invoice=invoice) form = InvoiceAddressForm(instance=invoice_address) bounce_target = reverse('register_invoice_order') return HttpResponseRedirect(bounce_target) else: # form is invalid form = InvoiceAddressForm(request.POST,instance=invoice_address) context = { 'form': form, 'stages': stages.as_list(), } return render(request, 'ewtisite/register_invoice_enter.html', context)
def test_create_url(self): self.assertEqual(Invoice.get_create_url(), reverse('invoice:create'))
def test_list_url(self): self.assertEqual(Invoice.get_list_url(), reverse('invoice:list'))
names = !cat /home/maxim/random_names streets = !cat /home/maxim/random_streets items = !cat /home/maxim/random_items for i in range(300): name = names[randint(0, len(names)-2)] street_number = randint(1,2000) street_name = streets[randint(0,len(streets)-2)] d = datetime.date(randint(2006,2010), randint(1,12), randint(1,27)) shipping_pickup_date = datetime.date(randint(2000,2010), randint(1,12), randint(1,27)) address = str(street_number) + " " + street_name city = "Toronto" shipping_handling = randint(10,50) invoice = Invoice(name=name, date=d, address=address, city=city, shipping_pickup_date=shipping_pickup_date, shipping_handling=shipping_handling) invoice.save() for i in range(randint(5,12)): item_name = items[randint(0, len(items)-2)] price = randint(50,300) quantity = randint(1,5) item = Item(name=item_name, invoice=invoice, price=price, quantity=quantity) item.save() print name + " - " + address + ": " + item_name + " = " + str(price) + " * " + str(quantity) for i in range(100): name = names[randint(0, len(names)-2)] street_number = randint(1,2000) street_name = streets[randint(0,len(streets)-2)] d = datetime.date(2011, 1, randint(1,22))
def test_str_none(self): i = Invoice(state=Invoice.STATE_PROFORMA) assert str(i) == "Proforma nr. None"
def create_doc(request): """ Using the current url, assemble the data to be sent to the document app Send the data - the document app will send back a pdf and save copy of the invoice as a html (or just in the database) """ #get the url for the current page, including the querystring source_url = "http://%s/%s/?%s%s" % (request.get_host(), "billing", 'format=json&', request.META['QUERY_STRING']) #log.debug("source_url: %s" % source_url) #get the user object from dokken using username and password username = '******' #move this later password = '******' #move and change this later try: user_info = get_user_info(username, password) except: return HttpResponse('No such user') user_uri = user_info[0]['resource_uri'] #construct the name name = "Huib-" month = None bill_month = date(date.today().year, date.today().month, 1) if 'month' in request.GET: month = int(request.GET['month']) bill_month = date(date.today().year, month, 1) name += bill_month.strftime("%m") if 'year' in request.GET: year = int(request.GET['year']) if month and month >= 7: year = year - 1 #get year is fiscal year name += date(year, 1, 1).strftime("%y") else: name += date.today().strftime("%y") if 'expense_code' in request.GET: name += "-%s" % request.GET['expense_code'] ec_root = None if 'ec_root' in request.GET: ec_root = request.GET['ec_root'] # Remove ec_root from document name # name += "-%s" % ec_root #get the last version number from the document with this name doc_version = get_doc_version_by_name(name, user_info, username, password) name = '-'.join([name, doc_version]) #get the current time now = str(datetime.utcnow().replace(tzinfo=utc)) #format now as a string #get the html for this page using urllib (is there a better way to do this?) sessionid = request.COOKIES['sessionid'] opener = urllib2.build_opener() opener.addheaders.append(('Cookie', 'sessionid=%s' % sessionid)) response = opener.open(source_url) content = response.read() soup = BeautifulSoup(content) html = str(soup.find(id="bill_content")) data = { 'name': name, 'user': user_uri, 'html': html, 'url': source_url, 'created': now, 'modified': now, } json_data = json.dumps(data) #json-fy the data #create the invoice user = User.objects.get(username=username) inv = Invoice() inv.invoice_number = name inv.bill_month = bill_month inv.expense_code_root = ec_root inv.html_content = html inv.user = user inv.created = now inv.modified = now inv.save() #create the django object in the document app destination_url = 'http://%s/a/api/document/' % settings.DOCUMENT_APP_HOST request = urllib2.Request(destination_url) request.add_header('Content-Type', 'application/json') request.add_header('Accept', 'application/json, text/html') base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '') request.add_header("Authorization", "Basic %s" % base64string) request.add_data(json_data) response = urllib2.urlopen(request) #get the uri id for the object that was created try: location = re.search( r'Location: (.+)$', response.headers.__str__(), re.M) except: return HttpResponse('No URI!') location = location.group(1) try: uri_id = re.search( r'http://%s/a/api/document/(\d+)/' % settings.DOCUMENT_APP_HOST, location, re.M) except: return HttpResponse('No ID!') uri_id = uri_id.group(1) #create the pdf using the uri id destination_url = 'http://%s/harvard_doc/pdf/%s/' % (settings.DOCUMENT_APP_HOST, uri_id) request = urllib2.Request(destination_url) request.add_header('Content-Type', 'application/json') request.add_header('Accept', 'application/json, text/html') base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '') request.add_header("Authorization", "Basic %s" % base64string) response = urllib2.urlopen(request) #this request creates the pdf on dokken #get the pdf from dokken destination_url = 'http://%s/uploads/%s.pdf' % (settings.DOCUMENT_APP_HOST, slugify(name)) pdf = urllib2.urlopen(destination_url) output = cStringIO.StringIO() output.write(pdf.read()) response = HttpResponse(output.getvalue(), content_type="application/pdf") output.close() response['Content-Disposition'] = 'attachment; filename=%s.pdf' % slugify(name) return response