def get_reports(self, domain=None):
attr_name = self.map_name
from corehq import reports
if domain:
project = Domain.get_by_name(domain)
else:
project = None
def process(reports):
if project and callable(reports):
reports = reports(project)
return tuple(reports)
corehq_reports = process(getattr(reports, attr_name, ()))
module_name = get_domain_module_map().get(domain)
if module_name is None:
custom_reports = ()
else:
module = __import__(module_name, fromlist=['reports'])
if hasattr(module, 'reports'):
reports = getattr(module, 'reports')
custom_reports = process(getattr(reports, attr_name, ()))
else:
custom_reports = ()
# soon to be removed
if not custom_reports:
domain_module = Domain.get_module_by_name(domain)
custom_reports = process(getattr(domain_module, attr_name, ()))
return corehq_reports + custom_reports
def get_reports(self, domain=None):
attr_name = self.map_name
from corehq import reports
if domain:
project = Domain.get_by_name(domain)
else:
project = None
def process(reports):
if project and callable(reports):
reports = reports(project)
return tuple(reports)
corehq_reports = process(getattr(reports, attr_name, ()))
module_name = get_domain_module_map().get(domain)
if module_name is None:
custom_reports = ()
else:
module = __import__(module_name, fromlist=['reports'])
if hasattr(module, 'reports'):
reports = getattr(module, 'reports')
custom_reports = process(getattr(reports, attr_name, ()))
else:
custom_reports = ()
# soon to be removed
if not custom_reports:
domain_module = Domain.get_module_by_name(domain)
custom_reports = process(getattr(domain_module, attr_name, ()))
return corehq_reports + custom_reports
def get_reports(self, domain):
attr_name = self.map_name
from corehq import reports
if domain:
domain_obj = Domain.get_by_name(domain)
else:
domain_obj = None
def process(reports):
if callable(reports):
reports = reports(domain_obj) if domain_obj else tuple()
return tuple(reports)
corehq_reports = process(getattr(reports, attr_name, ()))
module_name = settings.DOMAIN_MODULE_MAP.get(domain)
if module_name is None:
custom_reports = ()
else:
module = __import__(module_name, fromlist=['reports' if six.PY3 else b'reports'])
if hasattr(module, 'reports'):
reports = getattr(module, 'reports')
custom_reports = process(getattr(reports, attr_name, ()))
else:
custom_reports = ()
# soon to be removed
if not custom_reports:
domain_module = Domain.get_module_by_name(domain)
custom_reports = process(getattr(domain_module, attr_name, ()))
return corehq_reports + custom_reports
def render(self, context):
request = context['request']
current_url_name = context['current_url_name']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = getattr(module, 'TABS', MENU_TABS)
visible_tabs = []
for tab_class in tabs:
t = tab_class(
request, current_url_name, domain=domain,
couch_user=couch_user, project=project, org=org)
t.is_active_tab = False
if t.real_is_viewable:
visible_tabs.append(t)
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = get_active_tab(visible_tabs,
request.get_full_path())
return mark_safe(render_to_string('style/includes/menu_main.html', {
'tabs': visible_tabs,
}))
def render(self, context):
request = context["request"]
couch_user = getattr(request, "couch_user", None)
project = getattr(request, "project", None)
domain = context.get("domain")
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, "TABS", ())
visible_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(request, domain=domain, couch_user=couch_user, project=project)
if t.real_is_viewable:
visible_tabs.append(t)
if t.is_active:
active_tab = t
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]["active_tab"] = active_tab
return mark_safe(
render_to_string("hqwebapp/partials/main_menu.html", {"tabs": visible_tabs, "active_tab": active_tab})
)
def render(self, context):
request = context['request']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, 'TABS', ())
visible_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(
request, domain=domain, couch_user=couch_user, project=project, org=org)
if t.real_is_viewable:
visible_tabs.append(t)
if t.is_active:
active_tab = t
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = active_tab
return mark_safe(render_to_string("hqwebapp/partials/main_menu.html", {
'tabs': visible_tabs,
'active_tab': active_tab,
}))
def render(self, context):
request = context["request"]
current_url_name = context["current_url_name"]
couch_user = getattr(request, "couch_user", None)
project = getattr(request, "project", None)
domain = context.get("domain")
org = context.get("org")
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, "TABS", ())
visible_tabs = []
all_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(request, current_url_name, domain=domain, couch_user=couch_user, project=project, org=org)
t.is_active_tab = False
all_tabs.append(t)
if t.real_is_viewable:
visible_tabs.append(t)
# only highlight the first tab considered active. This allows
# multiple tabs to contain the same sidebar item, but in all but
# the first it will effectively be a link to the other tabs.
for t in all_tabs:
if t.is_active_fast:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in all_tabs:
if t.is_active:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in visible_tabs:
if t.url and request.get_full_path().startswith(t.url):
active_tab = t
break
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]["active_tab"] = active_tab
return mark_safe(render_to_string("hqwebapp/partials/main_menu.html", {"tabs": visible_tabs}))
def get_reports(self, domain=None):
attr_name = self.map_name
import corehq
domain_module = Domain.get_module_by_name(domain)
corehq_reports = tuple(getattr(corehq, attr_name, ()))
custom_reports = getattr(domain_module, attr_name, ())
if isinstance(custom_reports, dict):
custom_reports = custom_reports[domain]
custom_reports = tuple(custom_reports)
return corehq_reports + custom_reports
def get_reports(self, domain=None):
attr_name = self.map_name
import corehq
domain_module = Domain.get_module_by_name(domain)
corehq_reports = tuple(getattr(corehq, attr_name, ()))
custom_reports = getattr(domain_module, attr_name, ())
if isinstance(custom_reports, dict):
custom_reports = custom_reports[domain]
custom_reports = tuple(custom_reports)
return corehq_reports + custom_reports
def get_reports(self, domain=None):
attr_name = self.map_name
import corehq
domain_module = Domain.get_module_by_name(domain)
if domain:
project = Domain.get_by_name(domain)
else:
project = None
def process(reports):
if project and callable(reports):
reports = reports(project)
return tuple(reports)
corehq_reports = process(getattr(corehq, attr_name, ()))
custom_reports = process(getattr(domain_module, attr_name, ()))
return corehq_reports + custom_reports
def get_reports(self, domain=None):
attr_name = self.map_name
import corehq
domain_module = Domain.get_module_by_name(domain)
if domain:
project = Domain.get_by_name(domain)
else:
project = None
def process(reports):
if project and callable(reports):
reports = reports(project)
return tuple(reports)
corehq_reports = process(getattr(corehq, attr_name, ()))
custom_reports = process(getattr(domain_module, attr_name, ()))
return corehq_reports + custom_reports
def render(self, context):
request = context['request']
current_url_name = context['current_url_name']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = getattr(module, 'TABS', corehq.TABS)
visible_tabs = []
for tab_class in tabs:
t = tab_class(request,
current_url_name,
domain=domain,
couch_user=couch_user,
project=project,
org=org)
t.is_active_tab = False
if t.real_is_viewable:
visible_tabs.append(t)
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = get_active_tab(
visible_tabs, request.get_full_path())
template = {
style_utils.BOOTSTRAP_2:
'style/bootstrap2/partials/menu_main.html',
style_utils.BOOTSTRAP_3:
'style/bootstrap3/partials/menu_main.html',
}[style_utils.get_bootstrap_version()]
return mark_safe(render_to_string(template, {
'tabs': visible_tabs,
}))
def render(self, context):
request = context['request']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, 'TABS', ())
visible_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(request,
domain=domain,
couch_user=couch_user,
project=project,
org=org)
if t.real_is_viewable:
visible_tabs.append(t)
if t.is_active:
active_tab = t
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = active_tab
return mark_safe(
render_to_string("hqwebapp/partials/main_menu.html", {
'tabs': visible_tabs,
'active_tab': active_tab,
}))
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
report_set = None
if project.report_whitelist:
report_set = set(project.report_whitelist)
reports = []
reports.extend(_get_configurable_reports(project))
monitoring_reports = (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
ProjectHealthDashboard,
)
inspect_reports = [
inspect.SubmitHistory,
CaseListReport,
OdmExportReport,
]
if toggles.CASE_LIST_EXPLORER.enabled(project.name):
inspect_reports.append(CaseListExplorer)
deployments_reports = (
deployments.ApplicationStatusReport,
deployments.AggregateUserStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.DeviceLogDetailsReport,
deployments.ApplicationErrorReport,
)
monitoring_reports = _filter_reports(report_set, monitoring_reports)
inspect_reports = _filter_reports(report_set, inspect_reports)
deployments_reports = _filter_reports(report_set, deployments_reports)
reports.extend([
(ugettext_lazy("Monitor Workers"), monitoring_reports),
(ugettext_lazy("Inspect Data"), inspect_reports),
(ugettext_lazy("Manage Deployments"), deployments_reports),
])
if project.commtrack_enabled:
supply_reports = (
commtrack.SimplifiedInventoryReport,
commtrack.InventoryReport,
commtrack.CurrentStockStatusReport,
commtrack.StockStatusMapReport,
)
if not should_use_sql_backend(project):
supply_reports = supply_reports + (
commtrack.ReportingRatesReport,
commtrack.ReportingStatusMapReport,
)
supply_reports = _filter_reports(report_set, supply_reports)
reports.insert(0, (ugettext_lazy("CommCare Supply"), supply_reports))
reports = list(_get_report_builder_reports(project)) + reports
from corehq.apps.accounting.utils import domain_has_privilege
messaging_reports = []
project_can_use_sms = domain_has_privilege(project.name,
privileges.OUTBOUND_SMS)
if project_can_use_sms:
messaging_reports.extend([
sms.MessagesReport,
])
# always have these historical reports visible
messaging_reports.extend([
sms.MessagingEventsReport,
sms.MessageEventDetailReport,
sms.SurveyDetailReport,
sms.MessageLogReport,
sms.SMSOptOutReport,
ivr.CallReport,
ivr.ExpectedCallbackReport,
sms.PhoneNumberReport,
sms.ScheduleInstanceReport,
])
messaging_reports += getattr(Domain.get_module_by_name(project.name),
'MESSAGING_REPORTS', ())
messaging_reports = _filter_reports(report_set, messaging_reports)
messaging = (ugettext_lazy("Messaging"), messaging_reports)
reports.append(messaging)
reports.extend(_get_dynamic_reports(project))
return reports
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
report_set = None
if project.report_whitelist:
report_set = set(project.report_whitelist)
reports = []
reports.extend(_get_configurable_reports(project))
monitoring_reports = (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
ProjectHealthDashboard,
)
inspect_reports = [
inspect.SubmitHistory, CaseListReport, OdmExportReport,
]
if toggles.CASE_LIST_EXPLORER.enabled(project.name):
inspect_reports.append(CaseListExplorer)
deployments_reports = (
deployments.ApplicationStatusReport,
deployments.AggregateUserStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.DeviceLogDetailsReport,
deployments.ApplicationErrorReport,
)
monitoring_reports = _filter_reports(report_set, monitoring_reports)
inspect_reports = _filter_reports(report_set, inspect_reports)
deployments_reports = _filter_reports(report_set, deployments_reports)
reports.extend([
(ugettext_lazy("Monitor Workers"), monitoring_reports),
(ugettext_lazy("Inspect Data"), inspect_reports),
(ugettext_lazy("Manage Deployments"), deployments_reports),
])
if project.commtrack_enabled:
supply_reports = (
commtrack.SimplifiedInventoryReport,
commtrack.InventoryReport,
commtrack.CurrentStockStatusReport,
commtrack.StockStatusMapReport,
)
if not should_use_sql_backend(project):
supply_reports = supply_reports + (
commtrack.ReportingRatesReport,
commtrack.ReportingStatusMapReport,
)
supply_reports = _filter_reports(report_set, supply_reports)
reports.insert(0, (ugettext_lazy("CommCare Supply"), supply_reports))
reports = list(_get_report_builder_reports(project)) + reports
from corehq.apps.accounting.utils import domain_has_privilege
messaging_reports = []
project_can_use_sms = domain_has_privilege(project.name, privileges.OUTBOUND_SMS)
if project_can_use_sms:
messaging_reports.extend([
sms.MessagesReport,
])
# always have these historical reports visible
messaging_reports.extend([
sms.MessagingEventsReport,
sms.MessageEventDetailReport,
sms.SurveyDetailReport,
sms.MessageLogReport,
sms.SMSOptOutReport,
ivr.CallReport,
ivr.ExpectedCallbackReport,
sms.PhoneNumberReport,
sms.ScheduleInstanceReport,
])
messaging_reports += getattr(Domain.get_module_by_name(project.name), 'MESSAGING_REPORTS', ())
messaging_reports = _filter_reports(report_set, messaging_reports)
messaging = (ugettext_lazy("Messaging"), messaging_reports)
reports.append(messaging)
reports.extend(_get_dynamic_reports(project))
return reports
def render(self, context):
request = context['request']
current_url_name = context['current_url_name']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, 'TABS', ())
visible_tabs = []
all_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(request,
current_url_name,
domain=domain,
couch_user=couch_user,
project=project,
org=org)
t.is_active_tab = False
all_tabs.append(t)
if t.real_is_viewable:
visible_tabs.append(t)
# only highlight the first tab considered active. This allows
# multiple tabs to contain the same sidebar item, but in all but
# the first it will effectively be a link to the other tabs.
for t in all_tabs:
if t.is_active_fast:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in all_tabs:
if t.is_active:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in visible_tabs:
if t.url and request.get_full_path().startswith(t.url):
active_tab = t
break
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = active_tab
return mark_safe(
render_to_string("hqwebapp/partials/main_menu.html", {
'tabs': visible_tabs,
}))
def get_reports(self, domain=None):
attr_name = self.map_name
import corehq
return getattr(corehq, attr_name, ()) + \
getattr(Domain.get_module_by_name(domain), attr_name, ())
def render(self, context):
request = context['request']
current_url_name = context['current_url_name']
couch_user = getattr(request, 'couch_user', None)
project = getattr(request, 'project', None)
domain = context.get('domain')
org = context.get('org')
try:
module = Domain.get_module_by_name(domain)
except (ValueError, AttributeError):
module = None
tabs = corehq.TABS + getattr(module, 'TABS', ())
visible_tabs = []
all_tabs = []
active_tab = None
for tab_class in tabs:
t = tab_class(
request, current_url_name, domain=domain,
couch_user=couch_user, project=project, org=org)
t.is_active_tab = False
all_tabs.append(t)
if t.real_is_viewable:
visible_tabs.append(t)
# only highlight the first tab considered active. This allows
# multiple tabs to contain the same sidebar item, but in all but
# the first it will effectively be a link to the other tabs.
for t in all_tabs:
if t.is_active_fast:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in all_tabs:
if t.is_active:
t.is_active_tab = True
active_tab = t
break
if active_tab is None:
for t in visible_tabs:
if t.url and request.get_full_path().startswith(t.url):
active_tab = t
break
# set the context variable in the highest scope so it can be used in
# other blocks
context.dicts[0]['active_tab'] = active_tab
template = {
style_utils.BOOTSTRAP_2: 'hqwebapp/partials/main_menu.html',
style_utils.BOOTSTRAP_3: 'style/includes/menu_main.html',
}[style_utils.bootstrap_version(request)]
return mark_safe(render_to_string(template, {
'tabs': visible_tabs,
}))
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
from corehq.apps.reports.standard.maps import DemoMapReport, DemoMapReport2, DemoMapCaseList
reports = [
(_("Monitor Workers"), (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
)),
(_("Inspect Data"), (
inspect.SubmitHistory, CaseListReport,
)),
(_("Manage Deployments"), (
deployments.ApplicationStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.FormErrorReport,
phonelog.DeviceLogDetailsReport
)),
(_("Demos for Previewers"), (
DemoMapReport, DemoMapReport2, DemoMapCaseList,
)),
]
if project.commtrack_enabled:
reports.insert(0, (_("Commtrack"), (
commtrack_reports.ReportingRatesReport,
commtrack_reports.CurrentStockStatusReport,
commtrack_reports.AggregateStockStatusReport,
commtrack_reports.RequisitionReport,
psi_prototype.VisitReport,
psi_prototype.SalesAndConsumptionReport,
psi_prototype.CumulativeSalesAndConsumptionReport,
psi_prototype.StockOutReport,
psi_prototype.StockReportExport,
commtrack_maps.StockStatusMapReport,
commtrack_maps.ReportingStatusMapReport,
)))
messaging_reports = (
sms.MessagesReport,
sms.MessageLogReport,
ivr.CallLogReport,
ivr.ExpectedCallbackReport,
)
messaging_reports += getattr(Domain.get_module_by_name(project.name), 'MESSAGING_REPORTS', ())
messaging = (lambda project, user: (
_("Logs") if project.commtrack_enabled else _("Messaging")), messaging_reports)
if project.commconnect_enabled:
reports.insert(0, messaging)
else:
reports.append(messaging)
reports.extend(dynamic_reports(project))
return reports
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
from corehq.apps.reports.standard.cases.careplan import make_careplan_reports
from corehq.apps.reports.standard.maps import DemoMapReport, DemoMapReport2, DemoMapCaseList
reports = []
reports.extend(_get_configurable_reports(project))
reports.extend([
(ugettext_lazy("Monitor Workers"), (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
ProjectHealthDashboard,
)),
(ugettext_lazy("Inspect Data"), (
inspect.SubmitHistory,
CaseListReport,
OdmExportReport,
)),
(ugettext_lazy("Manage Deployments"), (
deployments.ApplicationStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.DeviceLogDetailsReport,
deployments.SyncHistoryReport,
deployments.ApplicationErrorReport,
)),
(ugettext_lazy("Demos"), (
DemoMapReport,
DemoMapReport2,
DemoMapCaseList,
)),
])
if project.commtrack_enabled:
supply_reports = (
commtrack.SimplifiedInventoryReport,
commtrack.InventoryReport,
commtrack.CurrentStockStatusReport,
commtrack.StockStatusMapReport,
)
if not should_use_sql_backend(project):
supply_reports = supply_reports + (
commtrack.ReportingRatesReport,
commtrack.ReportingStatusMapReport,
)
reports.insert(0, (ugettext_lazy("CommCare Supply"), supply_reports))
if project.has_careplan:
from corehq.apps.app_manager.models import CareplanConfig
config = CareplanConfig.for_domain(project.name)
if config:
cp_reports = tuple(make_careplan_reports(config))
reports.insert(0, (ugettext_lazy("Care Plans"), cp_reports))
reports = list(_get_report_builder_reports(project)) + reports
from corehq.apps.accounting.utils import domain_has_privilege
messaging_reports = []
project_can_use_sms = domain_has_privilege(project.name,
privileges.OUTBOUND_SMS)
if project_can_use_sms:
messaging_reports.extend([
sms.MessagesReport,
])
# always have these historical reports visible
messaging_reports.extend([
sms.MessagingEventsReport,
sms.MessageEventDetailReport,
sms.SurveyDetailReport,
sms.MessageLogReport,
sms.SMSOptOutReport,
ivr.CallReport,
ivr.ExpectedCallbackReport,
])
messaging_reports += getattr(Domain.get_module_by_name(project.name),
'MESSAGING_REPORTS', ())
messaging = (ugettext_lazy("Messaging"), messaging_reports)
reports.append(messaging)
reports.extend(_get_dynamic_reports(project))
return reports
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
from corehq.apps.reports.standard.cases.careplan import make_careplan_reports
reports = []
reports.extend(_get_configurable_reports(project))
reports.extend([
(ugettext_lazy("Monitor Workers"), (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
ProjectHealthDashboard,
)),
(ugettext_lazy("Inspect Data"), (
inspect.SubmitHistory, CaseListReport, OdmExportReport,
)),
(ugettext_lazy("Manage Deployments"), (
deployments.ApplicationStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.DeviceLogDetailsReport,
deployments.SyncHistoryReport,
deployments.ApplicationErrorReport,
)),
])
if project.commtrack_enabled:
supply_reports = (
commtrack.SimplifiedInventoryReport,
commtrack.InventoryReport,
commtrack.CurrentStockStatusReport,
commtrack.StockStatusMapReport,
)
if not should_use_sql_backend(project):
supply_reports = supply_reports + (
commtrack.ReportingRatesReport,
commtrack.ReportingStatusMapReport,
)
reports.insert(0, (ugettext_lazy("CommCare Supply"), supply_reports))
if project.has_careplan:
from corehq.apps.app_manager.models import CareplanConfig
config = CareplanConfig.for_domain(project.name)
if config:
cp_reports = tuple(make_careplan_reports(config))
reports.insert(0, (ugettext_lazy("Care Plans"), cp_reports))
reports = list(_get_report_builder_reports(project)) + reports
from corehq.apps.accounting.utils import domain_has_privilege
messaging_reports = []
project_can_use_sms = domain_has_privilege(project.name, privileges.OUTBOUND_SMS)
if project_can_use_sms:
messaging_reports.extend([
sms.MessagesReport,
])
# always have these historical reports visible
messaging_reports.extend([
sms.MessagingEventsReport,
sms.MessageEventDetailReport,
sms.SurveyDetailReport,
sms.MessageLogReport,
sms.SMSOptOutReport,
ivr.CallReport,
ivr.ExpectedCallbackReport,
])
messaging_reports += getattr(Domain.get_module_by_name(project.name), 'MESSAGING_REPORTS', ())
messaging = (ugettext_lazy("Messaging"), messaging_reports)
reports.append(messaging)
reports.extend(_get_dynamic_reports(project))
return reports
def REPORTS(project):
from corehq.apps.reports.standard.cases.basic import CaseListReport
from corehq.apps.reports.standard.cases.careplan import make_careplan_reports
from corehq.apps.reports.standard.maps import DemoMapReport, DemoMapReport2, DemoMapCaseList
reports = [
(ugettext_lazy("Monitor Workers"), (
monitoring.WorkerActivityReport,
monitoring.DailyFormStatsReport,
monitoring.SubmissionsByFormReport,
monitoring.FormCompletionTimeReport,
monitoring.CaseActivityReport,
monitoring.FormCompletionVsSubmissionTrendsReport,
monitoring.WorkerActivityTimes,
)),
(ugettext_lazy("Inspect Data"), (
inspect.SubmitHistory, CaseListReport,
)),
(ugettext_lazy("Manage Deployments"), (
deployments.ApplicationStatusReport,
receiverwrapper.SubmissionErrorReport,
phonelog.FormErrorReport,
phonelog.DeviceLogDetailsReport
)),
(ugettext_lazy("Demos for Previewers"), (
DemoMapReport, DemoMapReport2, DemoMapCaseList,
)),
]
if project.commtrack_enabled:
reports.insert(0, (ugettext_lazy("Commtrack"), (
commtrack_reports.InventoryReport,
commtrack_reports.CurrentStockStatusReport,
commtrack_maps.StockStatusMapReport,
commtrack_reports.ReportingRatesReport,
commtrack_maps.ReportingStatusMapReport,
# commtrack_reports.RequisitionReport,
)))
if project.has_careplan:
from corehq.apps.app_manager.models import CareplanConfig
config = CareplanConfig.for_domain(project.name)
if config:
cp_reports = tuple(make_careplan_reports(config))
reports.insert(0, (ugettext_lazy("Care Plans"), cp_reports))
from corehq.apps.accounting.utils import domain_has_privilege
messaging_reports = []
project_can_use_sms = domain_has_privilege(project.name, privileges.OUTBOUND_SMS)
if project_can_use_sms:
messaging_reports.extend([
sms.MessagesReport,
])
# always have this historical report visible
messaging_reports.append(sms.MessageLogReport)
project_can_use_inbound_sms = domain_has_privilege(project.name, privileges.INBOUND_SMS)
if project_can_use_inbound_sms:
messaging_reports.extend([
ivr.CallLogReport,
ivr.ExpectedCallbackReport,
system_overview.SystemOverviewReport,
system_overview.SystemUsersReport,
])
messaging_reports += getattr(Domain.get_module_by_name(project.name), 'MESSAGING_REPORTS', ())
messaging = (lambda project, user: (
ugettext_lazy("Logs") if project.commtrack_enabled else ugettext_lazy("Messaging")), messaging_reports)
if project.commconnect_enabled:
reports.insert(0, messaging)
else:
reports.append(messaging)
reports.extend(dynamic_reports(project))
return reports
