def forms_valid(self, form, formset):
user = self.request.user
invoice = Invoice(
recipient=user,
status='new',
compound=True,
date=timezone.now(),
invoiced_entity=form.cleaned_data['invoiced_entity'],
billing_address=form.cleaned_data['billing_address'],
)
invoice.save()
for i, form in enumerate(formset.forms):
if not hasattr(form, 'invoice'):
continue
child_invoice = form.invoice
InvoiceLine(
invoice_id=invoice.id,
line_order=i,
reference='INV#{}'.format(child_invoice.reference_number),
description='DebConf attendance for {}'.format(
child_invoice.recipient.userprofile.display_name()),
unit_price=child_invoice.total,
quantity=1,
).save()
self.reference_number = invoice.reference_number
return super().forms_valid(form, formset)
def test_xml_generation(sample_invoice_xml):
invoice = Invoice()
invoice_xml = _xml_to_string(invoice.to_xml())
sample_xml = _xml_to_string(sample_invoice_xml)
assert invoice_xml == sample_xml
def create_invoices(startDate, endDate):
startdatetime = datetime(startDate.year, startDate.month, startDate.day)
enddatetime = datetime(endDate.year, endDate.month, endDate.day)
# because sql will check on 0:00 am on end date, if shipdate was 7pm on enddate, it will not be included
enddatetime = enddatetime + timedelta(days=1)
# startdatetime = datetime.combine(startDate, datetime.min.time())
# enddatetime = datetime.combine(endDate, datetime.max.time())
shipped_orders = Order.objects.filter(shipDate__range=(startdatetime, enddatetime)).filter(orderStatus="Shipped").order_by('orderNo')
invoice_amounts = {}
orderNoList = []
if len(shipped_orders) == 0:
logger.exception(
' admin or system tried generated invoice for ' + str(startDate) + ' to ' + str(endDate) + ', But no shipped order during these days.')
return 0
for order in shipped_orders:
try:
invoiceno = "SFMINV-" + startDate.strftime("%m%d") + "-" + endDate.strftime("%m%d") \
+ "-" + order.store.storeCode
if invoiceno not in list(invoice_amounts.keys()):
print('adding invoice for store', order.storeName)
# invoicenote = "invoice from SFM"
# check if the invoice already exists, if so delete the invoice and create new
Invoice.objects.filter(invoiceNo=invoiceno).delete()
invoice = Invoice(startDate=startDate, endDate=endDate, storeName=order.storeName, store=order.store, invoiceNo=invoiceno,
status="Unpaid", notes="", subTotal=0, discount=0, taxrate=0)
invoice.save()
invoice_amounts[invoiceno] = 0
# print(order.saleDate)
orderdate = order.saleDate if order.saleDate is not None else order.shipDate.date()
invoice = Invoice.objects.get(invoiceNo=invoiceno)
if order.customerPaidShipping is not None and order.customerPaidShipping > 0 and order.orderNo not in orderNoList:
invoiceshipitem = InvoiceItems(invoice=invoice, shipDate=order.shipDate.date(), orderDate=orderdate,
orderNo=order.orderNo, customer=order.recipientName, description='Shipping',
amount=order.customerPaidShipping)
invoiceshipitem.save()
invoice_amounts[invoiceno] += order.customerPaidShipping
orderNoList.append(order.orderNo)
product = Product.objects.get(sfmId=order.sfmId)
amt = product.price
desc = order.sfmId + '-' + order.design
invoiceitem = InvoiceItems(invoice=invoice, shipDate=order.shipDate.date(), orderDate=orderdate,
orderNo=order.orderNo, customer=order.recipientName, description=desc,
amount=amt)
invoiceitem.save()
invoice_amounts[invoiceno] += amt
except Exception as err:
print('error ----', str(err))
logger.exception('Error in invoice ' + invoiceno + ', item for order ' + order.sfmId + ', Aborting... details: ' + str(err))
raise Exception('Error generating invoice')
logger.info(' admin or system generated invoice for ' + str(startDate) + ' to ' + str(endDate) + ' , count: ' + str(len(invoice_amounts)))
updateInvoices(invoice_amounts)
return len(invoice_amounts)
def generate_invoice(cls, character, ref, amount, message):
# generate an invoice and return it
due = timezone.now() + timedelta(days=14)
return Invoice(character=character,
amount=round(amount, -6),
invoice_ref=ref,
note=message,
due_date=due)
def save(self, invoice, invoice_items, company):
with transaction.atomic():
instance = Invoice(**invoice)
instance.company = company
print(instance.released_at)
instance.save()
for item in invoice_items:
entry = InvoiceItem(**item)
entry.invoice = instance
entry.save()
def verifyPayment(request):
request_body = json.loads(request.body.decode('utf-8'))
print(request_body)
params = {}
try:
params['razorpay_payment_id'] = request_body['payment_id']
params['razorpay_signature'] = request_body['signature']
except KeyError:
return Response({'message': 'Provide both payment_id and signature'})
try:
params['razorpay_order_id'] = orders[request.user.email]['id']
except KeyError:
return Response({'message': 'No order found for this user'})
env = environ.Env(
DEBUG=(bool, False)
)
environ.Env.read_env()
RAZORPAY_ID = env('RAZORPAY_ID')
RAZORPAY_SECRET_KEY = env('RAZORPAY_SECRET_KEY')
client = razorpay.Client(auth=(RAZORPAY_ID, RAZORPAY_SECRET_KEY))
result = 1
try:
client.utility.verify_payment_signature(params)
except razorpay.errors.SignatureVerificationError:
result = 0
if result == 1:
order = client.order.fetch(params['razorpay_order_id'])
invoice = Invoice(type='bill', order_id=order['id'])
invoice.save()
payment = Payment(buyer=request.user, invoice=invoice, amount=order['amount'] / 100)
payment.save()
bill = Bill.objects.get(id=order['notes']['bill_id'])
bill.is_paid = True
bill.save()
return Response({'success': result})
def create(request):
next_page = 'invoices/create.html'
clients = Client.objects.all()
if request.method == 'POST':
client = Client.objects.get(pk=request.POST['input_client'])
reference_name = request.POST['input_reference_name']
reference_number = -1 if 'input_reference_number' not in request.POST or request.POST['input_reference_number'] == '' else request.POST.get('input_reference_number', -1)
items_description = request.POST.getlist('input_description')
items_price = request.POST.getlist('input_price')
if len(items_description) == 0 or len(items_price) == 0:
message = 'Debe especificar al menos un item'
level = 'danger'
return render(request,'invoices/create.html',{'message': message,'message_level':level})
input_date = request.POST['input_date_created']
if input_date == '':
message = 'Debe especificar la fecha'
level = 'danger'
return render(request,'invoices/create.html',{'clients':clients,'message': message,'message_level':level})
else:
date_formated = datetime.datetime.strptime(input_date,'%d/%M/%Y').strftime('%Y-%M-%d')
i = Invoice(
sub_total = request.POST['input_subtotal'],
iva = request.POST['input_iva'],
total = request.POST['input_total'],
date_created = date_formated,
reference_number = reference_number,
reference_name = reference_name,
client = client
)
i.save()
print items_description
for index in xrange(0,len(items_description)):
item = Item(description = items_description[index], price = items_price[index], invoice = i)
item.save()
return HttpResponseRedirect('/invoices/%s/'%i.id)
else:
selected_client = request.GET.get('client_id','')
t = loader.get_template(next_page)
c = RequestContext(request,{'clients':clients, 'selected_client':selected_client})
return HttpResponse(t.render(c))
def create_consumption_and_invoice(measurer, measure):
with transaction.atomic():
consumption_history = ConsumptionHistory.objects.create(
from_date = measurer.last_visit,
consumption = measurer.calculate_consumption(measure),
measurer = measurer
)
measurer.register_visit(measure)
invoice = Invoice(
detail = consumption_history,
client = measurer.house.familyboss,
place = measurer.house
)
invoice.save()
return {
'consumption' : consumption_history.consumption,
'amount' : invoice.amount,
'house' : measurer.house.house_id
}
def load_invoice(request):
variables = {}
if request.POST:
invoice = Invoice()
detail_invoice = []
xmlfile = request.FILES['xmlfile']
tree = ET.parse(xmlfile)
root = tree.getroot()
emision = int(root.attrib['emision'])
emision = datetime.utcfromtimestamp(emision).strftime('%Y-%m-%d')
invoice.date = emision
tipo = root.attrib['tipo']
invoice.type = tipo
folio = root.attrib['folio']
invoice.folio = int(folio)
rut_emisor = root[0].attrib['rut']
invoice.issuing_rut = str(rut_emisor)
nombre_emisor = root[0].attrib['razonSocial']
invoice.issuing_name = nombre_emisor
rut_receptor = root[1].attrib['rut']
invoice.receiver_rut = str(rut_receptor)
nombre_receptor = root[1].attrib['razonSocial']
invoice.receiver_name = nombre_receptor
detail = []
for r in root[2]:
dic = {
'monto': r.attrib['monto'],
'iva': r.attrib['iva'],
'detalle': r.text
}
detail.append(dic)
invoice.detail = str(detail)
try:
invoice.save()
variables['mensaje'] = "guardado correctamente"
print("se guardo")
except:
variables['mensaje'] = "error al guardar"
print("no se guardo")
return render(request, 'invoices/load_invoice.html', variables)
def test_xml_header_generation(sender, client_address, sample_summary):
invoice = Invoice(
sender=sender,
invoice_number="00001A",
invoice_type="TD01",
invoice_currency="EUR",
invoice_summary=sample_summary,
invoice_date=date(2019, 6, 16),
transmission_format="FPR12",
recipient_code="ABCDEFG",
recipient_tax_code="AAABBB12B34Z123D",
recipient_first_name="Patrick",
recipient_last_name="A",
recipient_address=client_address,
)
xml = invoice.to_xml()
assert xml is not None
header = xml.xpath(
"/p:FatturaElettronica/FatturaElettronicaHeader",
namespaces={
"p":
"http://ivaservizi.agenziaentrate.gov.it/docs/xsd/fatture/v1.2"
},
)[0]
t_data = header.xpath("DatiTrasmissione")[0]
assert t_data.xpath("IdTrasmittente/IdPaese")[0].text == "IT"
assert t_data.xpath("IdTrasmittente/IdCodice")[0].text == "PIABCDE"
assert t_data.xpath("ProgressivoInvio")[0].text == "00001A"
assert t_data.xpath("FormatoTrasmissione")[0].text == "FPR12"
# TODO: test PEC address
assert t_data.xpath("CodiceDestinatario")[0].text == "ABCDEFG"
# TODO: might need to add this to the invoice, in order to be able to
# TODO: use different party for invoices (if ever needed)
# Supplier data
s_data = header.xpath("CedentePrestatore/DatiAnagrafici")[0]
assert s_data.xpath("IdFiscaleIVA/IdPaese")[0].text == "IT"
# TODO: add this to the model if it is the P. IVA
# assert s_data.xpath("IdFiscaleIVA/IdCodice")[0].text == "IT"
assert s_data.xpath("RegimeFiscale")[0].text == "RF01"
assert (s_data.xpath("Anagrafica/Denominazione")[0].text ==
"Python Italia APS")
a_data = header.xpath("CedentePrestatore/Sede")[0]
assert a_data.xpath("Indirizzo")[0].text == "Via Mugellese 1/A"
assert a_data.xpath("CAP")[0].text == "50013"
assert a_data.xpath("Comune")[0].text == "Campi Bisenzio"
assert a_data.xpath("Provincia")[0].text == "FI"
assert a_data.xpath("Nazione")[0].text == "IT"
# Client data
c_data = header.xpath("CessionarioCommittente/DatiAnagrafici")[0]
assert c_data.xpath("CodiceFiscale")[0].text == "AAABBB12B34Z123D"
assert c_data.xpath("Anagrafica/Nome")[0].text == "Patrick"
assert c_data.xpath("Anagrafica/Cognome")[0].text == "A"
ca_data = header.xpath("CessionarioCommittente/Sede")[0]
assert ca_data.xpath("Indirizzo")[0].text == "Via Roma 1"
assert ca_data.xpath("CAP")[0].text == "83100"
assert ca_data.xpath("Comune")[0].text == "Avellino"
assert ca_data.xpath("Provincia")[0].text == "AV"
assert ca_data.xpath("Nazione")[0].text == "IT"
def test_xml_body_generation(sender, client_address, sample_summary):
invoice = Invoice(
sender=sender,
invoice_number="00001A",
invoice_type="TD01",
invoice_currency="EUR",
invoice_date=date(2019, 6, 16),
invoice_summary=sample_summary,
invoice_tax_rate=22.00,
invoice_amount=2.00,
invoice_tax_amount=2.00,
causal=("A" * 200 + "B" * 200),
transmission_format="FPR12",
recipient_code="ABCDEFG",
recipient_tax_code="AAABBB12B34Z123D",
recipient_first_name="Patrick",
recipient_last_name="A",
recipient_address=client_address,
)
xml = invoice.to_xml()
assert xml is not None
body = xml.xpath(
"/p:FatturaElettronica/FatturaElettronicaBody",
namespaces={
"p":
"http://ivaservizi.agenziaentrate.gov.it/docs/xsd/fatture/v1.2"
},
)[0]
general_data = body.xpath("DatiGenerali/DatiGeneraliDocumento")[0]
assert general_data.xpath("TipoDocumento")[0].text == "TD01"
assert general_data.xpath("Data")[0].text == "2019-06-16"
assert general_data.xpath("Divisa")[0].text == "EUR"
assert general_data.xpath("Numero")[0].text == "00001A"
# make sure the limit for the causal is respected (200 chars)
assert len(general_data.xpath("Causale")) == 2
assert general_data.xpath("Causale")[0].text == "A" * 200
assert general_data.xpath("Causale")[1].text == "B" * 200
# Invoice summary
summary = body.xpath("DatiBeniServizi")[0]
assert len(summary.xpath("DettaglioLinee")) == 2
first_item = summary.xpath("DettaglioLinee")[0]
second_item = summary.xpath("DettaglioLinee")[1]
assert first_item.xpath("NumeroLinea")[0].text == "1"
assert first_item.xpath("Descrizione")[0].text == "item 1"
assert first_item.xpath("Quantita")[0].text == "1.00"
assert first_item.xpath("PrezzoUnitario")[0].text == "1.00"
assert first_item.xpath("PrezzoTotale")[0].text == "1.00"
assert first_item.xpath("AliquotaIVA")[0].text == "0.00"
assert second_item.xpath("NumeroLinea")[0].text == "2"
assert second_item.xpath("Descrizione")[0].text == "item 2"
assert second_item.xpath("Quantita")[0].text == "2.00"
assert second_item.xpath("PrezzoUnitario")[0].text == "2.00"
assert second_item.xpath("PrezzoTotale")[0].text == "2.00"
assert second_item.xpath("AliquotaIVA")[0].text == "0.00"
# TODO: this needs to be formatted to have two decimal places
assert summary.xpath("DatiRiepilogo/AliquotaIVA")[0].text == "22.0"
assert summary.xpath("DatiRiepilogo/ImponibileImporto")[0].text == "2.0"
assert summary.xpath("DatiRiepilogo/Imposta")[0].text == "2.0"
def invoice_user(user, force=False, save=False):
from bursary.models import Bursary
attendee = user.attendee
try:
bursary = user.bursary
except Bursary.DoesNotExist:
bursary = Bursary()
lines = []
fee_info = FEE_INVOICE_INFO.get(attendee.fee)
if fee_info:
fee_info['quantity'] = 1
lines.append(InvoiceLine(**fee_info))
try:
accomm = attendee.accomm
except ObjectDoesNotExist:
accomm = None
if accomm and not bursary.potential_bursary('accommodation'):
for line in invoice_accomm(accomm):
lines.append(InvoiceLine(**line))
try:
food = attendee.food
except ObjectDoesNotExist:
food = None
if food and not bursary.potential_bursary('food'):
for line in invoice_food(food):
lines.append(InvoiceLine(**line))
for paid_invoice in user.invoices.filter(status='paid', compound=False):
lines.append(
InvoiceLine(
reference='INV#{}'.format(paid_invoice.reference_number),
description='Previous Payment Received',
unit_price=-paid_invoice.total,
quantity=1,
))
invoice = Invoice(recipient=user,
status='new',
date=timezone.now(),
invoiced_entity=attendee.invoiced_entity,
billing_address=attendee.billing_address)
# Only save invoices if non empty
if save and lines:
invoice.save()
total = 0
for i, line in enumerate(lines):
line.line_order = i
total += line.total
if save:
line.invoice_id = invoice.id
line.save()
return {
'invoice': invoice,
'lines': lines,
'total': total,
'total_twd': total * TWD_EXCHANGE_RATE,
}
