Commit cffc26d0d9e198edb51c359a04b3b40eb26a6df3

Anon Ray
Tue Jun 10 02:20:01 IST 2014

Tree SHA1: 3f809f7
Parent SHA1: 5e1b0c3 (Merge branch 'dev' of github.com:janastu/swtstore into dev)
raw diff | raw patch

Fix PEP8 styles. Fix wrong info in README.

  - Fix PEP8 in most python files in classes.
  - Fix README saying '--recursive' in git clone.

README.md 2 -+
runserver.py 3 -++
swtstore/application.py 7 ---++++
swtstore/classes/__init__.py 1 +
swtstore/classes/exceptions.py 6 ++++++
swtstore/classes/models/client.py 38 -------------------+++++++++++++++++++
swtstore/classes/models/context.py 3 -++
swtstore/classes/models/group.py 1 -
swtstore/classes/models/membership.py 1 -
swtstore/classes/models/sweet.py 24 ---------------+++++++++
swtstore/classes/models/types.py 2 -+
swtstore/classes/views/api.py 24 ------------++++++++++++
swtstore/classes/views/app.py 24 -------------+++++++++++
swtstore/classes/views/context.py 16 --------++++++++
swtstore/classes/views/frontend.py 6 ---+++
swtstore/classes/views/oauth.py 7 -----++
swtstore/classes/views/sweet.py 8 -----+++
swtstore/classes/views/user.py 14 ------++++++++
swtstore/sample_config.py 4 --++

Diff rendering mode:
inline
side by side

README.md

 * Clone the repository from <https://git.pantoto.org/sweet-web/sweet-web-engine>
   > `` $ git clone --recursive https://git.pantoto.org/sweet-web/sweet-web-engine.git ``
+  > `` $ git clone https://git.pantoto.org/sweet-web/sweet-web-engine.git ``
 * It is recommended to do the installation inside a python virtual
   environment.

runserver.py

 # Script to run the application server in development mode
 import sys, os
+import sys
+import os
 # Get the path to the base directory of the app
 BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__)))

swtstore/application.py

     __init__.py
 """
 from flask import Flask, request, jsonify, render_template, make_response, g
 import os
 import logging
 from logging.handlers import RotatingFileHandler
+from flask import Flask, request, jsonify, render_template, make_response
 from classes.database import db
 from config import DefaultConfig
 from classes import views
-…
     db.app = app
     oauth.init_app(app)
 # return the current db instance
 # TODO: is this needed so much?
 def getDBInstance():
-…
     log_handler = RotatingFileHandler(log_file, maxBytes=max_size,
                                       backupCount=10)
     if app.config.has_key('LOG_LEVEL'):
+    if 'LOG_LEVEL' in app.config:
         log_level = app.config['LOG_LEVEL'] or 'ERROR'
     else:
         log_level = 'ERROR'

swtstore/classes/init.py

 """
     __init__.py
 """
 from database import db
 from oauth import oauth
 import models

swtstore/classes/exceptions.py

 from sqlalchemy.exc import DontWrapMixin
 class AlreadyExistsError(Exception, DontWrapMixin):
     pass
 class InvalidPayload(Exception, DontWrapMixin):
+    pass
+class ContextDoNotExist(Exception, DontWrapMixin):
     pass

swtstore/classes/models/client.py

     _redirect_uris = db.Column(db.Text)
     _default_scopes = db.Column(db.Text)
     @property
     def client_id(self):
         return self.id
-…
     def __str__(self):
         return '<Client: %s :: ID: %s>' % (self.name, self.id)
     # create and persist the client to the database
     def persist(self):
         db.session.add(self)
-…
 #TODO: find out how to better structure the following code
 # OAuthLib decorators used by OAuthLib in the OAuth flow
 @oauth.clientgetter
 def loadClient(client_id):
     current_app.logger.debug('@oauth.clientgetter')
     #return Client.query.filter_by(id=client_id).first()
     return Client.query.get(client_id)
 @oauth.grantgetter
 def loadGrant(client_id, code):
     current_app.logger.debug('@oauth.grantgetter')
     return Grant.query.filter_by(client_id=client_id, code=code).first()
 @oauth.grantsetter
 def saveGrant(client_id, code, request, *args, **kwargs):
     current_app.logger.debug('@oauth.grantsetter')
     expires = datetime.utcnow() + timedelta(seconds=100)
     grant = Grant(
         client_id = client_id,
         code = code['code'],
         redirect_uri = request.redirect_uri,
         _scopes = ' '.join(request.scopes),
         user = User.getCurrentUser(),
         expires = expires
+        client_id=client_id,
+        code=code['code'],
+        redirect_uri=request.redirect_uri,
+        _scopes=' '.join(request.scopes),
+        user=User.getCurrentUser(),
+        expires=expires
     )
     db.session.add(grant)
     db.session.commit()
     return grant
 @oauth.tokengetter
 def loadToken(access_token=None, refresh_token=None):
     current_app.logger.debug('@oauth.tokengetter')
-…
     elif refresh_token:
         return Token.query.filter_by(refresh_token=refresh_token).first()
 @oauth.tokensetter
 def saveToken(token, request, *args, **kwargs):
     current_app.logger.debug('@oauth.tokensetter')
-…
     expires = datetime.utcnow() + timedelta(seconds=expires_in)
     tok = Token(
         access_token = token['access_token'],
         refresh_token = token['refresh_token'],
         token_type = token['token_type'],
         _scopes = token['scope'],
         expires = expires,
         client_id = request.client.id,
         user = request.user
+        access_token=token['access_token'],
+        refresh_token=token['refresh_token'],
+        token_type=token['token_type'],
+        _scopes=token['scope'],
+        expires=expires,
+        client_id=request.client.id,
+        user=request.user
     )
     db.session.add(tok)
     db.session.commit()
     return tok
 @oauth.usergetter
 def getUser():
     return User.getCurrentUser()
 # Authorized Clients
 class AuthorizedClients(db.Model):
     """
