def create_trans(self, s1='Q', s2='Q'): Connection.objects.bulk_create(( Connection(identity='1111111111', backend=self.backend), Connection(identity='2222222222', backend=self.backend), Connection(identity='3333333333', backend=self.backend), Connection(identity='4444444444', backend=self.backend), )) dbm = Message.objects.create(text="test", direction="O") for connection in Connection.objects.order_by('id')[:2]: dbm.transmissions.create(connection=connection, status=s1) for connection in Connection.objects.order_by('id')[2:]: dbm.transmissions.create(connection=connection, status=s2) ids = dbm.transmissions.order_by('id').values_list('id', flat=True) trans1 = dbm.transmissions.filter(id__in=ids[:2]) trans2 = dbm.transmissions.filter(id__in=ids[2:]) return self.backend, dbm, trans1, trans2
def test_404_is_raised_when_no_poll_exists(self): backend = Backend(name="test") self.view.get_connection = Mock(return_value=Connection(identity="77777", backend=backend)) self.view.get_backend = Mock(return_value=backend) self.view.contact_exists = Mock(return_value=True) with self.assertRaises(Http404): response = self.get_http_response_from_view(self.build_kwargs("my_backend","77777","12"), self.view)
def responder_loop(self, seconds=10): self.info("Starting responder...") while True: # look for any new handled messages # in the database, and send the responses for msg_in_waiting in MessageInWaiting.objects.filter(status="H"): self.info("Responding to %s.", msg_in_waiting) for response in msg_in_waiting.responses.all(): self.info("Response: %s.", response) # only send confirmed or added responses if response.type != "O": db_connection = msg_in_waiting.get_connection() if db_connection is not None: db_backend = db_connection.backend # we need to get the real backend from the router # to properly send it real_backend = self.router.get_backend(db_backend.slug) if real_backend: connection = Connection(real_backend, db_connection.identity) response_msg = OutgoingMessage(connection, response.text) self.router.outgoing(response_msg) else: # TODO: should we fail harder here? This will permanently # disable responses to this message which is bad. self.error("Can't find backend %s. Messages will not be sent") # mark the original message as responded to msg_in_waiting.status="R" msg_in_waiting.save() # wait until it's time to check again time.sleep(seconds)
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
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))
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'])
def forward(message, identity, text): if message.connection: conn = Connection(backend=message.connection.backend, identity=identity) send(text, conn) #print conn, text return True else: return False
def get_ussd_connection(fallback_connection): backend = ussd_push_backend() if not backend: return fallback_connection return Connection( backend=backend, identity=fallback_connection.identity, contact=fallback_connection.contact )
def create_message(self, id, backend): fake_connection = Connection(identity=str(id)) fake_connection.backend, created = Backend.objects.get_or_create( name=backend) fake_connection.save() message = Message(status='Q', direction="O") message.connection = fake_connection message.batch = self.batch1 message.save() return message
def test_that_return_not_registered_if_contact_does_not_exist(self): view = ViewUReporter() fake_check = Mock() fake_check.return_value = {"id": "", "language": "", "registered": False} view.get_contact = fake_check kwargs = {"backend": "console", "user_address": "999"} view.get_backend = Mock(return_value=Backend(name="my_backend")) view.get_connection = Mock(return_value=Connection(identity="999")) http_response = self.get_http_response_from_view(kwargs, view) json_string = http_response.content data = json.loads(json_string) self.assertDictEqual({"success": False, "reason": "Ureporter not found"}, data)
def test_that_return_registered_true_if_contact_exists(self): view = ViewUReporter() fake_check = Mock() fake_check.return_value = {"id": 12, "language": "en", "registered": True} view.get_contact = fake_check kwargs = {"backend": "console", "user_address": "999"} view.get_backend = Mock(return_value=Backend(name="my_backend")) view.get_connection = Mock(return_value=Connection(identity="999")) http_response = self.get_http_response_from_view(kwargs, view) json_string = http_response.content data = json.loads(json_string) self.assertEqual(True, data['success']) self.assertEqual(True, data['user']['registered']) self.assertEqual('en', data['user']['language'])
def test_that_valid_get_request_returns_poll_summary(self): backend = Backend(name="test") self.view.get_connection = Mock(return_value=Connection(identity="77777", backend=backend)) self.view.get_backend = Mock(return_value=backend) self.view.contact_exists = Mock(return_value=True) self.view.get_poll = Mock(return_value=Poll(question="Testing?")) poll_summary = {"total": 1, "responses": [{"name": "T", "count": 1}]} self.view.get_poll_summary = Mock(return_value=poll_summary) expected_data = { "success": True, "poll_result": poll_summary } response = self.get_http_response_from_view(self.build_kwargs("my_backend","77777","12"), self.view) data = json.loads(response.content) self.assertEquals(200,response.status_code) self.assertDictEqual(expected_data, data)
def save(self, commit=True): model = super(ContactDetailForm, self).save(commit=False) if commit: model.save() conn = model.default_connection if not conn: if settings.DEFAULT_BACKEND: backend = Backend.objects.get( name=settings.DEFAULT_BACKEND) else: backend = Backend.objects.all()[0] conn = Connection(backend=backend, contact=model.contact_ptr) conn.identity = self.cleaned_data['phone'] conn.save() print conn return model
def test_should_insert_a_classifier_message_for_each_category(self): categories = self.create_dummy_categories() self.load_ibm_seed_data.create_ibm_message_category = self.create_ibm_message_category_mock self.load_ibm_seed_data.create_backend = lambda name: Backend(name=name ) self.load_ibm_seed_data.create_connection = lambda backend, identity: Connection( backend=backend, identity=identity) self.load_ibm_seed_data.create_message = lambda connection, text, direction, status: ( Message(connection=connection, text=text, direction=direction, status=status), True) self.load_ibm_seed_data.create_seed_data(categories) self.assertEquals(self.categories_with_messages_inserted, categories)
def default_connection(self, identity): # when you re-assign default connection, should you delete the unused connection? probably. from rapidsms.models import Connection backend = self.default_backend default = self.default_connection if default is not None: if default.identity == identity and default.backend == backend: # our job is done return default.delete() try: conn = Connection.objects.get(backend=backend, identity=identity) except Connection.DoesNotExist: # good, it doesn't exist already conn = Connection(backend=backend, identity=identity) conn.contact = self conn.save()
def _send_question(self, session, msg=None): """Sends the next question in the session, if there is one""" state = session.state if state and state.question: response = state.question.text logger.info("Sending: %s", response) if msg: msg.respond(response) else: # we need to get the real backend from the router # to properly send it real_backend = self.router.get_backend( session.connection.backend.slug) if real_backend: connection = Connection(real_backend, session.connection.identity) outgoing_msg = OutgoingMessage(connection, response) self.router.outgoing(outgoing_msg) else: # todo: do we want to fail more loudly than this? logger.error( "Can't find backend %s. Messages will not " "be sent", connection.backend.slug)
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))
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)
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))
def build_connection(self, contact=Contact()): return Connection(identity=77777, backend=Backend(name='my backend'), contact=contact)
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_contact_exists_when_connection_has_contact(self): view = UReporterApiView() connection = Connection(contact=Contact()) self.assertEqual(True, view.contact_exists(connection))
def test_that_if_the_user_address_does_not_exist_you_get_a_404(self): backend = Backend(id=89) connection = Connection(identity=999, backend=backend) fake_request = self.setup_post_request(backend, connection) with self.assertRaises(Http404): response = self.view.dispatch(fake_request)