예제 #1
0
 def testSaveSameContactTwice(self):
     NAME = "newuser"
     PHONE = "+233123"
     contact = Contact(name=NAME)
     form = CommoditiesContactForm({
         'name': NAME,
         'phone': PHONE
     },
                                   instance=contact)
     self.assertTrue(form.is_valid())
     # this time around, the form should NOT throw an error on re-registration
     contact.save()
     contact.set_default_connection_identity(PHONE,
                                             settings.DEFAULT_BACKEND)
     form = CommoditiesContactForm({
         'name': NAME,
         'phone': PHONE
     },
                                   instance=contact)
     self.assertTrue(form.is_valid())
     # this time around, the form should throw an error on duplicate registration
     NEWNAME = "newname"
     new_contact = Contact(name=NEWNAME)
     form = CommoditiesContactForm({
         'name': NEWNAME,
         'phone': PHONE
     },
                                   instance=new_contact)
     self.assertFalse(form.is_valid())
예제 #2
0
    def _save_contact(self, data):
        """Save contact to database"""

        # Create connection, or if this is a re-register, just use (one
        # of) the old one(s).
        old_connections = self.connections.filter(contact__isnull=True)
        if len(old_connections) > 0:
            conn = old_connections[0]
        else:
            gsm_backend = Backend.objects.get(name='gsm')
            #gsm_backend = Backend.objects.get(name='message_tester')
            conn = Connection(backend=gsm_backend, identity=data['phone_no'])

        # Create contact
        contact = Contact(name=data['name'],
                          language=data['lang'],
                          is_active=False,
                          only_important=data['only_important'])
        contact.save()
        contact.categories = data['categories']
        contact.save()
        conn.contact = contact
        conn.save()

        return contact
예제 #3
0
    def handle(self, message):
        entry = ScriptProgress.objects.filter(
            script__slug__startswith='hotline_script',
            connection=message.connection)
        text = (message.text).lower()

        if (not entry.exists()):
            matches = difflib.get_close_matches(
                text, settings.REPORT_KEYWORDS.keys(), 1)

            if not matches:
                return False

            keyword = matches[0]
            language = settings.REPORT_KEYWORDS[keyword]
            slug_name = 'hotline_script_%s' % language

            ScriptProgress.objects.create(
                script=Script.objects.get(slug=slug_name),
                connection=message.connection)
            report = IGReport.objects.create(connection=message.connection,
                                             keyword=message.text)
            contact = Contact(name=message.connection.identity,
                              language=language)
            contact.save()
            report.connection.contact = contact
            report.connection.save()

            return True

        return False
예제 #4
0
파일: views.py 프로젝트: dimagi/rapidsms
def registration(req, pk=None, template="registration/dashboard.html"):
    contact = None
    connection = None
    bulk_form = None

    if pk is not None:
        contact = get_object_or_404(Contact, pk=pk)
        connection = get_object_or_404(Connection, contact__name=contact.name)

    if req.method == "POST":
        if req.POST["submit"] == "Delete Contact":
            contact.delete()
            return HttpResponseRedirect(reverse(registration))

        elif "bulk" in req.FILES:
            # TODO use csv module
            #reader = csv.reader(open(req.FILES["bulk"].read(), "rb"))
            #for row in reader:
            for line in req.FILES["bulk"]:
                line_list = line.split(',')
                name = line_list[0].strip()
                backend_name = line_list[1].strip()
                identity = line_list[2].strip()

                contact = Contact(name=name)
                contact.save()
                # TODO deal with errors!
                backend = Backend.objects.get(name=backend_name)

                connection = Connection(backend=backend, identity=identity,\
                    contact=contact)
                connection.save()

            return HttpResponseRedirect(reverse(registration))
        else:
            contact_form = ContactForm(instance=contact, data=req.POST)
            connection_form = ConnectionForm(req.POST, instance=connection)

            if contact_form.is_valid() and connection_form.is_valid():
                contact = contact_form.save()
                connection = connection_form.save(commit=False)
                connection.contact = contact
                connection.save()
                return HttpResponseRedirect(reverse(registration))

    else:
        contact_form = ContactForm(instance=contact)
        bulk_form = BulkRegistrationForm()
        connection_form = ConnectionForm(instance=connection)

    return render_to_response(
        template, {
            "contacts_table": ContactTable(Contact.objects.all(), request=req),
            "contact_form": contact_form,
            "connection_form": connection_form,
            "bulk_form": bulk_form,
            "contact": contact
        },
        context_instance=RequestContext(req))
