예제 #1
0
    def test_product_type_filter(self):
        """
        Notifications will not be sent if the stockout is a product type does
        not interest the user.
        """

        self.user.get_domain_membership(self.TEST_DOMAIN).program_id = self.program.get_id
        self.user.save()

        program = Program(domain=self.TEST_DOMAIN, name='Test Program 2')
        program.save()

        bootstrap_web_user(
            username='******', domain=self.TEST_DOMAIN, phone_number='+44445', location=self.district,
            password='******', email='*****@*****.**', user_data={}, program_id=program.get_id
        )

        assign_products_to_location(self.facility, [self.product])
        assign_products_to_location(self.other_facility, [self.product])
        assign_products_to_location(self.last_facility, [self.product])

        create_stock_report(self.facility, {'tp': 0})
        create_stock_report(self.other_facility, {'tp': 0})
        create_stock_report(self.last_facility, {'tp': 0})

        generated = list(UrgentStockoutAlert(self.TEST_DOMAIN).get_notifications())
        self.assertEqual(len(generated), 1)
        self.assertEqual(generated[0].user.get_id, self.user.get_id)
예제 #2
0
    def test_product_type_filter(self):
        """
        Notifications will not be sent if the stockout is a product type does
        not interest the user.
        """

        self.user.get_domain_membership(self.TEST_DOMAIN).program_id = self.program.get_id
        self.user.save()

        program = Program(domain=self.TEST_DOMAIN, name='Test Program 2')
        program.save()

        other_user = bootstrap_web_user(
            username='******', domain=self.TEST_DOMAIN, phone_number='+44445', location=self.region,
            password='******', email='*****@*****.**', user_data={}
        )

        assign_products_to_location(self.facility, [self.product])
        assign_products_to_location(self.other_facility, [self.product])
        assign_products_to_location(self.last_facility, [self.product])

        generated = list(UrgentNonReporting(self.TEST_DOMAIN).get_notifications())
        self.assertEqual(len(generated), 2)
        self.assertEqual({generated[0].user.get_id, generated[1].user.get_id},
                         {self.user.get_id, other_user.get_id})
예제 #3
0
    def __init__(self, product, *args, **kwargs):
        self.product = product

        kwargs['initial'] = self.product._doc
        kwargs['initial']['code'] = self.product.code

        super(ProductForm, self).__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-3 col-md-4 col-lg-2'
        self.helper.field_class = 'col-sm-4 col-md-5 col-lg-3'

        programs = Program.by_domain(self.product.domain, wrap=False)
        self.fields['program_id'].choices = tuple((prog['_id'], prog['name']) for prog in programs)

        # make sure to select default program if
        # this is a new product
        if not product._id:
            self.initial['program_id'] = Program.default_for_domain(self.product.domain)._id

        self.helper.layout = Layout(
            'name',
            'code',
            'description',
            'unit',
            'program_id',
            'cost'
        )
예제 #4
0
class SignalsTest(OpenLMISTestBase):
    requisitions_enabled = True
    program = None

    def createProgram(self):
        self.program = Program()
        self.program.domain = TEST_DOMAIN
        self.program.code = "QYZ"
        self.program.name = "hiv_program"

        self.program.save()

    def createProducts(self):
        with open(os.path.join(self.datapath, "sample_product_1.json")) as f:
            lmis_product_1 = json.loads(f.read())

        with open(os.path.join(self.datapath, "sample_product_2.json")) as f:
            lmis_product_2 = json.loads(f.read())

        lmis_product_1["program_id"] = self.program._id
        lmis_product_2["program_id"] = self.program._id

        product_1 = Product(lmis_product_1)
        product_2 = Product(lmis_product_2)
        product_1.save()
        product_2.save()

        self.products = []
        self.products.append(product_1)
        self.products.append(product_2)

    def setUp(self):
        super(SignalsTest, self).setUp()
        self.datapath = os.path.join(os.path.dirname(__file__), "data")
        self.spps.clear()
        self.createProgram()
        self.createProducts()

    def fixmetestSyncStockRequisition(self):
        from corehq.apps.commtrack.stockreport import Requisition

        requisition_cases = []
        config = self.domain.commtrack_settings
        for spp in self.spps.values():
            transaction = Requisition(
                config=config,
                product_id=spp.product,
                case_id=spp._id,
                action_name=config.get_action_by_type(RequisitionActions.REQUEST).action_name,
                value=20,
            )
            req = create_requisition(self.user._id, spp, transaction)
            requisition_cases.append(req)
        endpoint = MockOpenLMISSubmitEndpoint("uri://mock/lmis/endpoint", username="******", password="******")
        stock_data_submission(sender=None, cases=requisition_cases, endpoint=endpoint)

        for req in requisition_cases:
            self.assertEqual(req.external_id, "REQ_123")
