This is a top down approach to understanding and documenting PSI.
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/startsite.sh
Prefix : This script initiates scoring and the web site.
[codesyntax lang=”python”]
echo ‘start scoring…’
cd /var/www/psi-pro
./runGunicorn.sh
echo ‘start website…’
cd /var/www/www.personalstyles.org/psiapp/server/
./runGunicorn.sh
[/codesyntax]
Suffix : Site startup begin with this script.
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/runGunicorn.sh
Prefix : Gunicorn ‘Green Unicorn’ is a Python WSGI HTTP Server for UNIX. It’s a pre-fork worker model. The Gunicorn server is broadly compatible with various web frameworks, simply implemented, light on server resources, and fairly speedy.
[codesyntax lang=”python”]
#!/bin/bash
PYPATH=psiapp
source bin/activate
export PYTHONPATH=$PYPATH:$PYTHONPATH
export SECRET_KEY=”sk_live_c7Q6vytm7tGYnmrVbzXe7S9T”
export PUBLISHABLE_KEY=”pk_live_KwQotfHuYQSK0P4AGOzXn7tZ”
exec bin/gunicorn -c gu.conf application &
[/codesyntax]
Suffix : Green Unicorn functions on top of EC2.
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/gu.conf
Prefix : Green Unicorn configuration file.
[codesyntax lang=”python”]
import multiprocessing
# change to your ip and port here
bind = “localhost:8080″
workers = multiprocessing.cpu_count() + 1
[/codesyntax]
Suffix : This file sets options for Green Unicorn.
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/application.py
Prefix : This code instantiates and instance of the application plus makes stripe ready for collecting payment for tests.
[codesyntax lang=”python”]
#!/usr/bin/python
# venv
activate_this = ‘/var/www/www.personalstyles.org/psiapp/server/venv/bin/activate_this.py’
execfile(activate_this, dict(__file__=activate_this))
# Stripe
import os
os.environ[‘SECRET_KEY’] = “sk_test_ZElQAExCI9MQhGfxGrVFzywq”
os.environ[‘PUBLISHABLE_KEY’] = “pk_test_SMEBzmeAE7310otcjYos1S3P”
# Logging
import sys
import logging
logging.basicConfig(stream=sys.stderr)
sys.path.insert(0,”/var/www/www.personalstyles.org/psiapp/server”)
# App
import psiapp
from psiapp import app as application
application.config[‘ADMIN_PASSWORD’] = ‘psi2000’
application.config[‘SECRET_KEY’] = ‘welcome to psi’
[/codesyntax]
Suffix : Initiate the application.
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/psiapp/require.py
Prefix : PSI app eauirements
[codesyntax lang=”python”]
”’
APP REQUIRE
”’
import os
import datetime
import requests
import re
from flask import Flask, request, Response, session, jsonify
from flask import render_template, send_from_directory, url_for
from flask import redirect, send_file, make_response, abort
from flask.ext.bcrypt import Bcrypt
from flask.ext.httpauth import HTTPBasicAuth
from flask.ext.restless import APIManager, ProcessingException
from flask.ext.sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_mail import Message
[/codesyntax]
Suffix : I*dentifies PSI application requirements
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/psiapp/models.py
Prefix : PSI app model contains the business logic for PSI application.
[codesyntax lang=”python”]
”’
APP MODELS
”’
from require import *
from sqlalchemy import sql
from sqlalchemy import event
from psiapp import app, db, flask_bcrypt
#############################################################################
################################ relations ##################################
#############################################################################
user_has_key = db.Table(‘user_has_key’,
db.Column(‘user_id’, db.Integer, db.ForeignKey(‘user.id’)),
db.Column(‘key_id’, db.Integer, db.ForeignKey(‘key.id’))
)
#############################################################################
################################# Test ######################################
#############################################################################
class Test(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
created_at = db.Column(
db.Date,
default=db.func.now()
)
user_id = db.Column(
db.Integer,
db.ForeignKey(‘user.id’)
)
key_id = db.Column(
db.Integer,
db.ForeignKey(‘key.id’)
)
dataid = db.Column(
db.String(256),
nullable=False
)
testauth = db.Column(
db.String(256),
nullable=False
)
def __repr__(self):
return ” % self.created_at
def __init__(self, user_id, payload):
try:
r = requests.put(app.config[‘ENGINE_SAVE’],json=payload)
if r.status_code == 201:
rdata = r.json()
self.dataid = rdata[‘dataid’]
self.testauth = rdata[‘testauth’]
self.user_id = user_id
else:
raise Exception(“ENGINE Server returned status “+str(r.status_code))
except Exception as e:
raise e
#############################################################################
################################ KeyType ####################################
#############################################################################
class KeyType(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
def __repr__(self):
return ” % self.name
#############################################################################
################################# Key #######################################
#############################################################################
class Key(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
used = db.Column(
db.Boolean,
nullable=False
)
begin = db.Column(
db.Date,
nullable=False
)
end = db.Column(
db.Date,
nullable=False
)
created_at = db.Column(
db.DateTime,
default=db.func.now()
)
key_type_id = db.Column(
db.Integer,
db.ForeignKey(‘key_type.id’)
)
tests = db.relationship(
‘Test’,
backref=db.backref(‘keys’)
)
def __repr__(self):
return ” % self.name
#############################################################################
########################### ReferenceType ###################################
#############################################################################
class ReferenceType(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
position = db.Column(
db.Integer
)
references = db.relationship(
‘Reference’,
backref=db.backref(‘type’)
)
def __init__(self, name):
self.name = name
def __repr__(self):
return ” % self.name
#############################################################################
############################### Reference ###################################
#############################################################################
class Reference(db.Model):
id = db.Column(
db.Integer,
primary_key=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
position = db.Column(
db.Integer
)
reference_type_id = db.Column(
db.Integer,
db.ForeignKey(‘reference_type.id’)
)
def __init__(self, name, reference_type_id):
self.name = name
self.reference_type_id = reference_type_id
def __repr__(self):
return ” % self.name
#############################################################################
############################### Answer ######################################
#############################################################################
class Answer(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
questions = db.relationship(
“Question”,
secondary=’question_has_answer’
)
def __repr__(self):
return ” % self.name
#############################################################################
################################ Question ###################################
#############################################################################
class Question(db.Model):
id = db.Column(
db.Integer,
primary_key=True
)
name = db.Column(
db.String(50),
unique=True,
nullable=False
)
answers = db.relationship(
“Answer”,
secondary=’question_has_answer’
)
def answers(self):
qas = []
for qa in self.question_answer_association:
qas.append({
‘id’:qa.answer.id,
‘name’:qa.answer.name,
‘score’:qa.score
})
return qas
def __init__(self, id, name):
self.id = id
self.name = name
def __repr__(self):
return ” % self.name
#############################################################################
############################# QuestionAnswers ###############################
#############################################################################
class QuestionAnswers(db.Model):
__tablename__ = ‘question_has_answer’
question_id = db.Column(
db.Integer,
db.ForeignKey(‘question.id’),
primary_key=True
)
answer_id = db.Column(
db.Integer,
db.ForeignKey(‘answer.id’),
primary_key=True
)
score = db.Column(
db.Integer,
nullable=False
)
question = db.relationship(
“Question”,
backref=”question_answer_association”
)
answer = db.relationship(
“Answer”,
backref=”question_answer_association”
)
def __init__(self, question_id, answer_id, score):
self.question_id = question_id
self.answer_id = answer_id
self.score = score
def __repr__(self):
return ” % (self.question.name +” “+ self.answer.name)
#############################################################################
################################# User ######################################
#############################################################################
class User(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
email = db.Column(
db.String(120),
unique=True,
nullable=False
)
password = db.Column(
db.String(80),
nullable=False
)
admin = db.Column(
db.Boolean,
default=False
)
testkeys = db.relationship(
‘Key’,
secondary=user_has_key,
backref=db.backref(‘users’, lazy=’dynamic’)
)
tests = db.relationship(
‘Test’,
backref=db.backref(‘users’)
)
def __init__(self, email, password, admin=False):
self.email = email
self.password = flask_bcrypt.generate_password_hash(password)
self.admin = admin
self.add_key()
def set_password(self, password):
self.password = flask_bcrypt.generate_password_hash(password)
def add_key(self):
self.testkeys.append(Key())
def is_authenticated(self):
return True
def is_admin(self):
return self.admin
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
def keycount(self):
return len(self.testkeys)
def user(self):
return {
“id”: self.id,
“keycount”: self.keycount()
}
def __repr__(self):
return ” % self.email
#############################################################################
################################# Image #####################################
#############################################################################
class Image(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(300),
nullable=False
)
def get_id(self):
return unicode(self.id)
#############################################################################
################################# AboutUs #####################################
#############################################################################
class AboutUs(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(200),
nullable=False
)
content = db.Column(
db.Text
)
def get_id(self):
return unicode(self.id)
#############################################################################
################################# AboutPsi #####################################
#############################################################################
class AboutPsi(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(200),
nullable=False
)
content = db.Column(
db.Text
)
def get_id(self):
return unicode(self.id)
#############################################################################
############################# Privacy Policy ################################
#############################################################################
class PrivacyPolicy(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(200),
nullable=False
)
content = db.Column(
db.Text
)
def get_id(self):
return unicode(self.id)
#############################################################################
############################# Contact Us ####################################
#############################################################################
class ContactUs(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
name = db.Column(
db.String(200),
nullable=False
)
content = db.Column(
db.Text
)
def get_id(self):
return unicode(self.id)
#############################################################################
################################# Blog ######################################
#############################################################################
class Blog(db.Model):
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True
)
title = db.Column(
db.String(200),
nullable=False
)
slug = db.Column(
db.String(200),
nullable=False
)
content = db.Column(
db.Text,
nullable=False
)
timestamp = db.Column(
db.DateTime,
nullable=False
)
timestamp_published = db.Column(
db.DateTime,
nullable=True
)
published = db.Column(
db.Boolean,
nullable=False
)
image_id = db.Column(
db.Integer,
db.ForeignKey(‘image.id’)
)
def __init__(self, title, content, slug=None, published=False):
now = datetime.datetime.utcnow()
self.title = title
self.slug = slug
self.timestamp = now
self.timestamp_published = None if not published else now
self.content = content
self.published = published
if not self.slug:
self.slug = re.sub(‘[^\w]+’, ‘-‘, self.title.lower())
def html_content(self):
hilite = CodeHiliteExtension(linenums=False, css_class=’highlight’)
extras = ExtraExtension()
markdown_content = markdown(self.content, extensions=[hilite, extras])
oembed_content = parse_html(
markdown_content,
oembed_providers,
urlize_all=True,
maxwidth=app.config[‘SITE_WIDTH’])
return Markup(oembed_content)
def content_snippet(self):
if len(self.content) > 600:
k = self.content[:600].rfind(” “)
return self.content[:k]+”…”
else:
return self.content
def short_description(self):
desc = self.content.strip(‘#’).strip()[:157]+”…”
return desc
[/codesyntax]
Suffix : Model of PSI app
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/psiapp/controller.py
Prefix : PSI app controller is the traffic cop for the application.
[codesyntax lang=”python”]
”’
MYAPP CONTROLLER
”’
from require import *
from psiapp import app, db, flask_bcrypt, auth, stripe, stripe_keys
from psiapp.models import *
from flask import stream_with_context
# from psiapp.models import *
###############
# Basic Views #
###############
# special file handlers and error handlers
”’
@app.route(‘/favicon.ico’)
def favicon():
return send_from_directory(‘static’, ‘imgs/favicon.png’)
”’
# routing for basic pages
@app.route(‘/’)
@app.route(‘/’)
@app.route(‘//’)
@app.route(‘/psi/’)
@app.route(‘/psi//’)
@app.route(‘/blog//’)
@app.route(‘/references//’)
@app.route(‘/samples//’)
def basic_pages(**kwargs):
return app.send_static_file(‘base.html’)
@app.errorhandler(404)
def page_not_found(e):
return render_template(‘404.html’), 404
###############
# Basic Views #
###############
#########
# API #
#########
###
# API Setup
def generate_temp_password(length):
if not isinstance(length, int) or length < 8:
raise ValueError(“temp password must have positive length”)
chars = “ABCDEFGHJKLMNPQRSTUVWXYZ23456789”
from os import urandom
return “”.join([chars[ord(c) % len(chars)] for c in urandom(length)])
# Pre and post process
def logged_in(*args, **kw):
if not session.get(‘logged_in’):
raise ProcessingException(description=’Not authenticated!’, code=401)
def is_admin(*args, **kw):
if not session.get(‘is_admin’):
raise ProcessingException(description=’Not authenticated!’, code=401)
# Create manager
api_manager = APIManager(
app,
flask_sqlalchemy_db=db,
preprocessors={
‘POST’:[logged_in]
}
)
api_manager.create_api(
User,
methods=[‘GET’,’POST’,’PATCH’,’DELETE’],
allow_patch_many=True,
exclude_columns=[‘password’,’keys’,’testkeys’],
include_methods=[‘keycount’],
preprocessors={
‘GET_SINGLE’:[logged_in],
‘GET_MANY’:[logged_in],
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PATCH_MANY’:[is_admin],
‘DELETE_SINGLE’:[is_admin],
‘DELETE_MANY’:[is_admin]
}
)
api_manager.create_api(
Test,
methods=[‘GET’,’POST’,’PATCH’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
Question,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’DELETE’],
include_methods=[‘answers’],
exclude_columns=[‘answers’,’question_answer_association’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
Blog,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
include_methods=[‘short_description’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
Reference,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
ReferenceType,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
AboutUs,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
ContactUs,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
PrivacyPolicy,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
api_manager.create_api(
AboutPsi,
max_results_per_page=200,
results_per_page=120,
methods=[‘GET’,’POST’,’PATCH’,’PUT’,’DELETE’],
preprocessors={
‘POST’:[is_admin],
‘PATCH_SINGLE’:[is_admin],
‘PUT’:[is_admin],
‘DELETE_SINGLE’:[is_admin]
}
)
dbsession = api_manager.session
###
# Blogs
@app.route(‘/api/blog/create’, methods=[“POST”])
def createblog():
json_data = request.json
blog = Blog(
title=json_data[‘title’],
content=json_data[‘content’],
published=json_data[‘published’]
)
try:
db.session.add(blog)
db.session.commit()
status = ‘success’
except:
status = ‘a blog with this title already exists’
return jsonify(result=status,id=blog.id)
###
# Stripe
@app.route(‘/api/stripe’)
def striped():
return jsonify(key=stripe_keys[‘publishable_key’])
@app.route(‘/api/charge’, methods=[‘POST’])
def charged():
print(“start charged”)
# Amount in cents
amount = 500
json_data = request.json
userEmail = json_data[‘stripeEmail’]
print(“get current user”)
user = User.query.get(session.get(‘user’)[‘id’])
print(user)
customer = stripe.Customer.create(
email=userEmail,
source=request.form[‘stripeToken’]
)
print(“customer created”)
charge = stripe.Charge.create(
customer=customer.id,
amount=amount,
currency=’usd’,
description=’PSI Charge’
)
print(“charge issued”)
#
## create key
#
key = Key()
db.session.add(key)
db.session.commit()
print(“key created”)
#
## add key to current user
#
print(“user keys:”)
print(user.testkeys)
user.testkeys.append(key)
db.session.add(user)
db.session.commit()
session[‘user’] = user.user()
print(“key added”)
return app.send_static_file(‘base.html’)
###
# Register/Login/Logout/Session
@app.route(‘/api/user/register’, methods=[‘POST’])
def register():
json_data = request.json
user = User(
email=json_data[’email’],
password=json_data[‘password’]
)
try:
db.session.add(user)
db.session.commit()
status = ‘success’
session[‘user’] = user.user()
session[‘logged_in’] = True
session[‘is_admin’] = user.is_admin()
db.session.close()
except Exception as e:
status = e.args
return jsonify(result=status)
@app.route(‘/api/user/addkey’, methods=[‘POST’])
def addkey():
result = “success”
status_code = 200
keycount = 0
try:
if session.get(‘is_admin’):
try:
json_data = request.json
user = User.query.get(json_data[‘id’])
user.add_key()
db.session.add(user)
db.session.commit()
keycount = user.keycount()
except Exception, e:
status_code = 400
raise e
else:
status_code = 401
raise Exception(“PERMISSIONS ERROR”)
except Exception, e:
result = e.args
return jsonify(result=result,status_code=status_code,keycount=keycount)
@app.route(‘/api/user/resetpassword’, methods=[‘POST’])
def resetpassword():
json_data = request.json
user = User.query.filter_by(email=json_data[’email’]).first()
gen_password = generate_temp_password(10)
user.set_password(gen_password)
try:
mail = Mail(app)
msg = Message(“Personal Styles – New Password Requested”,
sender=(“Personal Styles”,app.config[‘MAIL_USERNAME’]),
recipients=[user.email]
)
msg.html = “Hello from PSI 120, We received a request to reset your password. Your new password is: “+gen_password+”
Please change your password after logging in. https://www.personalstyles.org/login”
mail.send(msg)
db.session.add(user)
db.session.commit()
db.session.close()
status = ‘success’
except Exception as e:
status = e.args
return jsonify(result=status)
@app.route(‘/api/contactform’, methods=[‘POST’])
def contactform():
json_data = request.json
try:
mail = Mail(app)
msg = Message(json_data[‘subject’],
sender=(“Personal Styles”,app.config[‘PSI_MAIL’]),
recipients=[(“Personal Styles”,app.config[‘PSI_MAIL’])],
cc=[(json_data[‘name’],json_data[’email’])]
)
msg.body = json_data[‘content’]
mail.send(msg)
status = ‘success’
except Exception as e:
status = e.args
return jsonify(result=status)
@app.route(‘/api/user/setpassword’, methods=[‘POST’])
def setpassword():
json_data = request.json
user = User.query.get(session.get(‘user’)[‘id’])
if user and flask_bcrypt.check_password_hash(user.password,json_data[‘oldpassword’]):
try:
user.set_password(json_data[‘newpassword’])
db.session.add(user)
db.session.commit()
db.session.close()
status = ‘success’
except Exception as e:
status = e.args
else:
status = “Password incorrect”
return jsonify(result=status)
@app.route(‘/api/user/login’, methods=[‘POST’])
def login():
json_data = request.json
user = User.query.filter_by(email=json_data[’email’]).first()
if user and flask_bcrypt.check_password_hash(user.password,json_data[‘password’]):
session[‘user’] = user.user()
session[‘logged_in’] = True
session[‘is_admin’] = user.is_admin()
user = user.user() if session.get(‘logged_in’) else False
isadmin = True if session.get(‘is_admin’) else False
return jsonify(user=user, admin=isadmin)
@app.route(‘/api/user/logout’, methods=[‘GET’])
def logout():
session.pop(‘user’,None)
session.pop(‘logged_in’,None)
session.pop(‘is_admin’,None)
return jsonify(result=’success’)
@app.route(‘/api/user/refresh’, methods=[‘GET’])
def user_refresh():
status = “no user logged in”
if session.get(‘logged_in’):
user = User.query.get(session.get(‘user’)[‘id’])
session[‘user’] = user.user()
status = “success”
return jsonify(status=status)
@app.route(‘/api/user/isloggedin’, methods=[‘GET’])
def isloggedin():
return jsonify(user=session.get(‘user’) if session.get(‘logged_in’) else False)
@app.route(‘/api/user/isadmin’, methods=[‘GET’])
def isadmin():
return jsonify(admin=True if session.get(‘is_admin’) else False)
@app.route(‘/api/test/submit’, methods=[‘POST’])
def submit():
json_data = request.json
status = “”
status_code = 502
testid = -1
try:
test = Test(
user_id=session.get(‘user’)[‘id’],
payload=json_data
)
# Verify the test was saved successfully
params = {“dataid”:test.dataid, “testauth”:test.testauth}
# TODO: Check to make sure we have results before sending any data
r = requests.post(app.config[‘ENGINE_SAVE’],json=params)
rdata = r.json()
status_code = r.status_code
if r.status_code == 202:
db.session.add(test)
db.session.commit()
user = User.query.get(session.get(‘user’)[‘id’])
if user.keycount() > 0:
user.testkeys = user.testkeys[1:]
db.session.add(user)
db.session.commit()
session[‘user’] = user.user()
status = ‘success’
testid = test.id
else:
raise Exception(“NO Keys Available”)
else:
raise Exception(“ENGINE Server returned response “+rdata)
except Exception as e:
status = e.args
return jsonify(status_code=status_code,status=status,testid=testid)
# 502 response if the test backend is dead
@app.route(‘/api/test/score’, methods=[‘POST’])
def score():
json_data = request.json
try:
test = Test.query.filter_by(id=json_data[‘testid’],user_id=session.get(‘user’)[‘id’]).first()
params = {“dataid”:test.dataid, “testauth”:test.testauth}
# TODO: Check to make sure we have results before sending any data
r = requests.post(app.config[‘ENGINE_SAVE’],json=params)
rdata = r.json()
if r.status_code == 202:
status = “success”
rdata = r.json()
return jsonify(result=status, scores=rdata)
else:
raise Exception(“ENGINE Server returned status “+str(r.status_code))
except Exception as e:
status = e.args
return jsonify(result=status)
@app.route(‘/api/test/pdf/’, methods=[‘GET’])
def reportget(rcode):
json_data = request.json
try:
# TODO: Check to make sure we have results before sending any data
r = requests.get(“%s/report/%s” % (app.config[‘ENGINE_ROOT’], rcode), stream=True )
if r.status_code == 202:
return Response(stream_with_context(r.iter_content()), content_type = r.headers[‘content-type’])
else:
raise Exception(“ENGINE Server returned status “+str(r.status_code))
except Exception as e:
status = e.args
return jsonify(result=status)
@app.route(‘/api/test/pdf/’, methods=[‘POST’])
def report(rcode):
json_data = request.json
try:
test = Test.query.filter_by(id=json_data[‘testid’],user_id=session.get(‘user’)[‘id’]).first()
params = {“dataid”:test.dataid, “testauth”:test.testauth}
# TODO: Check to make sure we have results before sending any data
r = requests.post(“%s/report/%s” % (app.config[‘ENGINE_ROOT’], rcode) ,json=params,stream=True)
if r.status_code == 202:
return Response(stream_with_context(r.iter_content()), content_type = r.headers[‘content-type’])
else:
raise Exception(“ENGINE Server returned status “+str(r.status_code))
except Exception as e:
status = e.args
return jsonify(result=status)
# Login/Logout
###
#########
# API #
#########
[/codesyntax]
Suffix : PSI Controller
File Name : /media/archman/ea322f0a-3437-473f-8fe2-fdc4c290c51e/home/ec2-user/psi-philander/psiapp/config.py
Prefix : PSI app configuration file contains configuration parameters.
[codesyntax lang=”python”]
”’
APP CONFIG
”’
WTF_CSRF_ENABLED = False
ADMIN_PASSWORD = ‘password’
SECRET_KEY = ‘secret key’
ENGINE_ROOT=”http://127.0.0.1:8081″
ENGINE_SAVE= “%s/data” % ENGINE_ROOT
ENGINE_SCORE=”%s/api” % ENGINE_ROOT
MAIL_SERVER = ‘smtp.gmail.com’
MAIL_PORT = 587
MAIL_USE_TLS = True
MAIL_USE_SSL = False
MAIL_USERNAME = ‘personalstyles.org@gmail.com’
MAIL_PASSWORD = ‘oHn;QBCm7*uR^E2’
PSI_MAIL = ‘info@personalstyles.org’
[/codesyntax]
Suffix : Configuration file