예제 #5
0
 def get_or_create_contact(self):
     if self.contact is not None:
         return self.contact
     contact = Contact(name=self.user.username)
     contact.save()
     self.contact = contact
     self.save()
     return self.contact
예제 #6
0
파일: join.py 프로젝트: makandok/mwana
    def handle(self, text):

        tokens = self.check_message_valid_and_clean(text)

        if not tokens:
            return
        clinic_code = LocationCode(tokens[0])
        name = tokens[2]
        pin = tokens[4]
        worker_type = clinic_code.get_worker_type()
        location_type = clinic_code.get_location_type()

        if is_already_valid_connection_type(self.msg.connection, worker_type):
            # refuse re-registration if they're still active and eligible
            self.respond(self.ALREADY_REGISTERED,
                         name=self.msg.connection.contact.name,
                         location=self.msg.connection.contact.location)
            return False

        try:
            location = Location.objects.get(slug__iexact=clinic_code.slug,
                                            type__slug__in=location_type)
            if self.msg.connection.contact is not None \
               and self.msg.connection.contact.is_active:
                # this means they were already registered and active, but not yet
                # receiving results.
                clinic = get_clinic_or_default(self.msg.connection.contact)
                if clinic != location:
                    self.respond(self.ALREADY_REGISTERED,
                                 name=self.msg.connection.contact.name,
                                 location=clinic)
                    return True
                else:
                    contact = self.msg.contact
            else:
                contact = Contact(location=location)
                clinic = get_clinic_or_default(contact)
            contact.name = name
            contact.pin = pin
            contact.save()
            contact.types.add(worker_type)

            self.msg.connection.contact = contact
            self.msg.connection.save()

            self.respond(
                "Hi %(name)s, thanks for registering for "
                "Results160 from %(location)s. "
                "Your PIN is %(pin)s. "
                "Reply with keyword 'HELP' if this is "
                "incorrect",
                name=contact.name,
                location=clinic.name,
                pin=pin)
        except Location.DoesNotExist:
            self.respond(
                "Sorry, I don't know about a location with code %(code)s. Please check your code and try again.",
                code=clinic_code)
 def test_that_if_there_are_no_polls_for_the_user_it_returns_success_and_an_empty_list(self):
     backend = Backend(id=89)
     connection = Connection(identity=999, backend=backend, contact=Contact())
     fake_request = self.setup_get_request(backend, connection)
     self.view.get_polls_for_contact = Mock(return_value=[])
     response = self.view.dispatch(fake_request)
     data = json.loads(response.content)
     self.assertEqual(True, data['success'])
     self.assertEqual([], data['poll_topics'])
예제 #8
0
 def testFormWithNoPhoneNumber(self):
     NAME = "newuser"
     PHONE = "+233123"
     contact = Contact(name=NAME)
     form = CommoditiesContactForm({'name': NAME}, instance=contact)
     self.assertFalse(form.is_valid())
     form = CommoditiesContactForm({
         'name': NAME,
         'phone': PHONE
     },
                                   instance=contact)
     self.assertTrue(form.is_valid())