예제 #5
0
    def test_programs(self):
        self.domain = bootstrap_domain(TEST_DOMAIN)
        self.addCleanup(self.domain.delete)
        bootstrap_products(self.domain.name)
        self.products = sorted(Product.by_domain(self.domain.name), key=lambda p: p._id)
        self.default_program = Program.by_domain(self.domain.name, wrap=True).one()
        self.new_program = make_program(
            self.domain.name,
            'new program',
            'newprogram'
        )
        self.assertTrue(self.default_program.default)
        self.assertFalse(self.new_program.default)

        with self.assertRaises(Exception) as context:
            self.default_program.delete()

        self.assertEqual(six.text_type(context.exception), 'You cannot delete the default program')

        # assign some product to the new program
        self.products[0].program_id = self.new_program._id
        self.products[0].save()

        # make sure start state is okay
        self.assertEqual(
            2,
            len(Program.by_domain(self.domain.name))
        )
        self.assertEqual(2, self.default_program.get_products_count())
        self.assertEqual(1, self.new_program.get_products_count())
        self.assertEqual(
            self.new_program._id,
            self.products[0].program_id
        )
        self.assertEqual(
            self.new_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )

        # stash the id before we delete
        new_program_id = self.new_program._id
        self.new_program.delete()

        with self.assertRaises(ResourceNotFound):
            Program.get(new_program_id)

        self.assertEqual(1, len(Program.by_domain(self.domain.name)))
        self.assertEqual(3, self.default_program.get_products_count())
        self.assertEqual(
            self.default_program._id,
            Product.get(self.products[0]._id).program_id
        )
        self.assertEqual(
            self.default_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )
예제 #6
0
    def test_delete(self):
        # assign some product to the new program
        self.products[0].program_id = self.new_program._id
        self.products[0].save()

        # make sure start state is okay
        self.assertEqual(
            2,
            len(Program.by_domain(self.domain.name))
        )
        self.assertEqual(
            2,
            Product.by_program_id(self.domain.name, self.default_program._id).count()
        )
        self.assertEqual(
            1,
            Product.by_program_id(self.domain.name, self.new_program._id).count()
        )
        self.assertEqual(
            self.new_program._id,
            self.products[0].program_id
        )
        self.assertEqual(
            self.new_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )

        # stash the id before we delete
        new_program_id = self.new_program._id
        self.new_program.delete()

        with self.assertRaises(ResourceNotFound):
            Program.get(new_program_id)

        self.assertEqual(
            1,
            len(Program.by_domain(self.domain.name))
        )
        self.assertEqual(
            3,
            Product.by_program_id(self.domain.name, self.default_program._id).count()
        )
        self.assertEqual(
            self.default_program._id,
            Product.get(self.products[0]._id).program_id
        )
        self.assertEqual(
            self.default_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )
예제 #7
0
파일: views.py 프로젝트: atinus/commcare-hq
    def product_data(self):
        data = []
        if self.show_inactive:
            products = Product.archived_by_domain(
                domain=self.domain,
                limit=self.limit,
                skip=self.skip(),
            )
        else:
            products = Product.by_domain(
                domain=self.domain,
                limit=self.limit,
                skip=self.skip(),
            )

        for p in products:
            if p.program_id:
                program = Program.get(p.program_id)
            else:
                program = get_or_create_default_program(self.domain)
                p.program_id = program.get_id
                p.save()

            info = p._doc
            info['program'] = program.name
            info['edit_url'] = reverse('commtrack_product_edit', kwargs={'domain': self.domain, 'prod_id': p._id})
            info['archive_action_desc'] = self.get_archive_text(self.show_inactive)
            info['archive_action_text'] = _("Un-Archive") if self.show_inactive else _("Archive")
            info['archive_url'] = reverse(
                'unarchive_product' if self.show_inactive else 'archive_product',
                kwargs={'domain': self.domain, 'prod_id': p._id}
            )
            data.append(info)
        return data
예제 #8
0
def stock_data_submission(sender, cases, endpoint=None, **kwargs):
    project = Domain.get_by_name(cases[0].domain)

    if project.commtrack_enabled and project.commtrack_settings.openlmis_enabled:

        if endpoint is None:
            endpoint = OpenLMISEndpoint.from_config(project.commtrack_settings.openlmis_config)

        # get agentCode and programCode - I assume all cases are part of the same program
        agentCode = (cases[0].get_supply_point_case()).location.site_code
        programCode = Program.get(cases[0].get_product().program_id).code

        products = []
        for case in cases:
            product = case.get_product()

            product_json = {'productCode': product.code}
            product_json['stockInHand'] = int(case.get_default_value())

            products.append(product_json)

        stock_data = {  'agentCode': agentCode,
                        'programCode': programCode,
                        'products': products
        }
        response = sync_stock_data_to_openlmis(submission=stock_data, openlmis_endpoint=endpoint)

        if response['requisitionId'] is not None:
            for case in cases:
                case.external_id = response['requisitionId']
                case.save()

            cases, send_notification = sync_requisition_from_openlmis(project.name, response['requisitionId'], endpoint)
            if send_notification:
                send_notifications(xform=None, cases=cases)
예제 #9
0
    def __init__(self, *args, **kwargs):
        from corehq.apps.locations.forms import LocationSelectWidget
        self.domain = kwargs.pop('domain', None)
        super(CommtrackUserForm, self).__init__(*args, **kwargs)
        self.fields['assigned_locations'].widget = LocationSelectWidget(
            self.domain, multiselect=True, id='id_assigned_locations'
        )
        self.fields['assigned_locations'].help_text = ExpandedMobileWorkerFilter.location_search_help
        self.fields['primary_location'].widget = PrimaryLocationWidget(
            css_id='id_primary_location',
            source_css_id='id_assigned_locations',
        )
        if self.commtrack_enabled:
            programs = Program.by_domain(self.domain)
            choices = list((prog.get_id, prog.name) for prog in programs)
            choices.insert(0, ('', ''))
            self.fields['program_id'].choices = choices
        else:
            self.fields['program_id'].widget = forms.HiddenInput()

        self.helper = FormHelper()

        self.helper.form_method = 'POST'
        self.helper.form_class = 'form-horizontal'
        self.helper.form_tag = False

        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
