示例#1
0
	def form_valid(self,form):
		connection = lookup_connections('envaya',[form.cleaned_data['phone_number']])[0],
		text = form.cleaned_data['message']
		
		send(text,connection)
		
		return HttpResponse("<pre>%s</pre>"%(pprint.pformat(form.cleaned_data),))
示例#2
0
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
示例#3
0
def forward (message, identity, text):
    
    if message.connection:
        conn, created = Connection.objects.get_or_create(backend = message.connection.backend, identity = identity)        
        send( text, conn)
        #print conn, text     
        return True
    else:
        return False
示例#4
0
    def send(self):
        """
        Raises an exception to help developers upgrade legacy code to use
        the new interface for sending messages.
        """
        # TODO decide if this API is deprecated and add a deprecation warning if so
        from rapidsms.router import send

        send(self.text, self.connection)
        self.sent = True
示例#5
0
	def send_batch(self,message,connections,verbose=True):
		'''
		Send a single message to a list of connections
		'''
		self.write("Sending: %s"%self.options['send'],verbose=verbose)
		self.write("Messages to Send: %i"%len(connections),verbose=verbose)
		self.write('Message: %s'%message)
		for i,conn in enumerate(connections):
			self.write('   %i: %s'%(i+1,conn),verbose=verbose)
			if self.options['send']:
				send(message,conn)
示例#6
0
文件: router.py 项目: Achaz/rapidsms
    def process_incoming(self, msg):
        """
        Process message through incoming phases and pass any generated
        responses to :func:`send <rapidsms.router.send>`. Called by
        ``receive_incoming``.

        :param msg: :class:`IncomingMessage <rapidsms.messages.incoming.IncomingMessage>` object
        """
        from rapidsms.router import send
        continue_processing = self.process_incoming_phases(msg)
        if continue_processing:
            for msg_context in msg.responses:
                send(**msg_context)
示例#7
0
def forward (identity, text):
    try:
        if text and identity:
            try:    backend = Backend.objects.filter(name = settings.PRIMARY_BACKEND)[0]
            except: backend = Backend.objects.filter(name = 'message_tester')[0] 
            #print backend
            conn = Connection(backend = backend, identity = identity)       
            send(text, conn)
            return True
    except:
        #print e
        return False
        pass
示例#8
0
def index(request):
    phone_number = request.GET.get('phone_number', '')
    message = request.GET.get('message', '')

    sent_identity = phone_number

    backend_to_use = choose_backend(phone_number)

    conn, created = Connection.objects.get_or_create(identity=sent_identity, backend=backend_to_use)

    send(message, conn)

    return HttpResponse("Message sent to: %s, Content: %s" % (phone_number, message))
示例#9
0
文件: app.py 项目: chaabni/SmartElect
 def _split_and_send_messages(self, msg, msg_type):
     width = settings.MAX_OUTGOING_LENGTH - settings.MSG_ORDER_NUMBER_LENGTH
     short_msgs = textwrap.wrap(msg.raw_text, width=width)
     for i, short_msg in enumerate(short_msgs):
         # format the msg with a paginator syntax at end of msg
         short_text = u"[%d/%d] %s" % (i + 1, len(short_msgs), short_msg)
         # RapidSMS has a 'fields' kwarg for extra metadata
         # Keep track of the fact that this is a split message
         # Keep track of the sequence of this message
         # Keep track of the proper msg_type
         fields = {'split': True, 'order': i + 1, 'msg_type': msg_type}
         kwargs = {"fields": fields}
         if i == 0:
             kwargs['in_response_to'] = msg.in_response_to
         send(short_text, msg.connections, **kwargs)
示例#10
0
    def test_outgoing(self):
        """Sent messages should call _queue_message with incoming=False"""

        with patch.object(CeleryRouter, '_queue_message') as mock_method:
            connections = self.lookup_connections(identities=['1112223333'])
            messages = send("test", connections)
        mock_method.assert_called_once_with(messages[0], incoming=False)
示例#11
0
 def test_send_with_connection(self):
     """Send accepts a single connection."""
     connection = self.create_connection()
     message = send("echo hello", connection)
     self.assertEqual(message.connection.identity, connection.identity)
     self.assertEqual(message.connection.backend.name,
                      connection.backend.name)
示例#12
0
 def test_send_with_connections(self):
     """Send accepts a list of connections."""
     connections = [self.create_connection(), self.create_connection()]
     message = send("echo hello", connections)
     self.assertEqual(len(message.connections), 2)
     self.assertEqual(message.connection.identity,
                      connections[0].identity)
     self.assertEqual(message.connection.backend.name,
                      connections[0].backend.name)
示例#13
0
 def send(self, sender=None, group=None):
     message = self.cleaned_data['message']
     text = "{0}: {1}".format(sender, message)
     recipients = set([contact.default_connection
                      for contact in group.contacts.all()])
     sent = send(text, list(recipients))
     GroupMessage.objects.create(group=group,
                                 message=sent.logger_msg,
                                 num_recipients=len(recipients))
     return sent
