app.py

#!/usr/bin/env python

import sqlite3
import datetime
import uuid
import json
import logging
import concurrent.futures
import asyncio
import re
from wsgiref.simple_server import make_server
from operator import itemgetter

from bottle import request, abort, Bottle, ServerAdapter, JSONPlugin
from bottle_sqlite import SQLitePlugin
import jwt
import websockets
import requests

logging.basicConfig(filename='app.log', level=logging.DEBUG) 
app = Bottle(autojson=False)

class PiphoneJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        """
        We need to implement this to be able to JSONEncode
        """
        if isinstance(obj, Call):
            return {  'caller': obj.caller
                , 'callee': obj.callee
                , 'callid': obj.id
                , 'url': obj.url()
                , 'history': obj.history
                , 'owner': obj.owner }
        else:
            return json.JSONEncoder.default(self, obj)

def sanitize_phonenumber(number):
    """
    This function is used to sanitize a phone number.
    If it starts with a +, it will be removed and replaced by 00.
    Any chars who do notbelong to [0-9] will be stripped.
    If the number doesn't starts with 00, a TypeError will be raised
    """
    if number[0] == '+':
        number = '00' + number[1:]
    number = ''.join([c for c in number if c in '0123456789'])
    if not number.startswith('00'):
        raise TypeError('{} is not a valid international number, it should start with 00')
    return number