예제 #10
0
    def __init__(self, *args, **kwargs):
        self.domain = None
        if 'domain' in kwargs:
            self.domain = kwargs['domain']
            del kwargs['domain']
        super(CommtrackUserForm, self).__init__(*args, **kwargs)
        self.fields['assigned_locations'].widget = SupplyPointSelectWidget(
            self.domain, multiselect=True, id='id_assigned_locations')
        self.fields['primary_location'].widget = PrimaryLocationWidget(
            css_id='id_primary_location',
            source_css_id='id_assigned_locations')
        if self.commtrack_enabled:
            programs = Program.by_domain(self.domain, wrap=False)
            choices = list((prog['_id'], prog['name']) for prog in programs)
            choices.insert(0, ('', ''))
            self.fields['program_id'].choices = choices
        else:
            self.fields['program_id'].widget = forms.HiddenInput()

        self.helper = FormHelper()

        self.helper.form_method = 'POST'
        self.helper.form_class = 'form-horizontal'
        self.helper.form_tag = False

        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
예제 #11
0
    def get_url(cls, domain=None, render_as=None, **kwargs):

        def _is_admin(user, domain):
            return isinstance(user, WebUser) and user.get_domain_membership(domain).is_admin

        def _is_read_only(user, domain):
            user_role = user.get_role()
            return isinstance(user, WebUser) and user_role == UserRole.get_read_only_role_by_domain(domain)

        def _can_see_reports(user):
            user_role = user.get_role()
            return isinstance(user, CommCareUser) and user_role.permissions.view_reports

        url = super(MultiReport, cls).get_url(domain=domain, render_as=None, kwargs=kwargs)
        request = kwargs.get('request')
        user = getattr(request, 'couch_user', None)
        if user:
            if _is_admin(user, domain):
                loc = SQLLocation.objects.filter(domain=domain, location_type='country')[0]
                url = '%s?location_id=%s' % (url, loc.location_id)
            elif _is_read_only(user, domain) or _can_see_reports(user):
                    dm = user.get_domain_membership(domain)
                    if dm.program_id:
                        program_id = dm.program_id
                    else:
                        program_id = Program.default_for_domain(domain)
                    url = '%s?location_id=%s&program_id=%s' % (
                        url,
                        dm.location_id if dm.location_id else '',
                        program_id if program_id else ''
                    )

        return url
예제 #12
0
    def __init__(self, data=None, excluded_emails=None, *args, **kwargs):
        domain = None
        location = None
        if 'domain' in kwargs:
            domain = Domain.get_by_name(kwargs['domain'])
            del kwargs['domain']
        if 'location' in kwargs:
            location = kwargs['location']
            del kwargs['location']
        super(AdminInvitesUserForm, self).__init__(data=data, *args, **kwargs)
        if domain and domain.commtrack_enabled:
            self.fields['supply_point'] = forms.CharField(
                label='Supply Point:',
                required=False,
                widget=SupplyPointSelectWidget(domain=domain.name),
                initial=location.location_id if location else '')
            self.fields['program'] = forms.ChoiceField(label="Program",
                                                       choices=(),
                                                       required=False)
            programs = Program.by_domain(domain.name, wrap=False)
            choices = list((prog['_id'], prog['name']) for prog in programs)
            choices.insert(0, ('', ''))
            self.fields['program'].choices = choices
        self.excluded_emails = excluded_emails or []

        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.form_method = 'POST'
        self.helper.form_class = 'form-horizontal'

        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
예제 #13
0
    def __init__(self, *args, **kwargs):
        self.domain = None
        if 'domain' in kwargs:
            self.domain = kwargs['domain']
            del kwargs['domain']
        super(CommtrackUserForm, self).__init__(*args, **kwargs)
        self.fields['assigned_locations'].widget = SupplyPointSelectWidget(
            self.domain, multiselect=True, id='id_assigned_locations'
        )
        self.fields['primary_location'].widget = PrimaryLocationWidget(
            css_id='id_primary_location',
            source_css_id='id_assigned_locations'
        )
        if self.commtrack_enabled:
            programs = Program.by_domain(self.domain, wrap=False)
            choices = list((prog['_id'], prog['name']) for prog in programs)
            choices.insert(0, ('', ''))
            self.fields['program_id'].choices = choices
        else:
            self.fields['program_id'].widget = forms.HiddenInput()

        self.helper = FormHelper()

        self.helper.form_method = 'POST'
        self.helper.form_class = 'form-horizontal'
        self.helper.form_tag = False

        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
예제 #14
0
    def createProgram(self):
        self.program = Program()
        self.program.domain = TEST_DOMAIN
        self.program.code = "QYZ"
        self.program.name = "hiv_program"

        self.program.save()
