def test_midend_doesnt_sum_if_no_endline_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=1))
self.data.append(mid_data)
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['low'], 1,
"should show under (350/500), got {0}".format(
program.scope_counts))
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['high'], 1,
"should show over (350/500), got {0}".format(program.scope_counts))
def setUp(self):
program = get_open_program()
indicator = i_factories.IndicatorFactory(
program=program,
target_frequency=Indicator.MID_END,
unit_of_measure_type=Indicator.PERCENTAGE,
lop_target=60)
targets = [
i_factories.PeriodicTargetFactory(indicator=indicator,
customsort=0,
start_date=None,
end_date=None,
target=80),
i_factories.PeriodicTargetFactory(indicator=indicator,
customsort=1,
start_date=None,
end_date=None,
target=65)
]
results = [
i_factories.ResultFactory(indicator=indicator,
periodic_target=targets[0],
date_collected=datetime.date(2018, 1, 1),
achieved=75),
i_factories.ResultFactory(indicator=indicator,
periodic_target=targets[0],
date_collected=datetime.date(2018, 2, 1),
achieved=70)
]
self.results_indicator = ResultsIndicator.results_view.get(
pk=indicator.pk)
self.metrics_indicator = MetricsIndicator.objects.with_annotations(
'scope').get(pk=indicator.pk)
def add_good_indicator(self):
indicator = self.get_indicator(Indicator.MID_END)
target_mid = i_factories.PeriodicTargetFactory(
indicator=indicator, period=PeriodicTarget.MIDLINE, target=400)
target_end = i_factories.PeriodicTargetFactory(
indicator=indicator, period=PeriodicTarget.ENDLINE, target=800)
self.targets.extend([target_mid, target_end])
def test_program_with_multiple_indicators_returns_correct_date(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2015, 12, 31)
)
indicator1 = i_factories.IndicatorFactory(
target_frequency=Indicator.ANNUAL,
program=program
)
i_factories.PeriodicTargetFactory(
indicator=indicator1,
start_date=datetime.date(2015, 1, 1),
end_date=datetime.date(2015, 12, 31)
)
indicator2 = i_factories.IndicatorFactory(
target_frequency=Indicator.TRI_ANNUAL,
program=program
)
for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 4, 30)),
(datetime.date(2015, 5, 1), datetime.date(2015, 8, 31)),
(datetime.date(2015, 9, 1), datetime.date(2015, 12, 31))]:
i_factories.PeriodicTargetFactory(
indicator=indicator2,
start_date=start,
end_date=end
)
self.assertEqual(program.last_time_aware_indicator_start_date, datetime.date(2015, 9, 1))
def test_lop_and_midend_just_mid_reporting(self):
self.get_closed_program()
indicator_lop = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=1000,
program=self.program)
lop_target = i_factories.PeriodicTargetFactory(
indicator=indicator_lop,
target=1000,
start_date=self.program.reporting_period_start,
end_date=self.program.reporting_period_end)
lop_data = i_factories.ResultFactory(
indicator=indicator_lop,
periodic_target=lop_target,
achieved=400,
date_collected=self.program.reporting_period_end -
datetime.timedelta(days=10))
indicator_midend = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=self.program)
mid_target = i_factories.PeriodicTargetFactory(
indicator=indicator_midend,
period=PeriodicTarget.MIDLINE,
target=1000)
mid_data = i_factories.ResultFactory(
indicator=indicator_midend,
periodic_target=mid_target,
achieved=400,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=20))
for indicator in MetricsIndicator.objects.with_annotations(
'reporting').all():
self.assertTrue(indicator.reporting)
def do_add_defined_target(indicator):
indicator.target_frequency = Indicator.MID_END
mid_target = i_factories.PeriodicTargetFactory(
indicator=indicator, period=PeriodicTarget.MIDLINE, target=1000)
end_target = i_factories.PeriodicTargetFactory(
indicator=indicator, period=PeriodicTarget.ENDLINE, target=400)
indicator.save()
return (mid_target, end_target)
def add_periodic_targets(self):
self.pt_out_of_country = i_factories.PeriodicTargetFactory(
indicator=self.indicator_out_of_country,
start_date=self.program_out_of_country.reporting_period_start,
end_date=self.program_out_of_country.reporting_period_end)
self.pt_in_country = i_factories.PeriodicTargetFactory(
indicator=self.indicator_in_country,
start_date=self.program_in_country.reporting_period_start,
end_date=self.program_in_country.reporting_period_end)
def add_good_indicator_multiple_targets(self):
indicator = self.get_indicator(Indicator.EVENT)
target_1 = i_factories.PeriodicTargetFactory(indicator=indicator,
period="Event 1",
target=400)
target_2 = i_factories.PeriodicTargetFactory(indicator=indicator,
period="Event 6",
target=500)
self.targets.extend([target_1, target_2])
def get_on_target_indicators(self):
# lop indicator on target to lop target value
lop_indicator = self.get_base_indicator()
lop_indicator.target_frequency = Indicator.LOP
lop_indicator.lop_target = 10000
lop_indicator.is_cumulative = False
lop_indicator.unit_of_measure_type = Indicator.NUMBER
lop_indicator.save()
lop_pt = i_factories.PeriodicTargetFactory(
indicator=lop_indicator,
target=lop_indicator.lop_target,
start_date=lop_indicator.program.reporting_period_start,
end_date=lop_indicator.program.reporting_period_end)
lop_data = self.get_base_data(lop_indicator)
lop_data.achieved = 10000
lop_data.periodic_target = lop_pt
lop_data.save()
self.data.append(lop_data)
# semi annual indicator with target and valid data
time_indicator = self.get_base_indicator()
time_indicator.target_frequency = Indicator.SEMI_ANNUAL
time_indicator.is_cumulative = True
time_indicator.unit_of_measure_type = Indicator.NUMBER
time_indicator.save()
start_date = self.program.reporting_period_start
mid_date = datetime.date(
start_date.year + 1 if start_date.month > 6 else start_date.year,
start_date.month -
6 if start_date.month > 6 else start_date.month + 6,
start_date.day)
time_target_1 = i_factories.PeriodicTargetFactory(
indicator=time_indicator,
target=400,
start_date=start_date,
end_date=mid_date - datetime.timedelta(days=1))
time_target_2 = i_factories.PeriodicTargetFactory(
indicator=time_indicator,
target=600,
start_date=mid_date,
end_date=self.program.reporting_period_end)
self.targets.extend([time_target_1, time_target_2])
data_1 = i_factories.ResultFactory(
indicator=time_indicator,
periodic_target=time_target_1,
date_collected=time_target_1.start_date +
datetime.timedelta(days=2),
achieved=200)
data_2 = i_factories.ResultFactory(
indicator=time_indicator,
periodic_target=time_target_2,
date_collected=time_target_2.start_date +
datetime.timedelta(days=2),
achieved=400)
self.data.extend([data_1, data_2])
return [lop_indicator, time_indicator]
def get_overtarget_indicators(self):
# lop indicator with 120/100 data
lop_indicator = self.get_base_indicator()
lop_indicator.target_frequency = Indicator.LOP
lop_indicator.is_cumulative = False
lop_indicator.lop_target = 100
lop_indicator.save()
lop_data = self.get_base_data(lop_indicator)
lop_data.achieved = 120
lop_data.save()
self.data.append(lop_data)
# negative direction of change so under data should show as over target
neg_indicator = self.get_base_indicator()
neg_indicator.target_frequency = Indicator.LOP
neg_indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
neg_indicator.lop_target = 800
neg_indicator.save()
neg_data = self.get_base_data(neg_indicator)
neg_data.achieved = 600
neg_data.save()
self.data.append(neg_data)
# mid end indicator _cumulative_ should check against end target only
midend_indicator = self.get_base_indicator()
midend_indicator.target_frequency = Indicator.MID_END
midend_indicator.is_cumulative = True
midend_indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=midend_indicator,
period=PeriodicTarget.MIDLINE,
customsort=0,
target=500)
end_target = i_factories.PeriodicTargetFactory(
indicator=midend_indicator,
period=PeriodicTarget.ENDLINE,
customsort=1,
target=800)
self.targets.extend([mid_target, end_target])
mid_data_1 = self.get_base_data(midend_indicator, mid_target)
mid_data_1.achieved = 200
mid_data_1.save()
mid_data_2 = self.get_base_data(midend_indicator, mid_target)
mid_data_2.achieved = 200
mid_data_2.save()
mid_data_3 = self.get_base_data(midend_indicator, end_target)
mid_data_3.achieved = 250
mid_data_3.save()
mid_data_4 = self.get_base_data(midend_indicator, end_target)
mid_data_4.achieved = 250
mid_data_4.save()
self.data.extend([mid_data_1, mid_data_2, mid_data_3, mid_data_4])
return [lop_indicator, neg_indicator, midend_indicator]
def test_midend_doesnt_sum_if_no_endline_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0
)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1
)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=1)
)
self.data.append(mid_data)
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
# both have data, defaults to non_cumulative, so should show sum of both targets:
self.assertEqual(
indicator.lop_target_progress, 500,
"should not sum targets (no data for endline) expecting 500, got {0}".format(indicator.lop_target_progress)
)
self.assertEqual(
indicator.lop_actual_progress, 350,
"should show only data, 350 got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, -1,
"should show under (350/500), got {0}".format(indicator.over_under)
)
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.over_under, 1,
"should show over (350/500), got {0}".format(indicator.over_under)
)
self.indicator.is_cumulative = True
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.lop_target_progress, 500,
"should not take endline target (no data`) expecting 500, got {0}".format(indicator.lop_target_progress)
)
def test_midend_target_sums_midend_with_both_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=1))
end_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=end_target,
achieved=950,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=10))
self.data.extend([mid_data, end_data])
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['on_scope'], 1,
"should show overunder as 0 (in range), got {0}".format(
program.scope_counts))
self.indicator.is_cumulative = True
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
# both have data, set to cumulative, so should show latest (endline) target:
self.assertEqual(
program.scope_counts['high'], 1,
"should show overunder as 1 (over range), got {0}".format(
program.scope_counts))
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['low'], 1,
"should show overunder as -1 (under range - negative DOC), got {0}"
.format(program.scope_counts))
def test_end_date_will_change_to_after_last_time_aware_target_set(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.ANNUAL,
program=program
)
for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 12, 31)),
(datetime.date(2016, 1, 1), datetime.date(2016, 12, 31)),
(datetime.date(2017, 1, 1), datetime.date(2017, 12, 31))]:
i_factories.PeriodicTargetFactory(
start_date=start,
end_date=end,
indicator=indicator
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2015-01-01',
'reporting_period_end': '2017-10-31',
'rationale': 'test'})
self.assertEqual(json.loads(response.content)['msg'], 'success')
self.assertEqual(len(json.loads(response.content)['failmsg']), 0)
self.assertEqual(response.status_code, 200)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2015, 1, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 10, 31))
def setUp(self):
for _ in range(10):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2014, 1, 1),
reporting_period_end=datetime.date(2014, 12, 31))
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
i_factories.CollectedDataFactory(indicator=indicator,
achieved=105)
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
evidence = w_factories.DocumentationFactory(program=program)
i_factories.CollectedDataFactory(indicator=indicator,
achieved=50,
evidence=evidence)
for _ in range(2):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP, program=program)
for _ in range(4):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=program)
for sort in range(2):
i_factories.PeriodicTargetFactory(
indicator=indicator,
target=40,
start_date=datetime.date(2014, 5, 1),
end_date=datetime.date(2014, 8, 1),
customsort=sort)
def get_indicators(self):
for c, kwargs in enumerate(self.indicator_kwargs):
indicator = i_factories.IndicatorFactory(program=self.program,
number=c,
**kwargs['indicator'])
for target_kwargs, period in zip(kwargs['targets'],
self.program.get_periods_for_frequency(indicator.target_frequency)):
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=target_kwargs['target'],
start_date=period['start'],
end_date=period['end'],
customsort=period['customsort']
)
for date_collected, achieved in target_kwargs['results']:
i_factories.ResultFactory(
periodic_target=target,
indicator=indicator,
date_collected=date_collected,
achieved=achieved
)
for date_collected, achieved in kwargs['results']:
i_factories.ResultFactory(
indicator=indicator,
date_collected=date_collected,
achieved=achieved
)
def add_midend_indicator(self, program):
indicator = i_factory.IndicatorFactory(
target_frequency=Indicator.MID_END,
lop_target=100,
program=program)
i_factory.PeriodicTargetFactory(indicator=indicator,
target=100,
start_date=datetime.date(2015, 1, 1),
end_date=datetime.date(2015, 6, 30),
customsort=0)
i_factory.PeriodicTargetFactory(indicator=indicator,
target=100,
start_date=datetime.date(2015, 7, 1),
end_date=datetime.date(2015, 12, 31),
customsort=1)
return indicator
def get_targets(self):
targets = []
results = []
start_date = self.program_dates[0]
end_date = self.program_dates[1]
next_date = self.next_date_func(start_date)
counter = 0
while start_date < end_date:
target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
start_date=start_date,
end_date=next_date - datetime.timedelta(days=1),
target=self.target_values[counter])
targets.append(target)
if counter < len(self.result_values):
results.append(
i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=target,
date_collected=start_date + datetime.timedelta(days=1),
achieved=self.result_values[counter]))
counter += 1
start_date = next_date
next_date = self.next_date_func(start_date)
return targets, results
def get_all_targets_defined_indicator(program):
indicator = get_one_target_defined_indicator(program)
i_factories.PeriodicTargetFactory(indicator=indicator,
start_date=datetime.date(2016, 1, 1),
end_date=datetime.date(2016, 12, 31),
target=100)
return indicator
def get_targets(self, indicator):
self.targets[indicator.pk] = [
i_factories.PeriodicTargetFactory(
target=50,
customsort=0,
indicator=indicator,
start_date=self.program.reporting_period_start,
end_date=self.program.reporting_period_end),
i_factories.PeriodicTargetFactory(
target=49,
customsort=1,
indicator=indicator,
start_date=self.program.reporting_period_start,
end_date=self.program.reporting_period_end)
]
self.result_target[indicator.pk] = 0
def get_target(self, indicator):
target = i_factories.PeriodicTargetFactory(indicator=indicator,
period="target {0}".format(
len(self.targets)),
target=100)
self.targets.append(target)
return target
def test_start_date_does_change_if_no_time_aware_target_set(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END,
program=program
)
i_factories.PeriodicTargetFactory(
start_date=None,
end_date=None,
customsort=0,
indicator=indicator
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2016-01-01',
'reporting_period_end': '2017-12-31',
'rationale': 'test'})
self.assertEqual(json.loads(response.content)['msg'], 'success')
self.assertEqual(len(json.loads(response.content)['failmsg']), 0)
self.assertEqual(response.status_code, 200)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2016, 1, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 12, 31))
def test_lop_and_midend_just_mid_reporting(self):
self.get_closed_program()
indicator_lop = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=1000,
program=self.program
)
lop_data = i_factories.CollectedDataFactory(
indicator=indicator_lop,
achieved=400,
date_collected=self.program.reporting_period_end - datetime.timedelta(days=10)
)
indicator_midend = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END,
program=self.program
)
mid_target = i_factories.PeriodicTargetFactory(
indicator=indicator_midend,
period=PeriodicTarget.MIDLINE,
target=1000
)
mid_data = i_factories.CollectedDataFactory(
indicator=indicator_midend,
periodic_target=mid_target,
achieved=400,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=20)
)
program = self.get_annotated_program()
self.assertEqual(program.scope_counts['nonreporting_count'], 0)
self.assertEqual(program.scope_counts['indicator_count'], 2)
def get_one_target_defined_indicator(program):
indicator = i_factories.IndicatorFactory(program=program,
target_frequency=Indicator.ANNUAL)
i_factories.PeriodicTargetFactory(indicator=indicator,
start_date=datetime.date(2015, 1, 1),
end_date=datetime.date(2015, 12, 31),
target=100)
return indicator
def setUp(self):
for _ in range(10):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2014, 1, 1),
reporting_period_end=datetime.date(2014, 12, 31))
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=indicator.lop_target,
start_date=indicator.program.reporting_period_start,
end_date=indicator.program.reporting_period_end)
i_factories.ResultFactory(indicator=indicator,
periodic_target=target,
achieved=105)
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=indicator.lop_target,
start_date=indicator.program.reporting_period_start,
end_date=indicator.program.reporting_period_end)
i_factories.ResultFactory(
indicator=indicator,
periodic_target=target,
achieved=50,
evidence_url='http://test_evidence_url')
for _ in range(2):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP, program=program)
for _ in range(4):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=program)
for sort in range(2):
i_factories.PeriodicTargetFactory(
indicator=indicator,
target=40,
start_date=datetime.date(2014, 5, 1),
end_date=datetime.date(2014, 8, 1),
customsort=sort)
def add_non_lop_indicator(self, program):
indicator = i_factory.IndicatorFactory(
target_frequency=Indicator.ANNUAL, lop_target=100, program=program)
i_factory.PeriodicTargetFactory(
indicator=indicator,
target=100,
start_date=program.reporting_period_start,
end_date=program.reporting_period_end)
return indicator
def add_annual_indicators(self, program, dates):
indicator = i_factory.IndicatorFactory(
target_frequency=Indicator.ANNUAL, lop_target=100, program=program)
for c, start_date in enumerate(dates):
end_date = start_date + datetime.timedelta(days=364)
i_factory.PeriodicTargetFactory(indicator=indicator,
target=100,
customsort=c,
start_date=start_date,
end_date=end_date)
return indicator
def get_nonreporting_indicators(self):
event_indicator = self.get_base_indicator()
event_indicator.target_frequency = Indicator.EVENT
event_indicator.save()
event_target = i_factories.PeriodicTargetFactory(
indicator=event_indicator,
target=400,
customsort=0,
period="event 1")
self.targets.append(event_target)
return [event_indicator]
def get_annual_targets(indicator, target_values):
start_date = indicator.program.reporting_period_start
targets = []
for c, value in enumerate(target_values):
targets.append(
i_factories.PeriodicTargetFactory(
indicator=indicator,
start_date=datetime.date(start_date.year + c, 1, 1),
end_date=datetime.date(start_date.year + c, 12, 31),
target=value))
return targets
def load_target(self, indicator, target, period=None, start_date=None):
end_date = start_date
period = "Period {0}".format(len(
self.targets)) if period is None else period
if start_date is not None:
end_date = self.DATE_FUNCS[indicator.target_frequency](start_date)
target = i_factories.PeriodicTargetFactory(indicator=indicator,
period=period,
target=target,
start_date=start_date,
end_date=end_date)
self.targets.append(target)
return target
def get_targets(self, indicator, target_values):
targets = []
for period, target_value in zip(
self.program.get_periods_for_frequency(
self.indicator_frequency), target_values):
targets.append(
i_factories.PeriodicTargetFactory(
start_date=period['start'],
end_date=period['end'],
customsort=period['customsort'],
target=target_value,
indicator=indicator))
return targets