예제 #9
0
파일: tests.py 프로젝트: dimagi/aremind
 def setUp(self):
     # Create some patients to correspond to the test messages
     self.patient = None
     for p in self.patients:
         contact = Contact(name=p['subject_number'])
         contact.save()
         patient = Patient(subject_number=p['subject_number'],
                           contact=contact)
         patient.save()
         if not self.patient:
             self.patient = patient
     for testmsg in self.testmsgs:
         patient = Patient.objects.get(subject_number=testmsg['subject_number'])
         self.assertTrue(patient is not None)
         patient.wisepill_msisdn = testmsg['msisdn']
         patient.save()
         testmsg['patient'] = patient
         self.assertEquals(patient.wisepill_msisdn,testmsg['msisdn'])
예제 #10
0
def contact(request, pk=None):
    if pk:
        contact = get_object_or_404(Contact, pk=pk)
    else:
        contact = Contact()
    contact_form = ContactForm(instance=contact)
    connection_formset = ConnectionFormSet(instance=contact)
    if request.method == 'POST':
        data = {}
        for key in request.POST:
            val = request.POST[key]
            if isinstance(val, basestring):
                data[key] = val
            else:
                try:
                    data[key] = val[0]
                except (IndexError, TypeError):
                    data[key] = val
        # print repr(data)
        del data
        if pk:
            if request.POST["submit"] == "Delete Contact":
                contact.delete()
                messages.add_message(request, messages.INFO, "Deleted contact")
                return HttpResponseRedirect(reverse(registration))
            contact_form = ContactForm(request.POST, instance=contact)
        else:
            contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            contact = contact_form.save(commit=False)
            connection_formset = ConnectionFormSet(request.POST,
                                                   instance=contact)
            if connection_formset.is_valid():
                contact.save()
                connection_formset.save()
                messages.add_message(request, messages.INFO, "Added contact")
                return HttpResponseRedirect(reverse(registration))
    return render(
        request, 'registration/contact_form.html', {
            "contact": contact,
            "contact_form": contact_form,
            "connection_formset": connection_formset,
        })
예제 #11
0
 def build_connection(self, contact=Contact()):
     return Connection(identity=77777,
                       backend=Backend(name='my backend'),
                       contact=contact)
예제 #12
0
class HSARegistrationHandler(RegistrationBaseHandler):
    """
    Registration for HSAs
    """

    keyword = "reg|register"

    def help(self):
        self.respond(config.Messages.HSA_HELP)

    def handle(self, text):
        if self.handle_preconditions(text):
            return

        # default to HSA
        role = ContactRole.objects.get(code=config.Roles.HSA)

        try:
            hsa_id = format_id(self.supply_point.code, self.extra)
        except IdFormatException, e:
            self.respond(str(e))
            return

        if Location.objects.filter(code=hsa_id, is_active=True).exists():
            self.respond(
                "Sorry, a location with %(code)s already exists. Another HSA may have already registered this ID",
                code=hsa_id)
            return
        if SupplyPoint.objects.filter(code=hsa_id,
                                      contact__is_active=True).exists():
            self.respond(
                "Sorry, a supply point with %(code)s already exists. Another HSA may have already registered this ID",
                code=hsa_id)
            return

        # create a location and supply point for the HSA
        if SupplyPoint.objects.filter(code=hsa_id,
                                      type=config.hsa_supply_point_type(),
                                      active=False).exists():
            # We have a previously deactivated HSA.  Reassociate.
            sp = SupplyPoint.objects.get(code=hsa_id,
                                         type=config.hsa_supply_point_type(),
                                         active=False)
            sp.name = self.contact_name
            sp.active = True
            sp.save()
            sp.location.is_active = True
            sp.location.name = self.contact_name
            sp.location.save()
        else:
            hsa_loc = Location.objects.create(
                name=self.contact_name,
                type=config.hsa_location_type(),
                code=hsa_id,
                parent=self.supply_point.location)
            sp = SupplyPoint.objects.create(
                name=self.contact_name,
                code=hsa_id,
                type=config.hsa_supply_point_type(),
                location=hsa_loc,
                supplied_by=self.supply_point)

        # overwrite the existing contact data if it was already there
        # we know at least they were not active since we checked above
        contact = self.msg.logistics_contact if hasattr(
            self.msg, 'logistics_contact') else Contact()
        contact.name = self.contact_name
        contact.supply_point = sp
        contact.role = role
        contact.is_active = True
        if not settings.LOGISTICS_APPROVAL_REQUIRED:
            contact.is_approved = True
        contact.save()
        self.msg.connection.contact = contact
        self.msg.connection.save()

        if settings.LOGISTICS_APPROVAL_REQUIRED:
            try:
                sh = Contact.objects.get(
                    supply_point__location=self.supply_point.location,
                    role=ContactRole.objects.get(code=Roles.HSA_SUPERVISOR))
                sh.message(config.Messages.APPROVAL_REQUEST,
                           hsa=contact.name,
                           code=hsa_id)
                self.respond(_(config.Messages.APPROVAL_WAITING),
                             hsa=contact.name)
            except Contact.DoesNotExist:
                # If there's no HSA supervisor registered, we silently approve them.  Oh well.
                contact.is_approved = True
                self.respond(_(config.Messages.REGISTRATION_CONFIRM),
                             sp_name=self.supply_point.name,
                             contact_name=contact.name,
                             role=contact.role.name)
        else:
            self.respond(_(config.Messages.REGISTRATION_CONFIRM),
                         sp_name=self.supply_point.name,
                         contact_name=contact.name,
                         role=contact.role.name)
