def post_save(self, obj, created=False):
if created:
description = u"Original expressions of dissatisfaction:\n%s\n\n%s" % (
u"\n".join(
map(
lambda desc: u"- %s" % desc,
obj.eod.get_category_descriptions(
include_severity=True))),
obj.eod.notes,
)
notes = u"Complaint created.\n\n{description}".format(
description=description.strip()).strip()
event = event_registry.get_event("complaint")()
event.process(obj.eod.case,
created_by=self.request.user,
notes=notes,
complaint=obj,
code="COMPLAINT_CREATED")
obj.eod.case.complaint_flag = True
obj.eod.case.save()
if getattr(obj, "_update_owner", False):
event = event_registry.get_event("complaint")()
event.process(
obj.eod.case,
created_by=self.request.user,
notes=u"Complaint owner set to %s" %
(obj.owner.get_full_name() or obj.owner.username),
complaint=obj,
code="OWNER_SET",
)
def test_select_selectable_code(self):
# get dict {event_key: [list of selectable codes]}
selectable_events = event_registry.get_selectable_events(
role=LOG_ROLES.OPERATOR)
for chosen_key, chosen_codes in selectable_events.items():
for chosen_code in chosen_codes:
# chosen key / code
event = event_registry.get_event(chosen_key)()
res = event.process(self.dummy_case,
code=chosen_code,
notes="selectable notes",
created_by=self.dummy_user)
self.assertLogEqual(
res,
Log(
case=self.dummy_case,
code=chosen_code,
type=LOG_TYPES.OUTCOME,
notes="selectable notes",
level=event.codes[chosen_code]["level"],
created_by=self.dummy_user,
),
)
def test_CASE_VIEWED_log_not_created_after_CASE_VIEWED_during_timer(self):
"""
During the lifetime of a timer, if a user viewed a case twice, we
should only log CASE_VIEWED once.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe('timer.Timer', created_by=self.dummy_user)
# case viewed
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
def _test_process_with_expicit_code(
self, expected_available_codes,
expected_type=LOG_TYPES.OUTCOME, expected_level=LOG_LEVELS.HIGH,
process_kwargs={}, code=None
):
event = event_registry.get_event(self.EVENT_KEY)()
codes = event.codes.keys()
self.assertItemsEqual(codes, expected_available_codes)
# building process params and overridding potential ones through process_kwargs
chosen_code = code or codes[0]
_process_kwargs = {
'case': self.dummy_case,
'code': chosen_code,
'notes': 'this is a note',
'created_by': self.dummy_user
}
_process_kwargs.update(process_kwargs)
res = event.process(**_process_kwargs)
# testing that everything worked
self.assertLogEqual(
res, Log(
case=_process_kwargs['case'],
code=_process_kwargs['code'],
type=expected_type,
notes=_process_kwargs['notes'],
level=expected_level,
created_by=_process_kwargs['created_by']
)
)
def test_stops_timer(self):
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
user = make_user()
timer = make_recipe('timer.Timer', created_by=user)
res = event.process(**{
'case': self.dummy_case,
'code': code,
'notes': 'this is a note',
'created_by': user
})
timer = Timer.objects.get(pk=timer.pk)
if code_data['stops_timer']:
self.assertTrue(timer.is_stopped())
self.assertEqual(res.timer, timer)
else:
self.assertFalse(timer.is_stopped())
self.assertEqual(res.timer, timer)
def reopen(self, request, pk):
obj = self.get_object()
closed_logs = obj.logs.filter(code__in=["COMPLAINT_CLOSED", "COMPLAINT_VOID"]) # complaint void
if not closed_logs.exists():
return DRFResponse(
"Cannot reopen a complaint that is not closed or void", status=status.HTTP_400_BAD_REQUEST
)
last_closed = closed_logs.order_by("-created").first()
notes = u"Complaint reopened.\nOriginally {action_name} {closed_date} by {closed_by}.".format(
action_name="voided" if last_closed.code == "COMPLAINT_VOID" else "closed",
closed_date=last_closed.created.strftime("%d/%m/%Y %H:%M"),
closed_by=last_closed.created_by.username,
)
notes += u"\n\n" + last_closed.notes
event = event_registry.get_event("complaint")()
event.process(
obj.eod.case, created_by=request.user, notes=notes.strip(), complaint=obj, code="COMPLAINT_REOPENED"
)
obj.resolved = None
obj.save()
obj.eod.case.complaint_flag = True
obj.eod.case.save()
closed_logs.delete()
return DRFResponse(status=status.HTTP_204_NO_CONTENT)
def reopen(self, request, pk):
obj = self.get_object()
closed_logs = obj.logs.filter(
code__in=["COMPLAINT_CLOSED", "COMPLAINT_VOID"]) # complaint void
if not closed_logs.exists():
return DRFResponse(
"Cannot reopen a complaint that is not closed or void",
status=status.HTTP_400_BAD_REQUEST)
last_closed = closed_logs.order_by("-created").first()
notes = u"Complaint reopened.\nOriginally {action_name} {closed_date} by {closed_by}.".format(
action_name="voided"
if last_closed.code == "COMPLAINT_VOID" else "closed",
closed_date=last_closed.created.strftime("%d/%m/%Y %H:%M"),
closed_by=last_closed.created_by.username,
)
notes += u"\n\n" + last_closed.notes
event = event_registry.get_event("complaint")()
event.process(obj.eod.case,
created_by=request.user,
notes=notes.strip(),
complaint=obj,
code="COMPLAINT_REOPENED")
obj.resolved = None
obj.save()
obj.eod.case.complaint_flag = True
obj.eod.case.save()
closed_logs.delete()
return DRFResponse(status=status.HTTP_204_NO_CONTENT)
def test_CASE_VIEWED_log_created_after_CASE_CREATED_if_no_timer(self):
"""
If no timer exists, CASE_VIEWED logs are always created, even after
CASE_CREATED logs.
"""
event = event_registry.get_event(self.EVENT_KEY)()
# case created
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "created"
})
self.assertEqual(Log.objects.count(), 1)
# case viewed
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 2)
def test_CASE_VIEWED_log_created_after_CASE_CREATED_if_no_timer(self):
"""
If no timer exists, CASE_VIEWED logs are always created, even after
CASE_CREATED logs.
"""
event = event_registry.get_event(self.EVENT_KEY)()
# case created
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'created'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 2)
def test_CASE_VIEWED_log_not_created_after_CASE_CREATED_during_timer(self):
"""
During the lifetime of a timer, if a user creates a case
and then views it, only 'CASE_CREATED' log is created.
In other words, we don't log 'CASE_VIEWED' to avoid noise.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe("timer.Timer", created_by=self.dummy_user)
# case created
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "created"
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
def test_CASE_VIEWED_log_not_created_after_CASE_VIEWED_during_timer(self):
"""
During the lifetime of a timer, if a user viewed a case twice, we
should only log CASE_VIEWED once.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe("timer.Timer", created_by=self.dummy_user)
# case viewed
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(
**{
"case": self.dummy_case,
"created_by": self.dummy_user,
"status": "viewed"
})
self.assertEqual(Log.objects.count(), 1)
class Add72workingHoursToContextCommandTestCase(CallCentreFixedOperatingHours,
TestCase):
def setUp(self):
super(Add72workingHoursToContextCommandTestCase, self).setUp()
self.instance = Command()
def create_callback(self, requires_action_at):
case = make_recipe("legalaid.case")
user = make_user()
make_recipe("call_centre.operator", user=user)
event = event_registry.get_event("call_me_back")()
event.get_log_code(case=case)
log = event.process(
case,
created_by=user,
notes="",
context={
"requires_action_at": requires_action_at,
"sla_15": get_sla_time(requires_action_at, 15),
"sla_30": get_sla_time(requires_action_at, 30),
"sla_120": get_sla_time(requires_action_at, 120),
"sla_480": get_sla_time(requires_action_at, 480),
},
)
case.set_requires_action_at(requires_action_at)
return log
def retrieve(self, request, *args, **kwargs):
resp = super(FullCaseViewSet, self).retrieve(request, *args, **kwargs)
event = event_registry.get_event("case")()
event.process(self.object, status="viewed", created_by=request.user, notes="Case viewed")
return resp
def test_set_requires_action_by(self):
"""
Tests that:
* if the code has the key `set_requires_action_by`,
after process, case.requires_action_by will be set to
that value
* if the code doesn't have the key `set_requires_action_by`,
after process, case.requires_action_by won't change
"""
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
self.dummy_case.requires_action_by = None
self.dummy_case.save()
user = make_user()
event.process(**{"case": self.dummy_case, "code": code, "notes": "this is a note", "created_by": user})
case = Case.objects.get(pk=self.dummy_case.pk)
if "set_requires_action_by" in code_data:
set_requires_action_by = code_data["set_requires_action_by"]
if callable(set_requires_action_by):
set_requires_action_by = set_requires_action_by(self.dummy_case)
self.assertEqual(case.requires_action_by, set_requires_action_by)
else:
self.assertEqual(case.requires_action_by, None)
def _test_process_with_implicit_code(
self,
expected_code,
expected_type=LOG_TYPES.OUTCOME,
expected_level=LOG_LEVELS.HIGH,
process_kwargs={},
dummy_case=None,
):
"""
Used to test the `process` call when there's only one possible implicit
code available so you don't need to pass an explicit one as param.
"""
event = event_registry.get_event(self.EVENT_KEY)()
if not dummy_case:
dummy_case = self.dummy_case
# building process params and overridding potential ones through process_kwargs
_process_kwargs = {"case": dummy_case, "notes": "this is a note", "created_by": self.dummy_user}
_process_kwargs.update(process_kwargs)
res = event.process(**_process_kwargs)
# testing that everything worked
self.assertLogEqual(
res,
Log(
case=_process_kwargs["case"],
code=expected_code,
type=expected_type,
notes=_process_kwargs["notes"],
level=expected_level,
created_by=_process_kwargs["created_by"],
),
)
def get_notes(self):
event_code = self.get_event_code()
event_cls = event_registry.get_event(self.LOG_EVENT_KEY)
event_description = event_cls.codes[event_code]["description"]
notes = u"%s.\n%s" % (event_description, super(ComplaintLogForm,
self).get_notes())
return notes.strip()
def test_CASE_VIEWED_log_not_created_after_CASE_CREATED_during_timer(self):
"""
During the lifetime of a timer, if a user creates a case
and then views it, only 'CASE_CREATED' log is created.
In other words, we don't log 'CASE_VIEWED' to avoid noise.
"""
event = event_registry.get_event(self.EVENT_KEY)()
self.assertEqual(Log.objects.count(), 0) # no logs
# db setup
make_recipe('timer.Timer', created_by=self.dummy_user)
# case created
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'created'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed log not created because case created log
# already exists
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
def save_event(self, user):
event = event_registry.get_event(self.get_event_key())()
event.process_split(self.new_case,
created_by=user,
notes=self.get_notes(),
context=self.get_context(),
**self.get_kwargs())
def list_by_event_key(self, request, event_key, *args, **kwargs):
try:
event = event_registry.get_event(event_key)
except ValueError:
return DRFResponse({"detail": "Not found"}, status=status.HTTP_404_NOT_FOUND)
response_data = self.format_codes(event.get_ordered_codes())
return DRFResponse(response_data, status=status.HTTP_200_OK)
def save_event(self, user):
event = event_registry.get_event(self.get_event_key())()
event.process_split(
self.new_case, created_by=user,
notes=self.get_notes(),
context=self.get_context(),
**self.get_kwargs()
)
def post_save(self, obj, created=False):
super(CaseViewSet, self).post_save(obj, created=created)
if created:
event = event_registry.get_event('case')()
event.process(
obj, status='created', created_by=self.request.user,
notes="Case created"
)
def test_CB4_errors(self):
dummy_case = make_recipe("legalaid.case", callback_attempt=3)
event = event_registry.get_event(self.EVENT_KEY)()
self.assertRaises(
ValueError, event.process, **{"case": dummy_case, "notes": "this is a note", "created_by": self.dummy_user}
)
self.assertEqual(dummy_case.log_set.count(), 0)
def retrieve(self, request, *args, **kwargs):
resp = super(FullCaseViewSet, self).retrieve(request, *args, **kwargs)
event = event_registry.get_event("case")()
event.process(self.object,
status="viewed",
created_by=request.user,
notes="Case viewed")
return resp
def create_diagnosis_log(self, obj, status):
try:
obj.case
except Case.DoesNotExist:
return
diagnosis_event = event_registry.get_event("diagnosis")()
patch = json.dumps(self.get_serializer_class()(obj).data)
kwargs = {"created_by": self.get_current_user(), "status": status, "patch": patch}
diagnosis_event.process(obj.case, **kwargs)
def test_get_using_event_key(self):
response = self.client.get(self.detail_url, HTTP_AUTHORIZATION="Bearer %s" % self.token, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
action = event_registry.get_event(self.get_event_key())
# building expected response data
codes = []
for code, code_data in action.codes.items():
codes.append({"code": code, "description": code_data["description"]})
self.assertItemsEqual(response.data, codes)
def post_save(self, obj, created=False):
super(BaseCaseLogMixin, self).post_save(obj, created=created)
if created:
event = event_registry.get_event("case")()
event.process(
obj,
status="created",
created_by=obj.created_by,
notes=self.get_log_notes(obj),
context=self.get_log_context(obj),
)
def test_CALLBACK_COMPLETE_errors_without_prev_CBx(self):
dummy_case = make_recipe("legalaid.case", callback_attempt=0)
event = event_registry.get_event(self.EVENT_KEY)()
self.assertRaises(
ValueError,
event.process,
**{"case": dummy_case, "notes": "this is a note", "created_by": self.dummy_user, "complete": True}
)
self.assertEqual(dummy_case.log_set.count(), 0)
def post_save(self, obj, created=False):
super(BaseCaseLogMixin, self).post_save(obj, created=created)
if created:
event = event_registry.get_event("case")()
event.process(
obj,
status="created",
created_by=obj.created_by,
notes=self.get_log_notes(obj),
context=self.get_log_context(obj),
)
def test_call_started_sla(self):
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 0, 0)):
case = make_recipe("legalaid.case")
user = make_user()
make_recipe("call_centre.operator", user=user)
event = event_registry.get_event("call_me_back")()
_dt = _make_datetime(2015, 1, 2, 9, 1, 0)
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 1, 0)):
event.get_log_code(case=case)
event.process(
case,
created_by=user,
notes="",
context={
"requires_action_at": _dt,
"sla_15": get_sla_time(_dt, 15),
"sla_30": get_sla_time(_dt, 30),
"sla_120": get_sla_time(_dt, 120),
"sla_480": get_sla_time(_dt, 480),
},
)
case.requires_action_at = _dt
case.save()
event = event_registry.get_event("case")()
with patch_field(Log, "created", _make_datetime(2015, 1, 2, 9, 30, 0)):
event.process(case, status="call_started", created_by=user, notes="Call started")
date_range = (_make_datetime(2015, 1, 1), _make_datetime(2015, 2, 1))
with mock.patch("reports.forms.MICB1Extract.date_range", date_range):
report = MICB1Extract()
qs = report.get_queryset()
self.assertFalse(qs[0][28])
def test_CB4_errors(self):
dummy_case = make_recipe('legalaid.case', callback_attempt=3)
event = event_registry.get_event(self.EVENT_KEY)()
self.assertRaises(
ValueError, event.process, **{
'case': dummy_case,
'notes': 'this is a note',
'created_by': self.dummy_user
})
self.assertEqual(dummy_case.log_set.count(), 0)
def create_means_test_log(self, obj, created):
try:
obj.case
except Case.DoesNotExist:
return
user = self.get_request_user()
means_test_event = event_registry.get_event("means_test")()
status = "changed" if not created else "created"
kwargs = {"created_by": user, "status": status, "context": {"state": obj.state}}
kwargs = self.get_means_test_event_kwargs(kwargs)
means_test_event.process(obj.case, **kwargs)
def test_CB4_errors(self):
dummy_case = make_recipe("legalaid.case", callback_attempt=3)
event = event_registry.get_event(self.EVENT_KEY)()
self.assertRaises(
ValueError, event.process, **{
"case": dummy_case,
"notes": "this is a note",
"created_by": self.dummy_user
})
self.assertEqual(dummy_case.log_set.count(), 0)
def create_diagnosis_log(self, obj, status):
try:
obj.case
except Case.DoesNotExist:
return
user = self.request.user
diagnosis_event = event_registry.get_event('diagnosis')()
patch = json.dumps(self.get_serializer_class()(obj).data)
kwargs = {'created_by': user, 'status': status, 'patch': patch}
diagnosis_event.process(obj.case, **kwargs)
def create_means_test_log(self, obj, created):
try:
obj.case
except Case.DoesNotExist:
return
user = self.request.user
means_test_event = event_registry.get_event('means_test')()
status = 'changed' if not created else 'created'
kwargs = {'created_by': user, 'status': status}
kwargs = self.get_means_test_event_kwargs(kwargs)
means_test_event.process(obj.case, **kwargs)
def test_CALLBACK_COMPLETE_errors_without_prev_CBx(self):
dummy_case = make_recipe("legalaid.case", callback_attempt=0)
event = event_registry.get_event(self.EVENT_KEY)()
self.assertRaises(
ValueError, event.process, **{
"case": dummy_case,
"notes": "this is a note",
"created_by": self.dummy_user,
"complete": True
})
self.assertEqual(dummy_case.log_set.count(), 0)
def clean_event_code(self):
code = self.cleaned_data.get("event_code")
if code:
if code == "RDSP":
# check that the case has really been assigned to a specialist
if not self.case.provider:
raise ValidationError("You can only use RDSP if the case is assigned to a specialist")
if code == "SAME":
# check that the client has really received alternative help
event = event_registry.get_event("alternative_help")
if not self.case.log_set.filter(code__in=event.codes.keys()).count():
raise ValidationError("You can only use SAME if the client has received alternative help")
return code
def clean_event_code(self):
code = self.cleaned_data.get("event_code")
if code:
if code == "RDSP":
# check that the case has really been assigned to a specialist
if not self.case.provider:
raise ValidationError("You can only use RDSP if the case is assigned to a specialist")
if code == "SAME":
# check that the client has really received alternative help
event = event_registry.get_event("alternative_help")
if not self.case.log_set.filter(code__in=event.codes.keys()).count():
raise ValidationError("You can only use SAME if the client has received alternative help")
return code
def create_diagnosis_log(self, obj, status):
try:
obj.case
except Case.DoesNotExist:
return
diagnosis_event = event_registry.get_event("diagnosis")()
patch = json.dumps(self.get_serializer_class()(obj).data)
kwargs = {
"created_by": self.get_current_user(),
"status": status,
"patch": patch
}
diagnosis_event.process(obj.case, **kwargs)
def post_save(self, obj, created=False):
if created:
description = u"Original expressions of dissatisfaction:\n%s\n\n%s" % (
u"\n".join(map(lambda desc: u"- %s" % desc, obj.eod.get_category_descriptions(include_severity=True))),
obj.eod.notes,
)
notes = u"Complaint created.\n\n{description}".format(description=description.strip()).strip()
event = event_registry.get_event("complaint")()
event.process(
obj.eod.case, created_by=self.request.user, notes=notes, complaint=obj, code="COMPLAINT_CREATED"
)
obj.eod.case.complaint_flag = True
obj.eod.case.save()
if getattr(obj, "_update_owner", False):
event = event_registry.get_event("complaint")()
event.process(
obj.eod.case,
created_by=self.request.user,
notes=u"Complaint owner set to %s" % (obj.owner.get_full_name() or obj.owner.username),
complaint=obj,
code="OWNER_SET",
)
def clean(self):
"""
Catches further validation errors before the save.
"""
cleaned_data = super(StopCallMeBackForm, self).clean()
if self._errors: # if already in error => skip
return cleaned_data
event = event_registry.get_event(self.get_event_key())()
try:
event.get_log_code(case=self.case, **self.get_kwargs())
except ValueError as e:
self._errors[NON_FIELD_ERRORS] = ErrorList([str(e)])
return cleaned_data
def clean(self):
"""
Catches further validation errors before the save.
"""
cleaned_data = super(StopCallMeBackForm, self).clean()
if self._errors: # if already in error => skip
return cleaned_data
event = event_registry.get_event(self.get_event_key())()
try:
event.get_log_code(case=self.case, **self.get_kwargs())
except ValueError as e:
self._errors[NON_FIELD_ERRORS] = ErrorList([str(e)])
return cleaned_data
def test_get_using_event_key(self):
response = self.client.get(self.detail_url,
HTTP_AUTHORIZATION="Bearer %s" % self.token,
format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
action = event_registry.get_event(self.get_event_key())
# building expected response data
codes = []
for code, code_data in action.codes.items():
codes.append({
"code": code,
"description": code_data["description"]
})
self.assertItemsEqual(response.data, codes)
def create_diagnosis_log(self, obj, status):
try:
obj.case
except Case.DoesNotExist:
return
user = self.request.user
diagnosis_event = event_registry.get_event('diagnosis')()
patch = json.dumps(self.get_serializer_class()(obj).data)
kwargs = {
'created_by': user,
'status': status,
'patch': patch
}
diagnosis_event.process(obj.case, **kwargs)
def create_means_test_log(self, obj, created):
try:
obj.case
except Case.DoesNotExist:
return
user = self.request.user
means_test_event = event_registry.get_event('means_test')()
status = 'changed' if not created else 'created'
kwargs = {
'created_by': user,
'status': status
}
kwargs = self.get_means_test_event_kwargs(kwargs)
means_test_event.process(obj.case, **kwargs)
def save(self, user):
code = self.get_event_code()
event = event_registry.get_event(self.get_event_key())()
code_data = event.codes[code]
val = super(RejectCaseForm, self).save(user)
# if requires_action by == None:
# mark case as closed (keep case.provider)
# else:
# reset provider (case not beloging to provider anymore)
if code_data.get('set_requires_action_by', False) == None:
self.case.close_by_provider()
else: # if requires_action_by == REQUIRES_ACTION_BY.OPERATOR
self.case.provider = None
self.case.save(update_fields=['provider'])
return val
def post_save(self, obj, created=False):
super(CaseViewSet, self).post_save(obj, created=created)
if created:
event = event_registry.get_event('case')()
event.process(obj,
status='created',
created_by=obj.created_by,
notes="Case created digitally")
if obj.requires_action_at:
form = WebCallMeBackForm(
case=obj,
data={},
requires_action_at=obj.requires_action_at)
if form.is_valid():
form.save(obj.created_by)
notify_callback_created(obj)
def post_save(self, obj, created=False):
super(CaseViewSet, self).post_save(obj, created=created)
if created:
event = event_registry.get_event('case')()
event.process(
obj, status='created', created_by=obj.created_by,
notes="Case created digitally"
)
if obj.requires_action_at:
form = WebCallMeBackForm(
case=obj, data={},
requires_action_at=obj.requires_action_at
)
if form.is_valid():
form.save(obj.created_by)
notify_callback_created(obj)
def create_means_test_log(self, obj, created):
try:
obj.case
except Case.DoesNotExist:
return
user = self.get_request_user()
means_test_event = event_registry.get_event("means_test")()
status = "changed" if not created else "created"
kwargs = {
"created_by": user,
"status": status,
"context": {
"state": obj.state
}
}
kwargs = self.get_means_test_event_kwargs(kwargs)
means_test_event.process(obj.case, **kwargs)
def test_CASE_VIEWED_log_created_after_CASE_VIEWED_if_no_timer(self):
event = event_registry.get_event(self.EVENT_KEY)()
# case viewed 1
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 1)
# case viewed 2
event.process(**{
'case': self.dummy_case,
'created_by': self.dummy_user,
'status': 'viewed'
})
self.assertEqual(Log.objects.count(), 2)
def test_select_selectable_code(self):
# get dict {event_key: [list of selectable codes]}
selectable_events = event_registry.get_selectable_events(role=LOG_ROLES.OPERATOR)
for chosen_key, chosen_codes in selectable_events.items():
for chosen_code in chosen_codes:
# chosen key / code
event = event_registry.get_event(chosen_key)()
res = event.process(
self.dummy_case,
code=chosen_code,
notes='selectable notes',
created_by=self.dummy_user)
self.assertLogEqual(res, Log(case=self.dummy_case,
code=chosen_code,
type=LOG_TYPES.OUTCOME,
notes='selectable notes',
level=event.codes[chosen_code]['level'],
created_by=self.dummy_user))
def test_stops_timer(self):
if not self.EVENT_KEY:
return
event = event_registry.get_event(self.EVENT_KEY)()
for code, code_data in event.codes.items():
user = make_user()
timer = make_recipe("timer.Timer", created_by=user)
res = event.process(
**{"case": self.dummy_case, "code": code, "notes": "this is a note", "created_by": user}
)
timer = Timer.objects.get(pk=timer.pk)
if code_data["stops_timer"]:
self.assertTrue(timer.is_stopped())
self.assertEqual(res.timer, timer)
else:
self.assertFalse(timer.is_stopped())
self.assertEqual(res.timer, timer)
def save(self, user):
category = self.cleaned_data['category']
matter_type1 = self.cleaned_data['matter_type1']
matter_type2 = self.cleaned_data['matter_type2']
internal = self.cleaned_data['internal']
self.new_case = self.case.split(
user=user, category=category,
matter_type1=matter_type1, matter_type2=matter_type2,
assignment_internal=internal
)
# create 'creat event' for new case
event = event_registry.get_event('case')()
event.process(
self.new_case, status='created',
created_by=self.new_case.created_by,
notes="Case created by Specialist"
)
super(SplitCaseForm, self).save(user)
return self.new_case
def pre_save(self, obj):
super(FullCaseViewSet, self).pre_save(obj)
if obj.pk:
if "notes" in obj.changed_fields:
cnh = CaseNotesHistory(case=obj)
cnh.operator_notes = obj.notes
cnh.created_by = self.request.user
cnh.save()
if "provider_notes" in obj.changed_fields:
cpnh = CaseNotesHistory(case=obj)
cpnh.provider_notes = obj.provider_notes
cpnh.created_by = self.request.user
cpnh.save()
if "complaint_flag" in obj.changed_fields:
event = event_registry.get_event("case")()
event.process(
obj,
status="complaint_flag_toggled",
created_by=self.request.user,
notes="Complaint flag toggled: %s" % obj.complaint_flag,
)
def _test_process_with_expicit_code(
self,
expected_available_codes,
expected_type=LOG_TYPES.OUTCOME,
expected_level=LOG_LEVELS.HIGH,
process_kwargs={},
code=None,
):
event = event_registry.get_event(self.EVENT_KEY)()
codes = event.codes.keys()
self.assertItemsEqual(codes, expected_available_codes)
# building process params and overridding potential ones through process_kwargs
chosen_code = code or codes[0]
_process_kwargs = {
"case": self.dummy_case,
"code": chosen_code,
"notes": "this is a note",
"created_by": self.dummy_user,
}
_process_kwargs.update(process_kwargs)
res = event.process(**_process_kwargs)
# testing that everything worked
self.assertLogEqual(
res,
Log(
case=_process_kwargs["case"],
code=_process_kwargs["code"],
type=expected_type,
notes=_process_kwargs["notes"],
level=expected_level,
created_by=_process_kwargs["created_by"],
),
)
