def test_should_not_create_existing_purchase_order_items_when_there_is_matching_sales_order_item(
self):
self.create_items()
self.sales_order_one = SalesOrderFactory(order_number=20148031)
self.sales_order_two = SalesOrderFactory(order_number=20147537)
self.facade.save_records(self.imported_purchase_order_data)
self.assertEqual(PurchaseOrderItem.objects.count(), 0)
def create_sales_orders(self):
self.sales_order_one = SalesOrderFactory(order_number=20153976)
self.sales_order_two = SalesOrderFactory(order_number=20143982)
self.sales_order_item_one = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_one,
item_number=10,
description='Laptop Lenovo ThinkPad T510')
self.sales_order_item_two = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_two,
item_number=20,
description='Laptop bag')
def create_sales_orders(self):
self.sales_order_one = SalesOrderFactory(order_number=20153976)
self.sales_order_two = SalesOrderFactory(order_number=20143982)
self.sales_order_item_one = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_one,
item_number=10)
self.sales_order_item_two = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_two,
item_number=20)
self.sales_order_item_three = SalesOrderItemFactory(
sales_order=self.sales_order_two,
item=self.item_three,
item_number=20)
def add_a_node_with_response(self, number=1):
delivery = DeliveryFactory(track=True)
programme = ProgrammeFactory(name='special_program')
sales_order = SalesOrderFactory(programme=programme)
quantity_received_qn = NumericQuestion.objects.get(label='amountReceived')
while number > 0:
purchase_order = PurchaseOrderFactory(order_number=4748278 + number, sales_order=sales_order)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order,
item=ItemFactory(material_code='Code 23' + str(number),
description='Jerrycans' + str(number)))
self.extra_ip_node = DeliveryNodeFactory(programme=delivery.programme, distribution_plan=delivery,
item=po_item,
quantity=40, acknowledged=40, balance=40, location='Amudat',
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
run = RunFactory(runnable=self.extra_ip_node)
NumericAnswerFactory(question=quantity_received_qn, value=40, run=run)
number -= 1
end_node_one = DeliveryNodeFactory(programme=delivery.programme,
consignee=self.end_user,
parents=[(self.extra_ip_node, 30)],
tree_position=DistributionPlanNode.END_USER,
item=po_item)
run_end_node_one = RunFactory(runnable=end_node_one)
NumericAnswerFactory(question=quantity_received_qn, value=43, run=run_end_node_one)
def test_should_create_sales_order_items_with_different_item_numbers(self):
num_sales_order_imports = SalesOrderItem.objects.count()
sales_order_facade = SalesOrderFacade('some/location')
item = ItemFactory(material_code='MYCODE123',
description='Some Description')
sales_order = SalesOrderFactory()
SalesOrderItemFactory(item=item,
item_number=200,
sales_order=sales_order)
sales_order_item_row = {
'item_number': 220,
'material_code': 'MYCODE123',
'item_description': 'Some Description',
'date': '2015-8-5',
'net_value': 250.0,
'quantity': 5.0
}
sales_order_facade._create_new_item(sales_order_item_row, sales_order)
self.assertEqual(num_sales_order_imports + 2,
SalesOrderItem.objects.count())
def test_gets_correct_last_shipment_date_value_for_stock_report(self):
programme = ProgrammeFactory(name='special_program')
delivery = DeliveryFactory(track=True, programme=programme)
sales_order = SalesOrderFactory(programme=programme)
purchase_order = PurchaseOrderFactory(order_number=4748278, sales_order=sales_order)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order,
item=ItemFactory(material_code='Code 23', description='Jerrycans'))
ip_node_one = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=40,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER,
delivery_date=FakeDate.build(2015, 03, 19))
run_one = RunFactory(runnable=ip_node_one)
quantity_received_qn = NumericQuestion.objects.get(label='amountReceived')
NumericAnswerFactory(question=quantity_received_qn, value=39, run=run_one)
last_shipment_date = FakeDate.build(2015, 10, 07)
ip_node_two = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=30,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER,
delivery_date=last_shipment_date)
run_two = RunFactory(runnable=ip_node_two)
NumericAnswerFactory(question=quantity_received_qn, value=40, run=run_two)
expected_data = [
{'document_number': purchase_order.order_number,
'programme': programme.name,
'last_shipment_date': str(last_shipment_date),
'total_value_received': Decimal('79'),
'total_value_dispensed': Decimal('0'),
'total_value_lost': Decimal('0'),
'balance': Decimal('79'),
'items': [{'code': unicode(po_item.item.material_code),
'description': unicode(po_item.item.description),
'consignee': self.ip.name,
'location': ip_node_one.location,
'quantity_delivered': 3,
'date_delivered': str(self.ip_node_two.delivery_date),
'quantity_confirmed': 2,
'date_confirmed': '2014-01-02',
'quantity_dispatched': 2,
'quantity_lost': 0,
'balance': 0
},
{'code': unicode(po_item.item.material_code),
'description': unicode(po_item.item.description),
'consignee': self.ip.name,
'location': ip_node_two.location,
'quantity_delivered': 5,
'date_delivered': str(self.ip_node_one.delivery_date),
'quantity_confirmed': 4,
'date_confirmed': '2014-01-01',
'quantity_dispatched': 2,
'quantity_lost': 0,
'balance': 2
}]
}]
response = self.client.get(ENDPOINT_URL)
self.assert_api_response_with_correct_last_shipment_date(response, expected_data)
def create_sales_orders(self):
self.sales_order_one = SalesOrderFactory(order_number=20148031, )
self.sales_order_two = SalesOrderFactory(order_number=20147537)
self.sales_order_item_one = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_one,
item_number=10,
description='Laptop Lenovo ThinkPad T510')
self.sales_order_item_two = SalesOrderItemFactory(
sales_order=self.sales_order_one,
item=self.item_two,
item_number=20,
description='Laptop bag')
self.sales_order_item_three = SalesOrderItemFactory(
sales_order=self.sales_order_two,
item=self.item_three,
item_number=20,
description='F-75 therap.diet sachet 102.5g/CAR-120')
def make_sales_order_item_details():
item_unit = ItemUnit.objects.create(name='EA')
item = Item.objects.create(description='Item 1', unit=item_unit)
sales_order = SalesOrderFactory()
return {'sales_order': sales_order.id, 'item': item.id, 'quantity': 23,
'net_price': 12000.0, 'net_value': 100.0, 'issue_date': '2014-01-21',
'delivery_date': '2014-01-21', 'item_number': 10}
def setup_purchase_orders_and_items(self):
self.programme_one = ProgrammeFactory(name='programme_one')
self.programme_two = ProgrammeFactory(name='programme_two')
so_one = SalesOrderFactory(programme=self.programme_one)
so_two = SalesOrderFactory(programme=self.programme_two)
so_item_one = SalesOrderItemFactory(sales_order=so_one, quantity=20, net_price=10, net_value=20 * 10)
so_item_two = SalesOrderItemFactory(sales_order=so_one, quantity=5, net_price=10, net_value=5 * 10)
so_item_three = SalesOrderItemFactory(sales_order=so_two, quantity=2, net_price=10, net_value=2 * 10)
self.po_one = PurchaseOrderFactory(sales_order=so_one)
self.po_two = PurchaseOrderFactory(sales_order=so_two)
self.po_item_one = PurchaseOrderItemFactory(purchase_order=self.po_one, quantity=20,
sales_order_item=so_item_one, value=200)
self.po_item_two = PurchaseOrderItemFactory(purchase_order=self.po_one, quantity=5,
sales_order_item=so_item_two, value=50)
self.po_item_three = PurchaseOrderItemFactory(purchase_order=self.po_two, quantity=2,
sales_order_item=so_item_three, value=20)
def test_fetched_purchase_orders_should_have_programme_name_and_programme_id(
self):
programme = ProgrammeFactory()
purchase_order = PurchaseOrderFactory(sales_order=SalesOrderFactory(
programme=programme))
response = self.client.get('%s%s/' % (ENDPOINT_URL, purchase_order.id))
self.assertDictContainsSubset(
{
'programme': programme.id,
'programme_name': programme.name
}, response.data)
def test_should_add_node_related_to_changed_sales_order_to_sync_data(
self, mock_scan):
sales_order = SalesOrderFactory(description="first order")
sales_order_item = SalesOrderItemFactory(sales_order=sales_order)
node = DeliveryNodeFactory(item=(PurchaseOrderItemFactory(
sales_order_item=sales_order_item)))
self.check_update_happens(node, sales_order, {
'field': 'description',
'value': "Changed Order"
}, {'term': {
'order_item.order.sales_order.id': [sales_order.id]
}}, mock_scan)
def create_purchase_orders(self):
programme = ProgrammeFactory(name='YP104 MANAGEMENT RESULTS')
consignee = ConsigneeFactory(name='Wakiso DHO')
date = datetime.date(2014, 07, 9)
po_one = PurchaseOrderFactory(order_number=45143984)
po_two = PurchaseOrderFactory(
order_number=40141010,
sales_order=SalesOrderFactory(programme=programme),
last_shipment_date=date)
po_item = PurchaseOrderItemFactory(
purchase_order=po_two, item=ItemFactory(description="HEK2013"))
distribution_plan = DeliveryFactory()
DeliveryNodeFactory(item=po_item,
distribution_plan=distribution_plan,
location="Wakiso",
consignee=consignee)
return po_one, po_two, programme, consignee
def test_should_serialise_node_sales_order_under_order(self):
sales_order = SalesOrderFactory()
release_order = ReleaseOrderFactory(sales_order=sales_order)
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(
release_order=release_order)))
expected = {
"programme_id": sales_order.programme.id,
"description": sales_order.description,
"date": sales_order.date,
"order_number": sales_order.order_number,
"id": sales_order.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(
expected, serialised[0]['order_item']['order']['sales_order'])
def test_should_get_release_orders(self):
sales_order = SalesOrderFactory()
purchase_order = PurchaseOrderFactory()
consignee = ConsigneeFactory()
release_order_details = {
'order_number': 232345434,
'delivery_date': '2014-10-05',
'sales_order': sales_order.id,
'purchase_order': purchase_order.id,
'consignee': consignee.id,
'waybill': 234256
}
created_release_order, _ = create_release_order(
self, release_order_details=release_order_details)
self.assertDictContainsSubset(release_order_details,
created_release_order)
self.assertDictContainsSubset({'items': []}, created_release_order)
self.assertDictContainsSubset(
{'programme': sales_order.programme.name}, created_release_order)
def create_release_orders(self):
programme = ProgrammeFactory(name='YP104 MANAGEMENT RESULTS')
sales_order = SalesOrderFactory(programme=programme)
consignee = ConsigneeFactory()
date = datetime.date(2014, 10, 05)
purchase_order = PurchaseOrderFactory()
ro_one = ReleaseOrderFactory(waybill=45143984)
ro_two = ReleaseOrderFactory(waybill=234256,
sales_order=sales_order,
purchase_order=purchase_order,
delivery_date=date)
ro_item = ReleaseOrderItemFactory(
release_order=ro_two, item=ItemFactory(description="HEK2013"))
distribution_plan = DeliveryFactory()
DeliveryNodeFactory(item=ro_item,
distribution_plan=distribution_plan,
location="Wakiso",
consignee=consignee)
return ro_one, ro_two, programme, consignee
def create_release_order(test_case, release_order_details=None):
if not release_order_details:
sales_order = SalesOrderFactory()
purchase_order = PurchaseOrderFactory(sales_order=sales_order)
consignee = ConsigneeFactory()
release_order_details = {'order_number': 232345434, 'delivery_date': datetime.date(2014, 10, 5),
'sales_order': sales_order.id, 'purchase_order': purchase_order.id,
'consignee': consignee.id, 'waybill': 234256, 'items': []}
if not release_order_details.get('items', None):
release_order_details['items'] = []
response = test_case.client.post(RELEASE_ORDER_ENDPOINT_URL, release_order_details, format='json')
formatted_data = response.data
formatted_data['delivery_date'] = str(formatted_data['delivery_date'])
test_case.assertEqual(response.status_code, 201)
return formatted_data, formatted_data['sales_order']
def make_node_details(test_case, plan_id=None):
item_unit = ItemUnit.objects.create(name='EA')
item = Item.objects.create(description='Item 1', unit=item_unit)
sales_order = SalesOrderFactory()
sales_order_details = {'sales_order': sales_order.id, 'item': item.id, 'quantity': 23,
'net_price': 12000.0, 'net_value': 100.0, 'issue_date': '2014-01-21',
'delivery_date': '2014-01-21', 'item_number': 10}
sales_item_id = create_sales_order_item(test_case, sales_order_details)['id']
consignee_id = create_consignee(test_case)['id']
if not plan_id:
plan_id = DeliveryFactory().id
node = {'item': sales_item_id, 'targeted_quantity': 10, 'delivery_date': '2014-01-21',
'location': 'GULU', 'consignee': consignee_id, 'distribution_plan': plan_id,
'contact_person_id': u'1223',
'tracked': True, 'remark': 'Dispatched', 'tree_position': 'END_USER'}
return node
def test_gets_all_response_for_node_consignee(self):
multichoice_question = MultipleChoiceQuestionFactory(
label='productReceived')
yes = multichoice_question.option_set.first()
numeric_question = NumericQuestionFactory(label='AmountReceived')
salt = ItemFactory(description='Salt')
sales_order = SalesOrderFactory()
sales_order_item = SalesOrderItemFactory(item=salt,
description='10 bags of salt',
sales_order=sales_order)
item = PurchaseOrderItemFactory(sales_order_item=sales_order_item)
node = DeliveryNodeFactory(quantity=100, item=item)
child_node_one = DeliveryNodeFactory(parents=[(node, 50)], item=item)
child_node_two = DeliveryNodeFactory(parents=[(node, 50)], item=item)
child_node_three = DeliveryNodeFactory(parents=[(child_node_one, 50)],
item=item)
run = RunFactory(runnable=node, status='completed')
run_one = RunFactory(runnable=child_node_one, status='completed')
run_two = RunFactory(runnable=child_node_two, status='completed')
run_three = RunFactory(runnable=child_node_three, status='completed')
NumericAnswerFactory(run=run, value=80, question=numeric_question)
MultipleChoiceAnswerFactory(run=run_one,
question=multichoice_question,
value=yes)
MultipleChoiceAnswerFactory(run=run_two,
question=multichoice_question,
value=yes)
NumericAnswerFactory(run=run_three,
value=80,
question=numeric_question)
self.maxDiff = None
expected_data = {
'node':
node.consignee.name,
'children': [{
'node':
child_node_one.consignee.name,
'children': [{
'node': child_node_three.consignee.name,
'children': [],
'answers': {
u'AmountReceived': u'80'
}
}],
'answers': {
u'productReceived': u'UNCATEGORISED'
}
}, {
'node': child_node_two.consignee.name,
'children': [],
'answers': {
u'productReceived': u'UNCATEGORISED'
}
}],
'answers': {
u'AmountReceived': u'80'
}
}
response_details_route = 'distribution-plan-responses/%s/sales_order_item/%s/'
endpoint_url = BACKEND_URL + response_details_route % (
node.consignee.id, item.id)
response = self.client.get(endpoint_url)
self.assertDictContainsSubset({'node': expected_data['node']},
response.data)
self.assertDictContainsSubset({'answers': expected_data['answers']},
response.data)
self.assertItemsEqual(expected_data['children'],
response.data['children'])
def create_sales_order(self, order_number=123):
return SalesOrderFactory(order_number=order_number)
