def test_get_by_domain(self): results = ReportConfiguration.by_domain('foo') self.assertEqual(2, len(results)) for item in results: self.assertTrue(item.config_id in ('foo1', 'foo2')) results = ReportConfiguration.by_domain('not-foo') self.assertEqual(0, len(results))
def testGetByDomain(self): results = ReportConfiguration.by_domain('foo') self.assertEqual(2, len(results)) for item in results: self.assertTrue(item.config_id in ('foo1', 'foo2')) results = ReportConfiguration.by_domain('not-foo') self.assertEqual(0, len(results))
def test_get_by_domain(self): results = ReportConfiguration.by_domain("foo") self.assertEqual(2, len(results)) for item in results: self.assertTrue(item.config_id in ("foo1", "foo2")) results = ReportConfiguration.by_domain("not-foo") self.assertEqual(0, len(results))
def test_linking_second_report_creates_single_datasource(self): create_linked_ucr(self.domain_link, self.report.get_id) new_report = get_sample_report_config() new_report.title = "Another Report" new_report.config_id = self.data_source.get_id new_report.domain = self.domain new_report.save() create_linked_ucr(self.domain_link, new_report.get_id) self.assertEqual(2, len(ReportConfiguration.by_domain(self.domain_link.linked_domain))) self.assertItemsEqual( [self.report.title, new_report.title], [r.title for r in ReportConfiguration.by_domain(self.domain_link.linked_domain)], )
def get_existing_reports(domain): from corehq.apps.userreports.models import ReportConfiguration existing_reports = ReportConfiguration.by_domain(domain) return [ report for report in existing_reports if not (report.title and report.title.startswith(TEMP_REPORT_PREFIX)) ]
def _get_configurable_reports(project): """ User configurable reports """ configs = ReportConfiguration.by_domain( project.name) + CustomReportConfiguration.by_domain(project.name) if configs: def _make_report_class(config): from corehq.apps.reports.generic import GenericReportView # this is really annoying. # the report metadata should really be pulled outside of the report classes @classmethod def get_url(cls, domain, **kwargs): return reverse(ConfigurableReport.slug, args=[domain, config._id]) @classmethod def show_in_navigation(cls, domain=None, project=None, user=None): return config.visible or ( user and toggles.USER_CONFIGURABLE_REPORTS.enabled( user.username)) return type( 'DynamicReport{}'.format(config._id), (GenericReportView, ), { 'name': config.title, 'description': config.description or None, 'get_url': get_url, 'show_in_navigation': show_in_navigation, }) yield (_('Reports'), [_make_report_class(config) for config in configs])
def _shared_context(domain): custom_data_sources = list(CustomDataSourceConfiguration.by_domain(domain)) return { 'domain': domain, 'reports': ReportConfiguration.by_domain(domain), 'data_sources': DataSourceConfiguration.by_domain(domain) + custom_data_sources, }
def test_remote_link_ucr(self, fake_ucr_getter): create_domain(self.domain) self.addCleanup(delete_all_domains) couch_user = WebUser.create(self.domain, "test", "foobar", None, None) django_user = couch_user.get_django_user() self.addCleanup(delete_all_users) api_key, _ = HQApiKey.objects.get_or_create(user=django_user) auth_headers = {'HTTP_AUTHORIZATION': 'apikey test:%s' % api_key.key} self.domain_link.save() url = reverse('linked_domain:ucr_config', args=[self.domain, self.report.get_id]) headers = auth_headers.copy() headers[REMOTE_REQUESTER_HEADER] = self.domain_link.linked_domain resp = self.client.get(url, **headers) fake_ucr_getter.return_value = json.loads(resp.content) # Create linked_report_info = create_linked_ucr(self.domain_link, self.report.get_id) self.assertEqual(1, len(ReportConfiguration.by_domain(self.domain_link.linked_domain))) self.assertEqual(self.report.get_id, linked_report_info.report.report_meta.master_id) # Update self.report.title = "Another new title" self.report.save() update_linked_ucr(self.domain_link, linked_report_info.report.get_id) report = ReportConfiguration.get(linked_report_info.report.get_id) self.assertEqual("Another new title", report.title)
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters_without_prefilters, } all_reports = ReportConfiguration.by_domain(app.domain) + \ StaticReportConfiguration.by_domain(app.domain) warnings = [] validity = module.check_report_validity() # We're now proactively deleting these references, so after that's been # out for a while, this can be removed (say June 2016 or later) if not validity.is_valid: module.report_configs = validity.valid_report_configs warnings.append( gettext_lazy('Your app contains references to reports that are ' 'deleted. These will be removed on save.') ) return { 'all_reports': [_report_to_config(r) for r in all_reports], 'current_reports': [r.to_json() for r in module.report_configs], 'warnings': warnings, }
def number_of_report_builder_reports(domain): from corehq.apps.userreports.models import ReportConfiguration existing_reports = ReportConfiguration.by_domain(domain) builder_reports = filter( lambda report: report.report_meta.created_by_builder, existing_reports ) return len(builder_reports)
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters, } all_reports = ReportConfiguration.by_domain(app.domain) warnings = [] validity = module.check_report_validity() if not validity.is_valid: module.report_configs = validity.valid_report_configs warnings.append( gettext_lazy( 'Your app contains references to reports that are deleted. These will be removed on save.') ) return { 'all_reports': [_report_to_config(r) for r in all_reports], 'current_reports': [r.to_json() for r in module.report_configs], 'warnings': warnings, }
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters_without_prefilters, } all_reports = ReportConfiguration.by_domain(app.domain) + \ StaticReportConfiguration.by_domain(app.domain) validity = module.check_report_validity() # We're now proactively deleting these references, so after that's been # out for a while, this can be removed (say June 2016 or later) if not validity.is_valid: module.report_configs = validity.valid_report_configs filter_choices = [ {'slug': f.doc_type, 'description': f.short_description} for f in get_all_mobile_filter_configs() ] auto_filter_choices = [ {'slug': f.slug, 'description': f.short_description} for f in get_auto_filter_configurations() ] return { 'all_reports': [_report_to_config(r) for r in all_reports], 'current_reports': [r.to_json() for r in module.report_configs], 'filter_choices': filter_choices, 'auto_filter_choices': auto_filter_choices, 'daterange_choices': [choice._asdict() for choice in get_simple_dateranges()], }
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters, } all_reports = ReportConfiguration.by_domain(app.domain) all_report_ids = set([r._id for r in all_reports]) invalid_report_references = filter( lambda r: r.report_id not in all_report_ids, module.report_configs) warnings = [] if invalid_report_references: module.report_configs = filter(lambda r: r.report_id in all_report_ids, module.report_configs) warnings.append( gettext_lazy( 'Your app contains references to reports that are deleted. These will be removed on save.') ) return { 'all_reports': [_report_to_config(r) for r in all_reports], 'current_reports': [r.to_json() for r in module.report_configs], 'invalid_report_references': invalid_report_references, 'warnings': warnings, }
def _get_report_builder_reports(project): from corehq.apps.userreports.models import ReportConfiguration reports = ReportConfiguration.by_domain(project.name) return filter( lambda report: report.report_meta.created_by_builder, reports )
def _get_configurable_reports(project): """ User configurable reports """ configs = ReportConfiguration.by_domain(project.name) if configs: def _make_report_class(config): from corehq.apps.reports.generic import GenericReportView # this is really annoying. # the report metadata should really be pulled outside of the report classes @classmethod def get_url(cls, domain, **kwargs): return reverse(ConfigurableReport.slug, args=[domain, config._id]) @classmethod def show_in_navigation(cls, domain=None, project=None, user=None): return config.visible or (user and toggles.USER_CONFIGURABLE_REPORTS.enabled(user.username)) return type('DynamicReport{}'.format(config._id), (GenericReportView, ), { 'name': config.title, 'description': config.description or None, 'get_url': get_url, 'show_in_navigation': show_in_navigation, }) yield (_('Project Reports'), [_make_report_class(config) for config in configs])
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters_without_prefilters, } all_reports = ReportConfiguration.by_domain(app.domain) + \ StaticReportConfiguration.by_domain(app.domain) warnings = [] validity = module.check_report_validity() # We're now proactively deleting these references, so after that's been # out for a while, this can be removed (say June 2016 or later) if not validity.is_valid: module.report_configs = validity.valid_report_configs warnings.append( gettext_lazy('Your app contains references to reports that are ' 'deleted. These will be removed on save.')) return { 'all_reports': [_report_to_config(r) for r in all_reports], 'current_reports': [r.to_json() for r in module.report_configs], 'warnings': warnings, }
def number_of_report_builder_reports(domain): from corehq.apps.userreports.models import ReportConfiguration existing_reports = ReportConfiguration.by_domain(domain) builder_reports = [ report for report in existing_reports if report.report_meta.created_by_builder ] return len(builder_reports)
def ucr_displays_by_id(self): return { config._id: _link( config.title, reverse(ConfigurableReportView.slug, args=[self.domain, config._id])) for config in ReportConfiguration.by_domain(self.domain) }
def _get_existing_reports(domain): from corehq.apps.userreports.models import ReportConfiguration from corehq.apps.userreports.views import TEMP_REPORT_PREFIX existing_reports = ReportConfiguration.by_domain(domain) return [ report for report in existing_reports if not report.title.startswith(TEMP_REPORT_PREFIX) ]
def _shared_context(domain): static_reports = list(StaticReportConfiguration.by_domain(domain)) static_data_sources = list(StaticDataSourceConfiguration.by_domain(domain)) return { 'domain': domain, 'reports': ReportConfiguration.by_domain(domain) + static_reports, 'data_sources': DataSourceConfiguration.by_domain(domain) + static_data_sources, }
def main_context(self): static_reports = list(StaticReportConfiguration.by_domain(self.domain)) static_data_sources = list(StaticDataSourceConfiguration.by_domain(self.domain)) context = super(BaseUserConfigReportsView, self).main_context context.update({ 'reports': ReportConfiguration.by_domain(self.domain) + static_reports, 'data_sources': DataSourceConfiguration.by_domain(self.domain) + static_data_sources, }) return context
def number_of_report_builder_reports(domain): from corehq.apps.userreports.models import ReportConfiguration from corehq.apps.userreports.views import TEMP_REPORT_PREFIX existing_reports = ReportConfiguration.by_domain(domain) builder_reports = [ report for report in existing_reports if report.report_meta.created_by_builder and not report.title.startswith(TEMP_REPORT_PREFIX) ] return len(builder_reports)
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters_without_prefilters, } all_reports = ReportConfiguration.by_domain(app.domain) + \ StaticReportConfiguration.by_domain(app.domain) validity = module.check_report_validity() # We're now proactively deleting these references, so after that's been # out for a while, this can be removed (say June 2016 or later) if not validity.is_valid: module.report_configs = validity.valid_report_configs filter_choices = [ {'slug': f.doc_type, 'description': f.short_description} for f in get_all_mobile_filter_configs() ] auto_filter_choices = [ {'slug': f.slug, 'description': f.short_description} for f in get_auto_filter_configurations() ] from corehq.apps.app_manager.suite_xml.features.mobile_ucr import get_column_xpath_client_template, get_data_path data_path_placeholders = {} for r in module.report_configs: data_path_placeholders[r.report_id] = {} for chart_id in r.complete_graph_configs.keys(): data_path_placeholders[r.report_id][chart_id] = get_data_path(r, app.domain) context = { 'report_module_options': { 'moduleName': module.name, 'moduleFilter': module.module_filter, 'availableReports': [_report_to_config(r) for r in all_reports], # structure for all reports 'currentReports': [r.to_json() for r in module.report_configs], # config data for app reports 'columnXpathTemplate': get_column_xpath_client_template(app.mobile_ucr_restore_version), 'dataPathPlaceholders': data_path_placeholders, 'languages': app.langs, 'mobileUcrV1': app.mobile_ucr_restore_version == MOBILE_UCR_VERSION_1, 'globalSyncDelay': Domain.get_by_name(app.domain).default_mobile_ucr_sync_interval, }, 'static_data_options': { 'filterChoices': filter_choices, 'autoFilterChoices': auto_filter_choices, 'dateRangeOptions': [choice._asdict() for choice in get_simple_dateranges()], }, 'uuids_by_instance_id': get_uuids_by_instance_id(app.domain), 'legacy_select2': True, } return context
def _new_report_module(request, domain, app, name, lang): module = app.add_module(ReportModule.new_module(name, lang)) # by default add all reports module.report_configs = [ ReportAppConfig( report_id=report._id, header={lang: report.title}, description={lang: report.description}, ) for report in ReportConfiguration.by_domain(domain) ] app.save() return back_to_main(request, domain, app_id=app.id, module_id=module.id)
def _get_report_module_context(app, module): def _report_to_config(report): return { 'report_id': report._id, 'title': report.title, 'description': report.description, 'charts': [chart for chart in report.charts if chart.type == 'multibar'], 'filter_structure': report.filters_without_prefilters, } all_reports = ReportConfiguration.by_domain(app.domain) + \ StaticReportConfiguration.by_domain(app.domain) validity = module.check_report_validity() # We're now proactively deleting these references, so after that's been # out for a while, this can be removed (say June 2016 or later) if not validity.is_valid: module.report_configs = validity.valid_report_configs filter_choices = [ {'slug': f.doc_type, 'description': f.short_description} for f in get_all_mobile_filter_configs() ] auto_filter_choices = [ {'slug': f.slug, 'description': f.short_description} for f in get_auto_filter_configurations() ] from corehq.apps.app_manager.suite_xml.features.mobile_ucr import get_column_xpath_client_template, get_data_path data_path_placeholders = {} for r in module.report_configs: data_path_placeholders[r.report_id] = {} for chart_id in r.complete_graph_configs.keys(): data_path_placeholders[r.report_id][chart_id] = get_data_path(r, app.domain) context = { 'report_module_options': { 'moduleName': module.name, 'moduleFilter': module.module_filter, 'availableReports': [_report_to_config(r) for r in all_reports], # structure for all reports 'currentReports': [r.to_json() for r in module.report_configs], # config data for app reports 'columnXpathTemplate': get_column_xpath_client_template(app.mobile_ucr_restore_version), 'dataPathPlaceholders': data_path_placeholders, 'languages': app.langs, 'supportSyncDelay': app.mobile_ucr_restore_version != MOBILE_UCR_VERSION_1, 'globalSyncDelay': Domain.get_by_name(app.domain).default_mobile_ucr_sync_interval, }, 'static_data_options': { 'filterChoices': filter_choices, 'autoFilterChoices': auto_filter_choices, 'dateRangeOptions': [choice._asdict() for choice in get_simple_dateranges()], }, } return context
def main_context(self): static_reports = list(StaticReportConfiguration.by_domain(self.domain)) static_data_sources = list( StaticDataSourceConfiguration.by_domain(self.domain)) context = super(BaseUserConfigReportsView, self).main_context context.update({ 'reports': ReportConfiguration.by_domain(self.domain) + static_reports, 'data_sources': DataSourceConfiguration.by_domain(self.domain) + static_data_sources, }) return context
def _new_report_module(request, domain, app, name, lang): module = app.add_module(ReportModule.new_module(name, lang)) # by default add all reports module.report_configs = [ ReportAppConfig( report_id=report._id, header={lang: report.title}, description=report.description, ) for report in ReportConfiguration.by_domain(domain) ] app.save() return back_to_main(request, domain, app_id=app.id, module_id=module.id)
def response_report_builder(project, new_plan_version): from corehq.apps.userreports.models import ReportConfiguration from corehq.apps.userreports.tasks import rebuild_indicators reports = ReportConfiguration.by_domain(project.name) builder_reports = [report for report in reports if report.report_meta.created_by_builder] for report in builder_reports: try: report.visible = True report.save() if report.config.is_deactivated: report.config.is_deactivated = False report.config.save() rebuild_indicators.delay(report.config._id) except DataSourceConfigurationNotFoundError: pass return True
def clean(self): """ Raise a validation error if there are already 5 data sources and this report won't be able to use one of the existing ones. """ cleaned_data = super(DataSourceForm, self).clean() existing_reports = ReportConfiguration.by_domain(self.domain) builder_reports = filter(lambda report: report.report_meta.created_by_builder, existing_reports) if len(builder_reports) >= self.max_allowed_reports: raise forms.ValidationError(_( "Too many reports!\n" "Creating this report would cause you to go over the maximum " "number of report builder reports allowed in this domain. Your" "limit is {number}. " "To continue, delete another report and try again. " ).format(number=self.max_allowed_reports)) return cleaned_data
def _safely_get_report_configs(project_name): try: configs = ReportConfiguration.by_domain(project_name) except BadSpecError as e: logging.exception(e) # Pick out the UCRs that don't have spec errors configs = [] for config_id in get_doc_ids_in_domain_by_class(project_name, ReportConfiguration): try: configs.append(ReportConfiguration.get(config_id)) except BadSpecError as e: logging.error("%s with report config %s" % (e.message, config_id)) try: configs.extend(StaticReportConfiguration.by_domain(project_name)) except BadSpecError as e: logging.exception(e) return configs
def _get_configurable_reports(project): """ User configurable reports """ configs = ReportConfiguration.by_domain(project.name) if configs: def _make_report_class(config): from corehq.apps.reports.generic import GenericReportView # this is really annoying. # the report metadata should really be pulled outside of the report classes @classmethod def get_url(cls, domain): return reverse(ConfigurableReport.slug, args=[domain, config._id]) return type('DynamicReport{}'.format(config._id), (GenericReportView, ), { 'name': config.title, 'description': config.description, 'get_url': get_url, }) yield (_('Project Reports'), [_make_report_class(config) for config in configs])
def test_remote_link_ucr(self, fake_ucr_getter): fake_ucr_getter.return_value = { "report": self.report, "datasource": self.data_source, } # Create linked_report_info = create_linked_ucr(self.domain_link, self.report.get_id) self.assertEqual( 1, len(ReportConfiguration.by_domain(self.domain_link.linked_domain))) self.assertEqual(self.report.get_id, linked_report_info.report.report_meta.master_id) # Update self.report.title = "Another new title" self.report.save() update_linked_ucr(self.domain_link, linked_report_info.report.get_id) report = ReportConfiguration.get(linked_report_info.report.get_id) self.assertEqual("Another new title", report.title)
def obj_get_list(self, bundle, **kwargs): domain = kwargs['domain'] return ReportConfiguration.by_domain(domain)
def _shared_context(domain): return { 'domain': domain, 'reports': ReportConfiguration.by_domain(domain), 'data_sources': DataSourceConfiguration.by_domain(domain), }
def _get_report_builder_reports(project): from corehq.apps.userreports.models import ReportConfiguration reports = ReportConfiguration.by_domain(project.name) return [report for report in reports if report.report_meta.created_by_builder]
def setUp(self): super(ReportTranslationTest, self).setUp() report = ReportConfiguration.by_domain(self.DOMAIN)[0] self.report_source = ReportFactory.from_spec(report)
def setUp(self): report = ReportConfiguration.by_domain(self.DOMAIN)[0] self.report_source = ReportFactory.from_spec(report)
def _get_report_builder_reports(project): from corehq.apps.userreports.models import ReportConfiguration reports = ReportConfiguration.by_domain(project.name) return [ report for report in reports if report.report_meta.created_by_builder ]