示例#14
0
    def test_sending_sms(self):
        """
        Tests that SMS-es are actually sent using the Nexmo outgoing backend.
        """
        try:
            from django.conf import settings
        except ImportError:
            self.fail(msg="No TEST_NUMBER found in settings!")

        from rapidsms.router import send
        from rapidsms.models import Connection, Backend
        from random import randint

        b = Backend.objects.get_or_create(name='envaya_nexmo')[0]
        c = Connection.objects.get_or_create(identity = settings.TEST_NUMBER, backend = b)[0]
        msg = "Hey, this is a test message from NexmoOutgoingBackendTest! \n Your Lucky number is %s" % (randint(1,42))

        send(msg,[c])
        print "Cannot actually verify whether the message was sent or not because of the limitations of rapdisms framework :-/"
示例#15
0
def send_msg_scheduled_events():
    """
    Send messages to contacts that are eligible for scheduled events.
    """
    
    contact_all = Contact.objects.all()
    scheduled_events_all = ScheduledEvent.objects.all()

    connections_to_send = Connection.objects.none()

    for event in scheduled_events_all:
        connections_to_send = Connection.objects.none()
        for contact in contact_all:
            if (event.event_date - contact.date_of_birth).days >= event.days:
                contact_conn = Connection.objects.filter(contact=contact)
                connections_to_send = connections_to_send | contact_conn

        for conn in connections_to_send:
            send(event.msg_to_send, conn)
示例#16
0
def send_occurrence_notifications(days=7):
    """
    Task to send reminders notifications for upcoming Occurrence

    Arguments:
    days: The number of upcoming days to filter upcoming Occurrences
    """
    start = datetime.date.today()
    end = start + datetime.timedelta(days=days)
    blacklist = [Notification.STATUS_PENDING, Notification.STATUS_COMPLETED, Notification.STATUS_MANUAL]
    appts = Occurrence.objects.filter(
        # Join subscriptions that haven't ended
        Q(Q(subscription__connection__timelines__end__gte=now()) | Q(subscription__connection__timelines__end__isnull=True)),
        subscription__connection__timelines__timeline=F('milestone__timeline'),
        # Filter occurrences in range
        date__range=(start, end),
    ).exclude(actions__status__in=blacklist)
    for appt in appts:
        # TODO allow both static messages AND appointment reminders for a
        # milestone
        language = get_language()
        msg = None
        translations = appt.milestone.translations.filter(
            language_code=getattr(settings, 'DEFUALT_LANGUAGE', 'en'))
            # each Timeline subscription can have a default language
        if translations:
            msg = translations[0].message
        if not msg:
            try:
                # if milestone has a default static message, fire away
                msg = appt.milestone.message
            except:
                pass
        if not msg:
            # format message as an appointment reminder
            msg = APPT_REMINDER % {'date': appt.date, 'pin': appt.subscription.pin}

        send(msg, appt.subscription.connection)
        Notification.objects.create(occurrence=appt,
                                    status=Notification.STATUS_PENDING,
                                    attempted=now(),
                                    message=msg)
示例#17
0
def training_materials_assign(request, pk=None):
    if pk:
        tm = get_object_or_404(TrainingMaterial, pk=pk)
    else:
        tm = TrainingMaterial()
    tm_form = AssignForm(instance=tm)
    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
        del data
        if pk:
            tm_form = AssignForm(request.POST, instance=tm)
        else:
            tm_form = AssignForm(request.POST)
        if tm_form.is_valid():
            tm = tm_form.save()
            assigned_users = tm_form.cleaned_data['assigned_users']
            notification = 'You have been assigned %s. To begin, reply with START %s.' % (tm.title, tm.tag)
            #self.cleaned_data['text']
            connections = []
            #assigned_users = tm_form.cleaned_data['assigned_users']
            for user in assigned_users:
                connections.append(user.default_connection)
            #connections = self.cleaned_data['assigned_users']
            send(notification, connections)
            #send(tm, assigned_users)
            tm.save()
            messages.add_message(request, messages.INFO, "Saved and sent training material.")
            return HttpResponseRedirect(reverse(training_materials))
    return render(request, 'training_materials/tm_assign1.html', {
        "tm": tm,
        "tm_form": tm_form,
        "range": range(tm.messagenum),#"x"*tm.messagenum,
    })
示例#18
0
 def handle(self, slug, text):
     """Broadcast messages to users in a group."""
     try:
         group = Group.objects.get(slug=slug)
     except Group.DoesNotExist:
         self.respond('Unknown group id "%s"' % slug.strip())
     else:
         # Check for membership
         connection = self.msg.connections[0]
         contacts = Contact.objects.filter(member__group=group)
         if not contacts.filter(connection__pk=connection.pk):
             self.respond('You are not a member of this group.')
         else:
             connections = Connection.objects.filter(
                 contact__in=contacts, backend=connection.backend,
             ).exclude(pk=connection.pk)
             count = connections.count()
             if count:
                 send('From %s: %s' % (slug, text), connections=connections)
             self.respond('Message was sent to %s member%s.' % (
                 count, count != 1 and 's' or ''))
