def test_should_filter_based_on_outcome_and_ip(self):
outcome_one = ProgrammeFactory(name='Outcome One')
outcome_two = ProgrammeFactory(name='Outcome Two')
consignee_one = ConsigneeFactory(name="Consignee One", type=Consignee.TYPES.implementing_partner)
consignee_two = ConsigneeFactory(name="Consignee Two", type=Consignee.TYPES.implementing_partner)
delivery_one = DeliveryFactory(programme=outcome_one, track=True)
delivery_two = DeliveryFactory(programme=outcome_two, track=True)
DeliveryNodeFactory(
distribution_plan=delivery_one,
consignee=consignee_one,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(
distribution_plan=delivery_two,
consignee=consignee_one,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(
distribution_plan=delivery_two,
consignee=consignee_two,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
endpoint_url = BACKEND_URL + 'stock-report?consignee=%d&outcome=%d' % (consignee_one.id, outcome_two.id)
response = self.client.get(endpoint_url)
results = response.data['results']
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['programme'], 'Outcome Two')
self.assertEqual(len(results[0]['items']), 1)
self.assertEqual(results[0]['items'][0]['consignee'], 'Consignee One')
def _setup_nodes_with_answers(self):
self._create_questions()
programme_one = ProgrammeFactory(name='programme one')
programme_two = ProgrammeFactory(name='programme two')
programme_three = ProgrammeFactory(name='programme three')
delivery_one = DeliveryFactory(track=True, programme=programme_one, delivery_date=date(2015, 3, 10),
location='Wakiso')
delivery_two = DeliveryFactory(track=True, programme=programme_two, delivery_date=date(2015, 6, 20),
location='Kampala')
delivery_three = DeliveryFactory(track=True, programme=programme_three, delivery_date=date(2015, 9, 30),
location='Fort portal')
DeliveryNodeFactory(distribution_plan=delivery_one, programme=programme_one,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_two, programme=programme_two,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_three, programme=programme_two,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
run_one = RunFactory(runnable=delivery_one)
MultipleChoiceAnswerFactory(run=run_one, question=self.delivery_received_qtn, value=self.yes_one)
MultipleChoiceAnswerFactory(run=run_one, question=self.delivery_in_good_order, value=self.no_two)
MultipleChoiceAnswerFactory(run=run_one, question=self.satisfied_with_delivery, value=self.no_three)
run_two = RunFactory(runnable=delivery_two)
MultipleChoiceAnswerFactory(run=run_two, question=self.delivery_received_qtn, value=self.no_one)
MultipleChoiceAnswerFactory(run=run_two, question=self.delivery_in_good_order, value=self.yes_two)
MultipleChoiceAnswerFactory(run=run_two, question=self.satisfied_with_delivery, value=self.yes_three)
run_three = RunFactory(runnable=delivery_three)
MultipleChoiceAnswerFactory(run=run_three, question=self.delivery_received_qtn, value=self.yes_one)
MultipleChoiceAnswerFactory(run=run_three, question=self.delivery_in_good_order, value=self.no_two)
MultipleChoiceAnswerFactory(run=run_three, question=self.satisfied_with_delivery, value=self.yes_three)
def test_should_get_programme_ips(self):
programe = ProgrammeFactory(name='Our Programme')
delivery = DeliveryFactory(programme=programe)
kisoro = ConsigneeFactory(name="KISORO")
wakiso = ConsigneeFactory(name="WAKISO")
guru = ConsigneeFactory(name="GURU DHO")
DeliveryNodeFactory(consignee=wakiso, distribution_plan=delivery)
DeliveryNodeFactory(consignee=guru, distribution_plan=delivery)
DeliveryNodeFactory(consignee=kisoro, distribution_plan=delivery)
self.assertEqual(len(programe.to_dict_with_ips()['ips']), 3)
def test_should_get_programme_ips(self):
programe = ProgrammeFactory(name='Our Programme')
delivery = DeliveryFactory(programme=programe)
kisoro = ConsigneeFactory(name="KISORO")
wakiso = ConsigneeFactory(name="WAKISO")
guru = ConsigneeFactory(name="GURU DHO")
DeliveryNodeFactory(consignee=wakiso, distribution_plan=delivery)
DeliveryNodeFactory(consignee=guru, distribution_plan=delivery)
DeliveryNodeFactory(consignee=kisoro, distribution_plan=delivery)
self.assertEqual(len(programe.to_dict_with_ips()['ips']), 3)
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_set_net_price_to_zero_if_quantity_of_an_item_is_zero(self):
ProgrammeFactory(wbs_element_ex='4380/A0/04/105')
item_one = ItemFactory(material_code='S0009113',
description='SQFlex 3-10 Pump C/W 1.4KW')
self.facade.save_records([{
'order_number':
20146879,
'programme_wbs_element':
'4380/A0/04/105/007',
'items': [{
'material_code': u'S0009113',
'item_number': u'10',
'item_description': u'SQFlex 3-10 Pump C/W 1.4KW',
'date': u'2014-01-03',
'net_value': u'3179.47',
'quantity': u'0'
}]
}])
order_item_one = SalesOrderItem(
sales_order=SalesOrder.objects.all()[0],
item_number=10,
item=item_one,
quantity=0,
net_value=Decimal('3179.4700'),
net_price=Decimal('0.00'),
issue_date=datetime.date(2014, 1, 3),
delivery_date=datetime.date(2014, 1, 3),
description=u'SQFlex 3-10 Pump C/W 1.4KW')
self.assertEqual(order_item_one, SalesOrderItem.objects.first())
def test_should_return_delivery_empty_value_if_no_answers(self):
self._create_questions()
programme_name = 'YP104 MANAGEMENT RESULTS'
wakiso = 'WAKISO DHO'
shipment_date = date(2015, 3, 10)
delivery = DeliveryFactory(
contact_person_id=CONTACT_PERSON_ID,
track=True,
programme=ProgrammeFactory(name=programme_name),
consignee=ConsigneeFactory(name=wakiso),
delivery_date=shipment_date)
order_number = 34230335
DeliveryNodeFactory(
contact_person_id=CONTACT_PERSON_ID,
distribution_plan=delivery,
track=True,
tree_position=Flow.Label.IMPLEMENTING_PARTNER,
item=PurchaseOrderItemFactory(purchase_order=PurchaseOrderFactory(
order_number=order_number)))
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_received_qtn,
value=self.yes_one)
MultipleChoiceAnswerFactory(run=run,
question=self.satisfied_with_delivery,
value=self.no_three)
programme = Programme.objects.get(name=programme_name)
consignee = Consignee.objects.get(name=wakiso)
yes = 'Yes'
no = 'No'
empty = ''
expected_response = [{
'deliveryReceived': yes,
'shipmentDate': date(2015, 3, 10),
'dateOfReceipt': empty,
'orderNumber': order_number,
'programme': {
'id': programme.id,
'name': programme.name
},
'consignee': {
'id': consignee.id,
'name': consignee.name
},
Question.LABEL.isDeliveryInGoodOrder: empty,
'satisfiedWithDelivery': no,
'urls': [],
'absoluteUrls': [],
'additionalDeliveryComments': empty,
'contactPersonId': CONTACT_PERSON_ID,
'value': 100,
'location': 'Kampala'
}]
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['results'], expected_response)
def setup_multiple_nodes_with_answers(self, number_of_nodes):
consignee_one = ConsigneeFactory(name='consignee one')
programme_one = ProgrammeFactory(name='my first programme')
po_item = PurchaseOrderItemFactory(item=ItemFactory(description='Mama kit'),
purchase_order=PurchaseOrderFactory(order_number=329293))
flow = FlowFactory(label='WEB')
question_1 = MultipleChoiceQuestionFactory(text='Was the item received?', label='itemReceived', flow=flow,
position=1)
option_1 = OptionFactory(text='Yes', question=question_1)
question_2 = NumericQuestionFactory(text='How much was received?', label='amountReceived', flow=flow)
question_3 = MultipleChoiceQuestionFactory(text='What is the quality of the product?', label='qualityOfProduct',
flow=flow, position=3)
option_3 = OptionFactory(text='Damaged', question=question_3)
question_4 = MultipleChoiceQuestionFactory(text='Are you satisfied with the product?',
label='satisfiedWithProduct', flow=flow, position=4)
option_4 = OptionFactory(text='Yes', question=question_4)
question_5 = TextQuestionFactory(label='dateOfReceipt', flow=flow, text='When was Delivery Received?')
nodes = []
for index in range(number_of_nodes):
node = DeliveryNodeFactory(consignee=consignee_one, item=po_item, programme=programme_one,
distribution_plan=DeliveryFactory(track=True),
track=True)
run_one = RunFactory(runnable=node)
MultipleChoiceAnswerFactory(question=question_1, run=run_one, value=option_1)
NumericAnswerFactory(question=question_2, run=run_one, value=5)
MultipleChoiceAnswerFactory(question=question_3, run=run_one, value=option_3)
MultipleChoiceAnswerFactory(question=question_4, run=run_one, value=option_4)
TextAnswerFactory(run=run_one, question=question_5, value='2014-10-10')
nodes.append(node)
return nodes
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
from eums.fixtures.end_user_questions import seed_questions
questions, options = seed_questions()
po_item = PurchaseOrderItemFactory(quantity=100, value=1000)
end_user_node_one = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=10, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_one, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_RECEIVED'])
self.programme = ProgrammeFactory(name='my-program')
self.ip = ConsigneeFactory()
distribution_plan = DeliveryFactory(programme=self.programme,
track=True)
self.today = FakeDate.today()
self.end_user_node_two = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=20,
item=po_item,
distribution_plan=distribution_plan)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=self.end_user_node_two, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_RECEIVED'])
end_user_node_three = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=30,
item=po_item,
distribution_plan=distribution_plan,
ip=self.ip,
consignee=self.ip,
delivery_date=self.today + datetime.timedelta(days=3))
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_three, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_four = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=40, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_four, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_five = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=50, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_five, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
non_response_node = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
track=True,
quantity=60,
item=po_item)
RunFactory(runnable=non_response_node, status=Run.STATUS.scheduled)
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 test_should_filter_based_on_outcome(self):
outcome_one = ProgrammeFactory(name='Outcome One')
outcome_two = ProgrammeFactory(name='Outcome Two')
delivery_one = DeliveryFactory(programme=outcome_one, track=True)
delivery_two = DeliveryFactory(programme=outcome_two, track=True)
DeliveryNodeFactory(distribution_plan=delivery_one, tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_two, tree_position=Flow.Label.IMPLEMENTING_PARTNER)
endpoint_url = BACKEND_URL + 'stock-report?outcome=%d' % outcome_two.id
response = self.client.get(endpoint_url)
results = response.data['results']
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['programme'], 'Outcome Two')
self.assertEqual(len(results[0]['items']), 1)
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
MultipleChoiceAnswer.objects.all().delete()
from eums.fixtures.ip_questions import seed_ip_questions
questions, options, _ = seed_ip_questions()
self.programme = ProgrammeFactory(name='my-program')
self.ip = ConsigneeFactory()
self.today = FakeDate.today()
po_item = PurchaseOrderItemFactory(quantity=100, value=1000)
ip_delivery_one = DeliveryFactory(location='some location',
track=True,
programme=self.programme,
consignee=self.ip,
ip=self.ip,
delivery_date=self.today +
datetime.timedelta(days=3))
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=10,
item=po_item,
distribution_plan=ip_delivery_one,
consignee=self.ip)
other_delivery = DeliveryFactory(location='Other location',
delivery_date=self.today,
track=True)
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=20,
item=po_item,
distribution_plan=other_delivery)
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['WAS_DELIVERY_RECEIVED'],
value=options['DELIVERY_WAS_RECEIVED'])
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['IS_DELIVERY_IN_GOOD_ORDER'],
value=options['IN_GOOD_CONDITION'])
non_response_delivery_one = DeliveryFactory(delivery_date=self.today +
datetime.timedelta(days=4),
location='some location',
track=True)
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=30,
item=po_item,
distribution_plan=non_response_delivery_one)
RunFactory(runnable=non_response_delivery_one,
status=Run.STATUS.scheduled)
def test_should_create_delivery(self):
today = datetime.date.today()
programme = ProgrammeFactory()
delivery = DeliveryFactory(programme=programme, delivery_date=today)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], delivery.id)
def test_should_filter_deliveries_by_programme(self):
programme = ProgrammeFactory(name='my programme')
delivery = DeliveryFactory(programme=programme)
DeliveryFactory()
response = self.client.get('%s?programme=%s' % (ENDPOINT_URL, 'my'))
self.assertEqual(Delivery.objects.count(), 2)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], delivery.id)
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_programme_to_sync_data(
self, mock_scan):
programme = ProgrammeFactory(name='Save mothers and children')
node = DeliveryNodeFactory(programme=programme)
self.check_update_happens(node, programme, {
'field': 'name',
'value': 'new name'
}, {'term': {
'programme.id': [programme.id]
}}, mock_scan)
def log_and_assert_create_delivery_permission(self, log_func, expected_status_code):
log_func()
programme = ProgrammeFactory()
consignee = ConsigneeFactory()
request_body = {
'programme': str(programme.id),
'consignee': str(consignee.id),
'location': 'Kampala',
'delivery_date': '2015-12-12',
'contact_person_id': 'some_id'
}
response = self.client.post(ENDPOINT_URL, data=request_body)
self.assertEqual(response.status_code, expected_status_code)
def test_should_filter_deliveries_by_programme_for_ip(self):
programme = ProgrammeFactory(name='cool programme')
first_consignee = ConsigneeFactory()
first_delivery = DeliveryFactory(consignee=first_consignee, track=True, programme=programme)
self.logout()
self.log_consignee_in(consignee=first_consignee)
DeliveryFactory(consignee=first_consignee, track=True)
response = self.client.get('%s?programme=%s' % (ENDPOINT_URL, 'cool'))
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], first_delivery.id)
def test_should_serialise_node_with_built_out_programme(self):
programme = ProgrammeFactory()
delivery = DeliveryFactory(programme=programme)
node = DeliveryNodeFactory(distribution_plan=delivery)
expected_programme_serialisation = {
"wbs_element_ex": programme.wbs_element_ex,
"id": programme.id,
"name": programme.name
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_programme_serialisation,
serialised[0]["programme"])
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_get_programmes_with_associated_ips(self):
programme = ProgrammeFactory(name='Our Programme')
delivery = DeliveryFactory(programme=programme)
kisoro = ConsigneeFactory(name="KISORO")
wakiso = ConsigneeFactory(name="WAKISO")
guru = ConsigneeFactory(name="GURU DHO")
DeliveryNodeFactory(consignee=wakiso, distribution_plan=delivery)
DeliveryNodeFactory(consignee=guru, distribution_plan=delivery)
DeliveryNodeFactory(consignee=kisoro, distribution_plan=delivery)
response = self.client.get(ENDPOINT_URL + 'with-ips/', format='json')
self.assertEqual(response.status_code, 200)
expected_response = get_programme(programme, response.data)[0]
[self.assertIn(ip, expected_response['ips']) for ip in [kisoro.id, wakiso.id, guru.id]]
def log_and_assert_track_delivery_permission(self, log_func, expected_status_code):
programme = ProgrammeFactory()
consignee = ConsigneeFactory()
delivery = DeliveryFactory(programme=programme, consignee=consignee, location='Kampala',
delivery_date='2015-12-12')
log_func()
response = self.client.put(ENDPOINT_URL + str(delivery.id) + '/', {
'programme': str(programme.id),
'consignee': str(consignee.id),
'location': 'Kampala',
'delivery_date': '2015-12-12',
'contact_person_id': 'some_id',
'track': 'true'
})
self.assertEqual(response.status_code, expected_status_code)
def create_node_and_answers(self,
number_of_deliveries,
order_number,
programme_name,
consignee,
comment,
is_purchase,
track,
tree_position=Flow.Label.IMPLEMENTING_PARTNER,
location='Madagascar',
contact_person_id=CONTACT_PERSON_ID):
while number_of_deliveries > 0:
delivery = DeliveryFactory(
contact_person_id=contact_person_id,
track=track,
programme=ProgrammeFactory(name=programme_name),
consignee=ConsigneeFactory(name=consignee),
delivery_date=date(2015, 3, 10),
location=location)
self._create_node(delivery, is_purchase, order_number, track,
tree_position, location)
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_received_qtn,
value=self.yes_one)
delivery_date = '12/03/2015'
TextAnswerFactory(run=run,
question=self.date_received_qtn,
value=delivery_date)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_in_good_order,
value=self.yes_two)
MultipleChoiceAnswerFactory(run=run,
question=self.satisfied_with_delivery,
value=self.no_three)
TextAnswerFactory(run=run,
question=self.additional_comments,
value=comment)
FileUploadFactory(plan=delivery, file='photo/2016/02/14/world.jpg')
FileUploadFactory(plan=delivery, file='photo/2016/02/14/peace.jpg')
number_of_deliveries -= 1
order_number += 1
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
MultipleChoiceAnswer.objects.all().delete()
from eums.fixtures.ip_questions import seed_ip_questions
questions, options, _ = seed_ip_questions()
self.programme = ProgrammeFactory(name='my-program')
self.ip = ConsigneeFactory()
self.today = FakeDate.today()
ip_delivery_one = DeliveryFactory(location='some location',
track=True,
programme=self.programme,
consignee=self.ip,
ip=self.ip,
delivery_date=self.today +
datetime.timedelta(days=3))
DeliveryFactory(location='Other location',
delivery_date=self.today,
track=True)
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['WAS_DELIVERY_RECEIVED'],
value=options['DELIVERY_WAS_RECEIVED'])
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['IS_DELIVERY_IN_GOOD_ORDER'],
value=options['IN_GOOD_CONDITION'])
non_response_delivery_one = DeliveryFactory(delivery_date=self.today +
datetime.timedelta(days=4),
location='some location',
track=True)
RunFactory(runnable=non_response_delivery_one,
status=Run.STATUS.scheduled)
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_programmes(self):
self.programme_one = ProgrammeFactory(wbs_element_ex='4380/A0/04/105')
self.programme_two = ProgrammeFactory(wbs_element_ex='4380/A0/04/106')
def test_string_representation_is_consignee_name_and_programme_name(self):
consignee = ConsigneeFactory()
programme = ProgrammeFactory()
report = DistributionReport(consignee=consignee, programme=programme)
self.assertEqual('%s, %s' % (consignee.name, programme.name),
str(report))
def test_no_two_programmes_should_have_the_same_wbs_element(self):
create_programme = lambda: ProgrammeFactory(wbs_element_ex=
'4380/A0/04/105')
create_programme()
self.assertRaises(IntegrityError, create_programme)
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
from eums.fixtures.end_user_questions import seed_questions
questions, options = seed_questions()
self.programme = ProgrammeFactory(name='my-program')
distribution_plan = DeliveryFactory(programme=self.programme,
track=True,
location='someLocation')
item_one = ItemFactory(description='desc_one',
material_code='code_one')
item_two = ItemFactory(description='desc_two',
material_code='code_two')
item_three = ItemFactory(description='desc_three',
material_code='code_three')
po_item_one = PurchaseOrderItemFactory(quantity=100,
value=1000,
item=item_one)
po_item_two = PurchaseOrderItemFactory(quantity=100,
value=1000,
item=item_two)
po_item_three = PurchaseOrderItemFactory(quantity=100,
value=1000,
item=item_three)
end_user_node_one = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=6,
location='someLocation',
distribution_plan=distribution_plan,
item=po_item_one)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_one, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_RECEIVED'])
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_one, status=Run.STATUS.scheduled),
question=questions['QUALITY_OF_PRODUCT'],
value=options['DAMAGED'])
NumericAnswerFactory(run=RunFactory(runnable=end_user_node_one,
status=Run.STATUS.scheduled),
question=questions['AMOUNT_RECEIVED'],
value=4)
self.ip = ConsigneeFactory()
self.today = FakeDate.today()
self.end_user_node_two = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=9,
location='someLocation',
item=po_item_two,
distribution_plan=distribution_plan)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=self.end_user_node_two, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_three = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=10,
item=po_item_three,
location='someLocation',
distribution_plan=distribution_plan,
ip=self.ip,
consignee=self.ip,
delivery_date=self.today + datetime.timedelta(days=3))
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_three, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_four = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=40, item=po_item_one)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_four, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_five = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=50, item=po_item_one)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_five, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
non_response_node = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
track=True,
quantity=60,
item=po_item_one)
RunFactory(runnable=non_response_node, status=Run.STATUS.scheduled)
def setup_nodes_with_answers(self):
DistributionPlanNode.append_positive_answers = MagicMock(return_value=None)
ip = ConsigneeFactory(name='ip one')
middle_man = ConsigneeFactory(name='middle man one', type=Consignee.TYPES.middle_man)
end_user_one = ConsigneeFactory(name='consignee one', type=Consignee.TYPES.end_user)
end_user_two = ConsigneeFactory(name='consignee two', type=Consignee.TYPES.end_user)
programme_one = ProgrammeFactory(name='my first programme')
programme_two = ProgrammeFactory(name='my second programme')
programme_three = ProgrammeFactory(name='my third programme')
purchase_order_item = PurchaseOrderItemFactory(item=ItemFactory(description='Mama kit'),
purchase_order=PurchaseOrderFactory(order_number=329293))
release_order_item = ReleaseOrderItemFactory(item=ItemFactory(description='Baba bla bla'),
release_order=ReleaseOrderFactory(waybill=5540322))
ip_node_one = DeliveryNodeFactory(consignee=ip, item=purchase_order_item, quantity=1500,
programme=programme_one, track=True,
distribution_plan=DeliveryFactory(track=True),
location='Fort portal', tree_position=Flow.Label.IMPLEMENTING_PARTNER)
ip_node_two = DeliveryNodeFactory(consignee=ip, item=release_order_item, quantity=100,
distribution_plan=DeliveryFactory(track=True), programme=programme_two,
location='Kampala', tree_position=Flow.Label.IMPLEMENTING_PARTNER, track=True)
ip_node_three = DeliveryNodeFactory(consignee=ip, item=release_order_item, quantity=100,
distribution_plan=DeliveryFactory(track=True), programme=programme_two,
location='Gulu', tree_position=Flow.Label.IMPLEMENTING_PARTNER, track=True)
ip_node_four = DeliveryNodeFactory(consignee=ip, item=purchase_order_item, quantity=100,
distribution_plan=DeliveryFactory(track=True), programme=programme_three,
location='Gulu', tree_position=Flow.Label.IMPLEMENTING_PARTNER, track=True)
middle_man_node = DeliveryNodeFactory(consignee=middle_man, item=purchase_order_item,
programme=programme_one, location='Wakiso', track=True,
tree_position=Flow.Label.MIDDLE_MAN, parents=[(ip_node_one, 1500)],
distribution_plan=None)
end_user_node_one = DeliveryNodeFactory(consignee=end_user_one,
item=purchase_order_item, parents=[(middle_man_node, 1000)],
programme=programme_one, location='Amuru', track=True,
distribution_plan=None)
end_user_node_two = DeliveryNodeFactory(consignee=end_user_two, item=purchase_order_item, track=True,
parents=[(middle_man_node, 500)], programme=programme_one,
distribution_plan=None)
assign_to_self_node = DeliveryNodeFactory(consignee=ip, item=purchase_order_item,
tree_position=Flow.Label.END_USER, parents=[(ip_node_four, 93)],
programme=programme_three, distribution_plan=None,
is_assigned_to_self=True)
# IP_ITEM Flow and Questions
ip_item_flow = FlowFactory(label=Flow.Label.IMPLEMENTING_PARTNER)
ip_item_question_1 = MultipleChoiceQuestionFactory(text='Was the item received?', label='itemReceived',
when_answered='update_consignee_inventory',
flow=ip_item_flow, position=1)
ip_item_option_1 = OptionFactory(text='Yes', question=ip_item_question_1)
ip_item_option_no = OptionFactory(text='No', question=ip_item_question_1)
ip_item_question_2 = NumericQuestionFactory(text='How much was received?', label='amountReceived',
when_answered='update_consignee_stock_level', flow=ip_item_flow,
position=3)
ip_item_question_3 = MultipleChoiceQuestionFactory(text='What is the quality of the product?',
label='qualityOfProduct',
flow=ip_item_flow, position=3)
ip_item_option_2 = OptionFactory(text='Good', question=ip_item_question_3)
ip_item_option_3 = OptionFactory(text='Damaged', question=ip_item_question_3)
ip_item_question_4 = MultipleChoiceQuestionFactory(text='Are you satisfied with the product?',
label='satisfiedWithProduct', flow=ip_item_flow, position=4)
ip_item_option_4 = OptionFactory(text='Yes', question=ip_item_question_4)
ip_item_option_5 = OptionFactory(text='No', question=ip_item_question_4)
# MIDDLE_MAN Flow and Questions
middle_man_flow = FlowFactory(label=Flow.Label.MIDDLE_MAN)
mm_question_1 = MultipleChoiceQuestionFactory(text='Was product received?', label='productReceived',
flow=middle_man_flow, position=1)
mm_option_1 = OptionFactory(text='Yes', question=mm_question_1)
mm_option_2 = OptionFactory(text='No', question=mm_question_1)
mm_question_2 = TextQuestionFactory(label='dateOfReceipt', flow=middle_man_flow,
text='When was item received?', position=2)
mm_question_3 = NumericQuestionFactory(text='What is the amount received?', label='amountReceived',
flow=middle_man_flow, position=3)
end_user_flow = FlowFactory(label=Flow.Label.END_USER)
eu_question_1 = MultipleChoiceQuestionFactory(text='Was the item received?', label='itemReceived',
flow=end_user_flow, position=1)
eu_option_1 = OptionFactory(text='Yes', question=eu_question_1)
eu_question_2 = NumericQuestionFactory(text='How much was received?', label='amountReceived',
flow=end_user_flow)
eu_question_3 = MultipleChoiceQuestionFactory(text='What is the quality of the product?',
label='qualityOfProduct', flow=end_user_flow, position=3)
eu_option_3 = OptionFactory(text='Damaged', question=eu_question_3)
eu_option_3_1 = OptionFactory(text='Good', question=eu_question_3)
eu_question_4 = MultipleChoiceQuestionFactory(text='Are you satisfied with the product?',
label='satisfiedWithProduct', flow=end_user_flow, position=4)
eu_option_4 = OptionFactory(text='Yes', question=eu_question_4)
eu_question_5 = TextQuestionFactory(label='dateOfReceipt', flow=end_user_flow,
text='When was Delivery Received?')
ip_run_one = RunFactory(runnable=ip_node_one)
MultipleChoiceAnswerFactory(question=ip_item_question_1, run=ip_run_one, value=ip_item_option_1)
NumericAnswerFactory(question=ip_item_question_2, run=ip_run_one, value=1500)
MultipleChoiceAnswerFactory(question=ip_item_question_3, run=ip_run_one, value=ip_item_option_2)
MultipleChoiceAnswerFactory(question=ip_item_question_4, run=ip_run_one, value=ip_item_option_4)
ip_run_three = RunFactory(runnable=ip_node_three)
MultipleChoiceAnswerFactory(question=ip_item_question_1, run=ip_run_three, value=ip_item_option_no)
ip_run_two = RunFactory(runnable=ip_node_two)
MultipleChoiceAnswerFactory(question=ip_item_question_1, run=ip_run_two, value=ip_item_option_1)
NumericAnswerFactory(question=ip_item_question_2, run=ip_run_two, value=50)
MultipleChoiceAnswerFactory(question=ip_item_question_3, run=ip_run_two, value=ip_item_option_3)
MultipleChoiceAnswerFactory(question=ip_item_question_4, run=ip_run_two, value=ip_item_option_5)
middle_man_node_run = RunFactory(runnable=middle_man_node)
MultipleChoiceAnswerFactory(question=mm_question_1, run=middle_man_node_run, value=mm_option_1)
TextAnswerFactory(question=mm_question_2, run=middle_man_node_run, value='2014-9-25')
NumericAnswerFactory(question=mm_question_3, run=middle_man_node_run, value=1501, remark='Some remark 2')
end_user_run_one = RunFactory(runnable=end_user_node_one)
MultipleChoiceAnswerFactory(question=eu_question_1, run=end_user_run_one, value=eu_option_1)
NumericAnswerFactory(question=eu_question_2, run=end_user_run_one, value=5)
MultipleChoiceAnswerFactory(question=eu_question_3, run=end_user_run_one, value=eu_option_3)
MultipleChoiceAnswerFactory(question=eu_question_4, run=end_user_run_one, value=eu_option_4)
TextAnswerFactory(run=end_user_run_one, question=eu_question_5, value='2014-10-10')
end_user_run_two = RunFactory(runnable=end_user_node_two)
MultipleChoiceAnswerFactory(question=eu_question_1, run=end_user_run_two, value=eu_option_1)
NumericAnswerFactory(question=eu_question_2, run=end_user_run_two, value=500)
MultipleChoiceAnswerFactory(question=eu_question_3, run=end_user_run_two, value=eu_option_3)
MultipleChoiceAnswerFactory(question=eu_question_4, run=end_user_run_two, value=eu_option_4)
TextAnswerFactory(question=eu_question_5, run=end_user_run_two, value='2013-12-12')
assign_to_self_run = RunFactory(runnable=assign_to_self_node)
MultipleChoiceAnswerFactory(question=eu_question_1, run=assign_to_self_run, value=eu_option_1)
NumericAnswerFactory(question=eu_question_2, run=assign_to_self_run, value=500)
TextAnswerFactory(question=eu_question_5, run=assign_to_self_run, value='2013-12-14')
MultipleChoiceAnswerFactory(question=eu_question_3, run=assign_to_self_run, value=eu_option_3_1)
MultipleChoiceAnswerFactory(question=eu_question_4, run=assign_to_self_run, value=eu_option_4)
return end_user_node_one, purchase_order_item, release_order_item, end_user_node_two, ip_node_two, ip, assign_to_self_node