-…
     @staticmethod
     def getByUser(user):
         authorized_clients = [row.client for row in \
+        authorized_clients = [row.client for row in
                 AuthorizedClients.query.filter_by(user_id=user.id).all()]
         current_app.logger.debug('authorized clients %s', authorized_clients)

swtstore/classes/models/context.py

 from datetime import datetime
 import json
+from sqlalchemy.exc import IntegrityError
 from swtstore.classes import db
 from swtstore.classes.models.types import JSONType
 from swtstore.classes.exceptions import AlreadyExistsError

swtstore/classes/models/sweet.py

 from swtstore.classes.database import db
 # custom SQLAlchemy type JSONType
 from swtstore.classes.models.types import JSONType
 from swtstore.classes.utils import urlnorm # normalize URLs
+from swtstore.classes.utils import urlnorm  # normalize URLs
 from swtstore.classes.models import Context, User
+from swtstore.classes.exceptions import InvalidPayload, ContextDoNotExist
 class Sweet(db.Model):
     """ customary docstring """
-…
     created = db.Column(db.DateTime, default=datetime.utcnow)
     def __init__(self, who, what, where, how):
         current_app.logger.info('initing sweet..')
         self.who = who
-…
         self.where = urlnorm(where)
         self.how = how
     def __repr__(self):
         return '[Sweet Object: <%s : @%s: #%s : %s>]' % (self.id, self.who,
                                                         self.what, self.where)
-…
         return None
     # create multiple sweets from a list of JSON
     @staticmethod
     def createSweets(who, payload):
         # the payload has to be a list; a list of swts
         for each in payload:
             if 'what' not in each and 'where' not in\
                 each and 'how' not in each:
+            if 'what' not in each and 'where' not in each and 'how' not in\
+                    each:
                 raise InvalidPayload('Invalid payload %s \n for creating\
+                raise InvalidPayload('Invalid payload %s \n while creating\
                                      mutiple sweets' % (each))
                 return None
-…
             what = Context.getByName(each['what'])
             if what is None:
                 current_app.logger.info('Context "%s" do not exist. Aborting',
                                     what)
                 g.error = 'Context do not exist'
                 abort(400) # this context doesn't exist!
+                raise ContextDoNotExist('Context %s do not exist!' %
+                                        (each['what']))
             current_app.logger.debug('SWEET PAYLOAD\n---\n%s\n%s\n%s\n%s\n----',
                                  who, what, each['where'], each['how'])
+                                    who, what, each['where'], each['how'])
             new_sweet = Sweet(who, what, each['where'], each['how'])
-…
             #'created': self.created.isoformat()
             'created': self.created.strftime('%a, %d %b %Y, %I:%M %p UTC'),
         }
     # create and persist the sweet to the database
     def persist(self):