示例#19
0
def send_msg_general_events():
    """
    Send messages to contacts that become eligible for general events.
    """
    
    contact_all = Contact.objects.all()
    gen_events_all = GeneralEvent.objects.all()

    connections_to_send = Connection.objects.none()

    curr_date = date.today()

    for event in gen_events_all:
        connections_to_send = Connection.objects.none()
        for contact in contact_all:
            if (curr_date - contact.date_of_birth).days == event.days:
                contact_conn = Connection.objects.filter(contact=contact)
                connections_to_send = connections_to_send | contact_conn

        for conn in connections_to_send:
            send(event.msg_to_send, conn)
示例#20
0
def send_appointment_notifications(days=7):
    """
    Task to send reminders notifications for upcoming Appointment

    Arguments:
    days: The number of upcoming days to filter upcoming Appointments
    """
    start = now()
    end = (start + datetime.timedelta(days=days)).replace(hour=23,
                                                          minute=59,
                                                          second=59)
    # get all subscriptions that haven't ended
    query = Q(date__gte=start) & Q(date__lte=end)
    blacklist = [Notification.STATUS_SENT, Notification.STATUS_CONFIRMED, Notification.STATUS_MANUAL]
    appts = Appointment.objects.filter(query).exclude(notifications__status__in=blacklist)
    for appt in appts:
        msg = APPT_REMINDER % {'date': appt.date}
        send(msg, appt.connection)
        Notification.objects.create(appointment=appt,
                                    status=Notification.STATUS_SENT,
                                    sent=now(),
                                    message=msg)
示例#21
0
def send_appointment_notifications(days=7):
    """
    Task to send reminders notifications for upcoming Appointment

    Arguments:
    days: The number of upcoming days to filter upcoming Appointments
    """
    start = datetime.date.today()
    end = start + datetime.timedelta(days=days)
    blacklist = [Notification.STATUS_SENT, Notification.STATUS_CONFIRMED, Notification.STATUS_MANUAL]
    appts = Appointment.objects.filter(
        # Join subscriptions that haven't ended
        Q(Q(subscription__connection__timelines__end__gte=now()) | Q(subscription__connection__timelines__end__isnull=True)),
        subscription__connection__timelines__timeline=F('milestone__timeline'),
        # Filter appointments in range
        date__range=(start, end),
    ).exclude(notifications__status__in=blacklist)
    for appt in appts:
        msg = APPT_REMINDER % {'date': appt.date}
        send(msg, appt.subscription.connection)
        Notification.objects.create(appointment=appt,
                                    status=Notification.STATUS_SENT,
                                    sent=now(),
                                    message=msg)
示例#22
0
def send_queued_messages():
    """ Send messages which have been queued for delivery. """
    messages = BroadcastMessage.objects.filter(status="queued")[:50]
    logger.info("Found {0} message(s) to send".format(messages.count()))
    for message in messages:
        connection = message.recipient.default_connection
        try:
            msg = send(message.broadcast.body, connection)[0]
        except Exception, e:
            msg = None
            logger.exception(e)
        if msg:
            logger.debug("Message sent successfully!")
            message.status = "sent"
            message.date_sent = get_now()
        else:
            logger.debug("Message failed to send.")
            message.status = "error"
        message.save()
示例#23
0
def lang_broadcast():
    connections = Connection.objects.all()
    for lang, conns in trans_helpers.group_connections(connections):
        with translation.override(lang):
            send(_('hello'), conns)
示例#24
0
 def send(self):
     """Send the message.  Equivalent to
     ``rapidsms.router.send(text, connections)``.
     """
     from rapidsms.router import send
     send(self.text, self.connection)
示例#25
0
 def send(self):
     message = self.cleaned_data['message']
     connections = self.cleaned_data['connections']
     return send(message, connections)
示例#26
0
 def send(self, text, connections, **kwargs):
     """A wrapper around the ``send`` API. See :ref:`sending-messages`."""
     return send(text, connections, **kwargs)
示例#27
0
文件: router.py 项目: asseym/rapidsms
 def send(self, text, connections):
     """send() API wrapper."""
     return send(text, connections)
示例#28
0
 def send_message(self):
     investigator = Investigator(mobile_number=self.mobile_number)
     investigator.backend = Backend.objects.all()[0]
     send(self.text_message(), [investigator])
示例#29
0
 def form_valid(self, form):
     send(form.cleaned_data['message'],
          Connection.objects.filter(backend=form.cleaned_data['backend']))
     messages.success(self.request, "Bulk message sent successfully.")
     return super(SendBulkMessage, self).form_valid(form)
示例#30
0
 def handle(self, backend_name, text):
     connections = Connection.objects.filter(backend__name=backend_name)
     send(text, connections)