A mini JSON REST relay for Twilio using Flask-Restful

mini_twilio_server.py

#!/usr/bin/env python

import json
import types
import logging
from datetime import datetime
from flask import Flask, Response, request, jsonify
from flask_restful import Resource, Api
from flask_sqlalchemy import SQLAlchemy
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException

app = Flask(__name__)
api = Api(app)
db = SQLAlchemy(app)

def api_route(self, *args, **kwargs):
    def wrapper(cls):
        self.add_resource(cls, *args, **kwargs)
        return cls
    return wrapper


def make_json_app():
    def make_json_error(ex):
        response = jsonify(message=str(ex))
        response.status_code = (ex.code
                                if isinstance(ex, HTTPException)
                                else 500)
        return response

    for code in default_exceptions.iterkeys():
        app.error_handler_spec[None][code] = make_json_error


class SerializableModel(object):
    def to_dict(self):
        value = {}
        for column in self.__table__.columns:
            attribute = getattr(self, column.name)
            if isinstance(attribute, datetime):
                attribute = str(attribute)
            value[column.name] = attribute
        return value


class Message(db.Model, SerializableModel):
    __tablename__ = 'Message'

    MessageSid = db.Column(db.String, primary_key=True)
    AccountSid = db.Column(db.String)
    ApiVersion = db.Column(db.String)
    Body = db.Column(db.String)
    From = db.Column(db.String)
    To = db.Column(db.String)

    def __init__(self, MessageSid, AccountSid, ApiVersion, Body, From, To):
        self.MessageSid = MessageSid
        self.AccountSid = AccountSid
        self.ApiVersion = ApiVersion
        self.Body = Body
        self.From = From
        self.To = To


@api.route('/e')
class Endpoint(Resource):
    def post(self):
        message_sid = request.values.get('MessageSid', None)
        account_sid = request.values.get('AccountSid', None)
        api_version = request.values.get('ApiVersion', None)
        body = request.values.get('Body', None)
        frm = request.values.get('From', None)
        to = request.values.get('To', None)

        if account_sid in app.config['TWILIO_ACCOUNT_SID_CSV'].split(','):
            message = Message(message_sid, account_sid, api_version, body, frm, to)
            db.session.add(message)
            db.session.commit()

            return Response(status=204)


@api.route('/m/<account_sid>')
class Messages(Resource):
    def get(self, account_sid):
        messages = [m.to_dict() for m in
                    Message.query.filter_by(AccountSid=account_sid)]
        return Response(json.dumps(messages),
                        status=200,
                        mimetype='application/json')

if __name__ == "__main__":
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'
    app.config['TWILIO_ACCOUNT_SID_CSV'] = ''
    api.route = types.MethodType(api_route, api)
    #logging.basicConfig(filename='app.log', level=logging.INFO)
    make_json_app()

    app.run(host='0.0.0.0', port=80, debug=True)