예제 #15
0
    def __init__(self, data=None, excluded_emails=None, *args, **kwargs):
        domain = None
        location = None
        if 'domain' in kwargs:
            domain = Domain.get_by_name(kwargs['domain'])
            del kwargs['domain']
        if 'location' in kwargs:
            location = kwargs['location']
            del kwargs['location']
        super(AdminInvitesUserForm, self).__init__(data=data, *args, **kwargs)
        if domain and domain.commtrack_enabled:
            self.fields['supply_point'] = forms.CharField(label='Supply Point:', required=False,
                                                          widget=SupplyPointSelectWidget(domain.name),
                                                          initial=location.location_id if location else '')
            self.fields['program'] = forms.ChoiceField(label="Program", choices=(), required=False)
            programs = Program.by_domain(domain.name, wrap=False)
            choices = list((prog['_id'], prog['name']) for prog in programs)
            choices.insert(0, ('', ''))
            self.fields['program'].choices = choices
        self.excluded_emails = excluded_emails or []

        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.form_method = 'POST'
        self.helper.form_class = 'form-horizontal'

        self.helper.label_class = 'col-sm-3 col-md-2'
        self.helper.field_class = 'col-sm-9 col-md-8 col-lg-6'
예제 #16
0
def program_fixture_generator(user, version, last_sync=None):
    fields = [
        'name',
        'code'
    ]
    data_fn = lambda: Program.by_domain(user.domain)
    return _simple_fixture_generator(user, "program", fields, data_fn, last_sync)
예제 #17
0
    def test_program_fixture(self):
        user = self.user
        Program(
            domain=user.domain,
            name="test1",
            code="t1"
        ).save()

        program_list = Program.by_domain(user.domain)
        program_xml = self.generate_program_xml(program_list, user)

        fixture = call_fixture_generator(program_fixture_generator, user)

        self.assertXmlEqual(
            program_xml,
            ElementTree.tostring(fixture[0])
        )
예제 #18
0
 def drilldown_map(self):
     options = []
     for program in Program.by_domain(self.domain):
         products = []
         for product in Product.by_program_id(self.domain, program._id):
             products.append({"val": product.get_id, "text": product.name})
         options.append({"val": program.get_id, "text": program.name, "next": products})
     return options
예제 #19
0
 def update_params(self):
     self.selected = self.request.GET.get("program")
     user = WebUser.get_by_username(str(self.request.user))
     if not self.selected and self.selected != "" and user.get_domain_membership(self.domain):
         self.selected = user.get_domain_membership(self.domain).program_id
     self.programs = Program.by_domain(self.domain)
     opts = [dict(val=program.get_id, text=program.name) for program in self.programs]
     self.options = opts
예제 #20
0
 def drilldown_map(self):
     options = [{"val": ALL_OPTION, "text": "All", "next": []}]
     for program in Program.by_domain(self.domain):
         products = [{"val": ALL_OPTION, "text": "All", "next": []}]
         for product in SQLProduct.objects.filter(domain=self.domain, program_id=program.get_id):
             products.append({"val": product.id, "text": product.name})
         options.append({"val": program.get_id, "text": program.name, "next": products})
     return options
예제 #21
0
    def __init__(self, product, *args, **kwargs):
        self.product = product

        kwargs['initial'] = self.product._doc
        kwargs['initial']['code'] = self.product.code

        super(ProductForm, self).__init__(*args, **kwargs)

        programs = Program.by_domain(self.product.domain, wrap=False)
        self.fields['program_id'].choices = tuple((prog['_id'], prog['name']) for prog in programs)

        # make sure to select default program if
        # this is a new product
        if not product._id:
            self.initial['program_id'] = Program.default_for_domain(
                self.product.domain
            )._id
예제 #22
0
    def __call__(self, restore_state):
        restore_user = restore_state.restore_user

        data_fn = lambda: Program.by_domain(restore_user.domain)
        return simple_fixture_generator(
            restore_user, self.id, "program",
            PROGRAM_FIELDS, data_fn, restore_state.last_sync_log
        )
예제 #23
0
 def setUp(self):
     super(ProgramsTest, self).setUp()
     self.default_program = Program.by_domain(self.domain.name, wrap=True).one()
     self.new_program = make_program(
         self.domain.name,
         'new program',
         'newprogram'
     )
예제 #24
0
    def test_programs(self):
        self.domain = bootstrap_domain(TEST_DOMAIN)
        self.addCleanup(self.domain.delete)
        bootstrap_products(self.domain.name)
        self.products = sorted(Product.by_domain(self.domain.name),
                               key=lambda p: p._id)
        self.default_program = Program.by_domain(self.domain.name,
                                                 wrap=True).one()
        self.new_program = make_program(self.domain.name, 'new program',
                                        'newprogram')
        self.assertTrue(self.default_program.default)
        self.assertFalse(self.new_program.default)

        with self.assertRaises(Exception) as context:
            self.default_program.delete()

        self.assertEqual(context.exception.message,
                         'You cannot delete the default program')

        # assign some product to the new program
        self.products[0].program_id = self.new_program._id
        self.products[0].save()

        # make sure start state is okay
        self.assertEqual(2, len(Program.by_domain(self.domain.name)))
        self.assertEqual(2, self.default_program.get_products_count())
        self.assertEqual(1, self.new_program.get_products_count())
        self.assertEqual(self.new_program._id, self.products[0].program_id)
        self.assertEqual(
            self.new_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id)

        # stash the id before we delete
        new_program_id = self.new_program._id
        self.new_program.delete()

        with self.assertRaises(ResourceNotFound):
            Program.get(new_program_id)

        self.assertEqual(1, len(Program.by_domain(self.domain.name)))
        self.assertEqual(3, self.default_program.get_products_count())
        self.assertEqual(self.default_program._id,
                         Product.get(self.products[0]._id).program_id)
        self.assertEqual(
            self.default_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id)
