Example #1
0
    def testCouchSyncToSQL(self):
        self.deleteAllLogs()
        self.assertEqual(self.getCouchCount(), 0)
        self.assertEqual(self.getSQLCount(), 0)

        # Test Create
        couch_obj = ExpectedCallbackEventLog()
        self.setRandomCouchObjectValues(couch_obj)
        couch_obj.save()

        sleep(1)
        self.assertEqual(self.getCouchCount(), 1)
        self.assertEqual(self.getSQLCount(), 1)

        sql_obj = ExpectedCallback.objects.get(couch_id=couch_obj._id)
        self.checkFieldValues(couch_obj, sql_obj, ExpectedCallback._migration_get_fields())
        self.assertTrue(ExpectedCallbackEventLog.get_db().get_rev(couch_obj._id).startswith('1-'))

        # Test Update
        self.setRandomCouchObjectValues(couch_obj)
        couch_obj.save()

        sleep(1)
        self.assertEqual(self.getCouchCount(), 1)
        self.assertEqual(self.getSQLCount(), 1)
        sql_obj = ExpectedCallback.objects.get(couch_id=couch_obj._id)
        self.checkFieldValues(couch_obj, sql_obj, ExpectedCallback._migration_get_fields())
        self.assertTrue(ExpectedCallbackEventLog.get_db().get_rev(couch_obj._id).startswith('2-'))
Example #2
0
def fire_sms_callback_event(reminder, handler, recipients, verified_numbers, logged_event):
    current_event = reminder.current_event

    for recipient in recipients:
        send_message = False
        if reminder.callback_try_count > 0:
            if reminder.event_initiation_timestamp:
                event = ExpectedCallback.by_domain_recipient_date(
                    reminder.domain,
                    recipient.get_id,
                    reminder.event_initiation_timestamp
                )
                if not event:
                    continue
                if event.status == CALLBACK_RECEIVED:
                    continue
                if Call.inbound_entry_exists(
                    recipient.doc_type,
                    recipient.get_id,
                    reminder.event_initiation_timestamp
                ):
                    event.status = CALLBACK_RECEIVED
                    event.save()
                    continue
            else:
                continue

            if (reminder.callback_try_count >=
                len(current_event.callback_timeout_intervals)):
                # On the last callback timeout, instead of sending the SMS
                # again, log the missed callback
                if event:
                    event.status = CALLBACK_MISSED
                    event.save()
            else:
                send_message = True
        else:
            # It's the first time sending the sms, so create an expected
            # callback event
            send_message = True
            event = ExpectedCallback.objects.create(
                domain=reminder.domain,
                date=reminder.event_initiation_timestamp,
                couch_recipient_doc_type=recipient.doc_type,
                couch_recipient=recipient.get_id,
                status=CALLBACK_PENDING,
            )

        if send_message:
            fire_sms_event(reminder, handler, [recipient], verified_numbers,
                logged_event, workflow=WORKFLOW_CALLBACK)
def fire_sms_callback_event(reminder, handler, recipients, verified_numbers,
                            logged_event):
    current_event = reminder.current_event

    for recipient in recipients:
        send_message = False
        if reminder.callback_try_count > 0:
            if reminder.event_initiation_timestamp:
                event = ExpectedCallback.by_domain_recipient_date(
                    reminder.domain, recipient.get_id,
                    reminder.event_initiation_timestamp)
                if not event:
                    continue
                if event.status == CALLBACK_RECEIVED:
                    continue
                if Call.inbound_entry_exists(
                        recipient.doc_type, recipient.get_id,
                        reminder.event_initiation_timestamp):
                    event.status = CALLBACK_RECEIVED
                    event.save()
                    continue
            else:
                continue

            if (reminder.callback_try_count >= len(
                    current_event.callback_timeout_intervals)):
                # On the last callback timeout, instead of sending the SMS
                # again, log the missed callback
                if event:
                    event.status = CALLBACK_MISSED
                    event.save()
            else:
                send_message = True
        else:
            # It's the first time sending the sms, so create an expected
            # callback event
            send_message = True
            event = ExpectedCallback.objects.create(
                domain=reminder.domain,
                date=reminder.event_initiation_timestamp,
                couch_recipient_doc_type=recipient.doc_type,
                couch_recipient=recipient.get_id,
                status=CALLBACK_PENDING,
            )

        if send_message:
            fire_sms_event(reminder,
                           handler, [recipient],
                           verified_numbers,
                           logged_event,
                           workflow=WORKFLOW_CALLBACK)