class Call(object):
    """
    This Class is used to manage operatiosn on a call, to print it and dump it.
    """
    history = []
    actions = {'Created': 'call_caller'
            , 'ChannelStateChange': 'change'
            , 'ChannelDtmfReceived': 'dtmf'}

    def __init__(self, caller, callee, owner, callid=None, db=None):
        try:
            self.caller = caller
            self.callee = callee
            self.owner = owner
            if callid == None:
                self.id = str(uuid.uuid4())
                self.db = db
                self.event_handler({'type': 'Created', 'timestamp': datetime.datetime.now().isoformat(), 'channel': {'id': 'Init'}})
            else:
                self.id = callid
        except Exception as e:
            logging.exception(e)
            raise e

    def url(self):
        return ''.join(['/calls/', self.id])

    def state(self):
        sort = sorted(self.history, reverse=True, key=itemgetter(1))
        return sort[0][0]

    @classmethod
    def load(cls, callid, db):
        logging.debug("Loading call {}".format(callid,))
        try:
            results = db.execute('SELECT caller, callee, owner, callid, history FROM calls WHERE callid = ?;', (callid,))
            result = results.fetchone()
            assert len(result) == 5
            object = cls(result[0], result[1], result[2], result[3])
            object.history = json.loads(result[4])
            object.db = db
            return object
        except Exception as e:
            logging.exception(e)
            raise e

    def update(self, new_state):
        '''
        Let's update the state of the call. new_state is a tuple in the form (newstate, timestamp,)
        '''
        logging.debug("Got a new state: {}".format(new_state,))
        self.history.append(new_state)
        self.save()

    def event_handler(self, event):
        '''
        There's a new event related to our call
        '''
        state = event['type']
        if state in self.actions:
            getattr(self, self.actions[state])(event=event)

    def dtmf(self, event):
        '''
        We received a DTMF sequence
        '''
        try:
            assert self.state().startswith('Up')
            # The only thing we want to do is to call the callee if we press 1
            if event['digit'] != '1':
                return
            # Now, we're connectig the other side
            # But first we should stop the playback
            results = self.db.execute('SELECT login_ari, pass_ari FROM users WHERE api = ?', (self.owner,))
            login_ari, token_ari = results.fetchone()
            payload = {}
            payload['app'] = 'piphone'
            payload['api_key'] = ':'.join([login_ari, token_ari])
            logging.debug('Stopping the playback currently running'.format(payload,))
            # We're stoping the playback, with the same ID as the channel, to keep track of it
            r = requests.delete('http://185.34.33.12:8088/ari/playbacks/{0}'.format(event['channel']['id']), data=payload)
            # Next we need to originate a call to the other side
            logging.info('Will now connect {} to {}'.format(self.caller, self.callee,))
            payload = {}
            payload['app'] = 'piphone'
            payload['api_key'] = ':'.join([login_ari, token_ari])
            payload['endpoint'] = 'SIP/' + sanitize_phonenumber(self.callee) + '@forfait-kwaoo'
            logging.debug('Preparing to send a request to the ARI with payload {}'.format(payload,))
            r = requests.post('http://185.34.33.12:8088/ari/channels/{}-{}'.format(self.id, sanitize_phonenumber(self.callee),), data=payload)
            # And now, just need to add the channel to the bridge
            payload = {}
            payload['app'] = 'piphone'
            payload['api_key'] = ':'.join([login_ari, token_ari])
            payload['channel'] = '{}-{}'.format(self.id, sanitize_phonenumber(self.callee),)
            r = requests.post('http://185.34.33.12:8088/ari/bridges/{}/addChannel'.format(self.id,), data=payload)
        except AssertionError as e:
            logging.error("Received a DTMF sequence out le being in  a '{}' state, ignoring: {}".format(self.state(), event['digit']))

    def change(self, event):
        '''
        Let's change the state of the call
        '''
        self.update((':'.join([event['channel']['state'], event['channel']['id'].split('-')[-1]]), event['timestamp'],))
        logging.info("New state for call {}: {}".format(event['channel']['id'], event['channel']['state']))
        # We now need to take action according to our new state
        if event['channel']['state'] == 'Up':
            # Are we the caller orthe callee?
            if event['channel']['id'].endswith(self.callee):
                # Callee side, let's just move
                return
            # Call is being picked up, we want to play a song
            payload = {}
            try:
                results = self.db.execute('SELECT login_ari, pass_ari FROM users WHERE api = ?', (self.owner,))
                login_ari, token_ari = results.fetchone()
                payload['app'] = 'piphone'
                payload['api_key'] = ':'.join([login_ari, token_ari])
                payload['media'] = 'sound:mario'
                payload['lang'] = 'en_US'
                logging.debug('Preparing to send a request to the ARI with payload {}'.format(payload,))
                # We're starting a playback, with the same ID as the channel, to keep track of it
                r = requests.post('http://185.34.33.12:8088/ari/channels/{0}/play/{0}'.format(event['channel']['id']), data=payload)
                logging.debug("Now playing a sound on channel {}".format(self.id))
            except Exception as e:
                logging.exception(e)
                raise e

    def call_caller(self, event):
        '''
        We want to call the caller. Which needs to be done via a bridge.
        Fisrt we set-up a bridge, then we originate a channel, postfixing the bridge id
        with the caller number.

        And then we connect the caller to the bridge.

        The bridge is a mixed one.
        '''
        self.update((':'.join([event['type'], event['channel']['id'].split('-')[-1]]), event['timestamp'],))
        results = self.db.execute('SELECT login_ari, pass_ari FROM users WHERE api = ?', (self.owner,))
        login_ari, token_ari = results.fetchone()
        payload = {}
        payload['app'] = 'piphone'
        payload['api_key'] = ':'.join([login_ari, token_ari])
        # Let's establish a bridge over the Kwai River
        try:
            payload['type'] = 'mixing'
            logging.debug("Initiating a bridge for call {}".format(self.id,))
            r = requests.post('http://185.34.33.12:8088/ari/bridges/{}'.format(self.id,), data=payload)
        except Exception as e:
            logging.exception(e)
            raise e

        # Now, let's create the channel
        payload = {}
        payload['app'] = 'piphone'
        payload['api_key'] = ':'.join([login_ari, token_ari])
        try:
            payload['endpoint'] = 'SIP/' + sanitize_phonenumber(self.caller) + '@forfait-kwaoo'
            logging.debug('Preparing to send a request to the ARI with payload {}'.format(payload,))
            r = requests.post('http://185.34.33.12:8088/ari/channels/{}-{}'.format(self.id, sanitize_phonenumber(self.caller),), data=payload)
        except Exception as e:
            logging.exception(e)
            raise e
        # Let's connect the channel to the bridge.
        payload = {}
        payload['app'] = 'piphone'
        payload['api_key'] = ':'.join([login_ari, token_ari])
        try:
            payload['channel'] = '{}-{}'.format(self.id, sanitize_phonenumber(self.caller),)
            logging.debug("Connection the channel to the bridge for call {}".format(self.id,))
            r = requests.post('http://185.34.33.12:8088/ari/bridges/{}/addChannel'.format(self.id,), data=payload)
        except Exception as e:
            logging.exception(e)
            raise e

    def save(self):
        '''
        Save the Call to database.
        '''
        logging.debug("Saving call {}: {}".format(self.id, json.dumps(self, cls=PiphoneJSONEncoder)))
        try:
            self.db.execute('''INSERT OR REPLACE INTO calls (caller, callee, owner, callid, history)
                VALUES (?, ?, ?, ?, ?) '''
                , (self.caller, self.callee, self.owner, self.id, json.dumps(self.history)))
            self.db.commit()
        except Exception as e:
            logging.exception(e)
            raise e