예제 #25
0
    def __call__(self, restore_state):
        restore_user = restore_state.restore_user

        data_fn = lambda: Program.by_domain(restore_user.domain)
        return simple_fixture_generator(
            restore_user, self.id, "program",
            PROGRAM_FIELDS, data_fn, restore_state.last_sync_log
        )
예제 #26
0
파일: forms.py 프로젝트: ekush/commcare-hq
    def __init__(self, product, *args, **kwargs):
        self.product = product

        kwargs['initial'] = self.product._doc
        kwargs['initial']['code'] = self.product.code

        super(ProductForm, self).__init__(*args, **kwargs)

        programs = Program.by_domain(self.product.domain, wrap=False)
        self.fields['program_id'].choices = tuple(
            (prog['_id'], prog['name']) for prog in programs)

        # make sure to select default program if
        # this is a new product
        if not product._id:
            self.initial['program_id'] = Program.default_for_domain(
                self.product.domain)._id
예제 #27
0
 def product_sync(self, ilsgateway_product):
     from custom.ilsgateway import PRODUCTS_CODES_PROGRAMS_MAPPING
     product = super(ILSGatewayAPI, self).product_sync(ilsgateway_product)
     programs = list(Program.by_domain(self.domain))
     for program, products in PRODUCTS_CODES_PROGRAMS_MAPPING.iteritems():
         if product.code in products:
             existing_program = filter(lambda p: p.name == program, programs)
             if not existing_program:
                 new_program = Program(domain=self.domain)
                 new_program.name = program
                 new_program.save()
                 product.program_id = new_program.get_id
                 product.save()
             else:
                 product.program_id = existing_program[0].get_id
                 product.save()
     return product
예제 #28
0
 def drilldown_map(self):
     options = [{"val": ALL_OPTION, "text": "All", "next": []}]
     for program in Program.by_domain(self.domain):
         products = [{"val": ALL_OPTION, "text": "All", "next": []}]
         for product in Product.by_program_id(self.domain, program._id):
             products.append({"val": product.get_id, "text": product.name + ' (%s)' % product.code})
         options.append({"val": program.get_id, "text": program.name, "next": products})
     return options
예제 #29
0
 def drilldown_map(self):
     options = [{"val": ALL_OPTION, "text": "All", "next": []}]
     for program in Program.by_domain(self.domain):
         products = [{"val": ALL_OPTION, "text": "All", "next": []}]
         for product in SQLProduct.objects.filter(domain=self.domain, program_id=program.get_id):
             products.append({"val": product.id, "text": product.name})
         options.append({"val": program.get_id, "text": program.name, "next": products})
     return options
예제 #30
0
 def setUp(self):
     super(ProgramsTest, self).setUp()
     self.default_program = Program.by_domain(self.domain.name, wrap=True).one()
     self.new_program = make_program(
         self.domain.name,
         'new program',
         'newprogram'
     )
예제 #31
0
    def test_selective_program_sync(self):
        user = self.user
        Program(domain=user.domain, name="test1", code="t1").save()

        program_list = Program.by_domain(user.domain)
        program_xml = self.generate_program_xml(program_list, user)

        fixture_original = call_fixture_generator(program_fixture_generator,
                                                  user)

        deprecated_generate_restore_payload(self.domain_obj, user)
        self.assertXmlEqual(program_xml,
                            ElementTree.tostring(fixture_original[0]))

        first_sync = self._get_latest_synclog()
        # make sure the time stamp on this first sync is
        # not on the same second that the programs were created
        first_sync.date += datetime.timedelta(seconds=1)

        # second sync is before any changes are made, so there should
        # be no programs synced
        fixture_pre_change = call_fixture_generator(program_fixture_generator,
                                                    user,
                                                    last_sync=first_sync)
        deprecated_generate_restore_payload(self.domain_obj, user)
        self.assertEqual([], fixture_pre_change,
                         "Fixture was not empty on second sync")

        second_sync = self._get_latest_synclog()

        self.assertTrue(first_sync._id != second_sync._id)

        # save should make the program more recently updated than the
        # last sync
        for program in program_list:
            program.save()

        # now that we've updated a program, we should get
        # program data in sync again
        fixture_post_change = call_fixture_generator(program_fixture_generator,
                                                     user,
                                                     last_sync=second_sync)

        # regenerate the fixture xml to make sure it is still legit
        self.assertXmlEqual(program_xml,
                            ElementTree.tostring(fixture_post_change[0]))
예제 #32
0
def delete_program(request, domain, prog_id):
    program = Program.get(prog_id)
    program.delete()
    return json_response({
        'success': True,
        'message': _("Program '{program_name}' has successfully been deleted.").format(
            program_name=program.name,
        )
    })