예제 #13
0
 def testEmptyInstance(self):
     NAME = "newuser"
     PHONE = "+233123"
     contact = Contact(name=NAME)
     form = CommoditiesContactForm({'name': NAME}, instance=None)
     self.assertFalse(form.is_valid())
예제 #14
0
def registration(req,
                 pk=None,
                 template="registration/dashboard.html",
                 contact_form=CommoditiesContactForm):
    contact = None
    connection = None
    bulk_form = None
    search = None
    registration_view = 'registration'
    registration_edit = 'registration_edit'
    if hasattr(settings, 'SMS_REGISTRATION_VIEW'):
        registration_view = settings.SMS_REGISTRATION_VIEW
    if hasattr(settings, 'SMS_REGISTRATION_EDIT'):
        registration_edit = settings.SMS_REGISTRATION_EDIT

    if pk is not None:
        contact = get_object_or_404(Contact, pk=pk)
        try:
            connection = Connection.objects.get(contact=contact)
        except Connection.DoesNotExist:
            connection = None
    if req.method == "POST":
        if req.POST["submit"] == "Delete Contact":
            name = unicode(contact)
            contact.delete()
            return HttpResponseRedirect("%s?deleted=%s" %
                                        (reverse(registration_view), name))
        elif "bulk" in req.FILES:
            # TODO use csv module
            #reader = csv.reader(open(req.FILES["bulk"].read(), "rb"))
            #for row in reader:
            for line in req.FILES["bulk"]:
                line_list = line.split(',')
                name = line_list[0].strip()
                backend_name = line_list[1].strip()
                identity = line_list[2].strip()

                contact = Contact(name=name)
                contact.save()
                # TODO deal with errors!
                backend = Backend.objects.get(name=backend_name)

                connection = Connection(backend=backend, identity=identity,\
                    contact=contact)
                connection.save()

            return HttpResponseRedirect(reverse(registration_view))
        else:
            contact_form = contact_form(instance=contact, data=req.POST)

            if contact_form.is_valid():
                created = False
                if contact is None:
                    created = True
                contact = contact_form.save()
                if created:
                    response = "Dear %(name)s, you have been registered on %(site)s" % \
                        {'name': contact.name,
                         'site': Site.objects.get(id=settings.SITE_ID).domain }
                    send_message(contact.default_connection, response)
                    return HttpResponseRedirect(
                        "%s?created=%s" %
                        (reverse(registration_edit,
                                 kwargs={'pk': contact.pk}), unicode(contact)))
    else:
        if pk is None:
            supplypoint = None
            if "supplypoint" in req.GET and req.GET["supplypoint"]:
                try:
                    supplypoint = SupplyPoint.objects.get(
                        code=req.GET["supplypoint"])
                except SupplyPoint.DoesNotExist, SupplyPoint.MultipleObjectsReturned:
                    pass
            contact_form = contact_form(instance=contact,
                                        initial={'supply_point': supplypoint})
        else:
 def test_that_retrieves_none_when_contact_do_not_have_a_poll(self):
     contact = Contact()
     contact.save()
     self.assertEqual(None, self.view.get_current_poll_for(contact))
