main.py

import os
import logging
import urllib
import csv
from StringIO import StringIO
import datetime
import time

import jinja2
from flask import make_response, jsonify, render_template
import flask.ext.assets
from webassets.ext.jinja2 import AssetsExtension
from webassets import Environment as AssetsEnvironment


from database import db_session
from models import *
from base import *
import utilities


app = utilities.init_flask(__name__)
assets = flask.ext.assets.Environment()
assets.init_app(app)


assets_env = AssetsEnvironment('./static/', '/static')
jinja_environment = jinja2.Environment(
    autoescape=True,
    loader=jinja2.FileSystemLoader(os.path.join(os.path.dirname(__file__), "templates")),
    extensions=[AssetsExtension])
jinja_environment.assets_environment = assets_env


@app.teardown_appcontext
def shutdown_session(exception=None):
    db_session.remove()


@app.route("/markers")
@user_optional
def markers(methods=["GET", "POST"]):
    logging.debug('getting markers')
    if request.method == "GET":
        ne_lat = float(request.values['ne_lat'])
        ne_lng = float(request.values['ne_lng'])
        sw_lat = float(request.values['sw_lat'])
        sw_lng = float(request.values['sw_lng'])
        zoom = int(request.values['zoom'])
        start_date = datetime.date.fromtimestamp(int(request.values['start_date']))
        end_date = datetime.date.fromtimestamp(int(request.values['end_date']))
        fatal = request.values['show_fatal']
        severe = request.values['show_severe']
        light = request.values['show_light']
        inaccurate = request.values['show_inaccurate']
        min_zoom_level = 16
        if zoom < min_zoom_level:
            markers = []
        else:
            # query = Marker.all()

            # if 'start_time' in request.values:
            #     query = query.filter("created >=", request.values["start_time"])
            # if 'start_time' in request.values:
            #     query = query.filter("created <=", request.values["end_time"])
            print ""
            logging.debug('querying markers in bounding box')
            results = Marker.bounding_box_fetch(ne_lat, ne_lng, sw_lat, sw_lng,
                                                start_date, end_date,
                                                fatal, severe, light, inaccurate)
            logging.debug('serializing markers')
            markers = [marker.serialize() for marker in results.all()]

        if request.values.get('format') == 'csv':
            if not markers:
                raise Exception("No markers available.")

            output_file = StringIO()
            output = csv.DictWriter(output_file, markers[0].keys())
            output.writeheader()
            for marker in markers:
                row = {k: v.encode('utf8')
                       if type(v) is unicode else v
                       for k, v in marker.iteritems()}
                output.writerow(row)

            return make_response((output_file.getvalue(),
                200,
                {u'Content-Type': 'text/csv',
                 u'Content-Disposition': u'attachment; filename="data.csv"'}))

        else: # defaults to json
            return jsonify(markers=markers)

    else:
        data = json.loads(self.request.body)
        marker = Marker.parse(data)
        marker.user = self.user
        marker.update_location()
        marker.put()
        return make_response(json.dumps(marker.serialize(self.user)))

@app.route("/markers/(.*)", methods=["GET", "PUT", "DELETE"])
@user_required
def marker(self, key_name):
    if request.method == "GET":
        marker = Marker.get_by_key_name(key_name)
        return make_response(json.dumps(marker.serialize(self.user)))

    elif request.method == "PUT":
        marker = Marker.get_by_key_name(key_name)
        data = json.loads(self.request.body)
        marker.update(data, self.user)
        return make_response(json.dumps(marker.serialize(self.user)))

    elif request.method == "DELETE":
        marker = Marker.get_by_key_name(key_name)
        marker.delete()

@app.route("/login", methods=["POST"])
@user_optional
def login():
    user = get_user()
    if user:
        return make_response(json.dumps(user.serialize()))

    if request.json:
        facebook_data = request.json
        user_id = facebook_data["userID"]
        access_token = facebook_data["accessToken"]
        user_details = json.loads(urllib.urlopen("https://graph.facebook.com/me?access_token=" + access_token).read())
        # login successful
        if user_details["id"] == user_id:
            user = User.query.filter(User.email == user_details["email"]).scalar()
            if not user:
                user = User(
                    email = user_details["email"],
                    first_name = user_details["first_name"],
                    last_name = user_details["last_name"],
                    username = user_details["username"],
                    facebook_id = user_details["id"],
                    facebook_url = user_details["link"],
                    access_token = facebook_data["accessToken"]
                )
            else:
                user.access_token = facebook_data["accessToken"]

            db_session.add(user)
            set_user(user)
            return make_response(json.dumps(user.serialize()))
        else:
            raise Exception("Error in logging in.")
    else:
        raise Exception("No login data or user logged in.")


@app.route("/logout")
@user_required
def do_logout():
    logout()

@app.route("/follow/(.*)")
@user_required
def follow(key_name):
    marker = Marker.get_by_key_name(key_name)
    follower = Follower.all().filter("marker", marker).filter("user", self.user).get()
    if not follower:
        Follower(parent = marker, marker = marker, user = self.user).put()

@app.route("/unfollow/(.*)")
@user_required
def unfollow(key_name):
    marker = Marker.get_by_key_name(key_name)
    follower = Follower.all().filter("marker", marker).filter("user", self.user).get()
    if follower:
        follower.delete()

@app.route('/', defaults={'marker_id': None})
@app.route('/<int:marker_id>')
def main(marker_id):
    # at this point the marker id is just a running number, and the
    # LMS is in the description and needs to be promoted to a DB
    # field so we can query it. We also need to add a provider id.
    context = {}
    marker = None
    if 'marker' in request.values:
        markers = Marker.get_marker(request.values['marker'])
        if markers.count() == 1:
            marker = markers[0]
            context['coordinates'] = (marker.latitude, marker.longitude)
            context['marker'] = marker.id
    if 'start_date' in request.values:
        context['start_date'] = string2timestamp(request.values['start_date'])
    elif marker:
        context['start_date'] = year2timestamp(marker.created.year)
    if 'end_date' in request.values:
        context['end_date'] = string2timestamp(request.values['end_date'])
    elif marker:
        context['end_date'] = year2timestamp(marker.created.year + 1)
    for attr in 'show_fatal', 'show_severe', 'show_light', 'show_inaccurate',\
                'zoom', 'lat', 'lon':
        if attr in request.values:
            context[attr] = request.values[attr]
    return render_template('index.html', **context)

def string2timestamp(s):
    return time.mktime(datetime.datetime.strptime(s, "%Y-%m-%d").timetuple())

def year2timestamp(y):
    return time.mktime(datetime.date(y, 1, 1).timetuple())

if __name__ == "__main__":
    logging.basicConfig(level=logging.DEBUG)
    app.run(debug=True)