예제 #33
0
    def test_program_fixture(self):
        user = self.user
        Program(domain=user.domain, name="test1", code="t1").save()

        program_list = Program.by_domain(user.domain)
        program_xml = self.generate_program_xml(program_list, user)

        fixture = call_fixture_generator(program_fixture_generator, user)

        self.assertXmlEqual(program_xml, fixture[0])

        # test restore with different user
        user2 = create_restore_user(self.domain, username='******')
        self.addCleanup(user2._couch_user.delete)
        program_xml = self.generate_program_xml(program_list, user2)
        fixture = call_fixture_generator(program_fixture_generator, user2)

        self.assertXmlEqual(program_xml, fixture[0])
예제 #34
0
def delete_program(request, domain, prog_id):
    program = Program.get(prog_id)
    program.delete()
    return JsonResponse({
        'success': True,
        'message': _("Program '{program_name}' has successfully been deleted.").format(
            program_name=program.name,
        )
    })
예제 #35
0
 def commtrack_programs():
     if app.commtrack_enabled:
         programs = Program.by_domain(app.domain)
         return [{
             'value': program.get_id,
             'label': program.name
         } for program in programs]
     else:
         return []
예제 #36
0
def make_program(domain, name, code, default=False):
    p = Program()
    p.domain = domain
    p.name = name
    p.code = code.lower()
    p.default = default
    p.save()
    return p
예제 #37
0
 def program_data(self):
     data = []
     programs = Program.by_domain(self.domain)
     for p in programs:
         info = p._doc
         info['is_default'] = info.pop('default')
         info['edit_url'] = reverse('commtrack_program_edit', kwargs={'domain': self.domain, 'prog_id': p._id})
         info['delete_url'] = reverse('delete_program', kwargs={'domain': self.domain, 'prog_id': p._id})
         data.append(info)
     return data
예제 #38
0
 def program_data(self):
     data = []
     programs = Program.by_domain(self.domain)
     for p in programs:
         info = p._doc
         info['is_default'] = info.pop('default')
         info['edit_url'] = reverse('commtrack_program_edit', kwargs={'domain': self.domain, 'prog_id': p._id})
         info['delete_url'] = reverse('delete_program', kwargs={'domain': self.domain, 'prog_id': p._id})
         data.append(info)
     return data
예제 #39
0
def get_or_create_default_program(domain):
    program = Program.default_for_domain(domain)

    if program:
        return program
    else:
        return make_program(domain,
                            _('Uncategorized'),
                            _('uncategorized'),
                            default=True)
예제 #40
0
    def test_program_fixture(self):
        user = create_restore_user(self.domain.name)
        Program(domain=user.domain, name="test1", code="t1").save()

        program_list = Program.by_domain(user.domain)
        program_xml = self.generate_program_xml(program_list, user)

        fixture = program_fixture_generator(user, V1)

        self.assertXmlEqual(program_xml, ElementTree.tostring(fixture[0]))
예제 #41
0
    def rendered_content(self):
        location = SQLLocation.objects.get(
            location_id=self.config['location_id'])
        if location.location_type.administrative:
            locations = get_descendants(self.config['location_id'])
            products = self.unique_products(locations, all=True)
        else:
            products = location.products
        programs = {
            program.get_id: program.name
            for program in Program.by_domain(self.domain)
        }
        headers = []
        if 'report_type' in self.config:
            from custom.ewsghana.reports.specific_reports.stock_status_report import MonthOfStockProduct
            headers = [
                h.html for h in MonthOfStockProduct(self.config).headers
            ]

        result = {}
        for idx, product in enumerate(products, start=1):
            program = programs[product.program_id]
            product_dict = {
                'name':
                product.name,
                'code':
                product.code,
                'idx':
                idx if not headers else
                headers.index(product.code) if product.code in headers else -1,
                'checked':
                self.config['program'] is None
                or self.config['program'] == product.program_id
            }
            if program in result:
                result[program]['product_list'].append(product_dict)
                if result[program]['all'] and not product_dict['checked']:
                    result[program]['all'] = False
            else:
                result[program] = {
                    'product_list': [product_dict],
                    'all': product_dict['checked']
                }

        for _, product_dict in result.iteritems():
            product_dict['product_list'].sort(key=lambda prd: prd['name'])
        return render_to_string(
            'ewsghana/partials/product_selection_pane.html', {
                'products_by_program':
                result,
                'is_rendered_as_email':
                self.config.get('is_rendered_as_email', False),
                'hide_columns':
                self.hide_columns
            })
예제 #42
0
 def _report_info(self):
     program_id = self.request.GET.get('filter_by_program')
     return [['Title of report', 'Location', 'Date range', 'Program'],
             [
                 self.title,
                 self.location.name if self.location else 'NATIONAL',
                 '{} - {}'.format(ews_date_format(self.datespan.startdate),
                                  ews_date_format(self.datespan.enddate)),
                 'all' if not program_id or program_id == 'all' else
                 Program.get(docid=program_id).name
             ], []]
예제 #43
0
파일: forms.py 프로젝트: atinus/commcare-hq
    def clean_name(self):
        name = self.cleaned_data['name']

        other_program_names = [
            p['name'] for p in Program.by_domain(self.program.domain, wrap=False)
            if p['_id'] != self.program._id
        ]
        if name in other_program_names:
            raise forms.ValidationError(_('Name already in use'))

        return name
