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 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 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 make_invoice(user, invoice_date, contact):
return clean_and_save(
Invoice(
user=user,
invoice_date=invoice_date,
contact=contact,
))
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 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_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 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 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 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 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 test_str_none(self):
i = Invoice(state=Invoice.STATE_PROFORMA)
assert str(i) == "Proforma nr. None"
def test_get_footer(self):
i = Invoice()
assert i.get_footer() is None
def test_get_info(self):
i = Invoice()
assert i.get_info() is None
