def test_generate(self):
        """Can we bulk generate periodic targets?"""

        tf = Indicator.MONTHLY
        result = generate_periodic_targets(tf, self.start_date,
                                           self.total_targets, self.event_name)

        self.assertTrue(len(result) == 10)
 def test_generate_third_annual(self):
     """does the generated period name for a new target end with the right number (counting up from existing)?"""
     for tf in self.DATE_AWARE_FREQUENCIES:
         result = generate_periodic_targets(tf, self.start_date, 1, '', 2)
         self.assertEqual(
             result[0]['period'][-1], '3',
             "third {0} target period name should end with 3, got {1}".
             format(tf, result[0]['period']))
    def test_mid(self):
        """Do we get back the correct response if we are doing MID?"""

        tf = Indicator.MID_END
        expected = [{'period': 'Midline'}, {'period': 'Endline'}]
        result = generate_periodic_targets(tf, self.start_date,
                                           self.total_targets, self.event_name)

        self.assertEqual(expected, result)
    def test_lop(self):
        """Do we get back the correct response if we are doing
        Life of Project?"""

        tf = Indicator.LOP
        expected = {'period': u'Life of Program (LoP) only'}
        result = generate_periodic_targets(tf, self.start_date,
                                           self.total_targets, self.event_name)
        self.assertDictEqual(expected, result)
Beispiel #5
0
    def make_targets(program, indicator):
        if indicator.target_frequency == Indicator.LOP:
            PeriodicTarget.objects.create(
                **{
                    'indicator': indicator,
                    'customsort': 1,
                    'edit_date': timezone.now(),
                    'period': 'LOP target',
                })
            return
        elif indicator.target_frequency == Indicator.EVENT:
            for i in range(3):
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Event {}'.format(i + 1),
                    })
            return

        target_generator = PeriodicTarget.generate_for_frequency(
            indicator.target_frequency)
        num_periods = len([
            p for p in target_generator(program.reporting_period_start,
                                        program.reporting_period_end)
        ])

        if indicator.target_frequency == Indicator.LOP:
            print 'lop num_periods'
        targets_json = generate_periodic_targets(
            tf=indicator.target_frequency,
            start_date=program.reporting_period_start,
            numTargets=num_periods)
        for i, pt in enumerate(targets_json):
            if indicator.target_frequency in [
                    Indicator.LOP, Indicator.MID_END
            ]:
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Period {}'.format(i + 1),
                    })
            else:
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Period {}'.format(i + 1),
                        'start_date': pt['start_date'],
                        'end_date': pt['end_date'],
                    })
Beispiel #6
0
def make_targets(program, indicator):
    num_periods = IPTT_ReportView._get_num_periods(
        program.reporting_period_start, program.reporting_period_end,
        indicator.target_frequency)
    targets_json = generate_periodic_targets(
        tf=indicator.target_frequency,
        start_date=program.reporting_period_start,
        numTargets=num_periods)
    for i, pt in enumerate(targets_json):
        PeriodicTargetFactory(indicator=indicator,
                              customsort=i,
                              start_date=pt['start_date'],
                              end_date=pt['end_date'],
                              edit_date=timezone.now())
Beispiel #7
0
def make_targets(program, indicator):
    num_periods = len([
        x
        for x in program.get_periods_for_frequency(indicator.target_frequency)
    ])
    targets_json = generate_periodic_targets(
        tf=indicator.target_frequency,
        start_date=program.reporting_period_start,
        numTargets=num_periods)
    for i, pt in enumerate(targets_json):
        PeriodicTargetFactory(indicator=indicator,
                              customsort=i,
                              start_date=pt['start_date'],
                              end_date=pt['end_date'],
                              edit_date=timezone.now())
Beispiel #8
0
 def generate_targets(self, indicator, skip=None):
     #pylint: disable=W0212
     target_frequency_num_periods = IPTT_ReportView._get_num_periods(
         self.program.reporting_period_start,
         self.program.reporting_period_end, self.frequency)
     if skip is not None:
         target_frequency_num_periods -= 1
     if target_frequency_num_periods == 0:
         return []
     generatedTargets = generate_periodic_targets(
         self.frequency, self.program.reporting_period_start,
         target_frequency_num_periods, '')
     to_return_targets = []
     for target in generatedTargets:
         to_return_targets.append(
             i_factories.PeriodicTargetFactory(
                 indicator=indicator,
                 period=target['period'],
                 start_date=target['start_date'],
                 end_date=target['end_date']))
     return to_return_targets
    def make_targets(program, indicator):
        if indicator.target_frequency == Indicator.EVENT:
            for i in range(3):
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Event {}'.format(i + 1),
                    })
            return

        num_periods = IPTT_ReportView._get_num_periods(
            program.reporting_period_start, program.reporting_period_end,
            indicator.target_frequency)
        targets_json = generate_periodic_targets(
            tf=indicator.target_frequency,
            start_date=program.reporting_period_start,
            numTargets=num_periods)
        for i, pt in enumerate(targets_json):
            if indicator.target_frequency in [
                    Indicator.LOP, Indicator.MID_END
            ]:
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Period {}'.format(i + 1),
                    })
            else:
                PeriodicTarget.objects.create(
                    **{
                        'indicator': indicator,
                        'customsort': i,
                        'edit_date': timezone.now(),
                        'period': 'Period {}'.format(i + 1),
                        'start_date': pt['start_date'],
                        'end_date': pt['end_date'],
                    })