def to_table(self, context):
"""This function should be overridden in subclasses and then used like
class FooReport(BaseReport):
...
def to_table(self, context):
# get default rows including description/filters etc
rows = super().to_table()
# report specific data
rows += [
[...],
]
"""
rows = [
[_("Report Title:"), context['report_title']],
[_("View On Site:"), self.get_report_url()],
[_("Report Type:"), context['report_name']],
[_("Report Description:"), context['report_description']],
[_("Generated:"), format_datetime(timezone.now())],
[],
["Filters:"],
]
for label, criteria in context['report_details']:
rows.append([label + ":", criteria])
if context.get("notes"):
rows.append(["Notes:"])
for note in context['notes']:
rows.append([note['heading'], note['content']])
return rows
def test_valid_edit_remove_ft(self):
"""Test that editing a fault and modifying a field works"""
FaultType.objects.create(code="fault type")
ft1 = utils.create_fault_type()
ft2 = utils.create_fault_type()
fault = utils.create_fault(fault_type=[ft1, ft2])
assert fault.modality is None
modality = u_models.Modality.objects.create(name="modality")
fault.unit.modalities.add(modality)
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": fault.unit.id,
"fault-modality": modality.pk,
"fault-fault_types_field": [ft2.code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
}
assert fault.fault_types.count() == 2
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.modality == modality
assert fault.fault_types.count() == 1
assert resp.url == self.list_url
def to_xlsx(self):
context = self.get_context()
f = BytesIO()
wb = xlsxwriter.Workbook(f, {'in_memory': True})
ws = wb.add_worksheet(name="Report")
row = 0
col = 0
for data_row in self.to_table(context):
for data in data_row:
# excel doesn't like urls longer than 255 chars, so write as string instead
if isinstance(data,
str) and "http" in data and len(data) > 255:
ws.write_string(row, col, data)
elif isinstance(data, timezone.datetime):
ws.write_string(row, col, format_datetime(data))
elif isinstance(data, datetime.date):
ws.write_string(row, col, format_as_date(data))
else:
try:
ws.write(row, col, data)
except TypeError:
ws.write(row, col, str(data))
col += 1
row += 1
col = 0
wb.close()
f.seek(0)
return f
def test_edit_with_invalid_reviews(self):
"""Test that editing a fault and adding a reviewer works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault(user=self.user)
rev_group = utils.create_fault_review_group()
self.user.groups.add(rev_group.group)
assert fault.modality is None
modality = u_models.Modality.objects.create(name="modality")
fault.unit.modalities.add(modality)
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": fault.unit.id,
"fault-modality": modality.pk,
"fault-fault_types_field": [fault.fault_types.first().code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
"review-form-0-group": rev_group.group.name,
"review-form-0-reviewed_by": "",
}
assert fault.faultreviewinstance_set.count() == 0
resp = self.client.post(edit_url, data)
assert resp.status_code == 200
assert resp.context['review_forms'][0].errors['reviewed_by']
def render_to_response(self, context):
import csv
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename="qatrackexport.csv"'
writer = csv.writer(response)
header1 = []
header2 = []
for h in context['headers']:
header1.extend([h.encode('utf-8'), '', ''])
header2.extend(["Date", "Value", "Ref"])
writer.writerow(header1)
writer.writerow(header2)
tz = timezone.get_current_timezone()
for row_set in context['rows']:
row = []
for date, val, ref in row_set:
date = format_datetime(date.astimezone(tz)) if date else ""
row.extend([date, val, ref])
writer.writerow(row)
return response
def test_invalid_edit(self):
"""Test that editing a fault and modifying a field works"""
modality = u_models.Modality.objects.create(name="modality")
FaultType.objects.create(code="fault type")
fault = utils.create_fault()
assert fault.modality is None
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": '',
"fault-modality": modality.pk,
"fault-fault_types_field": [fault.fault_types.first().code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
}
resp = self.client.post(edit_url, data)
assert resp.status_code == 200
def __init__(self, *args, **kwargs):
super(CreateTestListInstanceForm, self).__init__(*args, **kwargs)
now = timezone.localtime(timezone.now())
self.fields['work_started'].initial = format_datetime(now)
self.fields['comment'].widget.attrs['rows'] = '3'
self.fields['comment'].widget.attrs['placeholder'] = _(
'Add comment about this set of tests')
self.fields['comment'].widget.attrs['class'] = 'autosize form-control'
def test_unreviewed_rtsqa(self):
ses_approved = sl_utils.create_service_event_status(
name='Approved',
is_review_required=False,
rts_qa_must_be_reviewed=True)
test_status = qa_utils.create_status()
tl = qa_utils.create_test_list()
t = qa_utils.create_test()
qa_utils.create_test_list_membership(tl, t)
tli_unreviewed = qa_utils.create_test_list_instance(test_list=tl)
qa_utils.create_test_instance(
tli_unreviewed,
unit_test_info=qa_utils.create_unit_test_info(unit=self.u_1),
status=test_status)
data = {
'datetime_service': format_datetime(timezone.now()),
'unit_field': self.u_1.id,
'service_area_field': self.sa_1.id,
'service_type': self.st.id,
'problem_description': 'problem',
'service_status': ses_approved.id,
'hours-INITIAL_FORMS': 0,
'hours-MAX_NUM_FORMS': 1000,
'hours-TOTAL_FORMS': 0,
'hours-MIN_NUM_FORMS': 0,
'parts-INITIAL_FORMS': 0,
'parts-MAX_NUM_FORMS': 1000,
'parts-TOTAL_FORMS': 0,
'parts-MIN_NUM_FORMS': 0,
'rtsqa-INITIAL_FORMS': 0,
'rtsqa-MAX_NUM_FORMS': 1000,
'rtsqa-TOTAL_FORMS': 1,
'rtsqa-MIN_NUM_FORMS': 0,
'rtsqa-0-all_reviewed': tli_unreviewed.all_reviewed,
'rtsqa-0-unit_test_collection':
tli_unreviewed.unit_test_collection.id,
'rtsqa-0-test_list_instance': tli_unreviewed.id,
'rtsqa-0-id': '',
}
response = self.client.post(self.url, data=data)
self.assertTrue(
'service_status' in response.context_data['form'].errors)
data['rtsqa-0-all_reviewed'] = ''
data['rtsqa-0-test_list_instance'] = ''
response = self.client.post(self.url, data=data)
self.assertTrue(
'service_status' in response.context_data['form'].errors)
def date_to_datestrings(apps, schema):
TestInstance = apps.get_model("qa", "TestInstance")
for ti in TestInstance.objects.filter(unit_test_info__test__type="date"):
ti.string_value = format_as_date(ti.date_value)
ti.save()
for ti in TestInstance.objects.filter(unit_test_info__test__type="datetime"):
ti.string_value = format_datetime(ti.datetime_value)
ti.save()
def service_event_searcher(request):
q = request.GET.get('q')
serviceevent = models.ServiceEvent.objects.filter(Q(id__icontains=q))[0:50]
return JsonResponse({
'items': [{
'id':
se.id,
'display':
'{} - Created on {}'.format(se.service_status.name,
format_datetime(se.datetime_service))
} for se in serviceevent],
'name':
'display'
})
def get_context(self):
context = super().get_context()
# since we're grouping by site, we need to handle sites separately
form = self.get_filter_form()
reviewed = form.cleaned_data.get("review_status")
qs = self.filter_set.qs
if reviewed == "unreviewed":
qs = qs.filter(faultreviewinstance=None)
elif reviewed == "reviewed":
qs = qs.exclude(faultreviewinstance=None)
sites = qs.order_by("unit__site__name", ).values_list(
"unit__site",
flat=True,
).distinct()
sites_data = []
for site in sites:
if site: # site can be None here since not all units may have a site
site = umodels.Site.objects.get(pk=site)
sites_data.append((site.name if site else "", []))
for fault in self.get_faults_for_site(qs, site):
sites_data[-1][-1].append({
'id':
fault.id,
'fault_type':
format_fault_types(fault),
'unit_name':
fault.unit.name,
'modality':
fault.modality.name
if fault.modality else _("Not specified"),
'occurred':
format_datetime(fault.occurred),
'link':
self.make_url(fault.get_absolute_url(), plain=True),
})
context['sites_data'] = sites_data
return context
def test_edit_with_changed_reviews(self):
"""Test that editing a fault with existing reviewer works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault(user=self.user)
rev_group = utils.create_fault_review_group()
utils.create_fault_review(fault=fault,
review_group=rev_group,
reviewed_by=self.user)
self.user.groups.add(rev_group.group)
new_u = qa_utils.create_user()
new_u.groups.add(rev_group.group)
modality = u_models.Modality.objects.create(name="modality")
fault.unit.modalities.add(modality)
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": fault.unit.id,
"fault-modality": modality.pk,
"fault-fault_types_field": [fault.fault_types.first().code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
"review-form-0-group": rev_group.group.name,
"review-form-0-reviewed_by": new_u.pk,
}
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [self.user.pk]
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.faultreviewinstance_set.count() == 1
assert list(
fault.faultreviewinstance_set.values_list(
"reviewed_by_id", flat=True)) == [new_u.pk]
def test_formset_required_fields(self):
data = {
'datetime_service': format_datetime(timezone.now()),
'unit_field': self.u_1.id,
'service_area_field': self.sa_1.id,
'service_type': self.st.id,
'problem_description': 'problem',
'service_status': self.default_ses.id,
'hours-INITIAL_FORMS': 0,
'hours-MAX_NUM_FORMS': 1000,
'hours-TOTAL_FORMS': 1,
'hours-MIN_NUM_FORMS': 0,
'parts-INITIAL_FORMS': 0,
'parts-MAX_NUM_FORMS': 1000,
'parts-TOTAL_FORMS': 1,
'parts-MIN_NUM_FORMS': 0,
'rtsqa-INITIAL_FORMS': 0,
'rtsqa-MAX_NUM_FORMS': 1000,
'rtsqa-TOTAL_FORMS': 0,
'rtsqa-MIN_NUM_FORMS': 0,
'parts-0-part': self.part.id,
'hours-0-user_or_thirdparty': 'user-%s' % self.user.id
}
response = self.client.post(self.url, data=data)
self.assertTrue(
'quantity' in response.context_data['part_used_formset'].errors[0])
self.assertTrue(
'time' in response.context_data['hours_formset'].errors[0])
data['parts-0-part'] = ''
data['parts-0-quantity'] = 1
data['hours-0-user_or_thirdparty'] = ''
data['hours-0-time'] = '0030'
response = self.client.post(self.url, data=data)
self.assertTrue(
'part' in response.context_data['part_used_formset'].errors[0])
self.assertTrue('user_or_thirdparty' in
response.context_data['hours_formset'].errors[0])
def item_val_to_string(item):
if item is None:
return ''
elif isinstance(item, str):
return item
elif isinstance(item, User):
return get_user_name(item)
elif isinstance(item, timezone.datetime):
return format_datetime(item)
elif isinstance(item, timezone.timedelta):
total_seconds = int(item.total_seconds())
hours = total_seconds // 3600
minutes = (total_seconds % 3600) // 60
return '{}:{:02}'.format(hours, minutes)
elif isinstance(item, (
QuerySet,
list,
tuple,
)):
return ', '.join([str(i) for i in item])
else:
return str(item)
def test_list_instance_report(request, pk):
tli = get_object_or_404(models.TestListInstance, id=pk)
utc = tli.unit_test_collection
wc = format_datetime(tli.work_completed)
base_opts = {
'report_type': TestListInstanceDetailsReport.report_type,
'report_format': request.GET.get("type", "pdf"),
'title': "%s - %s - %s" % (utc.unit.name, tli.test_list.name, wc),
'include_signature': False,
'visible_to': [],
}
report_opts = {
'work_completed': "%s - %s" % (wc, wc),
'unit_test_collection': [utc.id],
}
report = TestListInstanceDetailsReport(base_opts=base_opts,
report_opts=report_opts,
user=request.user)
return report.render_to_response(base_opts['report_format'])
def test_valid_edit_remove_attach(self):
"""Test that editing a fault and modifying a field works"""
FaultType.objects.create(code="fault type")
fault = utils.create_fault()
test_file = SimpleUploadedFile("TESTRUNNER_test_file.json", b"{}")
attach = Attachment.objects.create(fault=fault,
attachment=test_file,
created_by=self.user)
assert fault.attachment_set.count() == 1
ft2 = utils.create_fault_type()
assert fault.modality is None
modality = u_models.Modality.objects.create(name="modality")
fault.unit.modalities.add(modality)
edit_url = reverse("fault_edit", kwargs={'pk': fault.pk})
se = sl_utils.create_service_event()
fault.related_service_events.add(se)
data = {
"fault-occurred": format_datetime(fault.occurred),
"fault-unit": fault.unit.id,
"fault-modality": modality.pk,
"fault-fault_types_field":
[fault.fault_types.first().code, ft2.code],
"fault-comment": "",
"fault-related_service_events": [se.pk],
"fault-attachments_delete_ids": [attach.id, ''],
}
resp = self.client.post(edit_url, data)
assert resp.status_code == 302
fault.refresh_from_db()
assert fault.attachment_set.count() == 0
def get_context(self):
context = super().get_context()
# since we're grouping by site, we need to handle sites separately
sites = self.filter_set.qs.order_by(
"unit_service_area__unit__site__name", ).values_list(
"unit_service_area__unit__site",
flat=True,
).distinct()
sites_data = []
for site in sites:
if site: # site can be None here since not all units may have a site
site = umodels.Site.objects.get(pk=site)
sites_data.append((site.name if site else "", []))
for se in self.get_ses_for_site(self.filter_set.qs, site):
initiated_by_link = (self.make_url(
se.test_list_instance_initiated_by.get_absolute_url(),
plain=True) if se.test_list_instance_initiated_by else
None)
related_ses = []
for se_rel in se.service_event_related.all():
related_ses.append(
(se_rel.id, se_rel.datetime_service,
self.make_url(se_rel.get_absolute_url(), plain=True)))
group_linkers = defaultdict(list)
for gli in se.grouplinkerinstance_set.all():
group_linkers[gli.group_linker.name].append(
gli.user.username)
hours = []
for h in se.hours_set.all():
u = h.user.username if h.user else "%s (%s)" % (str(
h.third_party), h.third_party.vendor.name)
hours.append((u, h.time))
rts_qc = []
for rts in se.returntoserviceqa_set.all():
tli = rts.test_list_instance
wc = format_datetime(tli.work_completed) if tli else ""
link = self.make_url(tli.get_absolute_url(),
plain=True) if tli else ""
rts_qc.append((rts.unit_test_collection.name, wc, link))
rts_comments = []
comment_qs = Comment.objects.for_model(se).values_list(
"user__username",
"submit_date",
"comment",
)
for user, dt, comment in comment_qs:
rts_comments.append((user, format_datetime(dt), comment))
parts = []
for part_used in se.partused_set.all():
parts.append(
(part_used.part.name, str(part_used.from_storage
or ""), part_used.quantity))
attachments = []
for a in se.attachment_set.all():
attachments.append(
(a.label, self.make_url(a.attachment.url, plain=True)))
sites_data[-1][-1].append({
'id':
se.id,
'service_date':
format_as_date(se.datetime_service),
'site':
site.name if site else "",
'unit_name':
se.unit_service_area.unit.name,
'service_area':
se.unit_service_area.service_area.name,
'service_type':
se.service_type.name,
'service_time':
se.duration_service_time,
'lost_time':
se.duration_lost_time,
'status':
se.service_status.name,
'created_by':
format_user(se.user_created_by),
'created_date':
format_datetime(se.datetime_created),
'modified_by':
format_user(se.user_modified_by),
'modified_date':
format_datetime(se.datetime_modified),
'problem':
se.problem_description,
'work':
se.work_description,
'safety':
se.safety_precautions,
'initiated_by':
se.test_list_instance_initiated_by,
'initiated_by_link':
initiated_by_link,
'related_ses':
related_ses,
'group_linkers':
sorted(group_linkers.items()),
'hours':
hours,
'rts_qc':
rts_qc,
'rts_comments':
rts_comments,
'parts':
parts,
'attachments':
attachments,
'link':
self.make_url(se.get_absolute_url(), plain=True),
})
context['sites_data'] = sites_data
return context
def get_context(self):
context = super().get_context()
# since we're grouping by site, we need to handle sites separately
form = self.get_filter_form()
reviewed = form.cleaned_data.get("review_status")
qs = self.filter_set.qs
if reviewed == "unreviewed":
qs = qs.filter(faultreviewinstance=None)
elif reviewed == "reviewed":
qs = qs.exclude(faultreviewinstance=None)
sites = qs.order_by("unit__site__name", ).values_list(
"unit__site",
flat=True,
).distinct()
sites_data = []
for site in sites:
if site: # site can be None here since not all units may have a site
site = umodels.Site.objects.get(pk=site)
sites_data.append((site.name if site else "", []))
for fault in self.get_faults_for_site(qs, site):
related_ses = []
for se_rel in fault.related_service_events.all():
related_ses.append(
(se_rel.id, se_rel.datetime_service,
self.make_url(se_rel.get_absolute_url(), plain=True)))
comments = []
comment_qs = Comment.objects.for_model(fault).values_list(
"user__username",
"submit_date",
"comment",
)
for user, dt, comment in comment_qs:
comments.append((user, format_datetime(dt), comment))
sites_data[-1][-1].append({
'id':
fault.id,
'occurred':
format_datetime(fault.occurred),
'site':
site.name if site else "",
'unit_name':
fault.unit.name,
'fault_type':
format_fault_types(fault),
'modality':
fault.modality.name
if fault.modality else _("Not specified"),
'created_by':
format_user(fault.created_by),
'created':
format_datetime(fault.created),
'modified_by':
format_user(fault.modified_by),
'modified':
format_datetime(fault.modified),
'reviewed_by':
format_review_users(fault),
'reviewed':
format_review_dates(fault),
'related_ses':
related_ses,
'comments':
comments,
'link':
self.make_url(fault.get_absolute_url(), plain=True),
})
context['sites_data'] = sites_data
return context
def format_review_dates(fault):
return ', '.join(
format_datetime(fri.reviewed)
for fri in fault.faultreviewinstance_set.all())
def to_table(self, context):
rows = [
[_("Report Title:"), context['report_title']],
[_("View On Site:"), self.get_report_url()],
[_("Report Type:"), context['report_name']],
[_("Report Description:"), context['report_description']],
[_("Generated:"), format_datetime(timezone.now())],
[],
["Filters:"],
]
for label, criteria in context['report_details']:
rows.append([label + ":", criteria])
for tli in context['queryset']:
rows.extend([
[],
[],
["Test List Instance:",
self.make_url(tli.get_absolute_url())],
[_("Created By") + ":",
format_user(tli.created_by)],
[_("Work Started") + ":",
format_as_date(tli.work_started)],
[
_("Work Completed") + ":",
format_as_date(tli.work_completed)
],
[
_("Duration") + ":",
_("In Progress")
if tli.in_progress else as_time_delta(tli.duration())
],
[_("Modified") + ":",
format_as_date(tli.modified)],
[_("Mofified By") + ":",
format_user(tli.modified_by)],
])
if tli.all_reviewed and not tli.reviewed_by:
rows.extend([
[_("Reviewed") + ":",
format_as_date(tli.modified)],
[_("Reviewed By") + ":",
_("Auto Reviewed")],
])
else:
rows.extend([
[_("Reviewed") + ":",
format_as_date(tli.reviewed)],
[_("Reviewed By") + ":",
format_user(tli.reviewed_by)],
])
for c in context['comments'].get(tli.pk, []):
rows.append(
[_("Comment") + ":",
format_datetime(c[0]), c[1], c[2]])
for a in tli.attachment_set.all():
rows.append([
_("Attachment") + ":", a.label,
self.make_url(a.attachment.url, plain=True)
])
rows.append([])
rows.append([
_("Test"),
_("Value"),
_("Reference"),
_("Tolerance"),
_("Pass/Fail"),
_("Review Status"),
_("Comment"),
_("Attachments"),
])
for ti, history in tli.history()[0]:
row = [
ti.unit_test_info.test.name,
ti.value_display(coerce_numerical=False),
ti.reference.value_display() if ti.reference else "",
ti.tolerance.name if ti.tolerance else "",
ti.get_pass_fail_display(),
ti.status.name,
ti.comment,
]
for a in ti.attachment_set.all():
row.append(self.make_url(a.attachment.url, plain=True))
rows.append(row)
return rows
def test_submit_valid(self):
st = sl_utils.create_service_type()
user = User.objects.filter(groups=self.gl_1.group).first()
user.user_permissions.add(
Permission.objects.get(codename='can_have_hours'))
data = {
'datetime_service':
format_datetime(timezone.now()),
'unit_field':
self.u_1.id,
'unit_field_fake':
self.u_1.id,
'service_area_field':
self.usa_1.service_area.id,
'service_type':
st.id,
'problem_description':
'uhhhhh ohhhh',
'work_description':
'stuff was done',
'safety_precautions':
'we were careful',
'qafollowup_notes':
'comment',
'service_event_related_field':
[sl_utils.create_service_event(unit_service_area=self.usa_1).id],
'service_status':
models.ServiceEventStatus.get_default().id,
'test_list_instance_initiated_by':
self.tli_1_1.id,
'duration_service_time':
'4321',
'duration_lost_time':
'1234',
'initiated_utc_field':
self.tli_1_1.unit_test_collection.id,
'group_linker_1':
user.id,
'hours-INITIAL_FORMS':
0,
'hours-MAX_NUM_FORMS':
1000,
'hours-TOTAL_FORMS':
1,
'hours-MIN_NUM_FORMS':
0,
'parts-INITIAL_FORMS':
0,
'parts-MAX_NUM_FORMS':
1000,
'parts-TOTAL_FORMS':
1,
'parts-MIN_NUM_FORMS':
0,
'rtsqa-INITIAL_FORMS':
0,
'rtsqa-MAX_NUM_FORMS':
1000,
'rtsqa-TOTAL_FORMS':
1,
'rtsqa-MIN_NUM_FORMS':
0,
'hours-0-time':
'100',
'hours-0-user_or_thirdparty':
'user-%s' % user.id,
'rtsqa-0-all_reviewed':
self.tli_1_2.all_reviewed,
'rtsqa-0-unit_test_collection':
self.tli_1_2.unit_test_collection.id,
'rtsqa-0-test_list_instance':
self.tli_1_2.id,
'parts-0-quantity':
1,
'parts-0-part':
self.part.id,
'parts-0-from_storage':
self.part.storage.all().first().id
}
se_count = models.ServiceEvent.objects.count()
response = self.client.post(self.url, data=data)
se_id = models.ServiceEvent.objects.filter(
problem_description='uhhhhh ohhhh').first().id
self.assertEqual(se_count + 1, models.ServiceEvent.objects.count())
self.assertEqual(
1,
p_models.PartUsed.objects.filter(service_event=se_id).count())
self.assertEqual(
1,
models.ReturnToServiceQA.objects.filter(
service_event=se_id).count())
self.assertEqual(
1,
models.Hours.objects.filter(service_event=se_id).count())
self.assertEqual(response.status_code, 302)
def render_log(service_log, user, link=True, show_rtsqa=False):
today = timezone.now().date()
if service_log.datetime.date() == today:
if timezone.now() - service_log.datetime < timezone.timedelta(hours=1):
datetime_display = '%s %s' % (
int((timezone.now() - service_log.datetime).total_seconds() / 60), _('minutes ago')
)
else:
datetime_display = format_as_time(service_log.datetime)
elif service_log.datetime.date() == today - timezone.timedelta(days=1):
datetime_display = '%s %s' % (_('Yesterday'), format_as_time(service_log.datetime))
else:
datetime_display = format_datetime(service_log.datetime)
context = {
'instance': service_log,
'datetime_display': datetime_display,
'user': get_user_name(service_log.user),
'can_view': user.has_perm('service_log.view_serviceevent') and service_log.service_event.is_active and link,
'show_rtsqa': show_rtsqa
}
if service_log.log_type == sl_models.NEW_SERVICE_EVENT:
return get_template('service_log/log_service_event_new.html').render(context)
elif service_log.log_type == sl_models.MODIFIED_SERVICE_EVENT:
try:
extra_info = json.loads(service_log.extra_info.replace("'", '"'))
except: # noqa: E722
extra_info = service_log.extra_info
context['extra_info'] = extra_info
return get_template('service_log/log_service_event_modified.html').render(context)
elif service_log.log_type == sl_models.STATUS_SERVICE_EVENT:
try:
extra_info = json.loads(service_log.extra_info.replace("'", '"'))
except: # noqa: E722
extra_info = service_log.extra_info
context['extra_info'] = extra_info
status_old_colour = cache.get(settings.CACHE_SERVICE_STATUS_COLOURS).get(extra_info['status_change']['old'])
context['old_status_tag'] = '<span class="label smooth-border" style="border-color: %s;">%s</span>' % (
status_old_colour, extra_info['status_change']['old']
) if status_old_colour is not None else extra_info['status_change']['old']
status_new_colour = cache.get(settings.CACHE_SERVICE_STATUS_COLOURS).get(extra_info['status_change']['new'])
context['new_status_tag'] = '<span class="label smooth-border" style="border-color: %s;">%s</span>' % (
status_new_colour, extra_info['status_change']['new']
) if status_new_colour is not None else extra_info['status_change']['new']
context['new_status_colour'] = status_new_colour
return get_template('service_log/log_service_event_status.html').render(context)
elif service_log.log_type == sl_models.CHANGED_RTSQA:
try:
extra_info = json.loads(service_log.extra_info.replace("'", '"'))
except: # noqa: E722
extra_info = service_log.extra_info
context['extra_info'] = extra_info
return get_template('service_log/log_rtsqa.html').render(context)
elif service_log.log_type == sl_models.DELETED_SERVICE_EVENT:
try:
extra_info = json.loads(service_log.extra_info.replace("'", '"'))
except: # noqa: E722
extra_info = service_log.extra_info
context['extra_info'] = extra_info
return get_template('service_log/log_service_event_deleted.html').render(context)
def setUp(self):
self.factory = RequestFactory()
self.view = views.UpdateServiceEvent.as_view()
self.default_ses = sl_utils.create_service_event_status(
is_default=True)
self.approved_ses = sl_utils.create_service_event_status(
is_review_required=False, rts_qa_must_be_reviewed=True)
sl_utils.create_service_event_status()
qa_utils.create_status(is_default=True)
now = timezone.now()
self.u_1 = qa_utils.create_unit(name='u_1')
self.sa_1 = sl_utils.create_service_area(name='sa_1')
self.usa_1 = sl_utils.create_unit_service_area(unit=self.u_1,
service_area=self.sa_1)
self.tl_1 = qa_utils.create_test_list(name='tl_1')
self.tli_1_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now - timezone.timedelta(hours=1))
self.tli_1_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_1, test_collection=self.tl_1),
test_list=self.tl_1,
work_completed=now)
self.se_1 = sl_utils.create_service_event(unit_service_area=self.usa_1)
self.u_2 = qa_utils.create_unit(name='u_2')
self.sa_2 = sl_utils.create_service_area(name='sa_2')
self.usa_2 = sl_utils.create_unit_service_area(unit=self.u_2,
service_area=self.sa_2)
self.tl_2 = qa_utils.create_test_list(name='tl_2')
self.tli_2_1 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now - timezone.timedelta(hours=1))
self.tli_2_2 = qa_utils.create_test_list_instance(
unit_test_collection=qa_utils.create_unit_test_collection(
unit=self.u_2, test_collection=self.tl_2),
test_list=self.tl_2,
work_completed=now)
self.se_2 = sl_utils.create_service_event(unit_service_area=self.usa_2)
self.url = reverse('sl_new')
self.user = create_user(is_superuser=True)
self.client.login(username='******', password='******')
perm = Permission.objects.get(codename='can_have_hours')
user_can_hours = User.objects.get(username='******')
user_can_hours.user_permissions.add(perm)
user_group_has_hours = create_user(uname='in_group_with_hours')
group_has_hours = create_group(name='can_have_hours')
group_has_hours.permissions.add(perm)
user_group_has_hours.groups.add(group_has_hours)
sl_utils.create_third_party()
group_linked = create_group(name='linked')
user_group_linked = create_user(uname='user_in_group_linked')
user_group_linked.groups.add(group_linked)
self.gl_1 = sl_utils.create_group_linker(group=group_linked)
self.part = sl_utils.create_part(add_storage=True)
self.st = sl_utils.create_service_type()
self.se = sl_utils.create_service_event(
unit_service_area=self.usa_1,
service_status=self.default_ses,
service_type=self.st)
self.url = reverse('sl_edit', kwargs={"pk": self.se.pk})
self.data = {
'datetime_service': format_datetime(timezone.now()),
'service_status': self.default_ses.id,
'service_type': self.st.id,
'is_review_required': 0,
'safety_precautions': 'safety_precautions',
'problem_description': 'problem_description',
'service_area_field': self.se.unit_service_area.service_area.id,
'unit_field': self.se.unit_service_area.unit.id,
'unit_field_fake': self.se.unit_service_area.unit.id,
'qafollowup_notes': 'qafollowup_notes',
'test_list_instance_initiated_by': self.tli_1_1.id,
'duration_lost_time': '0100',
'duration_service_time': '0100',
'hours-INITIAL_FORMS': 0,
'hours-MAX_NUM_FORMS': 1000,
'hours-TOTAL_FORMS': 0,
'hours-MIN_NUM_FORMS': 0,
'parts-INITIAL_FORMS': 0,
'parts-MAX_NUM_FORMS': 1000,
'parts-TOTAL_FORMS': 0,
'parts-MIN_NUM_FORMS': 0,
'rtsqa-INITIAL_FORMS': 0,
'rtsqa-MAX_NUM_FORMS': 1000,
'rtsqa-TOTAL_FORMS': 0,
'rtsqa-MIN_NUM_FORMS': 0,
}
