Produits Entr'ouvert » Passerelle

from django.db import models

from passerelle.utils.jsonresponse import APIError

from passerelle.base.models import SMSResource

class ChoositSMSGateway(SMSResource):

    key = models.CharField(verbose_name=_('Key'), max_length=64)

    TEST_DEFAULTS = {

        'create_kwargs': {

            'key': '1234',

        },

        'test_vectors': [

            {

                'response': '',

    @classmethod

    def get_verbose_name(cls):

        return cls._meta.verbose_name

    def send_msg(self, text, sender, destinations, **kwargs):

        """Send a SMS using the Choosit provider"""

        # from http://sms.choosit.com/documentation_technique.html

        results = []

        for dest in destinations:

            params = {

                'key': self.key,

                'recipient': dest,

                'content': text[:160],

            }

            data = {'data': json.dumps(params)}

        ('l', _('sms direct')),

        ('ll', _('sms low-cost')),

        ('n', _('sms top')),

    )

    username = models.CharField(verbose_name=_('Username'), max_length=64)

    password = models.CharField(verbose_name=_('Password'), max_length=64)

    quality = models.CharField(max_length=4, choices=MESSAGES_QUALITIES, default='l',

                               verbose_name=_('Message quality'))

    manager_view_template_name = 'passerelle/manage/messages_service_view.html'

    TEST_DEFAULTS = {

        'create_kwargs': {

            'username': 'john',

            'password': 'doe',

        },

    }

    class Meta:

        verbose_name = 'Mobyt'

        db_table = 'sms_mobyt'

    def send_msg(self, text, sender, destinations, **kwargs):

        """Send a SMS using the Mobyt provider"""

        rcpt = ','.join(destinations)

        params = {

            'user': self.username,

            'pass': self.password,

            'rcpt': rcpt,

            'data': text,

            'sender': sender,

            'qty': self.quality,

        raise OrangeError('Orange returned Invalid JSON content: %s' % response.text)

class OrangeSMSGateway(SMSResource):

    username = models.CharField(verbose_name=_('Identifier'), max_length=64)

    password = models.CharField(verbose_name=_('Password'), max_length=64)

    groupname = models.CharField(verbose_name=_('Group'), max_length=64)

    manager_view_template_name = 'passerelle/manage/messages_service_view.html'

    class Meta:

        verbose_name = _('Orange')

        db_table = 'sms_orange'

    def get_access_token(self):

        headers = {'content-type': 'application/x-www-form-urlencoded'}

            URL_DIFFUSION % group_id, json=payload, headers=headers)

        if response.status_code != 201:

            raise OrangeError('Orange fails to send SMS: %s, %s' % (

                response.status_code, response.text))

        return get_json(response)

    def send_msg(self, text, sender, destinations, **kwargs):

        '''Send a SMS using the Orange provider'''

        access_token = self.get_access_token()

        group_id = self.group_id_from_name(access_token)

        response = self.diffusion(access_token, group_id, destinations, text)

        return response

    )

    account = models.CharField(verbose_name=_('Account'), max_length=64)

    username = models.CharField(verbose_name=_('Username'), max_length=64)

    password = models.CharField(verbose_name=_('Password'), max_length=64)

    msg_class = models.IntegerField(choices=MESSAGES_CLASSES, default=1,

                                    verbose_name=_('Message class'))

    credit_threshold_alert = models.PositiveIntegerField(verbose_name=_('Credit alert threshold'),

                                                         default=100)

    credit_left = models.PositiveIntegerField(verbose_name=_('Credit left'), default=0)

    manager_view_template_name = 'passerelle/manage/messages_service_view.html'

    TEST_DEFAULTS = {

        'create_kwargs': {

            'account': '1234',

            'username': 'john',

            'password': 'doe',

    }

    class Meta:

        verbose_name = 'OVH'

        db_table = 'sms_ovh'

    def send_msg(self, text, sender, destinations, **kwargs):

        """Send a SMS using the OVH provider"""

        text = force_text(text).encode('utf-8')

        to = ','.join(destinations)

        params = {

            'account': self.account.encode('utf-8'),

            'login': self.username.encode('utf-8'),

            'password': self.password.encode('utf-8'),

            'from': sender.encode('utf-8'),

from passerelle.utils.jsonresponse import APIError

from passerelle.base.models import SMSResource

from django.utils.translation import ugettext_lazy as _

class OxydSMSGateway(SMSResource):

    username = models.CharField(verbose_name=_('Username'), max_length=64)

    password = models.CharField(verbose_name=_('Password'), max_length=64)

    manager_view_template_name = 'passerelle/manage/messages_service_view.html'

    TEST_DEFAULTS = {

        'create_kwargs': {

            'username': 'john',

            'password': 'doe',

        },

    URL = 'http://sms.oxyd.fr/send.php'

    class Meta:

        verbose_name = 'Oxyd'

        db_table = 'sms_oxyd'

    def send_msg(self, text, sender, destinations, **kwargs):

        """Send a SMS using the Oxyd provider"""

        results = []

        for dest in destinations:

            params = {

                'id': self.username,

                'pass': self.password,

                'num': dest,

                'sms': text.encode('utf-8'),

                'flash': '0',

class SMSResource(BaseResource):

    category = _('SMS Providers')

    documentation_url = 'https://doc-publik.entrouvert.com/admin-fonctionnel/les-tutos/configuration-envoi-sms/'

    _can_send_messages_description = _('Sending messages is limited to the following API users:')

    max_message_length = models.IntegerField(_('Maximum message length'), default=160)

        numbers = []

        for dest in destinations:

            # most gateways needs the number prefixed by the country code, this is

            # really unfortunate.

            dest = dest.strip()

            number = ''.join(re.findall('[0-9]', dest))

            if dest.startswith('+'):

                number = '00' + number

            elif number.startswith('00'):

                # assumes 00 is international access code, remove it

                pass

            else:

                raise APIError('phone number %r is unsupported (no international prefix, '

                               'no local trunk prefix)' % number)

            numbers.append(number)

        return numbers

    @endpoint(perm='can_send_messages', methods=['post'])

    def send(self, request, *args, **kwargs):

            assert 'to' in data, 'missing "to" in JSON payload'

            assert isinstance(data['message'], six.text_type), 'message is not a string'

            assert isinstance(data['from'], six.text_type), 'from is not a string'

            assert all(map(lambda x: isinstance(x, six.text_type), data['to'])), \

                'to is not a list of strings'

        except (ValueError, AssertionError) as e:

            raise APIError('Payload error: %s' % e)

        data['message'] = data['message'][:self.max_message_length]

        logging.info('sending message %r to %r with sending number %r',

                     data['message'], data['to'], data['from'])

        result = {'data': self.send_msg(data['message'], data['from'], data['to'], stop=stop)}

        SMSLog.objects.create(appname=self.get_connector_slug(), slug=self.slug)

        return result

    class Meta:

        abstract = True

import mock

import pytest

from django.contrib.contenttypes.models import ContentType

from passerelle.apps.ovh.models import OVHSMSGateway

from passerelle.base.models import ApiUser, AccessRight, SMSResource, SMSLog

from test_manager import login, admin_user

import utils

pytestmark = pytest.mark.django_db

klasses = SMSResource.__subclasses__()

def test_clean_numbers():

@pytest.fixture(params=klasses)

def connector(request, db):

    klass = request.param

    kwargs = getattr(klass, 'TEST_DEFAULTS', {}).get('create_kwargs', {})

    kwargs.update({

        'title': klass.__name__,