def test_no_cases_owned_by_user(self, mock):
"""
Test to verify that only data belonging to users managed by the supervisor is returned.
"""
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user_no_data,
custom_cache=locmem_cache)
self.assertEqual(list(indicator_set.user_to_case_map), [])
self.assertEqual(indicator_set.users_needing_data, set())
self.assertEqual(indicator_set.owners_needing_data, set())
self.assertEqual(indicator_set.get_data(), {})
def test_users_assigned_via_group(self, mock):
# Ensure that users who are assigned to the supervisor via a group are also included
# in final data set.
indicator_set = CallCenterIndicators(
self.domain.name,
self.domain.default_timezone,
self.domain.call_center_config.case_type,
self.supervisor,
custom_cache=locmem_cache
)
self.assertEqual(list(indicator_set.user_to_case_map), [self.user.get_id])
self.assertEqual(indicator_set.users_needing_data, set([self.user.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.user.get_id]))
self._test_indicators(self.user, indicator_set.get_data(), expected_standard_indicators())
def test_sync_log(self):
user_case = CaseAccessors(self.cc_domain.name).get_case_by_domain_hq_user_id(self.cc_user.get_id, CASE_TYPE)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
override_cases=[CallCenterCase.from_case(user_case)]
)
self.assertEqual(indicator_set.user_to_case_map.keys(), [self.cc_user.get_id])
self.assertEqual(indicator_set.users_needing_data, set([self.cc_user.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user.get_id]))
self._test_indicators(self.cc_user, indicator_set.get_data(), expected_standard_indicators())
def test_standard_indicators_no_legacy(self):
config = CallCenterIndicatorConfig.default_config(include_legacy=False)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
indicator_config=config
)
self._test_indicators(
self.cc_user,
indicator_set.get_data(),
expected_standard_indicators(include_legacy=False))
def test_standard_indicators(self):
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache
)
self.assertEqual(
set(indicator_set.user_to_case_map.keys()),
set([self.cc_user.get_id, self.cc_user_no_data.get_id])
)
self.assertEqual(indicator_set.users_needing_data, set([self.cc_user.get_id, self.cc_user_no_data.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user.get_id, self.cc_user_no_data.get_id]))
self.check_cc_indicators(indicator_set.get_data(), expected_standard_indicators())
def test_cases_owned_by_group(self, mock):
# Ensure that indicators include cases owned by a case sharing group the user is part of.
indicator_set = CallCenterIndicators(
self.domain.name,
self.domain.default_timezone,
self.domain.call_center_config.case_type,
self.supervisor,
custom_cache=locmem_cache
)
self.assertEqual(list(indicator_set.user_to_case_map), [self.user.get_id])
self.assertEqual(indicator_set.users_needing_data, set([self.user.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.user.get_id, self.group.get_id]))
expected = expected_standard_indicators()
expected['totalCases'] = 0 # no cases with user_id = self.user.get_id
self._test_indicators(self.user, indicator_set.get_data(), expected)
def test_opened_closed(self, mock):
"""
Test that cases_closed and cases_opened indicators count based on the user that
opened / closed the case and not the case owner.
"""
indicator_set = CallCenterIndicators(
self.domain.name,
self.domain.default_timezone,
self.domain.call_center_config.case_type,
self.supervisor,
custom_cache=locmem_cache)
expected = expected_standard_indicators()
# cases opened / closed by another user so expect 0
for key in expected:
if key.startswith('cases_opened') or key.startswith(
'cases_closed'):
expected[key] = 0
self._test_indicators(self.user, indicator_set.get_data(), expected)
def test_standard_indicators_case_totals_only(self, mock):
config = CallCenterIndicatorConfig.default_config(include_legacy=False)
config.cases_total.all_types = False
config.cases_opened.all_types = False
config.cases_closed.all_types = False
config.cases_active.all_types = False
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
indicator_config=config)
self._test_indicators(
self.cc_user, indicator_set.get_data(),
expected_standard_indicators(include_legacy=False,
include_totals=True,
case_types=[]))
def test_standard_indicators_case_week1_only(self, mock):
config = CallCenterIndicatorConfig.default_config(include_legacy=False)
config.forms_submitted.date_ranges = {WEEK1}
config.cases_total.totals.date_ranges = {WEEK1}
config.cases_opened.totals.date_ranges = {WEEK1}
config.cases_closed.totals.date_ranges = {WEEK1}
config.cases_active.totals.date_ranges = {WEEK1}
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
indicator_config=config)
self._test_indicators(
self.cc_user, indicator_set.get_data(),
expected_standard_indicators(include_legacy=False,
include_totals=True,
limit_ranges=[WEEK1]))
def calculate_indicators():
"""
Although this task runs every 15 minutes it only re-calculates the
indicators for a domain if we're within 15 minutes after midnight in
the domain's timezone.
"""
domains = [
domain for domain in get_call_center_domains()
for midnight in domain.midnights
if is_midnight_for_domain(midnight, error_margin=20)
]
logger.info(
"Calculating callcenter indicators for domains:\n{}".format(domains))
for domain in domains:
all_cases = get_call_center_cases(domain.name, domain.cc_case_type)
indicator_set = CallCenterIndicators(domain.name,
domain.default_timezone,
domain.cc_case_type,
user=None,
override_cases=all_cases,
override_cache=True)
indicator_set.get_data()
def callcenter_test(request):
user_id = request.GET.get("user_id")
date_param = request.GET.get("date")
enable_caching = request.GET.get('cache')
doc_id = request.GET.get('doc_id')
if not user_id and not doc_id:
return render(request, "hqadmin/callcenter_test.html", {"enable_caching": enable_caching})
error = None
user = None
user_case = None
domain = None
if user_id:
try:
user = CommCareUser.get(user_id)
domain = user.project
except ResourceNotFound:
error = "User Not Found"
elif doc_id:
try:
doc = CommCareUser.get_db().get(doc_id)
domain = Domain.get_by_name(doc['domain'])
doc_type = doc.get('doc_type', None)
if doc_type == 'CommCareUser':
case_type = domain.call_center_config.case_type
user_case = CaseAccessors(doc['domain']).get_case_by_domain_hq_user_id(doc['_id'], case_type)
elif doc_type == 'CommCareCase':
if doc.get('hq_user_id'):
user_case = CommCareCase.wrap(doc)
else:
error = 'Case ID does does not refer to a Call Center Case'
except ResourceNotFound:
error = "User Not Found"
try:
query_date = dateutil.parser.parse(date_param)
except ValueError:
error = "Unable to parse date, using today"
query_date = date.today()
def view_data(case_id, indicators):
new_dict = OrderedDict()
key_list = sorted(indicators)
for key in key_list:
new_dict[key] = indicators[key]
return {
'indicators': new_dict,
'case': CommCareCase.get(case_id),
}
if user or user_case:
custom_cache = None if enable_caching else cache.caches['dummy']
override_case = CallCenterCase.from_case(user_case)
cci = CallCenterIndicators(
domain.name,
domain.default_timezone,
domain.call_center_config.case_type,
user,
custom_cache=custom_cache,
override_date=query_date,
override_cases=[override_case] if override_case else None
)
data = {case_id: view_data(case_id, values) for case_id, values in cci.get_data().items()}
else:
data = {}
context = {
"error": error,
"mobile_user": user,
"date": json_format_date(query_date),
"enable_caching": enable_caching,
"data": data,
"doc_id": doc_id
}
return render(request, "hqadmin/callcenter_test.html", context)
expected.update(get_indicators('cases_total', [0L, 0L, 0L, 0L]))
expected.update(get_indicators('cases_opened', [0L, 0L, 0L, 0L]))
expected.update(get_indicators('cases_closed', [0L, 0L, 0L, 0L]))
expected.update(get_indicators('cases_active', [0L, 0L, 0L, 0L]))
# custom
expected.update(
get_indicators('motherForms', [3L, 3L, 9L, 0L], is_legacy=True))
expected.update(
get_indicators('childForms', [0L, 0L, 0L, 0L], is_legacy=True))
expected.update(
get_indicators('motherDuration', [3L, 4L, 4L, 0L], is_legacy=True))
indicator_set = CallCenterIndicators(
self.aarohi_domain.name,
self.aarohi_domain.default_timezone,
self.aarohi_domain.call_center_config.case_type,
self.aarohi_user,
custom_cache=locmem_cache)
self._test_indicators(self.aarohi_user, indicator_set.get_data(),
expected)
def test_caching(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name,
self.cc_user._id, CASE_TYPE)
expected_indicators = {'a': 1, 'b': 2}
cached_data = CachedIndicators(user_id=self.cc_user.get_id,
case_id=user_case.case_id,
domain=self.cc_domain.name,
indicators=expected_indicators)
indicator_set = CallCenterIndicators(