예제 #16
0
 def test_that_contact_exists_when_connection_has_contact(self):
     view = UReporterApiView()
     connection = Connection(contact=Contact())
     self.assertEqual(True, view.contact_exists(connection))
예제 #17
0
def register_user(request, template="malawi/register-user.html"):
    context = dict()
    context['facilities'] = SupplyPoint.objects.filter(type__code="hf").order_by('code')
    context['backends'] = Backend.objects.all()
    context['dialing_code'] = settings.COUNTRY_DIALLING_CODE # [sic]
    if request.method != 'POST':
        return render_to_response(template, context, context_instance=RequestContext(request))

    id = request.POST.get("id", None)
    facility = request.POST.get("facility", None)
    name = request.POST.get("name", None)
    number = request.POST.get("number", None)
    backend = request.POST.get("backend", None)

    if not (id and facility and name and number and backend):
        messages.error(request, "All fields must be filled in.")
        return render_to_response(template, context, context_instance=RequestContext(request))
    hsa_id = None
    try:
        hsa_id = format_id(facility, id)
    except IdFormatException:
        messages.error(request, "HSA ID must be a number between 0 and 99.")
        return render_to_response(template, context, context_instance=RequestContext(request))

    try:
        parent = SupplyPoint.objects.get(code=facility)
    except SupplyPoint.DoesNotExist:
        messages.error(request, "No facility with that ID.")
        return render_to_response(template, context, context_instance=RequestContext(request))

    if Location.objects.filter(code=hsa_id).exists():
        messages.error(request, "HSA with that code already exists.")
        return render_to_response(template, context, context_instance=RequestContext(request))

    try:
        number = int(number)
    except ValueError:
        messages.error(request, "Phone number must contain only numbers.")
        return render_to_response(template, context, context_instance=RequestContext(request))

    hsa_loc = Location.objects.create(name=name, type=config.hsa_location_type(),
                                          code=hsa_id, parent=parent.location)
    sp = SupplyPoint.objects.create(name=name, code=hsa_id, type=config.hsa_supply_point_type(),
                                        location=hsa_loc, supplied_by=parent, active=True)
    sp.save()
    contact = Contact()
    contact.name = name
    contact.supply_point = sp
    contact.role = ContactRole.objects.get(code=config.Roles.HSA)
    contact.is_active = True
    contact.save()

    connection = Connection()
    connection.backend = Backend.objects.get(pk=int(backend))
    connection.identity = "+%s%s" % (settings.COUNTRY_DIALLING_CODE, number) #TODO: Check validity of numbers
    connection.contact = contact
    connection.save()

    messages.success(request, "HSA added!")

    return render_to_response(template, context, context_instance=RequestContext(request))