Example #4
0
 def rows(self):
     data = ExpectedCallback.by_domain(
         self.domain,
         start_date=self.datespan.startdate_utc,
         end_date=self.datespan.enddate_utc
     ).order_by('date')
     result = []
     
     status_descriptions = {
         CALLBACK_PENDING : _("Pending"),
         CALLBACK_RECEIVED : _("Received"),
         CALLBACK_MISSED : _("Missed"),
     }
     
     # Store the results of lookups for faster loading
     username_map = {} 
     
     for event in data:
         recipient_id = event.couch_recipient
         if recipient_id in [None, ""]:
             username = "******"
         elif recipient_id in username_map:
             username = username_map.get(recipient_id)
         else:
             username = "******"
             try:
                 if event.couch_recipient_doc_type == "CommCareCase":
                     username = CommCareCase.get(recipient_id).name
                 else:
                     username = CouchUser.get_by_user_id(recipient_id).username
             except Exception:
                 pass
            
             username_map[recipient_id] = username
         
         timestamp = ServerTime(event.date).user_time(self.timezone).done()
         
         row = [
             self._fmt_timestamp(timestamp),
             self._fmt(username),
             self._fmt(status_descriptions.get(event.status, "-")),
         ]
         
         result.append(row)
     
     return result
Example #5
0
    def rows(self):
        data = ExpectedCallback.by_domain(
            self.domain,
            start_date=self.datespan.startdate_utc,
            end_date=self.datespan.enddate_utc).order_by('date')
        result = []

        status_descriptions = {
            CALLBACK_PENDING: _("Pending"),
            CALLBACK_RECEIVED: _("Received"),
            CALLBACK_MISSED: _("Missed"),
        }

        # Store the results of lookups for faster loading
        username_map = {}

        for event in data:
            recipient_id = event.couch_recipient
            if recipient_id in [None, ""]:
                username = "******"
            elif recipient_id in username_map:
                username = username_map.get(recipient_id)
            else:
                username = "******"
                try:
                    if event.couch_recipient_doc_type == "CommCareCase":
                        username = CommCareCase.get(recipient_id).name
                    else:
                        username = CouchUser.get_by_user_id(
                            recipient_id).username
                except Exception:
                    pass

                username_map[recipient_id] = username

            timestamp = ServerTime(event.date).user_time(self.timezone).done()

            row = [
                self._fmt_timestamp(timestamp),
                self._fmt(username),
                self._fmt(status_descriptions.get(event.status, "-")),
            ]

            result.append(row)

        return result
