moved from scratchpad repo

Author: RawIron

.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+.idea
+lib

README.md

@@ -1 +1,11 @@
-# flask-appengine-demo
+# flask-appengine-demo
+
+a little MAGIC
+gae calls run.py
+run.py add flask lib to the syspath
+
+
+REST Api server
+has an admin api
+has a client api
+serves the playlist of a user

app.yaml

@@ -0,0 +1,51 @@
+application: application
+version: 1
+runtime: python27
+api_version: 1
+threadsafe: true
+
+default_expiration: "5d"
+
+builtins:
+- appstats: on
+- admin_redirect: on
+- deferred: on
+- remote_api: on
+
+libraries:
+- name: jinja2
+  version: "2.6"
+- name: markupsafe
+  version: "0.15"
+
+inbound_services:
+- warmup
+
+
+handlers:
+- url: /favicon.ico
+  static_files: application/static/img/favicon.ico
+  upload: application/static/img/favicon.ico
+
+- url: /stylesheets
+  static_dir: application/static/css
+
+- url: /robots.txt
+  static_files: application/static/robots.txt
+  upload: application/static/robots.txt
+
+- url: /gae_mini_profiler/static
+  static_dir: lib/gae_mini_profiler/static
+
+- url: /gae_mini_profiler/.*
+  script: lib.gae_mini_profiler.main.application
+
+- url: /static
+  static_dir: application/static
+
+- url: /example/.*
+  script: run_example.example.app
+
+- url: /.*
+  script: run.application.app
+

appengine_config.py

@@ -0,0 +1,20 @@
+"""
+App Engine config
+"""
+
+
+def gae_mini_profiler_should_profile_production():
+    """Uncomment the first two lines
+       to enable GAE Mini Profiler on production for admin accounts"""
+    # from google.appengine.api import users
+    # return users.is_current_user_admin()
+    return False
+
+
+from google.appengine.api import logservice
+
+logservice.AUTOFLUSH_ENABLED = True
+logservice.AUTOFLUSH_EVERY_SECONDS = None
+logservice.AUTOFLUSH_EVERY_BYTES = None
+logservice.AUTOFLUSH_EVERY_LINES = 100
+

application/__init__.py

@@ -0,0 +1,35 @@
+"""
+Initialize Flask app
+
+"""
+
+from flask import Flask
+
+# from flask_debugtoolbar import DebugToolbarExtension
+from gae_mini_profiler import profiler, templatetags
+from werkzeug.debug import DebuggedApplication
+
+
+app = Flask('application')
+app.config.from_object('application.settings')
+
+# Enable jinja2 loop controls extension
+app.jinja_env.add_extension('jinja2.ext.loopcontrols')
+
+@app.context_processor
+def inject_profiler():
+    return dict(profiler_includes=templatetags.profiler_includes())
+
+
+# Pull in URL dispatch routes
+import urls
+
+# Flask-DebugToolbar (only enabled when DEBUG=True)
+# toolbar = DebugToolbarExtension(app)
+
+# Werkzeug Debugger (only enabled when DEBUG=True)
+if app.debug:
+    app = DebuggedApplication(app, evalex=True)
+
+# GAE Mini Profiler (only enabled on dev server)
+app = profiler.ProfilerWSGIMiddleware(app)

application/decorators.py

@@ -0,0 +1,42 @@
+"""
+decorators.py
+
+Decorators for URL handlers
+"""
+
+from functools import wraps
+from google.appengine.api import users
+from flask import redirect, request, abort
+
+
+def login_not_required(func):
+    """does not require login credentials"""
+    @wraps(func)
+    def decorated_view(*args, **kwargs):
+        if not users.get_current_user():
+            pass
+            #return redirect(users.create_login_url(request.url))
+        return func(*args, **kwargs)
+    return decorated_view
+
+
+def login_required(func):
+    """Requires standard login credentials"""
+    @wraps(func)
+    def decorated_view(*args, **kwargs):
+        if not users.get_current_user():
+            return redirect(users.create_login_url(request.url))
+        return func(*args, **kwargs)
+    return decorated_view
+
+
+def admin_required(func):
+    """Requires App Engine admin credentials"""
+    @wraps(func)
+    def decorated_view(*args, **kwargs):
+        if users.get_current_user():
+            if not users.is_current_user_admin():
+                abort(401)  # Unauthorized
+            return func(*args, **kwargs)
+        return redirect(users.create_login_url(request.url))
+    return decorated_view

