def test_get_proformas(self): batch_size = 50 ProformaFactory.create_batch(batch_size) url = reverse('proforma-list') response = self.client.get(url) assert response.status_code == status.HTTP_200_OK response = self.client.get(url + '?page=2') assert response.status_code == status.HTTP_200_OK
def test_get_proforma(self, mocked_settings): ProformaFactory.reset_sequence(1) upload_path = '%s/documents/' % settings.MEDIA_ROOT proforma = ProformaFactory.create(pdf=PDF.objects.create(upload_path=upload_path)) proforma.generate_pdf() url = reverse('proforma-detail', kwargs={'pk': proforma.pk}) for show_pdf_storage_url, pdf_url in [ (True, build_absolute_test_url(proforma.pdf.url)), (False, build_absolute_test_url(reverse('pdf', args=[proforma.pdf.pk]))) ]: mocked_settings.SILVER_SHOW_PDF_STORAGE_URL = show_pdf_storage_url response = self.client.get(url) provider_url = build_absolute_test_url(reverse('provider-detail', [proforma.provider.pk])) customer_url = build_absolute_test_url(reverse('customer-detail', [proforma.customer.pk])) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, { "id": proforma.pk, "series": "ProformaSeries", "number": proforma.number, "provider": provider_url, "customer": customer_url, "archived_provider": '{}', "archived_customer": '{}', "due_date": None, "issue_date": None, "paid_date": None, "cancel_date": None, "sales_tax_name": "VAT", "sales_tax_percent": '1.00', "currency": text_type("RON"), "transaction_currency": proforma.transaction_currency, "transaction_xe_rate": ("%.4f" % proforma.transaction_xe_rate if proforma.transaction_xe_rate else None), "transaction_xe_date": proforma.transaction_xe_date, "pdf_url": pdf_url, "state": "draft", "invoice": None, "proforma_entries": [], "total": 0, "total_in_transaction_currency": 0, "transactions": [] })
def test_add_transaction_with_amount_greater_than_what_should_be_charged(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) proforma = ProformaFactory.create(customer=customer, state=Proforma.STATES.ISSUED, issue_date=timezone.now().date()) proforma.create_invoice() invoice = proforma.related_document valid_until = datetime.now().replace(microsecond=0) url = reverse('payment-method-transaction-list', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk}) invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) data = { 'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.id}), 'valid_until': valid_until, 'amount': invoice.total_in_transaction_currency + 1, 'invoice': invoice_url, 'proforma': proforma_url } response = self.client.post(url, format='json', data=data) expected_data = { 'non_field_errors': ["Amount is greater than the amount that should be charged in " "order to pay the billing document."] } self.assertEqual(response.data, expected_data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_cancel_proforma_with_provided_date(self): provider = ProviderFactory.create() customer = CustomerFactory.create() proforma = ProformaFactory.create(provider=provider, customer=customer) proforma.issue() url = reverse('proforma-state', kwargs={'pk': proforma.pk}) data = {'state': 'canceled', 'cancel_date': '2014-10-10'} 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'), 'cancel_date': '2014-10-10', 'state': 'canceled' } assert response.status_code == status.HTTP_200_OK assert all(item in list(response.data.items()) for item in mandatory_content.items()) assert Invoice.objects.count() == 0
def test_actions_failed_no_log_entries(self): proforma = ProformaFactory.create() url = reverse('admin:silver_proforma_changelist') mock_log_entry = MagicMock() mock_log_action = MagicMock() mock_log_entry.objects.log_action = mock_log_action exceptions = cycle([ValueError, TransitionNotAllowed]) def _exception_thrower(*args): raise next(exceptions) mock_action = MagicMock(side_effect=_exception_thrower) mock_proforma = MagicMock() mock_proforma.issue = mock_action mock_proforma.cancel = mock_action mock_proforma.pay = mock_action mock_proforma.clone_into_draft = mock_action mock_proforma.create_invoice = mock_action with patch.multiple('silver.admin', LogEntry=mock_log_entry, Proforma=mock_proforma): actions = ['issue', 'pay', 'cancel', 'clone', 'create_invoice'] for action in actions: self.admin.post(url, { 'action': action, '_selected_action': [str(proforma.pk)] }) assert not mock_log_action.call_count
def test_add_multiple_proforma_entries(self): proforma = ProformaFactory.create() url = reverse('proforma-entry-create', kwargs={'document_pk': proforma.pk}) request_data = { "description": "Page views", "unit_price": 10.0, "quantity": 20 } entries_count = 5 for cnt in range(entries_count): response = self.client.post(url, data=json.dumps(request_data), content_type='application/json') assert response.status_code == status.HTTP_201_CREATED, response.data entry = proforma.entries.get(id=response.data['id']) document_entry_definition.check_response(entry, response.data, request_data) # check proforma entries in new request url = reverse('proforma-detail', kwargs={'pk': proforma.pk}) response = self.client.get(url) proforma_entries = response.data.get('proforma_entries', []) assert len(proforma_entries) == entries_count
def test_documents_list_case_1(self): """ One proforma, one invoice, without related documents """ proforma = ProformaFactory.create() invoice_entries = DocumentEntryFactory.create_batch(3) invoice = InvoiceFactory.create(invoice_entries=invoice_entries) invoice.issue() payment_method = PaymentMethodFactory.create(customer=invoice.customer) transaction = TransactionFactory.create(payment_method=payment_method, invoice=invoice) url = reverse('document-list') with patch('silver.utils.payments._get_jwt_token', new=self._jwt_token): response = self.client.get(url) # ^ there's a bug where specifying format='json' doesn't work response_data = response.data self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response_data), 2) self.assertIn(self._get_expected_data(invoice, [transaction]), response_data) self.assertIn(self._get_expected_data(proforma), response_data)
def test_issue_proforma_with_custom_issue_date_and_due_date(self): provider = ProviderFactory.create() customer = CustomerFactory.create() proforma = ProformaFactory.create(provider=provider, customer=customer) url = reverse('proforma-state', kwargs={'pk': proforma.pk}) 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 list(response.data.items()) for item in mandatory_content.items()) 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_delete_proforma_entry(self): proforma = ProformaFactory.create() url = reverse('proforma-entry-create', kwargs={'document_pk': proforma.pk}) entry_data = { "description": "Page views", "unit_price": 10.0, "quantity": 20 } entries_count = 10 for cnt in range(entries_count): self.client.post(url, data=json.dumps(entry_data), content_type='application/json') url = reverse('proforma-entry-update', kwargs={ 'document_pk': proforma.pk, 'entry_pk': list(proforma._entries)[0].pk }) response = self.client.delete(url) assert response.status_code == status.HTTP_204_NO_CONTENT url = reverse('proforma-detail', kwargs={'pk': proforma.pk}) response = self.client.get(url) invoice_entries = response.data.get('proforma_entries', None) assert len(invoice_entries) == entries_count - 1
def test_add_transaction_with_draft_document(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) proforma = ProformaFactory.create(customer=customer) proforma_url = reverse('proforma-detail', args=[proforma.pk]) valid_until = datetime.now().replace(microsecond=0) url = reverse('payment-method-transaction-list', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk}) data = { 'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk}), 'valid_until': valid_until, 'amount': 200.0, 'proforma': proforma_url } response = self.client.post(url, format='json', data=data) expected_data = { 'non_field_errors': [u'The transaction must have a non-draft billing document ' u'(invoice or proforma).'] } self.assertEqual(response.data, expected_data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_add_transaction_with_documents_for_a_different_customer(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) proforma = ProformaFactory.create() proforma.issue() proforma.create_invoice() proforma.refresh_from_db() invoice = proforma.related_document valid_until = datetime.now().replace(microsecond=0) url = reverse('payment-method-transaction-list', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk}) invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) data = { 'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.id}), 'valid_until': valid_until, 'amount': 200.0, 'invoice': invoice_url, 'proforma': proforma_url } response = self.client.post(url, format='json', data=data) expected_data = { 'non_field_errors': [u"Customer doesn't match with the one in documents."] } self.assertEqual(response.data, expected_data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_proforma_total_with_tax_integrity(self): proforma_entries = DocumentEntryFactory.create_batch(5) proforma = ProformaFactory.create(proforma_entries=proforma_entries) proforma.sales_tax_percent = Decimal('20.00') assert proforma.total == proforma.total_before_tax + proforma.tax_value
def test_pay_proforma_with_provided_date(self): provider = ProviderFactory.create() customer = CustomerFactory.create() proforma = ProformaFactory.create(provider=provider, customer=customer) proforma.issue() url = reverse('proforma-state', kwargs={'pk': proforma.pk}) data = {'state': 'paid', 'paid_date': '2014-05-05'} response = self.client.put(url, data=json.dumps(data), content_type='application/json') proforma.refresh_from_db() assert response.status_code == status.HTTP_200_OK due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS) invoice_url = build_absolute_test_url( reverse('invoice-detail', [proforma.related_document.pk])) 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': invoice_url } assert response.status_code == status.HTTP_200_OK assert all(item in list(response.data.items()) for item in mandatory_content.items()) invoice = Invoice.objects.all()[0] assert proforma.related_document == invoice assert invoice.related_document == proforma
def test_proforma_currency_used_for_transaction_currency(self): customer = CustomerFactory.create(currency=None) proforma = ProformaFactory.create(customer=customer, currency='EUR', transaction_currency=None) self.assertEqual(proforma.transaction_currency, 'EUR')
def test_proforma_tax_value_decimal_places(self): proforma_entries = DocumentEntryFactory.create_batch(3) proforma = ProformaFactory.create(proforma_entries=proforma_entries) proforma.sales_tax_percent = Decimal('20.00') assert self._get_decimal_places(proforma.tax_value) == 2
def handle(self, *args, **options): proforma = ProformaFactory.create( proforma_entries=[DocumentEntryFactory.create()], state=Proforma.STATES.ISSUED) proforma.create_invoice() invoice = InvoiceFactory.create( invoice_entries=[DocumentEntryFactory.create()], state=Invoice.STATES.ISSUED, related_document=None) TransactionFactory.create(state=Transaction.States.Settled, invoice=invoice, payment_method__customer=invoice.customer, proforma=None) InvoiceFactory.create_batch( size=3, invoice_entries=[DocumentEntryFactory.create()], state=Invoice.STATES.PAID, related_document=None) InvoiceFactory.create_batch( size=3, invoice_entries=[DocumentEntryFactory.create()], state=Invoice.STATES.DRAFT, related_document=None) InvoiceFactory.create_batch( size=3, invoice_entries=[DocumentEntryFactory.create()], state=Invoice.STATES.CANCELED, related_document=None)
def test_no_transaction_settle_with_only_related_proforma(self): proforma = ProformaFactory.create(related_document=None) customer = proforma.customer PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False, verified=True, ) proforma.issue() transaction = proforma.transactions[0] # here transaction.proforma is the same object as the proforma from the # DB due to the way transition callbacks and saves are called transaction.settle() self.assertEqual(proforma.state, proforma.STATES.PAID) invoice = proforma.related_document self.assertEqual(invoice.state, invoice.STATES.PAID) self.assertEqual(list(proforma.transactions), list(invoice.transactions)) self.assertEqual(len(proforma.transactions), 1)
def test_add_transaction_without_currency_and_amount(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) entries = DocumentEntryFactory.create_batch(2) proforma = ProformaFactory.create(customer=customer, state=Proforma.STATES.ISSUED, issue_date=timezone.now().date(), currency='USD', transaction_currency='RON', transaction_xe_rate=Decimal('0.25'), proforma_entries=entries) proforma.create_invoice() invoice = proforma.related_document valid_until = datetime.now().replace(microsecond=0) + timedelta( minutes=30) url = reverse('payment-method-transaction-list', kwargs={ 'customer_pk': customer.pk, 'payment_method_id': payment_method.pk }) payment_method_url = reverse('payment-method-detail', kwargs={ 'customer_pk': customer.pk, 'payment_method_id': payment_method.id }) invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) data = { 'payment_method': reverse('payment-method-detail', kwargs={ 'customer_pk': customer.pk, 'payment_method_id': payment_method.id }), 'valid_until': valid_until, 'invoice': invoice_url, 'proforma': proforma_url } response = self.client.post(url, format='json', data=data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.data['payment_method'], payment_method_url) self.assertEqual(response.data['valid_until'][:-1], valid_until.isoformat()) self.assertEqual(response.data['can_be_consumed'], True) self.assertEqual(response.data['amount'], force_str(invoice.total_in_transaction_currency)) self.assertEqual(response.data['invoice'], invoice_url) self.assertEqual(response.data['proforma'], proforma_url) self.assertEqual(response.data['currency'], invoice.transaction_currency)
def test_pay_proforma_related_invoice_state_change_to_paid(self): proforma = ProformaFactory.create() proforma.issue() proforma.create_invoice() proforma.pay() assert proforma.related_document.state == Invoice.STATES.PAID assert proforma.state == Invoice.STATES.PAID
def test_draft_proforma_series_number(self): proforma = ProformaFactory.create() proforma.number = None assert proforma.series_number == '%s-draft-id:%d' % (proforma.series, proforma.pk) proforma.series = None assert proforma.series_number == 'draft-id:%d' % proforma.pk
def test_cancel_issued_invoice_with_related_proforma(self): proforma = ProformaFactory.create() proforma.issue() if not proforma.related_document: proforma.create_invoice() proforma.related_document.cancel() assert proforma.related_document.state == proforma.state == Invoice.STATES.CANCELED
def test_pay_proforma_when_in_draft_state(self): provider = ProviderFactory.create() customer = CustomerFactory.create() proforma = ProformaFactory.create(provider=provider, customer=customer) url = reverse('proforma-state', kwargs={'pk': proforma.pk}) data = {'state': 'paid'} response = self.client.put(url, data=json.dumps(data), content_type='application/json') assert response.status_code == status.HTTP_403_FORBIDDEN assert response.data == {'detail': 'A proforma can be paid only if it is in issued state.'} assert Invoice.objects.count() == 0
def test_edit_proforma_in_issued_state(self): proforma = ProformaFactory.create() proforma.issue() url = reverse('proforma-detail', kwargs={'pk': proforma.pk}) data = {"description": "New Page views"} response = self.client.patch(url, data=json.dumps(data), content_type='application/json') assert response.status_code == status.HTTP_400_BAD_REQUEST error_message = 'You cannot edit the document once it is in issued state.' assert response.data == {'non_field_errors': [error_message]}
def test_add_transaction(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) entry = DocumentEntryFactory(quantity=1, unit_price=200) proforma = ProformaFactory.create(customer=customer, proforma_entries=[entry]) proforma.issue() proforma.create_invoice() proforma.refresh_from_db() invoice = proforma.related_document payment_method_url = reverse('payment-method-detail', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.id}) invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) url = reverse('payment-method-transaction-list', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk}) valid_until = datetime.now().replace(microsecond=0) + timedelta(minutes=30) currency = invoice.transaction_currency data = { 'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.id}), 'amount': invoice.total_in_transaction_currency, 'invoice': invoice_url, 'proforma': proforma_url, 'valid_until': valid_until, 'currency': currency, } response = self.client.post(url, format='json', data=data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.data['payment_method'], payment_method_url) self.assertEqual(response.data['valid_until'][:-1], valid_until.isoformat()) self.assertEqual(response.data['can_be_consumed'], True) self.assertEqual(response.data['amount'], force_text(invoice.total_in_transaction_currency)) self.assertEqual(response.data['invoice'], invoice_url) self.assertEqual(response.data['proforma'], proforma_url) self.assertEqual(response.data['currency'], currency) self.assertTrue(Transaction.objects.filter(uuid=response.data['id']))
def test_generate_pdfs_task(monkeypatch): issued_invoice = InvoiceFactory.create() issued_invoice.issue() paid_invoice = InvoiceFactory.create() paid_invoice.issue() paid_invoice.pay() canceled_invoice = InvoiceFactory.create() canceled_invoice.issue() canceled_invoice.cancel() issued_invoice_already_generated = InvoiceFactory.create() issued_invoice_already_generated.issue() issued_invoice_already_generated.pdf.dirty = False issued_invoice_already_generated.pdf.save() issued_proforma = ProformaFactory.create() issued_proforma.issue() issued_proforma_already_generated = ProformaFactory.create() issued_proforma_already_generated.issue() issued_proforma_already_generated.pdf.dirty = False issued_proforma_already_generated.pdf.save() documents_to_generate = [ issued_invoice, canceled_invoice, paid_invoice, issued_proforma ] for document in documents_to_generate: assert document.pdf.dirty lock_mock = MagicMock() monkeypatch.setattr('silver.tasks.redis.lock', lock_mock) with patch('silver.tasks.group') as group_mock: generate_pdfs() assert group_mock.call_count
def test_illegal_state_change_when_in_draft_state(self): provider = ProviderFactory.create() customer = CustomerFactory.create() proforma = ProformaFactory.create(provider=provider, customer=customer) url = reverse('proforma-state', kwargs={'pk': proforma.pk}) data = {'state': 'illegal-state'} response = self.client.put(url, data=json.dumps(data), content_type='application/json') assert response.status_code == status.HTTP_403_FORBIDDEN assert response.data == {'detail': 'Illegal state value.'} assert Invoice.objects.count() == 0
def test_pay_proforma_with_no_related_invoice_creates_invoice(self): proforma = ProformaFactory.create() proforma.customer.payment_due_days = 30 proforma.issue() proforma.pay() invoice = proforma.related_document assert proforma.state == Invoice.STATES.PAID assert invoice.state == Invoice.STATES.PAID assert invoice.total == proforma.total assert invoice.due_date - invoice.issue_date == datetime.timedelta( days=30)
def test_patch_transaction_not_allowed_fields(self): payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor) customer = payment_method.customer transaction = TransactionFactory.create(payment_method=payment_method) proforma = ProformaFactory.create(state='issued', customer=customer) invoice = InvoiceFactory.create(state='issued', customer=customer, related_document=proforma) proforma.related_document = invoice proforma.save() invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) url = reverse('transaction-detail', args=[transaction.customer.pk, transaction.uuid]) new_payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer) new_payment_method_url = reverse('payment-method-detail', kwargs={ 'customer_pk': new_payment_method.customer.pk, 'payment_method_id': new_payment_method.pk }) data = { 'proforma': proforma_url, 'invoice': invoice_url, 'currency': 'EUR', 'amount': 1234, 'payment_method': new_payment_method_url } response = self.client.patch(url, format='json', data=data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual( response.data, { 'proforma': [u'This field may not be modified.'], 'invoice': [u'This field may not be modified.'], 'currency': [u'This field may not be modified.'], 'amount': [u'This field may not be modified.'], 'payment_method': [u'This field may not be modified.'] })
def test_add_transaction_with_currency_different_from_document(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) proforma = ProformaFactory.create(customer=customer, state=Proforma.STATES.ISSUED, issue_date=timezone.now().date()) proforma.create_invoice() invoice = proforma.related_document valid_until = datetime.now().replace(microsecond=0) url = reverse('payment-method-transaction-list', kwargs={ 'customer_pk': customer.pk, 'payment_method_id': payment_method.pk }) invoice_url = reverse('invoice-detail', args=[invoice.pk]) proforma_url = reverse('proforma-detail', args=[proforma.pk]) data = { 'payment_method': reverse('payment-method-detail', kwargs={ 'customer_pk': customer.pk, 'payment_method_id': payment_method.id }), 'valid_until': valid_until, 'currency': 'EUR', 'amount': invoice.total_in_transaction_currency, 'invoice': invoice_url, 'proforma': proforma_url } response = self.client.post(url, format='json', data=data) expected_data = { 'non_field_errors': [ u"Transaction currency is different from it's " u"document's transaction_currency." ] } self.assertEqual(response.data, expected_data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_actions_log_entries(self): proforma = ProformaFactory.create() url = reverse('admin:silver_proforma_changelist') mock_log_entry = MagicMock() mock_log_action = MagicMock() mock_log_entry.objects.log_action = mock_log_action mock_action = Mock(return_value=Mock(series_number='aaa', admin_change_url="result_url")) mock_proforma = MagicMock() mock_proforma.issue = mock_action mock_proforma.cancel = mock_action mock_proforma.pay = mock_action mock_proforma.clone_into_draft = mock_action mock_proforma.create_invoice = mock_action with patch.multiple('silver.admin', LogEntry=mock_log_entry, Proforma=mock_proforma): actions = ['issue', 'pay', 'cancel', 'clone', 'create_invoice'] for action in actions: self.admin.post(url, { 'action': action, '_selected_action': [str(proforma.pk)] }) assert mock_action.call_count mock_action.reset_mock() if action == 'clone': action = 'clone_into_draft' mock_log_action.assert_called_with( user_id=self.user.pk, content_type_id=ContentType.objects.get_for_model(proforma).pk, object_id=proforma.pk, object_repr=force_str(proforma), action_flag=CHANGE, change_message='{action} action initiated by user.'.format( action=action.capitalize().replace('_', ' ') ) )