Example #6
0
    def rows(self):
        group_id = None
        if self.request.couch_user.is_commcare_user():
            group_ids = self.request.couch_user.get_group_ids()
            if len(group_ids) > 0:
                group_id = group_ids[0]

        data = {}

        for case in get_cases_in_domain(self.domain, type='participant'):
            if case.closed:
                continue

            # If a site coordinator is viewing the report, only show participants from that site (group)
            if group_id is None or group_id == case.owner_id:
                timezone = pytz.timezone(case.get_case_property("time_zone"))
                data[case._id] = {
                    "name": case.name,
                    "time_zone": timezone,
                    "dates": [None] * 14,
                }

        dates = self.get_past_two_weeks()
        date_strings = [json_format_date(date) for date in dates]

        start_date = dates[0] - timedelta(days=1)
        end_date = dates[-1] + timedelta(days=2)

        expected_callback_events = ExpectedCallback.by_domain(
            self.domain,
            start_date=datetime.combine(start_date, time(0, 0)),
            end_date=datetime.combine(end_date, time(0, 0))).order_by('date')

        for event in expected_callback_events:
            if event.couch_recipient in data:
                timezone = data[event.couch_recipient]["time_zone"]
                event_date = (ServerTime(
                    event.date).user_time(timezone).ui_string("%Y-%m-%d"))
                if event_date in date_strings:
                    data[event.couch_recipient]["dates"][date_strings.index(
                        event_date)] = event.status

        result = []
        for case_id, data_dict in data.items():
            row = [
                self._fmt(data_dict["name"]),
                None,
                None,
                None,
            ]

            total_no_response = 0
            total_indicated = 0
            total_pending = 0

            for date_status in data_dict["dates"]:
                if date_status == CALLBACK_PENDING:
                    total_indicated += 1
                    total_pending += 1
                    row.append(self._fmt(_("pending")))
                elif date_status == CALLBACK_RECEIVED:
                    total_indicated += 1
                    row.append(self._fmt(_("OK")))
                elif date_status == CALLBACK_MISSED:
                    total_indicated += 1
                    total_no_response += 1
                    row.append(self._fmt_highlight(_("No Response")))
                else:
                    row.append(self._fmt(_("not indicated")))

            if total_no_response > 0:
                row[1] = self._fmt_highlight(total_no_response)
            else:
                row[1] = self._fmt(total_no_response)
            row[2] = self._fmt(total_indicated)
            row[3] = self._fmt(total_pending)

            result.append(row)

        return result
Example #7
0
    def rows(self):
        group_id = None
        if self.request.couch_user.is_commcare_user():
            group_ids = self.request.couch_user.get_group_ids()
            if len(group_ids) > 0:
                group_id = group_ids[0]

        data = {}

        for case in get_cases_in_domain(self.domain, type='participant'):
            if case.closed:
                continue

            # If a site coordinator is viewing the report, only show participants from that site (group)
            if group_id is None or group_id == case.owner_id:
                timezone = pytz.timezone(case.get_case_property("time_zone"))
                data[case._id] = {
                    "name": case.name,
                    "time_zone": timezone,
                    "dates": [None] * 14,
                }

        dates = self.get_past_two_weeks()
        date_strings = [json_format_date(date) for date in dates]

        start_date = dates[0] - timedelta(days=1)
        end_date = dates[-1] + timedelta(days=2)

        expected_callback_events = ExpectedCallback.by_domain(
            self.domain,
            start_date=datetime.combine(start_date, time(0, 0)),
            end_date=datetime.combine(end_date, time(0, 0))
        ).order_by('date')

        for event in expected_callback_events:
            if event.couch_recipient in data:
                timezone = data[event.couch_recipient]["time_zone"]
                event_date = (ServerTime(event.date).user_time(timezone)
                              .ui_string("%Y-%m-%d"))
                if event_date in date_strings:
                    data[event.couch_recipient]["dates"][date_strings.index(event_date)] = event.status

        result = []
        for case_id, data_dict in data.items():
            row = [
                self._fmt(data_dict["name"]),
                None,
                None,
                None,
            ]
            
            total_no_response = 0
            total_indicated = 0
            total_pending = 0
            
            for date_status in data_dict["dates"]:
                if date_status == CALLBACK_PENDING:
                    total_indicated += 1
                    total_pending += 1
                    row.append(self._fmt(_("pending")))
                elif date_status == CALLBACK_RECEIVED:
                    total_indicated += 1
                    row.append(self._fmt(_("OK")))
                elif date_status == CALLBACK_MISSED:
                    total_indicated += 1
                    total_no_response += 1
                    row.append(self._fmt_highlight(_("No Response")))
                else:
                    row.append(self._fmt(_("not indicated")))
            
            if total_no_response > 0:
                row[1] = self._fmt_highlight(total_no_response)
            else:
                row[1] = self._fmt(total_no_response)
            row[2] = self._fmt(total_indicated)
            row[3] = self._fmt(total_pending)
            
            result.append(row)
        
        return result
 def get_expected_callback(self, date, recipient_id):
     return ExpectedCallback.by_domain_recipient_date(
         self.domain,
         recipient_id,
         date
     )