ems/scr/API.py

'''
Created on 24.10.2013

@author: Philipp Rauch
@version: 0.5
'''

from flask import Flask, jsonify, abort, make_response, request
from time import time
import socket

app = Flask(__name__)
app_host = '0.0.0.0' #api_host='0.0.0.0' for public access
app_port = '5000'
api_host = socket.gethostname() if app_host == '0.0.0.0' else app_host
api_url = 'http://%s:%s' % (api_host, app_port)

#### BUFFER ####
class Buffer(object):
    device = {
             'battery' : {
                    'id': 1,
                    'voltage' : 400.11,
                    'current' : 20.264,
                    'power' : 53.465,
                    'capacity' : 80.34,
                    'isCharging' : False,
                    'isMaster' : True,
                    'dyn' : None },
               'ac_grid' : {
                    'id': 2,
                    'voltage' : 400.23,
                    'current' : 10.423,
                    'power' : 23.35,
                    'isOn' : True,
                    'isFeed' : True,
                    'isMaster' : False,
                    'dyn' : None }
              }
    error = {
                'db_error' : {
                    'id' : 1,
                    'content' : None }
             }
    dc_labor = {
                'device' : device,
                'error' : error
                }

    dc_grid = {
                'device' : 'device',
                'error' : 'error'
                }

    ac_grid = {
                'device' : 'device',
                'error' : 'error'
                }

    system = {
              'dc_labor' : dc_labor, 
              'dc_grid' : dc_grid, 
              'ac_grid' : ac_grid
              }

    isInitialised = False

    def __init__(self):
        self.isInitialised = True

    def get_instance(self):
        if self.isInitialised:
            return self
        else:
            return Buffer().__init__()


    def gen_start_url(self, l):
        '''
        generate a URL form a list
        @param l: list of aspacts of the URL
        @return: URL
        '''
        url = api_url
        for i in l:
            url = '%s/%s' % (url, i)
        return url

    def get_level(self, l):
        '''
        iterating over a dictionary on a given path
        @param l: items witch tell the path to the value
        @return: dictionary with the key and value of the last item in the list 
        '''
        level = l.pop(0)
        for i in l:
            if isinstance(level, dict) and i in level:
                level = level.get(i)
            else:
                abort(404)
        self.set_href(level, self.gen_start_url(l))        #set all links above
        return {l[-1] : level}

    def generate_links(self, dic, url, postfix):
        '''
        generats a link to dic if dic is a dictionary
        @param dic: variable that is being tested on a dictionary
        @param url: previous url
        @param postfix: appendix to the given url
        '''
        if isinstance(dic, dict):
            url = '%s/%s' % (url, postfix)
            self.set_href(dic, url)
        else:
            return

    def set_href(self, dic, url):
        '''
        set the ref link if dic is a dictionary
        @param dic: variable that is being tested on a dictionary
        @param url: url to the first dictionary
        '''
        if isinstance(dic, dict):
            for i in dic.keys():
                self.generate_links(dic.get(i), url, i)
            dic.update({'_href': url})
            dic.update({'_timestamp' : time()})

    def foo(self, l, args):
        '''
        @param l: list
        @param args: arguments from the reqest
        @return: Dictionary
        '''
        del l[-1]
        dic = self.get_level(l).get(l[-1])
        if isinstance(dic, dict) and 'dyn' in dic:
            message = 'generating view for %s' % (l[-1])
        else:
            abort(404)
        return { l[-1] : message, 'args' : args.to_dict(flat=False)}

    def update_buffer(self):
        #ToDo
        None

    def init_buffer(self):
        #ToDo
        None

buf = Buffer().get_instance()

########## ERROR Handler ##########
@app.errorhandler(405)
def not_allowed(error):
    return make_response(jsonify( { 'error': '405 Not Allowed' } ), 405)

@app.errorhandler(404)
def not_found(error):
    return make_response(jsonify( { 'error': '404 Not Found' } ), 404)

@app.errorhandler(400)
def bad_reqest(error):
    return make_response(jsonify( { 'error': '400 Bad Reqest' } ), 400)

##########  GET Handler  ##########
@app.route('/', methods = ['GET'])
def get_root():
    buf.set_href(Buffer.system, api_url)
    return jsonify( { 'system' : Buffer.system } )

@app.route('/<path:path>', methods = ['GET'])
def get_catch_all(path):
    l = path.split('/')
    l.insert(0, Buffer.system)
    if '' == l[-1]:                      # if last element of list is empty
        del l[-1]                        # remove it
        out = buf.get_level(l)
    elif 'dyn' == l[-1]:
        args = request.args                 # returns a dictionary with a list of values for each key
                                            # each value and each key is represented as a string
                                            # to convert it to a dictionary use to_dict(flat=False)
                                            # to_dict(flat=True) returns the key and the first item of the value list.
        out = buf.foo(l, args)
    else:
        out = buf.get_level(l)
    return jsonify( out )

#########  POST Handler ##########
#@app.route('/db', methods = ['POST'])
#def create_item():
#    if not request.json or not 'title' in request.json:
#        abort(400)
#    item = {
#        'id': db[-1]['id'] + 1,
#        'title': request.json['title'],
#        'description': request.json.get('description', ""),
#        'done': False
#    }
#    db.append(item)
#    return jsonify( { 'item': item } ), 201

##########  PUT Handler  ##########
#@app.route('/db/<int:item_id>', methods = ['PUT'])
#def update_item(item_id):
#    item = filter(lambda t: t['id'] == item_id, db)
#    if len(item) == 0:
#        abort(404)
#    if not request.json:
#        abort(400)
#    if 'title' in request.json and type(request.json['title']) != unicode:
#        abort(400)
#    if 'description' in request.json and type(request.json['description']) is not unicode:
#        abort(400)
#    if 'done' in request.json and type(request.json['done']) is not bool:
#        abort(400)
#    item[0]['title'] = request.json.get('title', item[0]['title'])
#    item[0]['description'] = request.json.get('description', item[0]['description'])
#    item[0]['done'] = request.json.get('done', item[0]['done'])
#    return jsonify( { 'item': item[0] } ), 201

########## DELET Handler ##########
#@app.route('/db/<int:item_id>', methods = ['DELETE'])
#def delete_item(item_id):
#    item = filter(lambda t: t['id'] == item_id, db)
#    if len(item) == 0:
#        abort(404)
#    db.remove(item[0])
#    return jsonify( { 'result': True } )

##########      RUN      ##########
if __name__ == '__main__':
    app.run(host = app_host, port = int(app_port), debug = True)