예제 #18
0
class CreateUserHandler(RecordResponseHandler):
    """
    Registration for HSAs
    """

    keyword = "hsa"
    
    def help(self):
        self.respond(config.Messages.HSA_HELP)

    @logistics_contact_and_permission_required(config.Operations.ADD_USER)
    def handle(self, text):
        words = text.split()
        if len(words) < 3:
            self.help()
        else:
            self.contact_name = " ".join(words[:-2])
            self.extra =   words[-2]
            code = words[-1]
            try:
                self.supply_point = SupplyPoint.objects.get(code__iexact=code)
            except SupplyPoint.DoesNotExist:
                self.respond(_(config.Messages.UNKNOWN_LOCATION), code=code )

        # default to HSA
        role = ContactRole.objects.get(code=config.Roles.HSA)
        
        def format_id(code, id):
            try:
                id_num = int(id)
                if id_num < 1 or id_num >= 100:
                    raise IdFormatException("id must be a number between 1 and 99. %s is out of range" % id)
                return "%s%02d" % (code, id_num)
            except ValueError:
                raise IdFormatException("id must be a number between 1 and 99. %s is not a number" % id)
        
        try:
            hsa_id = format_id(self.supply_point.code, self.extra)
        except IdFormatException, e:
            self.respond(str(e))
            return
        
        if Location.objects.filter(code=hsa_id).exists():
            self.respond("Sorry, a location with %(code)s already exists. Another HSA may have already registered this ID", code=hsa_id)
            return
        if SupplyPoint.objects.filter(code=hsa_id, contact__is_active=True).exists():
            self.respond("Sorry, a supply point with %(code)s already exists. Another HSA may have already registered this ID", code=hsa_id)
            return
        
        # create a location and supply point for the HSA
        hsa_loc = Location.objects.create(name=self.contact_name, type=config.hsa_location_type(),
                                          code=hsa_id, parent=self.supply_point.location)
        sp = SupplyPoint.objects.create(name=self.contact_name, code=hsa_id, type=config.hsa_supply_point_type(), 
                                        location=hsa_loc, supplied_by=self.supply_point)
        
        # overwrite the existing contact data if it was already there
        # we know at least they were not active since we checked above
        contact =  Contact()
        contact.name = self.contact_name
        contact.supply_point = sp
        contact.role = role
        contact.is_active = True
        contact.save()
        self.respond(_(config.Messages.REGISTRATION_CONFIRM), sp_name=self.supply_point.name,
                     contact_name=contact.name, role=contact.role.name)
예제 #19
0
def migrate():

    for product in old_models.Product.objects.all():
        p = new_models.Product(name=product.name,
                               units=product.units,
                               sms_code=product.sms_code,
                               description=product.description)
        p.save()

    for p in old_models.ProductReportType.objects.all():
        r = new_models.ProductReportType(name=p.name, sms_code=p.sms_code)
        r.save()

    # Necessary because there's no slug field
    types = (("MOHSW", "moh"), ("REGION", "reg"), ("DISTRICT", "dis"),
             ("FACILITY", "fac"))

    for t in types:
        nt = new_models.SupplyPointType(name=t[0], code=t[1])
        nt.save()

    for object in old_models.ServiceDeliveryPoint.objects.all():
        if new_models.SupplyPoint.objects.filter(name=object.name).exists():
            return

        l = new_models.Location(point=object.point if object.point else None,
                                type=object.type,
                                parent_type=object.parent_type,
                                parent_id=object.parent_id,
                                parent=object.parent)
        l.save()
        sp = new_models.SupplyPoint(
            name=object.sdp_name,
            is_active=object.active,
            location=l,
            type=new_models.SupplyPointType.objects.get(name=object.type.name))
        if new_models.SupplyPoint.objects.filter(
                name=sp.location.parent.name).exists():
            sp.supplied_by = new_models.SupplyPoint.objects.get(
                name=sp.location.parent.name)

        sp.save()

        for a in old_models.ActiveProduct.objects.filter(
                service_delivery_point=object):
            ps = new_models.ProductStock(
                is_active=a.is_active,
                supply_point=sp,
                quantity=a.current_quantity,
                product=new_models.Product.objects.get(
                    sms_code=a.product.sms_code))
            ps.save()

    roles = (("Facility in-charge", "ic"), ("DMO", "dm"), ("RMO", "rm"),
             ("District Pharmacist", "dp"), ("MOHSW", "mh"), ("MSD", "ms"))

    for r in roles:
        c = new_models.ContactRole(name=r[0], code=r[1])
        c.save()
    for oc in old_models.ContactDetail.objects.all():
        c = Contact(name=oc.name,
                    role=new_models.ContactRole.objects.get(name=oc.role.name),
                    supply_point=new_models.SupplyPoint.objects.get(
                        name=oc.service_delivery_point.name))
        c.save()
        for cb in ConnectionBase.objects.filter(contact=oc):
            cb.contact = c
            cb.save()