swtstore/classes/models/types.py

 # class:: Types
 # extend  SQLAlchemy Types
 from datetime import datetime
 import json
 from sqlalchemy import types
 class JSONType(types.TypeDecorator):
     """

swtstore/classes/views/api.py

 from flask import Module, jsonify, request, make_response, abort, g, json,\
                     current_app
+from flask import Module, jsonify, request, make_response
+from flask import abort, g, json, current_app
 from swtstore.classes.models import Context
 from swtstore.classes.models import Sweet
 from swtstore.classes.exceptions import AlreadyExistsError, InvalidPayload
 from swtstore.classes.utils import urlnorm # normalize URLs
+from swtstore.classes.models import Context, Sweet
+from swtstore.classes.exceptions import AlreadyExistsError, InvalidPayload,\
+    ContextDoNotExist
+from swtstore.classes.utils import urlnorm  # normalize URLs
 from swtstore.classes.utils.httputils import makeCORSHeaders
 from swtstore.classes import oauth
-…
     payload = request.json or request.data
     if not payload:
         current_app.logger.error('data not found in payload!')
         g.error= 'data not found in payload!'
+        g.error = 'data not found in payload!'
         abort(400)
     current_app.logger.debug('new sweet payload recvd.. %s', payload)
-…
     try:
         swts = Sweet.createSweets(who, payload)
     except InvalidPayload(msg):
         current_app.logger.error('Invalid Payload in request')
+    except (InvalidPayload, ContextDoNotExist) as e:
+        current_app.logger.error('Error creating sweets. Error: %s', e)
         abort(400)
     response.status_code = 200
-…
     response = makeCORSHeaders(response, origin)
     if request.method == 'OPTIONS':
         reponse.status_code = 200
+        response.status_code = 200
         return response
     args = request.args
-…
     current_app.logger.debug('getContextByName : %s', context)
     return jsonify(context.to_dict())
 # Get a specific context with its definition; based on id
 @api.route('/contexts/<int:id>', methods=['GET'])
 def getContextById(id):
-…
     current_app.logger.debug('new context created: %s', new_context)
     # all ok. save the new context
     res = new_context.persist()
+    new_context.persist()
     response.status_code = 200
     return response

swtstore/classes/views/app.py

 # -*- coding utf-8 -*-
 # classes/views/apps.py
 from flask import Module, jsonify, request, render_template, redirect,\
                   url_for, flash, abort
+from flask import Module, request, render_template, redirect,\
+    url_for, abort
 from hashlib import md5
 from werkzeug.security import gen_salt
 from swtstore.classes.models import Client, User
-…
                 abort(404)
         new_app = Client(
             id = gen_salt(40),
             client_secret = gen_salt(50),
             name = request.form.get('name'),
             description = request.form.get('desc'),
             user_id = current_user.id,
             _host_url = request.form.get('host_url'),
             _redirect_uris = urlnorm(request.form.get('redirect_uris')),
             _default_scopes = ' '.join(request.form.get('scopes').split(',')),
             _is_private = False
+            id=gen_salt(40),
+            client_secret=gen_salt(50),
+            name=request.form.get('name'),
+            description=request.form.get('desc'),
+            user_id=current_user.id,
+            _host_url=request.form.get('host_url'),
+            _redirect_uris=urlnorm(request.form.get('redirect_uris')),
+            _default_scopes=' '.join(request.form.get('scopes').split(',')),
+            _is_private=False
         )
         new_app.persist()

swtstore/classes/views/context.py

 # -*- coding utf-8 -*-
 # classes/views/context.py
 from flask import Module, jsonify, request, render_template, redirect,\
                     url_for, json, current_app
+from flask import Module, request, render_template, redirect,\
+    url_for, json, current_app, abort
 from swtstore.classes.models import Context, User
 context = Module(__name__)
 @context.route('/register', methods=['GET', 'POST'])
 def register():
     current_user = User.getCurrentUser()
-…
         return render_template('context/register.html')
     if request.method == 'POST':
       if not request.form.get('name') or not request.form.get('defn'):
           abort(400)
+        if not request.form.get('name') or not request.form.get('defn'):
+            abort(400)
     current_app.logger.debug('New Context: defn: %s ',
                              request.form.get('defn'))
-…
     current_app.logger.debug('Resulting json_ld %s', json_ld)
     new_context = Context(
         name = request.form.get('name'),
         definition = json_ld,
         user_id = current_user.id
+        name=request.form.get('name'),
+        definition=json_ld,
+        user_id=current_user.id
     )
     current_app.logger.debug('New Context created: %s', new_context)
     new_context.persist()

swtstore/classes/views/frontend.py

 # classes/views/frontend.py
 from flask import Module, jsonify, request, render_template, redirect,\
                 url_for, g, current_app
+from flask import Module, render_template
 from swtstore.classes.models import Sweet, User
+from swtstore.classes.models import Sweet
 frontend = Module(__name__)
 @frontend.route('/', methods=['GET'])
 def index():

swtstore/classes/views/oauth.py

 # -*- coding utf-8 -*-
 # classes/views/oauth.py
 from flask import Module, jsonify, request, render_template, redirect,\
                     url_for, current_app
 import requests
+from flask import Module, jsonify, request, render_template, current_app
 from swtstore.classes import oauth
 from swtstore.classes.models import Client, AuthorizedClients, User
-…
         else:
             return render_template('oauth/authorize.html', **kwargs)
     confirm = request.form.get('confirm', 'no')
     authorized = request.form.get('authorized', 'no')
     current_app.logger.debug('confirm authorize from user: %s', confirm)
-…
     #print request.form
     current_app.logger.debug('access token touched..')
     return None
 @Oauth.route('/errors')
 def error():

swtstore/classes/views/sweet.py

 # classes/views/sweet.py
 from flask import Module, jsonify, request, render_template, redirect,\
                     url_for, abort, json
+from flask import Module, render_template, abort
 from swtstore.classes.models import Context, Sweet, User
+from swtstore.classes.models import Sweet
 sweet = Module(__name__)
 @sweet.route('/<int:id>', methods=['GET'])
 def showSweet(id):

swtstore/classes/views/user.py

 import requests
 # flask imports
 from flask import Module, jsonify, request, render_template, session,\
                 make_response, url_for, redirect, json, current_app
+from flask import Module, request, render_template, session,\
+    make_response, url_for, redirect, json, current_app
 # swtstore imports
 from swtstore.classes.models import User, Sweet, Context, Client,\
                                     AuthorizedClients
+    AuthorizedClients
 from swtstore.classes.utils.httputils import makeCORSHeaders
 from swtstore.config import DefaultConfig
-…
 user = Module(__name__)
 @user.route('/login', methods=['POST'])
 def login():
-…
     response.status_code = 500
     return response
 @user.route('/logout', methods=['POST'])
 def logout():
-…
     response.status_code = 200
     return response
 @user.route('/me', methods=['GET', 'POST'])
 def profile():
-…
     apps = Client.getClientsByCreator(user.id)
     return render_template('user/apps.html', apps=apps)
 @user.route('/me/authorized_apps', methods=['GET', 'POST'])
 def authorizedApps():
-…
     if request.method == 'GET':
         authorized_clients = AuthorizedClients.getByUser(user)
         return render_template('user/authorized_apps.html',
                                 authorized_clients=authorized_clients)
+                        authorized_clients=authorized_clients)
     # else POST request
     client_id = request.form.get('revoke-id', '')

swtstore/sample_config.py

 class DefaultConfig():
     """
-…
     # been done prior to editing this line.
     # Refer https://wiki.debian.org/PostgreSql#User_access for creating users
     # in postgresql.
     SQLALCHEMY_DATABASE_URI =\
             'dialect+driver://username:password@host:port/database'
+    SQLALCHEMY_DATABASE_URI = 'dialect+driver://username:password@host:port/database'
     # Log level for the application
     LOG_LEVEL = 'ERROR'

Commit cffc26d0d9e198edb51c359a04b3b40eb26a6df3

Gitorious