def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': 1})
data = {
'state': 'paid',
'paid_date': '2014-05-05'
}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': 'http://testserver/invoices/1/'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = get_object_or_None(Invoice, pk=1)
proforma = get_object_or_None(Proforma, pk=1)
assert proforma.invoice == invoice
assert invoice.proforma == proforma
invoice = get_object_or_None(Invoice, proforma=proforma)
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'paid', 'paid_date': '2014-05-05'}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': 'http://testserver/invoices/1/'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = get_object_or_None(Invoice, pk=1)
proforma = get_object_or_None(Proforma, pk=1)
assert proforma.invoice == invoice
assert invoice.proforma == proforma
invoice = get_object_or_None(Invoice, proforma=proforma)
def test_issue_proforma_with_custom_issue_date_and_due_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {
'state': 'issued',
'issue_date': '2014-01-01',
'due_date': '2014-01-20'
}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': '2014-01-20',
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_issue_proforma_with_default_dates(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'issued'}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_issue_invoice_with_custom_issue_date_and_due_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
InvoiceFactory.create(provider=provider, customer=customer)
url = reverse('invoice-state', kwargs={'pk': 1})
data = {
'state': 'issued',
'issue_date': '2014-01-01',
'due_date': '2014-01-20'
}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': '2014-01-20',
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
invoice = get_object_or_None(Invoice, pk=1)
def test_issue_invoice_with_default_dates(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
InvoiceFactory.create(provider=provider, customer=customer)
url = reverse('invoice-state', kwargs={'pk': 1})
data = {'state': 'issued'}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
invoice = get_object_or_None(Invoice, pk=1)
def get_queryset(self):
plan = get_object_or_None(Plan, pk=self.kwargs['pk'])
return plan.metered_features.all() if plan else None
def patch(self, request, *args, **kwargs):
mf_product_code = self.kwargs.get('mf_product_code', None)
subscription_pk = self.kwargs.get('subscription_pk', None)
try:
subscription = Subscription.objects.get(pk=subscription_pk)
except Subscription.DoesNotExist:
return Response({"detail": "Subscription Not found."},
status=status.HTTP_404_NOT_FOUND)
# TODO: change this to try-except
metered_feature = get_object_or_None(
subscription.plan.metered_features,
product_code__value=mf_product_code
)
if not metered_feature:
return Response({"detail": "Metered Feature Not found."},
status=status.HTTP_404_NOT_FOUND)
if subscription.state != 'active':
return Response({"detail": "Subscription is not active."},
status=status.HTTP_403_FORBIDDEN)
required_fields = ['date', 'count', 'update_type']
provided_fields = {}
errors = {}
for field in required_fields:
try:
provided_fields[field] = request.data[field]
except KeyError:
errors[field] = ["This field is required."]
for key in provided_fields:
if not provided_fields[key]:
errors[key] = ["This field may not be blank."]
if errors:
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
date = request.data['date']
consumed_units = request.data['count']
update_type = request.data['update_type']
consumed_units = Decimal(consumed_units)
try:
date = datetime.datetime.strptime(date,
'%Y-%m-%d').date()
except TypeError:
return Response({'detail': 'Invalid date format. Please '
'use the ISO 8601 date format.'},
status=status.HTTP_400_BAD_REQUEST)
if date < subscription.start_date:
return Response({"detail": "Date is out of bounds."},
status=status.HTTP_400_BAD_REQUEST)
bsd = subscription.bucket_start_date(date)
bed = subscription.bucket_end_date(date)
if not bsd or not bed:
return Response(
{'detail': 'An error has been encountered.'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
interval = next(
(i for i in subscription.updateable_buckets()
if i['start_date'] == bsd and i['end_date'] == bed),
None)
if interval is None:
return Response({"detail": "Date is out of bounds."},
status=status.HTTP_400_BAD_REQUEST)
if metered_feature not in \
subscription.plan.metered_features.all():
err = "The metered feature does not belong to the " \
"subscription's plan."
return Response(
{"detail": err},
status=status.HTTP_400_BAD_REQUEST
)
log = MeteredFeatureUnitsLog.objects.filter(
start_date=bsd,
end_date=bed,
metered_feature=metered_feature.pk,
subscription=subscription_pk
).first()
if log is not None:
if update_type == 'absolute':
log.consumed_units = consumed_units
elif update_type == 'relative':
log.consumed_units += consumed_units
log.save()
else:
log = MeteredFeatureUnitsLog.objects.create(
metered_feature=metered_feature,
subscription=subscription,
start_date=bsd,
end_date=bed,
consumed_units=consumed_units
)
return Response({"count": log.consumed_units},
status=status.HTTP_200_OK)