application/generate_keys.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+generate_keys.py
+
+Generate CSRF and Session keys, output to secret_keys.py file
+
+Usage:
+    generate_keys.py [-f]
+
+Outputs secret_keys.py file in current folder
+
+By default, an existing secret_keys file will not be replaced.
+Use the '-f' flag to force the new keys to be written to the file
+
+
+"""
+
+import string
+import os.path
+
+from optparse import OptionParser
+from random import choice
+from string import Template
+
+
+# File settings
+file_name = 'secret_keys.py'
+file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), file_name)
+
+file_template = Template('''# CSRF- and Session keys
+
+CSRF_SECRET_KEY = '$csrf_key'
+SESSION_KEY = '$session_key'
+''')
+
+
+# Get options from command line
+parser = OptionParser()
+parser.add_option("-f", "--force", dest="force", 
+    help="force overwrite of existing secret_keys file", action="store_true")
+parser.add_option("-r", "--randomness", dest="randomness", 
+    help="length (randomness) of generated key; default = 24", default=24)
+(options, args) = parser.parse_args()
+
+
+def generate_randomkey(length):
+    """Generate random key, given a number of characters"""
+    chars = string.letters + string.digits
+    return ''.join([choice(chars) for i in range(length)])
+
+
+def write_file(contents):
+    with open(file_path, 'wb') as f:
+        f.write(contents)
+
+
+def generate_keyfile(csrf_key, session_key):
+    """Generate random keys for CSRF- and session key"""
+    output = file_template.safe_substitute(dict(
+        csrf_key=csrf_key, session_key=session_key
+    ))
+    if os.path.exists(file_path):
+        if options.force is None:
+            print "Warning: secret_keys.py file exists.  Use 'generate_keys.py --force' to force overwrite."
+        else:
+            write_file(output)
+    else:
+        write_file(output)
+
+
+def main():
+    r = options.randomness
+    csrf_key = generate_randomkey(r)
+    session_key = generate_randomkey(r)
+    generate_keyfile(csrf_key, session_key)
+
+
+if __name__ == "__main__":
+    main()
+

application/models.py

@@ -0,0 +1,44 @@
+"""
+models.py
+
+App Engine datastore models
+"""
+
+
+from google.appengine.ext import ndb
+
+
+class PurchaseLogMonthly(ndb.Model):
+    name = ndb.StringProperty(indexed=False)
+    ofYearMonth = ndb.IntegerProperty(indexed=False)
+    ofYear = ndb.IntegerProperty(indexed=False)
+    ofMonth = ndb.IntegerProperty(indexed=False)
+
+class PurchaseLogEntry(ndb.Model):
+    purchasedOn = ndb.DateTimeProperty(auto_now_add=False)
+    userName = ndb.StringProperty(indexed=False)
+    videoName = ndb.StringProperty(indexed=False)
+    videoPrice = ndb.IntegerProperty()
+
+
+class UserCounters(ndb.Model):
+    name = ndb.StringProperty(indexed=False)
+    lastLogin = ndb.DateTimeProperty(auto_now_add=True)
+    videoWatchHistory = ndb.StringProperty()
+    loginCounter = ndb.IntegerProperty()
+    videoWatchCounter = ndb.IntegerProperty()
+
+
+class GlobalCountersDaily(ndb.Model):
+    name = ndb.StringProperty(indexed=False)
+    ofDay = ndb.DateProperty(auto_now_add=False)
+
+class GlobalCountersTotal(ndb.Model):
+    name = ndb.StringProperty(indexed=False)
+
+class GlobalCounters(ndb.Model):
+    videoWatchCounter = ndb.IntegerProperty()
+    loginCounter = ndb.IntegerProperty()
+    purchasesCounter = ndb.IntegerProperty()
+    revenueCounter = ndb.IntegerProperty()
+

application/playlists/__init__.py

@@ -0,0 +1 @@
+

application/playlists/models.py

@@ -0,0 +1,78 @@
+"""
+models.py
+
+App Engine datastore models
+"""
+
+
+from google.appengine.ext import ndb
+
+
+# We set the same parent key on the 'Playlist' to ensure one playlist
+# per entity group. Queries across the single entity group
+# will be consistent. However, the write rate to a single entity group
+# should be limited to ~1/second.
+
+def _playlists_key(playlist_name):
+    """Constructs a Datastore key for a playlist entity"""
+    key = ndb.Key(playlist_name, playlist_name)
+    return key
+
+
+class Playlists(ndb.Model):
+
+    name = ndb.StringProperty(required=True, indexed=True)
+    videoUri = ndb.StringProperty(indexed=False)
+    available = ndb.BooleanProperty(indexed=False, default=True)
+    tags = ndb.StringProperty(repeated=True)
+    createdAt = ndb.DateTimeProperty(indexed=False, auto_now_add=True)
+
+    @classmethod
+    def all(cls):
+        playlists = []
+        for entry in cls.query():
+            playlist = cls._createDictionaryFrom(entry)
+            playlists.append(playlist)
+        return playlists
+
+    @classmethod
+    def new(cls, playlist_name):
+        ancestor_key = _playlists_key(playlist_name)
+        return Playlists(parent=ancestor_key)
+
+    @classmethod
+    def byKey(cls, playlist_name, video_id):
+        ancestor_key = _playlists_key(playlist_name)
+        key = ndb.Key(Playlists, video_id, parent=ancestor_key)
+        entry = key.get()
+        video = cls._createDictionaryFrom(entry)
+        return video
+
+    @classmethod
+    def allVideos(cls, playlist_name):
+        ancestor_key = _playlists_key(playlist_name)
+        videos = []
+        for entry in cls.query(ancestor=ancestor_key):
+            video = cls._createDictionaryFrom(entry)
+            videos.append(video)
+        return videos
+
+    @classmethod
+    def deleteVideo(cls, playlist_name, playlist_id):
+        ancestor_key = _playlists_key(playlist_name)
+        key = ndb.Key(Playlists, playlist_id, parent=ancestor_key)
+        key.delete()
+
+    @classmethod
+    def _createDictionaryFrom(cls, entry):
+        if entry is None:
+            return {}
+        video = {}
+        video['parentId'] = entry.key.parent().id()
+        video['parentKind'] = entry.key.parent().kind()
+        video['id'] = entry.key.id()
+        video['kind'] = entry.key.kind()
+        video['name'] = entry.name
+        video['videoUri'] = entry.videoUri
+        return video
+

application/playlists/testViews.py

@@ -0,0 +1,6 @@
+import sys
+print sys.path
+import views
+
+if __name__ == '__main__':
+    print views.api_get_playlists()