예제 #20
0
파일: views.py 프로젝트: fagan2888/pikwa
def registration(req, pk=None):
    contact = None
    sellerSummary = None

    if pk is not None:
        contact = get_object_or_404(Contact, pk=pk)

    if req.method == "POST":
        if req.POST["submit"] == "Delete Contact":
            contact.delete()
            return HttpResponseRedirect(reverse(registration))

        elif "bulk" in req.FILES:
            # TODO use csv module
            #reader = csv.reader(open(req.FILES["bulk"].read(), "rb"))
            #for row in reader:
            for line in req.FILES["bulk"]:
                line_list = line.split(',')
                name = line_list[0].strip()
                backend_name = line_list[1].strip()
                identity = line_list[2].strip()

                contact = Contact(name=name)
                contact.save()
                # TODO deal with errors!
                backend = Backend.objects.get(name=backend_name)

                connection = Connection(backend=backend, identity=identity,\
                    contact=contact)
                connection.save()

            return HttpResponseRedirect(reverse(registration))
        else:
            contact_form = ContactForm(instance=contact, data=req.POST)

            if contact_form.is_valid():
                contact = contact_form.save()
                return HttpResponseRedirect(reverse(registration))

    else:
        contact_form = ContactForm(instance=contact)
        #Not allowing user to add contacts through the UI for now
        #If we eventually do, the line below sets the new contacts'
        #organization to that of the logged in user
        #################
        #instance=Contact(organization=req.user.get_profile().organization))
        seller_summary = getSellerSummary(contact)
        bulk_form = BulkRegistrationForm()

    if req.user.is_staff:
        ctable = ContactTable(Contact.objects.exclude(alias='nobody'),
                              request=req)
        org = None
    else:
        ctable = ContactTable(Contact.objects.filter(
            organization=req.user.get_profile().organization),
                              request=req)
        org = req.user.get_profile().organization

    return render_to_response("registration/dashboard.html", {
        "organization": org,
        "contacts_table": ctable,
        "contact_form": contact_form,
        "bulk_form": bulk_form,
        "contact": contact,
        "seller_summary": seller_summary
    },
                              context_instance=RequestContext(req))
예제 #21
0
    def setUp(self):
        settings.LOGISTICS_STOCKED_BY = 'user'
        TestScript.setUp(self)
        location = Location.objects.get(code='de')
        facilitytype = SupplyPointType.objects.get(code='hc')
        self.rms = SupplyPoint.objects.get(code='garms')
        facility, created = SupplyPoint.objects.get_or_create(
            code='dedh',
            name='Dangme East District Hospital',
            location=location,
            active=True,
            type=facilitytype,
            supplied_by=self.rms)
        assert facility.supplied_by == self.rms
        mc = Product.objects.get(sms_code='mc')
        self.lf = Product.objects.get(sms_code='lf')
        ProductStock(product=mc, supply_point=facility,
                     monthly_consumption=8).save()
        ProductStock(product=self.lf,
                     supply_point=facility,
                     monthly_consumption=5).save()
        facility = SupplyPoint(code='tf',
                               name='Test Facility',
                               location=location,
                               active=True,
                               type=facilitytype,
                               supplied_by=self.rms)
        facility.save()
        mc = Product.objects.get(sms_code='mc')
        mg = Product.objects.get(sms_code='mg')
        self.mc_stock = ProductStock(is_active=True,
                                     supply_point=facility,
                                     product=mc,
                                     monthly_consumption=10)
        self.mc_stock.save()
        self.lf_stock = ProductStock(is_active=True,
                                     supply_point=facility,
                                     product=self.lf,
                                     monthly_consumption=10)
        self.lf_stock.save()
        self.mg_stock = ProductStock(is_active=False,
                                     supply_point=facility,
                                     product=mg,
                                     monthly_consumption=10)
        self.mg_stock.save()

        ng = Product.objects.get(sms_code='ng')
        self.ng_stock = ProductStock(is_active=True,
                                     supply_point=facility,
                                     product=ng,
                                     monthly_consumption=None)
        self.ng_stock.save()

        self.contact = Contact(name='test user')
        self.contact.save()
        self.connection = Connection(backend=Backend.objects.all()[0],
                                     identity="888",
                                     contact=self.contact)
        self.connection.save()
        self.contact.supply_point = facility
        self.contact.save()
        self.contact.commodities.add(ng)