예제 #44
0
 def _report_info(self):
     program_id = self.request.GET.get('filter_by_program')
     return [
         ['Title of report', 'Location', 'Date range', 'Program'],
         [
             self.title,
             self.active_location.name,
             '{} - {}'.format(self.datespan.startdate_display, self.datespan.enddate_display),
             'all' if not program_id or program_id == 'all' else Program.get(docid=program_id).name
         ],
         []
     ]
예제 #45
0
def get_or_create_default_program(domain):
    program = Program.default_for_domain(domain)

    if program:
        return program
    else:
        return make_program(
            domain,
            _('Uncategorized'),
            _('uncategorized'),
            default=True
        )
예제 #46
0
def create_test_products(domain):
    program = Program(domain=domain, name='HIV/AIDS', code='hiv')
    program.save()

    abacavir = Product(
        domain=domain,
        name="Abacavir 300mg",
        code_="abc",
        program_id=program.get_id,
    )
    abacavir.save()

    ali = Product(
        domain=domain,
        name="AL 20mg/120mg 1X6",
        code_="ali",
        program_id=program.get_id,
    )
    ali.save()

    al = Product(
        domain=domain,
        name="AL 20mg/120mg 4x6",
        code_="alk"
    )
    al.save()

    ad = Product(
        domain=domain,
        name="A-L Dispersible",
        code_="ad"
    )
    ad.save()

    al = Product(
        domain=domain,
        name="A-L Suspension",
        code_="al"
    )
    al.save()
예제 #47
0
    def test_selective_program_sync(self):
        user = self.user
        Program(
            domain=user.domain,
            name="test1",
            code="t1"
        ).save()

        program_list = Program.by_domain(user.domain)
        program_xml = self.generate_program_xml(program_list, user)

        fixture_original = call_fixture_generator(program_fixture_generator, user)

        deprecated_generate_restore_payload(self.domain_obj, user)
        self.assertXmlEqual(
            program_xml,
            ElementTree.tostring(fixture_original[0])
        )

        first_sync = self._get_latest_synclog()
        # make sure the time stamp on this first sync is
        # not on the same second that the programs were created
        first_sync.date += datetime.timedelta(seconds=1)

        # second sync is before any changes are made, so there should
        # be no programs synced
        fixture_pre_change = call_fixture_generator(program_fixture_generator, user, last_sync=first_sync)
        deprecated_generate_restore_payload(self.domain_obj, user)
        self.assertEqual(
            [],
            fixture_pre_change,
            "Fixture was not empty on second sync"
        )

        second_sync = self._get_latest_synclog()

        self.assertTrue(first_sync._id != second_sync._id)

        # save should make the program more recently updated than the
        # last sync
        for program in program_list:
            program.save()

        # now that we've updated a program, we should get
        # program data in sync again
        fixture_post_change = call_fixture_generator(program_fixture_generator, user, last_sync=second_sync)

        # regenerate the fixture xml to make sure it is still legit
        self.assertXmlEqual(
            program_xml,
            ElementTree.tostring(fixture_post_change[0])
        )
예제 #48
0
 def test_create_product(self):
     with open(os.path.join(self.datapath, 'sample_products.json')) as f:
         product = Product(json.loads(f.read())[0])
     self.assertEqual(0, len(Prod.by_domain(TEST_DOMAIN)))
     ewsghana_product = self.api_object.product_sync(product)
     self.assertEqual(product.sms_code, ewsghana_product.code.lower())
     self.assertEqual(product.name, ewsghana_product.name)
     self.assertEqual(product.description, ewsghana_product.description)
     self.assertEqual(product.units, str(ewsghana_product.unit))
     self.assertIsNotNone(ewsghana_product.program_id)
     program = Program.get(ewsghana_product.program_id)
     self.assertEqual(product.program.name, program.name)
     self.assertEqual(product.program.code, program.code)
예제 #49
0
    def test_set_program(self):
        program_id = uuid.uuid4().hex
        program = Program(_id=program_id, name="Program Name")

        self._test_change_messages(UserChangeMessage.program_change, [program],
                                   {
                                       "program": {
                                           "set_program": {
                                               "id": program_id,
                                               "name": "Program Name"
                                           }
                                       }
                                   }, f"Program: Program Name[{program_id}]")
예제 #50
0
 def update_params(self):
     self.selected = self.request.GET.get('program')
     user = WebUser.get_by_username(str(self.request.user))
     if not self.selected and \
        self.selected != '' and \
        user.get_domain_membership(self.domain):
         self.selected = user.get_domain_membership(self.domain).program_id
     self.programs = Program.by_domain(self.domain)
     opts = [
         dict(val=program.get_id, text=program.name)
         for program in self.programs
     ]
     self.options = opts
예제 #51
0
파일: forms.py 프로젝트: ekush/commcare-hq
    def clean_name(self):
        name = self.cleaned_data['name'].strip()
        if not name:
            raise forms.ValidationError(_('This field is required.'))

        other_program_names = [
            p['name'] for p in Program.by_domain(self.program.domain, wrap=False)
            if p['_id'] != self.program._id
        ]
        if name in other_program_names:
            raise forms.ValidationError(_('Name already in use'))

        return name
