def test_record_on_operation_no_machine(self):
order = self._make_order()
dao.order_dao.change_order_state(
order.order_id, OrderStatusType.order_ready_for_production)
employee = self._employee()
operation_id = order.parts[0].operations[0].operation_id
d1 = datetime(2012, 12, 31, 8)
self.server.record_pointage_on_operation(
operation_id, self.employee_id, d1, "Nostromo",
TaskActionReportType.start_task, None)
d2 = datetime(2012, 12, 31, 9)
self.server.record_pointage_on_operation(
operation_id, self.employee_id, d2, "Nostromo",
TaskActionReportType.stop_task, None)
d3 = datetime(2012, 12, 31, 10)
self.server.record_pointage_on_operation(
operation_id, self.employee_id, d3, "Nostromo",
TaskActionReportType.start_task, None)
d4 = datetime(2012, 12, 31, 11)
self.server.record_pointage_on_operation(
operation_id, self.employee_id, d4, "Nostromo",
TaskActionReportType.stop_task, None)
h = self.server.get_person_data(self.employee_id, d1.date())
mainlog.debug("/// " * 50)
mainlog.debug(h)
self.assertEqual(
3, h.presence[3].presence_time) # From 8 to 11 == 3 hours
def test_one_colleague(self):
order = self._make_order()
dao.order_dao.change_order_state(
order.order_id, OrderStatusType.order_ready_for_production)
employee = self._employee()
employee2 = self.dao_employee.create(u"Frankie Franky" + chr(233))
operation = order.parts[0].operations[0]
m = Machine()
m.fullname = "Test"
m.is_active = True
m.operation_definition_id = operation.operation_definition_id
session().add(m)
session().commit()
machine_service._reset_cache()
# A colleague
d3 = datetime(2012, 12, 31, 9)
self.server.record_pointage_on_operation(
operation.operation_id, employee2.employee_id, d3, "Nostromo",
TaskActionReportType.start_task, m.machine_id)
mainlog.debug("test_one_colleague-1")
operation, machines, next_action_kind, colleagues = self.server.get_operation_information(
employee.employee_id, operation.operation_id)
mainlog.debug("test_one_colleague-2")
assert len(colleagues) == 1
assert colleagues[0].reporter_id == employee2.employee_id
assert colleagues[0].kind == TaskActionReportType.start_task
def test_presence_recording(self):
# TestClockService.test_presence_recording
t1 = datetime(2012, 12, 31, 8, 0)
self.assertEqual(
0,
len(
self.tar_dao.get_reports_for_employee_id_on_date(
self.employee_id, t1.date())))
self.server.record_presence(self.employee_id, t1, "Nostromo",
TaskActionReportType.presence)
self.assertEqual(
1,
len(
self.tar_dao.get_reports_for_employee_id_on_date(
self.employee_id, t1.date())))
t2 = t1 + timedelta(seconds=30)
self.server.record_presence(self.employee_id, t2, "Nostromo",
TaskActionReportType.presence)
self.assertEqual(
2,
len(
self.tar_dao.get_reports_for_employee_id_on_date(
self.employee_id, t2.date())))
ot = self.server.get_ongoing_tasks(self.employee_id,
t1 + timedelta(hours=3))
self.assertEqual(0, len(ot))
h = self.server.get_person_data(self.employee_id, t1.date())
mainlog.debug("test : get_person_data")
mainlog.debug(h)
self.assertEqual(30, round(
3600 * h.presence[3].presence_time)) # Duration is in hours
self.assertEqual(date(2012, 12, 31), h.presence[3].day)
# self.assertEqual([t2,None,None,None], h.presence['presence_end'])
# New time between two exisiting times. It shouldn't be recorded because it's useless.
t2 = t1 + timedelta(seconds=15)
self.server.record_presence(self.employee_id, t2, "Nostromo",
TaskActionReportType.presence)
self.assertEqual(
2,
len(
self.tar_dao.get_reports_for_employee_id_on_date(
self.employee_id, t2.date())))
def test_set_day_event(self):
event = DayEvent()
event.employee_id = self.employee_id
event.event_type = DayEventType.holidays
mainlog.debug("Type {}".format(type(event)))
self.server.set_event_on_days(event, [(date(2012, 12, 15), 7.5)])
r = self.server.events_for_month(date(2012, 12, 1))
mainlog.debug(r)
assert len(r) == 1
assert r[0].duration == 7.5
assert r[0].date == date(2012, 12, 15)
assert r[0].event_type == DayEventType.holidays
assert r[0].employee_id == self.employee_id
def test_record_on_operation_definition(self):
d1 = datetime(2012, 12, 31, 8)
self.server.record_pointage_on_unbillable(
self.opdef.operation_definition_id, self.employee_id, d1,
"Nostromo", TaskActionReportType.start_task)
d2 = datetime(2012, 12, 31, 9)
self.server.record_pointage_on_unbillable(
self.opdef.operation_definition_id, self.employee_id, d2,
"Nostromo", TaskActionReportType.stop_task)
d3 = datetime(2012, 12, 31, 10)
self.server.record_pointage_on_unbillable(
self.opdef.operation_definition_id, self.employee_id, d3,
"Nostromo", TaskActionReportType.start_task)
d4 = datetime(2012, 12, 31, 11)
self.server.record_pointage_on_unbillable(
self.opdef.operation_definition_id, self.employee_id, d4,
"Nostromo", TaskActionReportType.stop_task)
ot = self.server.get_ongoing_tasks(self.employee_id,
d1 + timedelta(minutes=5))
self.assertEqual(1, len(ot))
ot = self.server.get_ongoing_tasks(self.employee_id,
d4 + timedelta(hours=5))
self.assertEqual(0, len(ot))
h = self.server.get_person_data(self.employee_id,
ts_to_date(d1 - timedelta(days=1)))
self.assertEqual(4, len(h.presence))
for x in h.presence:
self.assertEqual(0, x.presence_time)
h = self.server.get_person_data(self.employee_id, d1.date())
mainlog.debug(h)
# self.assertEqual([d1,None,None,None], h['presence_begin'])
# self.assertEqual([d4,None,None,None], h['presence_end'])
self.assertEqual(
3.0, h.presence[3].presence_time) # From 8 to 11 == 3 hours
def test_ongoing_task(self):
# In the following the dates are reversed, it's too make
# things a bit harder :-)
# A first task (for an order)
order = self._order_dao.make("Test order", self.customer)
order.state = OrderStatusType.order_ready_for_production
self._order_dao.save(order)
d1 = datetime(2012, 12, 31, 11)
self.server.record_pointage_on_order(
order.order_id, self.opdef_order.operation_definition_id,
self.employee_id, d1, "Nostromo", TaskActionReportType.start_task)
ot = self.server.get_ongoing_tasks(self.employee_id,
d1 + timedelta(hours=3))
mainlog.debug("Task action reports")
for tar in session().query(TaskActionReport).all():
mainlog.debug(tar)
self.assertEqual(1, len(ot))
# A second task
d2 = datetime(2012, 12, 31, 10)
# self.clock_server.recordPointage(bc,self.employee_id, datetime.strftime(d2, "%Y%m%dT%H:%M:%S"),"Nostromo")
self.server.record_pointage_on_unbillable(
self.opdef.operation_definition_id, self.employee_id, d1,
"Nostromo", TaskActionReportType.start_task)
ot = self.server.get_ongoing_tasks(self.employee_id,
d1 + timedelta(hours=3))
self.assertEqual(2, len(ot))
# A third task
order_part = self._order_part_dao.make(order)
order_part.description = "Part 1"
order_part.position = 1
self._order_part_dao.save(order_part)
pf = self._production_file_dao.make()
pf.order_part = order_part
order_part.production_file = [pf]
session().add(pf)
session().flush()
operation = self._operation_dao.make()
operation.production_file = pf
operation.description = "operation desc"
operation.operation_model = self.opdef_op
session().add(operation)
session().commit()
machine = self._make_machine("Tarazer",
operation.operation_definition_id)
d3 = datetime(2012, 12, 31, 9)
self.server.record_pointage_on_operation(
operation.operation_id, self.employee_id, d3, "Nostromo",
TaskActionReportType.start_task, machine.machine_id)
# bc = BarCodeIdentifier.code_for(operation)
# self.clock_server.recordPointage(bc,self.employee_id, datetime.strftime(d1, "%Y%m%dT%H:%M:%S"),"Nostromo")
ot = self.server.get_ongoing_tasks(self.employee_id,
d1 + timedelta(hours=3))
self.assertEqual(3, len(ot))
# Day in day out must not affect the number of ongoing tasks
d4 = datetime(2012, 12, 31, 8)
self.server.record_presence(self.employee_id, d4, "Nostromo",
TaskActionReportType.day_in)
ot = self.server.get_ongoing_tasks(self.employee_id,
d1 + timedelta(hours=3))
self.assertEqual(3, len(ot))