def authenticated(f):
    '''
    We need a decorator to check if our query is authenticated.
    We will store an API key and SECRET in ur database, the client
    needs to have both of them.
    He must then send us a JWT token with an API claim in the payload.
    The JWT token must be encoded and signed with the SECRET. If the
    token is bad, we return a 403.
    '''
    def wrapped(db, *args, **kwargs):
        # Let's get the JWT token. It should be a params (from get or post or whatev')
        logging.debug("Authetication: {}".format([':'.join([key, request.params[key]]) for key in request.params],))
        if 'token' not in request.params:
            logging.error("No token found in the params")
            abort(401, "No token found in the query")
        # We want the api id in the params to.
        if 'api' not in request.params:
            logging.error("No api id found in the params")
            abort(401, "No api id found in the params")
        # Now, let's get the token on our side
        try:
            results = db.execute('SELECT token FROM users WHERE api = ?', (request.params['api'],)).fetchall()
            assert len(results) == 1
            token = results[0][0]
            auth_token = jwt.decode(request.params['token'], token)
            assert auth_token['api'] == request.params['api']
            for key in auth_token:
                request.params[key] = auth_token[key]
        except (jwt.exceptions.InvalidTokenError, AssertionError) as e:
            logging.error("Access refused")
            logging.exception(e)
            abort(403, e)
        except Exception as e:
            abort(500, e)
        return f(db, *args, **kwargs)
    return wrapped

class Server(ServerAdapter):
    """
    This class manage all that is needed to run the REST App of the piphone. It is in charge of
    launching an Executor, start the event loop in its own thread and run the bottle app.
    """
    server = None
    running = False
    options = None
    callbacks = {}

    def __init__(self, debug=False, *args, **kwargs):
        """
        We're starting the logger subsytem, create the Thread Pool and stuff
        """
        self.logger = logging.getLogger('server')
        if debug:
            self.logger.setLevel(logging.DEBUG)
        self.logger.addHandler(logging.FileHandler('app.log'))
        self.threads = concurrent.futures.ThreadPoolExecutor()
        self.loop = asyncio.get_event_loop()
        self.db = sqlite3.connect('call.db')

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

    async def __listen(self):
        ws_logger = logging.getLogger('websockets')
        ws_logger.setLevel(logging.DEBUG)
        ws_logger.addHandler(logging.FileHandler('app.log'))
        async with websockets.connect('ws://185.34.33.12:8088/ari/events?app=piphone&api_key=piphone:passpiphone') as websocket:
            while self.running == True:
                ws_logger.info("Waiting for events on websocket")
                event = await websocket.recv()
                # Let's call the applications function
                await self.dispatch(json.loads(event))
                # This is now where I want to create callbacks from events

    async def dispatch(self, event):
        """
        Let's work on our events. Parse them and do request on the ARI API. Event is
        a dict loaded from JSON.
        """
        self.logger.debug('Event received: {}'.format(event,))
        # Let's get the call ID, the call id isthe channel id minus the last -part.
        if 'channel' not in event:
            self.logger.debug('Not a channel event, skip')
            return
        call_id = re.sub('-\d+$', '', event['channel']['id'])
        call = Call.load(call_id, self.db)
        call.event_handler(event)

    def run(self, handler):
        """
        We're starting the REST application, and the launch applications
        """
        self.running = True
        self.server = make_server('127.0.0.1', 8080, handler, **self.options)
        self.threads.submit(self.server.serve_forever)
        self.loop.run_until_complete(self.__listen())

    def stop(self):
        self.running = False
        self.loop.close()
        self.server.shutdown()
        self.threads.shutdown(wait=False)
        