예제 #52
0
def ews_product_extension(couch_product, product):
    if not product.program.code:
        return couch_product
    program = Program.get_by_code(couch_product.domain, product.program.code)
    if not program:
        program = Program(domain=couch_product.domain)
        program.name = product.program.name
        program.code = product.program.code.lower()
        program._doc_type_attr = "Program"
        program.save()
    if couch_product.program_id != program._id:
        couch_product.program_id = program._id
        couch_product.save()

    return couch_product
예제 #53
0
    def test_delete(self):
        # assign some product to the new program
        self.products[0].program_id = self.new_program._id
        self.products[0].save()

        # make sure start state is okay
        self.assertEqual(
            2,
            len(Program.by_domain(self.domain.name))
        )
        self.assertEqual(2, self.default_program.get_products_count())
        self.assertEqual(1, self.new_program.get_products_count())
        self.assertEqual(
            self.new_program._id,
            self.products[0].program_id
        )
        self.assertEqual(
            self.new_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )

        # stash the id before we delete
        new_program_id = self.new_program._id
        self.new_program.delete()

        with self.assertRaises(ResourceNotFound):
            Program.get(new_program_id)

        self.assertEqual(1, len(Program.by_domain(self.domain.name)))
        self.assertEqual(3, self.default_program.get_products_count())
        self.assertEqual(
            self.default_program._id,
            Product.get(self.products[0]._id).program_id
        )
        self.assertEqual(
            self.default_program._id,
            SQLProduct.objects.get(product_id=self.products[0]._id).program_id
        )
예제 #54
0
파일: forms.py 프로젝트: ekush/commcare-hq
 def __init__(self, *args, **kwargs):
     domain = None
     if 'domain' in kwargs:
         domain = kwargs['domain']
         del kwargs['domain']
     super(CommtrackUserForm, self).__init__(*args, **kwargs)
     self.fields['location'].widget = SupplyPointSelectWidget(domain=domain)
     if Domain.get_by_name(domain).commtrack_enabled:
         programs = Program.by_domain(domain, wrap=False)
         choices = list((prog['_id'], prog['name']) for prog in programs)
         choices.insert(0, ('', ''))
         self.fields['program_id'].choices = choices
     else:
         self.fields['program_id'].widget = forms.HiddenInput()
예제 #55
0
    def _get_fixture_items(self, restore_state):
        restore_user = restore_state.restore_user

        project = restore_user.project
        if not project or not project.commtrack_enabled:
            return []

        data = Program.by_domain(restore_user.domain)

        if not self._should_sync(data, restore_state.last_sync_log):
            return []

        return simple_fixture_generator(restore_user, self.id, "program",
                                        PROGRAM_FIELDS, data)
예제 #56
0
def sync_openlmis_program(domain, lmis_program):
    program = get_program(domain, lmis_program)
    if program is None:
        program = Program(domain=domain)

    program.name = lmis_program.name
    program.code = lmis_program.code.lower()
    program._doc_type_attr = "Program"
    program.save()
    if lmis_program.products:
        for lmis_product in lmis_program.products:
            sync_openlmis_product(domain, program, lmis_product)
    return program
예제 #57
0
    def __init__(self, product, *args, **kwargs):
        self.product = product

        kwargs['initial'] = self.product._doc
        kwargs['initial']['code'] = self.product.code

        super(ProductForm, self).__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_tag = False
        self.helper.label_class = 'col-sm-3 col-md-4 col-lg-2'
        self.helper.field_class = 'col-sm-4 col-md-5 col-lg-3'

        programs = Program.by_domain(self.product.domain)
        self.fields['program_id'].choices = tuple(
            (prog.get_id, prog.name) for prog in programs)

        # make sure to select default program if
        # this is a new product
        if not product._id:
            self.initial['program_id'] = Program.default_for_domain(
                self.product.domain)._id

        self.helper.layout = Layout('name', 'code', 'description', 'unit',
                                    'program_id', 'cost')
예제 #58
0
def program_fixture_generator_json(domain):
    if Program.by_domain(domain).count() == 0:
        return None

    fields = list(PROGRAM_FIELDS)
    fields.append('@id')

    uri = 'jr://fixture/{}'.format(ProgramFixturesProvider.id)
    return {
        'id': 'programs',
        'uri': uri,
        'path': '/programs/program',
        'name': 'Programs',
        'structure': {f: {'name': f, 'no_option': True} for f in fields},
    }
예제 #59
0
 def report_subtitles(self):
     if self.is_rendered_as_email:
         program = self.request.GET.get('filter_by_program')
         products = self.request.GET.getlist('filter_by_product')
         return mark_safe("""
         <br>For Filters:<br>
         Location: {0}<br>
         Program: {1}<br>
         Product: {2}<br>
         Date range: {3} - {4}
         """.format(
             self.location.name,
             Program.get(program).name if program and program != ALL_OPTION
             else ALL_OPTION.title(), ", ".join([
                 p.name
                 for p in SQLProduct.objects.filter(product_id__in=products)
             ])
             if products != ALL_OPTION and products else ALL_OPTION.title(),
             ews_date_format(self.datespan.startdate_utc),
             ews_date_format(self.datespan.enddate_utc)))
     return None