def test_regional_road_is_detected(self):
report = Report(
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
postalcode=1000,
address='my address',
address_number='1',
secondary_category=self.secondary_category,
category=self.category,
)
report.save()
self.assertTrue(report.address_regional)
report = Report(
point=dict_to_point({
"x": '149776',
"y": '170805'
}),
postalcode=1000,
address='my address',
address_number='1',
secondary_category=self.secondary_category,
category=self.category,
)
report.save()
self.assertFalse(report.address_regional)
def testReportResponsibleAssignment(self):
'''Test the assignment of a responsible when creating a report'''
new_report = Report(
status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({"x": '149776', "y": '170105'}),
address_number='6h',
created_by=self.manager_etterbeek
)
new_report.save()
# when created by pro report is under responsibility of etterbeek, not bxl
self.assertEquals(new_report.responsible_entity, self.etterbeek)
new_report = Report(
status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({"x": '149776', "y": '170105'}),
address_number='6h',
citizen=self.citizen
)
new_report.save()
# when created by citizen, postalcode used for resonsible
self.assertEquals(new_report.responsible_entity, self.bxl)
def test_list_entity_manager_reports(self):
new_report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
citizen=self.citizen)
new_report.responsible_department = self.group
new_report.save()
reports = Report.objects.all()
self.assertEquals(1,
len(reports.entity_responsible(self.entity_manager)))
self.assertEquals(1, len(reports.responsible(self.entity_manager)))
new_report.responsible_department = self.group
new_report.save()
reports = Report.objects.all()
self.assertEquals(1, len(reports.responsible(self.entity_manager)))
def test_update_priority(self):
#Test default value of priority set to 1
new_report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
created_by=self.manager)
new_report.save()
self.assertEquals(new_report.gravity, 0)
self.assertEquals(new_report.probability, 0)
self.assertEquals(new_report.get_priority(), 0)
self.client.login(username='******', password='******')
#Test update report priority
self.client.get(
reverse("report_update_priority", args=[new_report.id]), {
'gravity': '2',
'probability': '4'
})
updated_report = Report.objects.get(id=new_report.id)
self.assertEquals(updated_report.gravity, 2)
self.assertEquals(updated_report.probability, 4)
self.assertEquals(updated_report.get_priority(), 8)
def test_list_contractor_manager_reports(self):
new_report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
citizen=self.citizen)
new_report.contractor = self.stib
new_report.responsible_department = self.group
new_report.save()
new_report2 = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005.2'
}),
address_number='6',
citizen=self.citizen)
new_report2.responsible_department = self.group
new_report2.save()
reports = Report.objects.all()
# Entity of contractor has 2 reports
self.assertEquals(
2, len(reports.entity_responsible(self.contractor_manager)))
#contractor is responsible for 2 reports (1 as manager, 1 as contractor)
self.assertEquals(2, len(reports.responsible(self.contractor_manager)))
def test_entity_surface_raise_exception_when_outside(self):
report = Report(
point=dict_to_point({
"x": '0',
"y": '0'
}),
postalcode=1000,
address='my address',
address_number='6h',
secondary_category=self.secondary_category,
category=self.category,
)
with self.assertRaises(Exception):
report.save()
def test_entity_surface_owner_is_responsible(self):
report = Report(
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
postalcode=1000,
address='my address',
address_number='6h',
secondary_category=self.secondary_category,
category=self.category,
)
report.save()
self.assertEqual(report.responsible_entity, self.commune)
def test_regional_road_is_detected_on_border(self):
report = Report(
# this point is outside the polygon of 1m
point=dict_to_point({
"x": '149776',
"y": '170026'
}),
postalcode=1000,
address='my address',
address_number='1',
secondary_category=self.secondary_category,
category=self.category,
)
report.save()
self.assertTrue(report.address_regional)
def test_dispatch_citizen(self):
self.report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
accepted_at=datetime.now())
self.report.save()
self.assertEquals(self.report.responsible_entity, self.organisation)
self.assertEquals(self.report.responsible_department, self.department)
def test_list_agent_reports(self):
new_report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
citizen=self.citizen)
new_report.save()
reports = Report.objects.all()
# Agent has no report
self.assertFalse(reports.responsible(self.agent))
def test_list_contractor_reports(self):
new_report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
citizen=self.citizen)
new_report.contractor = self.bxl
new_report.save()
reports = Report.objects.all()
# Contractor has reports
self.assertTrue(reports.entity_responsible(self.contractor))
def testReportFileType(self):
new_report = Report(
status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({"x": '149776', "y": '170105'}),
address_number='6h',
created_by=self.manager_etterbeek
)
new_report.save()
reportFile = ReportFile(file_type=ReportFile.PDF, report=new_report)
self.assertTrue(reportFile.is_pdf())
self.assertFalse(reportFile.is_word())
self.assertFalse(reportFile.is_excel())
self.assertFalse(reportFile.is_image())
self.assertTrue(reportFile.is_document())
reportFile = ReportFile(file_type=ReportFile.WORD, report=new_report)
self.assertFalse(reportFile.is_pdf())
self.assertTrue(reportFile.is_word())
self.assertFalse(reportFile.is_excel())
self.assertFalse(reportFile.is_image())
self.assertTrue(reportFile.is_document())
reportFile = ReportFile(file_type=ReportFile.EXCEL, report=new_report)
self.assertFalse(reportFile.is_pdf())
self.assertFalse(reportFile.is_word())
self.assertTrue(reportFile.is_excel())
self.assertFalse(reportFile.is_image())
self.assertTrue(reportFile.is_document())
reportFile = ReportFile(file_type=ReportFile.IMAGE, report=new_report)
self.assertFalse(reportFile.is_pdf())
self.assertFalse(reportFile.is_word())
self.assertFalse(reportFile.is_excel())
self.assertTrue(reportFile.is_image())
self.assertFalse(reportFile.is_document())
def test_dispatch_pro(self):
"""
when a report is created by a agent / manager / entity
responsible entity is computed based on responsible entity from creator
"""
self.client.login(username='******', password='******')
self.report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1090,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
created_by=self.manager,
accepted_at=datetime.now())
self.report.save()
self.assertEquals(self.report.responsible_entity, self.organisation)
self.assertEquals(self.report.responsible_department, self.department)
def inject_data(self):
with open(self.pave_csv, 'rb') as pave_file:
pave_reader = csv.reader(pave_file, delimiter=';', quotechar='"')
firstline = True
errors = []
for row in list(pave_reader)[self.index_start:self.index_end]:
# logger.info(row)
# Avoid CSV headers
if firstline:
firstline = False
continue
logger.info('Report with NEW PAVE id {}'.format(
self._get_pave_id(row)))
# Create new report
report = Report(citizen=self._get_pave_user(),
private=True,
pending=True)
report.bypassNotification = True
try:
self.set_category(report, row)
except KeyError:
errors.append(
{self._get_pave_id(row): "Invalid categories"})
continue
self.set_address(report, row)
self.set_external_id(report, row)
self.set_regional_flag(report, row)
report.save()
self.set_description(report, row)
self.set_history(report, row)
try:
ReportFile.objects.get(
file__icontains=row[self.PAVE_PICTURE_IDX],
report__id=report.id)
logger.info(
' Image {} of Report {} ALREADY exists'.format(
row[self.PAVE_PICTURE_IDX], report.id))
except ReportFile.DoesNotExist:
logger.info(' NEW image {} for Report {}'.format(
row[self.PAVE_PICTURE_IDX], report.id))
try:
self.set_pictures(report, row)
except:
errors.append(
{self._get_pave_id(row): "Picture problem"})
continue
except ReportFile.MultipleObjectsReturned:
logger.info(
' Oops, Report {} already has multiple same images {}'
.format(report.id, row[self.PAVE_PICTURE_IDX]))
if errors:
logger.error(errors)
logger.error("{} errors".format(len(errors)))
def setUp(self):
self.bxl = OrganisationEntity.objects.get(id=4)
self.manager_bxl = FMSUser(is_active=True,
email="*****@*****.**",
telephone="0123456789",
last_used_language="fr",
manager=True,
organisation=self.bxl)
self.manager_bxl.set_password('test')
self.manager_bxl.save()
self.group = OrganisationEntity(type="D",
name_nl="Werken",
name_fr="Travaux",
phone="090987",
dependency=self.bxl,
email="*****@*****.**")
self.group.save()
self.group_mail_config = GroupMailConfig()
self.group_mail_config.group = self.group
self.group_mail_config.save()
self.usergroupmembership = UserOrganisationMembership(
user_id=self.manager_bxl.id,
organisation_id=self.group.id,
contact_user=True)
self.usergroupmembership.save()
self.citizen = FMSUser(email="*****@*****.**",
telephone="0123456789",
last_used_language="fr")
self.citizen.save()
self.secondary_category = ReportCategory.objects.all()[0]
self.category = self.secondary_category.category_class
self.client.login(username=self.manager_bxl.email, password='******')
self.report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
created_by=self.manager_bxl)
self.report.save()
self.report.attachments.add(
ReportComment(text='test comment 1',
security_level=ReportComment.PRIVATE))
self.client.logout()
self.report.attachments.add(
ReportComment(text='test comment 2',
security_level=ReportComment.PUBLIC))
self.report.attachments.add(
ReportComment(text='test comment 3',
logical_deleted=True,
security_level=ReportComment.PUBLIC))
self.client = Client()
def setUp(self):
self.client = Client()
self.secondary_category = ReportCategory.objects.all()[0]
self.category = self.secondary_category.category_class
self.organisation = OrganisationEntity.objects.get(pk=14)
self.organisation2 = OrganisationEntity.objects.get(pk=15)
self.group = OrganisationEntity(type="D",
name_nl="Werken",
name_fr="Travaux",
phone="090987",
dependency=self.organisation,
email="*****@*****.**")
self.group.save()
self.group_mail_config = GroupMailConfig()
self.group_mail_config.group = self.group
self.group_mail_config.save()
self.group2 = OrganisationEntity(type="D",
name_nl="Werken2",
name_fr="Travaux2",
phone="090987",
dependency=self.organisation2,
email="*****@*****.**")
self.group2.save()
self.group_mail_config2 = GroupMailConfig()
self.group_mail_config2.group = self.group2
self.group_mail_config2.save()
self.manager = FMSUser(is_active=True,
telephone="0123456789",
last_used_language="fr",
password='******',
first_name="manager",
last_name="manager",
email="*****@*****.**",
manager=True)
self.manager.set_password('test')
self.manager.organisation = self.organisation
self.manager.save()
self.manager2 = FMSUser(is_active=True,
telephone="0123456789",
last_used_language="fr",
password='******',
first_name="manager2",
last_name="manager2",
email="*****@*****.**",
manager=True)
self.manager2.set_password('test')
self.manager2.organisation = self.organisation
self.manager2.save()
self.usergroupmembership = UserOrganisationMembership(
user_id=self.manager.id,
organisation_id=self.group.id,
contact_user=True)
self.usergroupmembership.save()
self.usergroupmembership = UserOrganisationMembership(
user_id=self.manager2.id,
organisation_id=self.group2.id,
contact_user=True)
self.usergroupmembership.save()
self.report = Report(status=Report.CREATED,
secondary_category=self.secondary_category,
category=self.category,
description='Just a test',
postalcode=1000,
address='my address',
point=dict_to_point({
"x": '149776',
"y": '170005'
}),
address_number='6h',
created_by=self.manager,
accepted_at=datetime.now())
self.report.save()
