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 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 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 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 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"], ), )