예제 #22
0
    def handle(self, text):

        sp_name = None
        msd_code = None
        if text.find(config.DISTRICT_REG_DELIMITER) != -1:
            phrases = [x.strip() for x in text.split(":")]
            if len(phrases) != 2:
                self.respond_error(_(config.Messages.REGISTER_HELP))
                return True
            name = phrases[0]
            sp_name = phrases[1]
            try:
                sdp = SupplyPoint.objects.get(type__code="district",
                                              name__istartswith=sp_name)
            except SupplyPoint.DoesNotExist:
                kwargs = {'name': sp_name}
                self.respond_error(
                    _(config.Messages.REGISTER_UNKNOWN_DISTRICT), **kwargs)
                return True
            except SupplyPoint.MultipleObjectsReturned:
                kwargs = {'name': sp_name}
                self.respond_error(
                    _(config.Messages.REGISTER_UNKNOWN_DISTRICT), **kwargs)
                return True

        else:
            words = text.split()
            names = []
            msd_codes = []
            for the_string in words:
                if re.match('^d\d+', the_string.strip().lower()):
                    msd_codes.append(the_string.strip().lower())
                else:
                    names.append(the_string)

            name = " ".join(names)

            if len(msd_codes) != 1:
                self.respond_error(_(config.Messages.REGISTER_HELP))
                return True
            else:
                [msd_code] = msd_codes
                try:
                    sdp = SupplyPoint.objects.get(code__iexact=msd_code)
                except SupplyPoint.DoesNotExist:
                    kwargs = {'msd_code': msd_code}
                    self.respond_error(
                        _(config.Messages.REGISTER_UNKNOWN_CODE), **kwargs)
                    return True

        # Default to Facility in-charge or District Pharmacist for now
        if sdp.type.code.lower() == config.SupplyPointCodes.DISTRICT:
            role = ContactRole.objects.get(
                code__iexact=config.Roles.DISTRICT_PHARMACIST)
        elif sdp.type.code.lower() == config.SupplyPointCodes.FACILITY:
            role = ContactRole.objects.get(code__iexact=config.Roles.IN_CHARGE)
        else:
            # TODO be graceful
            self.add_tag("Error")
            raise Exception("bad location type: %s" % sdp.type.name)

        contact = self.msg.logistics_contact if hasattr(
            self.msg, 'logistics_contact') else Contact()
        contact.name = name
        contact.supply_point = sdp
        contact.role = role
        contact.is_active = True
        contact.is_approved = True
        contact.language = config.Languages.DEFAULT
        contact.save()

        self.msg.connection.contact = contact
        self.msg.connection.save()

        if sp_name:
            kwargs = {'sdp_name': sdp.name, 'contact_name': contact.name}
            self.respond(_(config.Messages.REGISTRATION_CONFIRM_DISTRICT),
                         **kwargs)
        else:
            kwargs = {
                'sdp_name': sdp.name,
                'msd_code': msd_code,
                'contact_name': contact.name
            }

            self.respond(_(config.Messages.REGISTRATION_CONFIRM), **kwargs)