def generate_indicator_report_location_disaggregation_quantity_data():
# Adding extra IndicatorReport to each QuantityReportable object
locations = Location.objects.all()
sample_disaggregation_value_map = {
"height": ["tall", "medium", "short", "extrashort"],
"age": ["1-2m", "3-4m", "5-6m", '7-10m', '11-13m', '14-16m'],
"gender": ["male", "female", "other"],
}
# Create the disaggregations and values in the db for all response plans
# including one for no response plan as well
for response_plan in [None] + list(ResponsePlan.objects.all()):
for disagg_name, values in sample_disaggregation_value_map.items():
disaggregation = DisaggregationFactory(name=disagg_name,
response_plan=response_plan)
for value in values:
DisaggregationValueFactory(disaggregation=disaggregation,
value=value)
queryset = Reportable.objects.filter(
blueprint__unit=IndicatorBlueprint.NUMBER).order_by('id')
for idx, reportable in enumerate(queryset):
# -- Extra IndicatorReport and IndicatorLocationData --
cluster_indicator_types = [
'partnerproject', 'partneractivity', 'clusterobjective'
]
if reportable.content_type.model in cluster_indicator_types:
# ProgressReport - IndicatorReport from
# QuantityReportable object
indicator_report = QuantityIndicatorReportFactory(
reportable=reportable)
indicator_report.progress_report = reportable.indicator_reports.first(
).progress_report
indicator_report.save()
# -- IndicatorLocationData --
# -- 0 num_disaggregation generation for 3 entries --
if idx % 8 == 0:
print(
"NO Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
# -- 1 num_disaggregation generation for 3 entries --
elif idx % 8 == 1:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["height"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
elif idx % 8 == 2:
add_disaggregations_to_reportable(reportable,
disaggregation_targets=["age"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
elif idx % 8 == 3:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["gender"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
# -- 2 num_disaggregation generation for 3 entries --
elif idx % 8 == 4:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["height", "age"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
elif idx % 8 == 5:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["height", "gender"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
elif idx % 8 == 6:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["gender", "age"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
# -- 3 num_disaggregation generation for 3 entries --
elif idx % 8 == 7:
add_disaggregations_to_reportable(
reportable, disaggregation_targets=["age", "gender", "height"])
print(
"Disaggregation (and DisaggregationValue) objects for QuantityReportable object {} created"
.format(idx))
for idx, reportable in enumerate(queryset):
# -- 0 num_disaggregation generation for 3 entries --
if reportable.disaggregations.count() == 0:
generate_0_num_disagg_data(reportable, indicator_type="quantity")
# -- 1 num_disaggregation generation for 3 entries --
elif reportable.disaggregations.count() == 1:
generate_1_num_disagg_data(reportable, indicator_type="quantity")
# -- 2 num_disaggregation generation for 3 entries --
elif reportable.disaggregations.count() == 2:
generate_2_num_disagg_data(reportable, indicator_type="quantity")
# -- 3 num_disaggregation generation for 3 entries --
elif reportable.disaggregations.count() == 3:
generate_3_num_disagg_data(reportable, indicator_type="quantity")
# 0 num_disaggregation
if reportable.disaggregations.count() != 0:
if reportable.locations.count() != 0:
first_reportable_location_id = reportable.locations.first().id
else:
first_reportable_location_id = None
for location_id in list(
reportable.indicator_reports.values_list(
'indicator_location_data__location', flat=True)):
if not first_reportable_location_id or (
first_reportable_location_id
and first_reportable_location_id != location_id):
reportable.locations.add(
Location.objects.get(id=location_id))
print(
"IndicatorReport and its Disaggregation data entries for QuantityReportable object {} created"
.format(idx))
# Making the rest of IndicatorReport objects not latest so that
# IndicatorReport objects with location data are guaranteed to show up
# first
today = datetime.date.today()
date = datetime.date(today.year, 1, today.day)
not_latest_queryset = IndicatorReport.objects.filter()
not_latest_queryset.filter(indicator_location_data__isnull=True) \
.update(time_period_start=date)
not_latest_queryset.filter(
indicator_location_data__disaggregation__isnull=True) \
.update(time_period_start=date)
def setUp(self):
self.country = CountryFactory()
self.workspace = WorkspaceFactory(countries=[
self.country,
])
self.user = NonPartnerUserFactory()
self.response_plan = ResponsePlanFactory(workspace=self.workspace)
self.cluster = ClusterFactory(type='cccm',
response_plan=self.response_plan)
self.prp_role = ClusterPRPRoleFactory(user=self.user,
workspace=self.workspace,
cluster=self.cluster,
role=PRP_ROLE_TYPES.cluster_imo)
self.loc_type = GatewayTypeFactory(country=self.country)
self.carto_table = CartoDBTableFactory(location_type=self.loc_type,
country=self.country)
self.loc1 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
self.loc2 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
for _ in range(2):
obj = ClusterObjectiveFactory(cluster=self.cluster,
locations=[
self.loc1,
self.loc2,
])
activity = ClusterActivityFactory(cluster_objective=obj,
locations=[self.loc1, self.loc2])
blueprint = QuantityTypeIndicatorBlueprintFactory()
clusteractivity_reportable = QuantityReportableToClusterActivityFactory(
content_object=activity, blueprint=blueprint)
clusteractivity_reportable.disaggregations.clear()
self.sample_disaggregation_value_map = {
"height": ["tall", "medium", "short", "extrashort"],
"age": ["1-2m", "3-4m", "5-6m", '7-10m', '11-13m', '14-16m'],
"gender": ["male", "female", "other"],
}
# Create the disaggregations and values in the db for all response plans
# including one for no response plan as well
for disagg_name, values in self.sample_disaggregation_value_map.items(
):
for value in values:
DisaggregationValueFactory(
disaggregation=DisaggregationFactory(
name=disagg_name,
response_plan=self.response_plan),
value=value)
add_disaggregations_to_reportable(
clusteractivity_reportable,
disaggregation_targets=["age", "gender", "height"])
LocationWithReportableLocationGoalFactory(
location=self.loc1,
reportable=clusteractivity_reportable,
)
LocationWithReportableLocationGoalFactory(
location=self.loc2,
reportable=clusteractivity_reportable,
)
super().setUp()
def setUp(self):
self.country = CountryFactory()
self.workspace = WorkspaceFactory(countries=[
self.country,
])
self.response_plan = ResponsePlanFactory(workspace=self.workspace)
self.cluster = ClusterFactory(type='cccm',
response_plan=self.response_plan)
self.loc_type = GatewayTypeFactory(country=self.country)
self.carto_table = CartoDBTableFactory(location_type=self.loc_type,
country=self.country)
self.loc1 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
self.loc2 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
self.unicef_officer = PersonFactory()
self.unicef_focal_point = PersonFactory()
self.partner_focal_point = PersonFactory()
self.objective = ClusterObjectiveFactory(cluster=self.cluster,
locations=[
self.loc1,
self.loc2,
])
self.activity = ClusterActivityFactory(
cluster_objective=self.objective, locations=[self.loc1, self.loc2])
self.partner = PartnerFactory(
country_code=self.country.country_short_code)
self.user = NonPartnerUserFactory()
self.partner_user = PartnerUserFactory(partner=self.partner)
ClusterPRPRoleFactory(user=self.user,
workspace=self.workspace,
cluster=self.cluster,
role=PRP_ROLE_TYPES.cluster_imo)
IPPRPRoleFactory(user=self.partner_user,
workspace=self.workspace,
role=PRP_ROLE_TYPES.ip_authorized_officer)
IPPRPRoleFactory(user=self.partner_user,
workspace=self.workspace,
cluster=None,
role=PRP_ROLE_TYPES.cluster_member)
self.project = PartnerProjectFactory(
partner=self.partner,
clusters=[self.cluster],
locations=[self.loc1, self.loc2],
)
self.p_activity = ClusterActivityPartnerActivityFactory(
partner=self.partner,
cluster_activity=self.activity,
)
self.project_context = PartnerActivityProjectContextFactory(
project=self.project,
activity=self.p_activity,
)
self.sample_disaggregation_value_map = {
"height": ["tall", "medium", "short", "extrashort"],
"age": ["1-2m", "3-4m", "5-6m", '7-10m', '11-13m', '14-16m'],
"gender": ["male", "female", "other"],
}
blueprint = QuantityTypeIndicatorBlueprintFactory(
unit=IndicatorBlueprint.NUMBER,
calculation_formula_across_locations=IndicatorBlueprint.SUM,
calculation_formula_across_periods=IndicatorBlueprint.SUM,
)
self.partneractivity_reportable = QuantityReportableToPartnerActivityProjectContextFactory(
content_object=self.project_context, blueprint=blueprint)
LocationWithReportableLocationGoalFactory(
location=self.loc1,
reportable=self.partneractivity_reportable,
)
LocationWithReportableLocationGoalFactory(
location=self.loc2,
reportable=self.partneractivity_reportable,
)
self.pd = ProgrammeDocumentFactory(workspace=self.workspace,
partner=self.partner,
sections=[
SectionFactory(),
],
unicef_officers=[
self.unicef_officer,
],
unicef_focal_point=[
self.unicef_focal_point,
],
partner_focal_point=[
self.partner_focal_point,
])
for idx in range(2):
qpr_period = QPRReportingPeriodDatesFactory(
programme_document=self.pd)
ProgressReportFactory(
start_date=qpr_period.start_date,
end_date=qpr_period.end_date,
due_date=qpr_period.due_date,
report_number=idx + 1,
report_type=qpr_period.report_type,
is_final=False,
programme_document=self.pd,
submitted_by=self.user,
submitting_user=self.user,
)
for idx in range(6):
hr_period = HRReportingPeriodDatesFactory(
programme_document=self.pd)
ProgressReportFactory(
start_date=hr_period.start_date,
end_date=hr_period.end_date,
due_date=hr_period.due_date,
report_number=idx + 1,
report_type=hr_period.report_type,
is_final=False,
programme_document=self.pd,
submitted_by=self.user,
submitting_user=self.user,
)
self.cp_output = PDResultLinkFactory(programme_document=self.pd, )
self.llo = LowerLevelOutputFactory(cp_output=self.cp_output, )
self.llo_reportable = QuantityReportableToLowerLevelOutputFactory(
content_object=self.llo,
blueprint=QuantityTypeIndicatorBlueprintFactory(
unit=IndicatorBlueprint.NUMBER,
calculation_formula_across_locations=IndicatorBlueprint.SUM,
))
self.llo_reportable.disaggregations.clear()
self.partneractivity_reportable.disaggregations.clear()
# Create the disaggregations and values in the db for all response plans
# including one for no response plan as well
for disagg_name, values in self.sample_disaggregation_value_map.items(
):
disagg = IPDisaggregationFactory(name=disagg_name)
cluster_disagg = DisaggregationFactory(
name=disagg_name, response_plan=self.response_plan)
self.llo_reportable.disaggregations.add(disagg)
self.partneractivity_reportable.disaggregations.add(cluster_disagg)
for value in values:
DisaggregationValueFactory(disaggregation=cluster_disagg,
value=value)
DisaggregationValueFactory(disaggregation=disagg, value=value)
LocationWithReportableLocationGoalFactory(
location=self.loc1,
reportable=self.llo_reportable,
)
LocationWithReportableLocationGoalFactory(
location=self.loc2,
reportable=self.llo_reportable,
)
for _ in range(2):
with patch("django.db.models.signals.ModelSignal.send", Mock()):
ClusterIndicatorReportFactory(
reportable=self.partneractivity_reportable,
report_status=INDICATOR_REPORT_STATUS.submitted,
)
# Creating Level-3 disaggregation location data for all locations
generate_3_num_disagg_data(self.partneractivity_reportable,
indicator_type="quantity")
for loc_data in IndicatorLocationData.objects.filter(
indicator_report__reportable=self.partneractivity_reportable):
QuantityIndicatorDisaggregator.post_process(loc_data)
for pr in self.pd.progress_reports.all():
ProgressReportIndicatorReportFactory(
progress_report=pr,
reportable=self.llo_reportable,
report_status=INDICATOR_REPORT_STATUS.submitted,
overall_status=OVERALL_STATUS.met,
)
# Creating Level-3 disaggregation location data for all locations
generate_3_num_disagg_data(self.llo_reportable,
indicator_type="quantity")
for loc_data in IndicatorLocationData.objects.filter(
indicator_report__reportable=self.llo_reportable):
QuantityIndicatorDisaggregator.post_process(loc_data)
super().setUp()
def setUp(self):
self.country = CountryFactory()
self.workspace = WorkspaceFactory(countries=[
self.country,
])
self.response_plan = ResponsePlanFactory(workspace=self.workspace)
self.cluster = ClusterFactory(type='cccm',
response_plan=self.response_plan)
self.loc_type = GatewayTypeFactory(country=self.country)
self.carto_table = CartoDBTableFactory(location_type=self.loc_type,
country=self.country)
self.user = NonPartnerUserFactory()
self.prp_role = ClusterPRPRoleFactory(user=self.user,
workspace=self.workspace,
cluster=self.cluster,
role=PRP_ROLE_TYPES.cluster_imo)
self.loc1 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
self.loc2 = LocationFactory(gateway=self.loc_type,
carto_db_table=self.carto_table)
self.objective = ClusterObjectiveFactory(cluster=self.cluster,
locations=[
self.loc1,
self.loc2,
])
self.activity = ClusterActivityFactory(
cluster_objective=self.objective, locations=[self.loc1, self.loc2])
self.partner = PartnerFactory(
country_code=self.country.country_short_code)
self.project = PartnerProjectFactory(
partner=self.partner,
clusters=[self.cluster],
locations=[self.loc1, self.loc2],
)
self.p_activity = ClusterActivityPartnerActivityFactory(
partner=self.partner,
cluster_activity=self.activity,
)
self.project_context = PartnerActivityProjectContextFactory(
project=self.project,
activity=self.p_activity,
)
self.sample_disaggregation_value_map = {
"height": ["tall", "medium", "short", "extrashort"],
"age": ["1-2m", "3-4m", "5-6m", '7-10m', '11-13m', '14-16m'],
"gender": ["male", "female", "other"],
}
# Create the disaggregations and values in the db for all response plans
# including one for no response plan as well
for disagg_name, values in self.sample_disaggregation_value_map.items(
):
for value in values:
DisaggregationValueFactory(
disaggregation=DisaggregationFactory(
name=disagg_name, response_plan=self.response_plan),
value=value)
super().setUp()