def post(self, request, format=None):
serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
resp, ok = self.repository.create(serializer.data)
if ok:
return Response(resp, status=status.HTTP_201_CREATED)
return Response(str(resp), status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class UserSerializer(serializers.ModelSerializer):
password = serializers.CharField(write_only=True)
password_confirmation = serializers.CharField(write_only=True)
invoices = InvoiceSerializer(many=True, read_only=True)
def validate(self, data):
password = data.pop('password')
password_confirmation = data.pop('password_confirmation')
if password != password_confirmation:
raise ValidationError({'password_confirmation': 'does not match'})
# #password validation happens here
# try:
# validations.validate_password(password=password)
# except ValidationError as err:
# raise serializers.ValidationError({'password': err.messages})
data['password'] = make_password(password)
return data
class Meta:
model = User
fields = ('id', 'username', 'email', 'password', 'password_confirmation', 'logo_image', 'tax_reg', 'address', 'phone_num', 'company_name', 'invoices')
def pay_invoices(invoices: list, amount) -> dict:
"""
Recive una lista de facturas y un dinero para efectuar el pago de las mismas.
Retorna:
ok : Indica si se pudo o no cancelar el total de facturas pendientes.
change : Monto restante del pago de facturas
number_of_payments : Numero de facturas pagas
unpaid_invoices : datos de las facturas que no se pudieron procesar.
"""
ok = True
amount = Decimal(amount)
with transaction.atomic():
for index, invoice in enumerate(invoices):
if amount >= invoice.amount:
amount -= invoice.amount
invoice.pay()
else:
ok = False
break
if ok:
number_of_payments = index + 1
unpaid_invoices = []
else:
number_of_payments = index
unpaid_invoices = invoices[index:invoices.count()]
return {
'ok': ok,
'change': amount,
'number_of_payments': number_of_payments,
'unpaid_invoices': InvoiceSerializer(unpaid_invoices, many=True).data,
}
def post(self, *args, **kwargs):
search_string = self.request.query_params.get('search')
return Response(
InvoiceSerializer(Invoice.objects.filter(
Q(shop__icontains=search_string)
| Q(articles__item__icontains=search_string)),
many=True).data)
class RestaurantSerializer(serializers.ModelSerializer):
author = SmallUserSerializer(required=False, read_only=True)
revenues = RevenueSerializer(required=False, read_only=True, many=True)
invoices = InvoiceSerializer(required=False, read_only=True, many=True)
class Meta:
model = Restaurant
fields = ['id', 'author', 'created', 'updated', 'name', 'country', 'street', 'city', 'zip', 'website', 'phone',
'email', 'image', 'revenues', 'invoices']
read_only_fields = ['author']
def invoice_list(request):
if request.method == 'GET':
invoices = Invoice.objects.all()
serializer = InvoiceSerializer(invoices, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
try:
order_by = self.get_order_by(request)
filter_by = self.get_filter_by(request)
items = self.get_items(order_by, filter_by)
results = self.paginate_queryset(items, request)
serializer = InvoiceSerializer(results, many=True)
return self.get_paginated_response(serializer.data)
except Exception as ex:
return Response(ex, status=status.HTTP_400_BAD_REQUEST)
def invoice_detail(request, pk):
try:
invoice = Invoice.objects.get(pk=pk)
except Invoice.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = InvoiceSerializer(invoice)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = InvoiceSerializer(invoice, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class LineSerializer(serializers.ModelSerializer):
'''
Define the Lineitem's serializer.
In addition, define the relationship with the parrent Invoice.
'''
invoice = InvoiceSerializer(read_only=True)
invoice_id = serializers.PrimaryKeyRelatedField(
queryset=Invoice.objects.all(), source='invoice')
def validate(self, data):
"""
Validating the amount claculation on each create or update
"""
try:
data['amount'] = data['quantity'] * data['rate']
except ValidationError:
raise serializers.ValidationError("Quantity and Rate need to be positvie decimal numbers")
return data
class Meta:
model = Line
fields = ('id', 'description', 'quantity', 'rate', 'amount', 'invoice', 'invoice_id')
read_only_fields = ('amount',)
def pending_invoices(self, request, *args, **kwargs):
family_boss = self.get_object()
invoices = family_boss.invoice_set.filter(paid=False)
serializer = InvoiceSerializer(invoices, many=True)
return Response(serializer.data)
def invoices(self, request, *args, **kwargs):
family_boss = self.get_object()
invoices = family_boss.invoice_set.all()
serializer = InvoiceSerializer(invoices, many=True)
return Response(serializer.data)
def process_csv(path, filename):
errors = []
total = 0
result = (True, errors)
file_serializer = FileSerializer(data={
'filename': filename,
'total_items_price': 0
})
if file_serializer.is_valid():
file = file_serializer.save()
#TODO: create logic to change the delimiter.
with open(path, mode='r', encoding='utf-8-sig') as csv_file:
reader = csv.reader(csv_file, delimiter=';')
line_count = 0
for row in reader:
if line_count == 0:
if not validate_headers(row):
result = (False, 'Wrong Headers')
break
line_count += 1
else:
try:
line_count += 1
invoice_data = {
'invoice_number': row[0],
'client_name': row[1],
'client_lastname': row[2],
'client_id': row[3],
'item_code': row[4],
'item_description': row[5],
'item_amount': row[6],
'item_price': row[7],
'item_discount_rate': row[8],
'file': file.id
}
invoice_serializer = InvoiceSerializer(
data=invoice_data)
if invoice_serializer.is_valid():
invoice_serializer.save()
total = total + float(row[7])
else:
errors.append({
'error_line':
line_count,
'error_description':
'The file ' + filename +
' is corrupt, validate file on line ' +
str(line_count),
'error_capturated':
invoice_serializer.errors
})
except IndexError:
result = (
False,
'Index error, validate the delimiter of the CSV must be ;'
)
break
except Exception as e:
result = (False, 'The file ' + filename +
' is corrupt, validate file on line ' +
str(line_count) + '. Error capturated: ' +
str(e))
break
file.total_items_price = total
file.save()
os.remove(path)
if result[0]:
serialized_result = ListFileSerializer(file)
content_result = json.loads(JSONRenderer().render(
serialized_result.data))
result = (True, errors, content_result)
return result
os.remove(path)
return (False, 'File corrupt')