@app.get('/calls/<callid>')
@app.get('/calls/')
@authenticated
def calls(db, callid=None):
    """
    Return the list of calls associated to the connected user.
    The call has a status, caller, callee and history (status change+timestamp)
    """
    logging.debug("GET {}".format(request.fullpath))
    if callid == None:
        try:
            results = db.execute('SELECT callid FROM calls WHERE owner = ?;', (request.params['api'],))
            calls = []
            for row in results.fetchall():
                call = Call.load(row[0], db)
                logging.debug("Call fetched: {}".format(json.dumps(call, cls=PiphoneJSONEncoder)))
                calls.append(call)
            head = {'call': request.fullpath, 'user': request.params['api'], 'hits': len(calls)}
            return {'head': head, 'data': calls}
        except Exception as e:
            logging.exception(e)
            abort(500, "Exception")
    # We first need to check if we can access the callid we asked for
    try:
        results = db.execute('SELECT callid FROM calls WHERE owner = ? AND callid = ? ;'
                , (request.params['api'], callid,))
        rows = results.fetchall()
        logging.debug("Found {} results: {}".format(len(rows), rows))
        assert len(rows) == 1
        call = Call.load(callid, db)
        head = {'call': call.url(), 'user': request.params['api'], 'hits': 1}
        return {'head': head, 'data': call}
    except AssertionError as e:
        logging.debug("Not exactly one results found, this is an issue")
        logging.error("Unauthorized access to call {} from user {}".format(callid, request.params['api']))
        abort(403, "You do not have the authorization to get this call")
    except Exception as e:
        logging.debug("Exception catched: {}".format(e,))
        logging.error("Call not found {}".format(callid,))
        abort(404, "This call does not exist")

@app.post('/calls/')
@app.post('/calls/<callid>')
@authenticated
def originate(db, callid=None):
    logging.debug("POST {}".format(request.fullpath))
    try:
        if callid is not None:
            call = Call(request.params['caller'], request.params['callee'], request.params['api'], callid=request.params['callid'], db=db)
        else:
            call = Call(request.params['caller'], request.params['callee'], request.params['api'], db=db)
        logging.debug("Originate a call: {}".format(json.dumps(call, cls=PiphoneJSONEncoder)))
        head = {'call': call.url()
            , 'user': request.params['api']
            , 'hits': 1}
        return {'header': head, 'data': call}
    except Exception as e:
        logging.debug("Missing params : {}".format([p for p in request.params],))
        logging.exception(e)
        abort(400, "Missing or incorrect fields, the call cannot be processed")

if __name__ == '__main__':
    app.install(SQLitePlugin(dbfile='call.db'))
    app.install(JSONPlugin(json_dumps=lambda s: json.dumps(s, cls=PiphoneJSONEncoder)))

    server=Server()
    try:
        app.run(server=server)
    except Exception as e:
        logging.exception(e)
        server.stop()
        raise e