def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
# For Dev purposes only can be removed in Production
from flask import render_template, send_from_directory
import os
@app.route('/')
def index():
return render_template('index.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'), filename)
# End
from app.basemodels import db
db.init_app(app)
# Blueprints
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
# Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
# Init Flask-Mail
mail.init_app(app)
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'), filename)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/api/upload', methods=['GET', 'POST'])
def upload():
if request.method == 'POST':
file = request.files['file']
extension = os.path.splitext(file.filename)[1]
f_name = str(uuid.uuid4()) + extension
f_name2 = file.filename
print(os.path,file=sys.stderr)
file.save("app/templates/Uploads/"+ f_name)
return json.dumps({'filename': f_name, 'filename2': f_name2})
# Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
from app.roles.views import roles
app.register_blueprint(roles, url_prefix='/api/v1/roles')
# Blueprints
from app.authors.views import authors
app.register_blueprint(authors, url_prefix='/api/v1/authors')
from app.posts.views import posts
app.register_blueprint(posts, url_prefix='/api/v1/posts')
from app.comments.views import comments
app.register_blueprint(comments, url_prefix='/api/v1/comments')
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
from app.basemodels import db
db.init_app(app)
# Blueprints
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
# Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
# Init Flask-Mail
mail.init_app(app)
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/admin')
def admin():
return render_template('admin.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'),
filename)
@app.route('/')
def index():
return render_template('index.html')
# Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
from app.roles.views import roles
app.register_blueprint(roles, url_prefix='/api/v1/roles')
# Blueprints
from app.terms.views import terms
app.register_blueprint(terms, url_prefix='/api/v1/terms')
from app.posts.views import posts
app.register_blueprint(posts, url_prefix='/api/v1/posts')
from app.comments.views import comments
app.register_blueprint(comments, url_prefix='/api/v1/comments')
from app.gallery.views import gallery
app.register_blueprint(gallery, url_prefix='/api/v1/gallery')
from app.posts.views1 import posts_read
app.register_blueprint(posts_read, url_prefix='/api/v1/r/posts')
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
from app.basemodels import db
db.init_app(app)
# Blueprints
from app.users.views import users
app.register_blueprint(users, url_prefix='/users')
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
# Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
# Init Flask-Mail
mail.init_app(app)
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'),
filename)
@app.route('/')
def index():
return render_template('index.html')
# Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
from app.roles.views import roles
app.register_blueprint(roles, url_prefix='/api/v1/roles')
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
# Blueprints
from app.responses.views import responses
app.register_blueprint(responses, url_prefix='/api/v1/responses')
from app.questions.views import questions
app.register_blueprint(questions, url_prefix='/api/v1/questions')
from app.surveys.views import surveys
app.register_blueprint(surveys, url_prefix='/api/v1/surveys')
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
app.response_class = MyResponse
#Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
# Blueprints
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.tasks.views import tasks
app.register_blueprint(tasks, url_prefix='/api/v1/tasks')
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
app.response_class = MyResponse
#Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
# Blueprints
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.tasks.views import tasks
app.register_blueprint(tasks, url_prefix='/api/v1/tasks')
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
from app.basemodels import db
db.init_app(app)
# Blueprints
from app.roles.views import roles
app.register_blueprint(roles, url_prefix='/api/v1/roles')
from app.languages.views import languages
app.register_blueprint(languages, url_prefix='/api/v1/languages')
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login
app.register_blueprint(login, url_prefix='/api/v1/login')
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
#Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
#Init Flask-Mail
mail.init_app(app)
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'), filename)
@app.route('/')
def index():
return render_template('index.html')
#Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
from app.roles.views import roles
app.register_blueprint(roles, url_prefix='/api/v1/roles')
# Blueprints
return app
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
app.response_class = MyResponse
#Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
# Blueprints
from app.followers.views import followers
app.register_blueprint(followers, url_prefix='/followers')
from app.statistics.views import statistics
app.register_blueprint(statistics, url_prefix='/statistics')
from app.tweets.views import tweets
app.register_blueprint(tweets, url_prefix='/tweets')
from app.users.views import users
app.register_blueprint(users, url_prefix='/users')
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
from app.basemodels import db
db.init_app(app)
from flask import render_template, send_from_directory
import os
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'),
filename)
@app.route('/')
def index():
return render_template('index.html')
from app.courses.views import courses
app.register_blueprint(courses, url_prefix='/api/v1/courses')
from app.students.views import students
app.register_blueprint(students, url_prefix='/api/v1/students')
return app
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
#Init Flask-Alchemy
from app.basemodels import db
db.init_app(app)
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
#Init Flask-Mail
mail.init_app(app)
#Create a background thread that can be responsible for wiping the directories periodically
#Note: In debugger mode, two threads are spawned (since Flask makes two threads so that it can restart on the fly)
def systemCleaner():
time.sleep(60) #Scan every 60 seconds
clk = time.ctime()
print(clk)
clk_list = clk.split(' ')
time_list = clk_list[4].split(':')
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0]
userList = os.listdir(fp + "/GT_USERS")
print(userList)
# Want to erase all temperory (and potentially in use files)
# Clense if the directories grow to a certain size (could potentially erase someones in progress work)
for userNames in userList:
fileListJSON = os.listdir(fp + "/GT_USERS" + "/" + userNames +
"/json")
fileListCropped = os.listdir(fp + "/GT_USERS" + "/" + userNames +
"/cropped")
fileListSegmented = os.listdir(fp + "/GT_USERS" + "/" + userNames +
"/segmented")
fileListLabelled = os.listdir(fp + "/GT_USERS" + "/" + userNames +
"/labelled")
if len(fileListJSON) > 500 or len(fileListCropped) > 250 or len(
fileListSegmented) > 250 or len(fileListLabelled) > 250:
print("resetting user files...sorry...")
for fileNameJSON in fileListJSON:
os.remove(fp + "/GT_USERS" + "/" + userNames + "/json" +
"/" + fileNameJSON)
for fileNameCropped in fileListCropped:
os.remove(fp + "/GT_USERS" + "/" + userNames + "/cropped" +
"/" + fileNameCropped)
for fileNameSegmented in fileListSegmented:
os.remove(fp + "/GT_USERS" + "/" + userNames +
"/segmented" + "/" + fileNameSegmented)
for fileNameLabelled in fileListLabelled:
os.remove(fp + "/GT_USERS" + "/" + userNames +
"/labelled" + "/" + fileNameLabelled)
# Periodic Clense each day at midnight
if (time_list[0] == "00" and time_list[1] == "00"):
print("server reset...")
for userNames in userList:
fileListJSON = os.listdir(fp + "/GT_USERS" + "/" + userNames +
"/json")
fileListCropped = os.listdir(fp + "/GT_USERS" + "/" +
userNames + "/cropped")
fileListSegmented = os.listdir(fp + "/GT_USERS" + "/" +
userNames + "/segmented")
fileListLabelled = os.listdir(fp + "/GT_USERS" + "/" +
userNames + "/labelled")
for fileNameJSON in fileListJSON:
os.remove(fp + "/GT_USERS" + "/" + userNames + "/json" +
"/" + fileNameJSON)
for fileNameCropped in fileListCropped:
os.remove(fp + "/GT_USERS" + "/" + userNames + "/cropped" +
"/" + fileNameCropped)
for fileNameSegmented in fileListSegmented:
os.remove(fp + "/GT_USERS" + "/" + userNames +
"/segmented" + "/" + fileNameSegmented)
for fileNameLabelled in fileListLabelled:
os.remove(fp + "/GT_USERS" + "/" + userNames +
"/labelled" + "/" + fileNameLabelled)
th = threading.Thread(target=systemCleaner)
th.daemon = True
th.start()
#Spawn the first thread
if MAINTAIN == True:
th = threading.Thread(target=systemCleaner)
th.daemon = True
th.start()
#Called from multiple scripts to revert to the base login screen
@app.route('/login')
def login():
return render_template('login.html')
#Navigates to the different directories in the document
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'),
filename)
#Function used to decode the authentication Key which prevents CSRF
def parse_token(req):
token = req.headers.get('Authorization').split()[1]
#return jwt.decode(token, SECRET_KEY, algorithms='HS256')
return token
#Called from the 'crop.js' script when the user is ready to proceed to the labelling screen
#Authenticates, does security check, cleans any unused files, returns the JSON file for the labeling algorithm
@app.route("/get_json/")
def getjson():
from StringIO import StringIO
import base64
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
segmented_filepath = request.args.get('segmented_filepath')
json_filepath = request.args.get('json_filepath')
email = request.args.get('email')
user = Users.query.filter_by(email=email).first()
if (not segmented_filepath.endswith('.jpg')) or (
not segmented_filepath.startswith('segmented')):
response = jsonify(message='Invalid File')
response.status_code = 400
return response
if not json_filepath.endswith('.json') or not json_filepath.startswith(
'json'):
response = jsonify(message='Invalid File')
response.status_code = 400
return response
# removing extra segmentation and json files not being used
left_seg, right_seg = segmented_filepath.split('_', 1)
left_json, right_json = json_filepath.split('_', 1)
left_seg = left_seg[len(left_seg) - 3:len(left_seg)]
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
fp = fp + "/GT_USERS/USER_" + str(user.id)
print(left_seg)
if (left_seg != "466"):
try:
os.remove(fp + '/segmented/466_' + right_seg)
os.remove(fp + '/json/466_' + right_json)
except:
pass
if (left_seg != '500'):
try:
os.remove(fp + '/segmented/500_' + right_seg)
os.remove(fp + '/json/500_' + right_json)
except:
pass
if (left_seg != '566'):
try:
os.remove(fp + '/segmented/566_' + right_seg)
os.remove(fp + '/json/566_' + right_json)
except:
pass
if (left_seg != '600'):
try:
os.remove(fp + '/segmented/600_' + right_seg)
os.remove(fp + '/json/600_' + right_json)
except:
pass
if (left_seg != '666'):
try:
os.remove(fp + '/segmented/666_' + right_seg)
os.remove(fp + '/json/666_' + right_json)
except:
pass
with open(fp + '/' + json_filepath) as json_file:
json_data = json.load(json_file)
response = {"json_data": json_data}
#response.status_code = 200
return jsonify(message=response)
#Called from the 'crop.js' script. Sends the image to the superpixel segmentation script for cropping
#Authenticates, runs segmentation script, returns segmented images
@app.route("/get_crop/")
def crop():
from StringIO import StringIO
import base64
import cv2
from matplotlib import pyplot as plt
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
x = request.args.get('x')
y = request.args.get('y')
w = request.args.get('w')
h = request.args.get('h')
email = request.args.get('email')
user = Users.query.filter_by(email=email).first()
filepath = request.args.get('filepath')
if (not filepath.endswith('.jpg')) or (
not filepath.startswith('images')):
response = jsonify(message='Invalid File')
response.status_code = 400
return response
try:
imDict = segmentation.getSegmentedImage(filepath, app.root_path,
int(x), int(y), int(w),
int(h), str(user.id))
except TypeError:
print("SLIC crashed")
response = jsonify(message="Internal Server Error")
response.status_code = 500
return response
dataJSON = json.dumps(imDict)
#print(dataJSON)
# jsonify imDict and send
response = jsonify(message=dataJSON)
response.status_code = 200
return response
#Called from the 'crop.js' script.
#Authenticates, transmutes the image for security, then saves it locally and returns the transmuted image
@app.route("/post_localsave/", methods=["POST"])
def localsave():
from StringIO import StringIO
import base64
import cv2
from matplotlib import pyplot as plt
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#print(request.headers.get('Authorization'))
#print(payload)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
img = request.json['imgData']
email = request.json['email']
user = Users.query.filter_by(email=email).first()
try:
lhs, rhs = img.split(',', 1)
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0]
fullpath_segmented_dirty = fp + '/GT_USERS/USER_' + str(
user.id) + "/images/temp_user.jpg"
fh = open(fullpath_segmented_dirty, "wb")
fh.write(rhs.decode('base64'))
fh.close()
#Image Augmentation
try:
temp_img = cv2.imread(fullpath_segmented_dirty)
height, width, channels = temp_img.shape
crop_img = temp_img[2:2 + height - 2, 2:2 + width -
2] # NOTE: its img[y: y + h, x: x + w]
fullpath_segmented_clean = fp + '/GT_USERS/USER_' + str(
user.id) + "/images/user.jpg"
cv2.imwrite(fullpath_segmented_clean, crop_img)
except:
os.remove(fullpath_segmented_dirty)
print("Bad Request!")
response = jsonify(message="Bad Request!")
response.status_code = 400
return response
try:
os.remove(fullpath_segmented_dirty)
except OSError:
pass
except TypeError:
print("Internal Server Error")
response = jsonify(message="Internal Server Error!")
response.status_code = 500
return response
response = jsonify(message="images/user.jpg")
response.status_code = 200
return response
#Called from the 'dashboard.js' script.
#Deletes the entry from the SQL server
@app.route('/delete_row/', methods=["POST"])
def deleteRow():
rowNum = request.json['imgID']
email = request.json['email']
user = Users.query.filter_by(email=email).first()
rowNum = int(float(rowNum))
#First we find the image_id based on the row count
stmt00 = "SELECT * from user_has_image WHERE users_id = :uid ORDER BY users_id ASC LIMIT :rowNum , 1"
result = db.session.execute(stmt00, {'uid': user.id, 'rowNum': rowNum})
theRow = result.fetchall()
imgID = theRow[0][1]
#Second we need to delete the item from user_has_image
stmt01 = "DELETE FROM user_has_image WHERE users_id = :uid AND images_id = :imgID"
db.session.execute(stmt01, {'uid': user.id, 'imgID': imgID})
db.session.commit()
#Next we need to check if anyone is still using this imageID
stmt02 = "SELECT * from user_has_image WHERE images_id = :imgID"
result = db.session.execute(stmt02, {'imgID': imgID})
theRow = result.fetchall()
#No one is using the image, delete it from other table
if (len(theRow) == 0):
print("no one using image, deleting...")
stmt03 = "DELETE FROM images WHERE id = :imgID"
db.session.execute(stmt03, {'imgID': imgID})
db.session.commit()
response = jsonify(message="worked")
response.status_code = 200
return response
#Called from the 'dashboard.js' script.
#Authenticates, transmutes the image for security, then hard save it to SQL server
@app.route('/post_image/', methods=["POST"])
def postInfo():
from StringIO import StringIO
import base64
import cv2
from matplotlib import pyplot as plt
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#print(request.headers.get('Authorization'))
#print(payload)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
img = request.json['imgData']
email = request.json['email']
user = Users.query.filter_by(email=email).first()
stmt00 = "SELECT id FROM images"
result = db.session.execute(stmt00)
theRow = result.fetchall()
rowLen = len(theRow)
print(rowLen)
if (rowLen == 0):
entryNum = 1
else:
print(theRow[rowLen - 1][0])
entryNum = theRow[rowLen - 1][0] + 1 #Number of image entires
print(entryNum)
#print("entries:"+str(entryNum))
#SQL Defense #2: Prepared Statements
#stmt = "UPDATE users SET users.activeLabels = :uActiveLabels WHERE users.email = :uEmail"
#stmt = "INSERT INTO images (relative_orig_filepath) VALUES ('images/wound.jpg')"
stmt1 = "INSERT INTO images (relative_orig_filepath) VALUES (:uPath)"
stmt2 = "INSERT INTO user_has_image (users_id, images_id, progress) VALUES (:uid, :entryNum, 0)"
pathName = 'images/image_' + str(entryNum) + '.jpg'
testPathName = 'images/test_image_' + str(entryNum) + '.jpg'
db.session.execute(stmt1, {'uPath': pathName})
db.session.commit()
print("pre-execute")
db.session.execute(stmt2, {'uid': user.id, 'entryNum': str(entryNum)})
db.session.commit()
try:
lhs, rhs = img.split(',', 1)
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0]
fullpath_segmented_dirty = fp + '/GT_USERS/USER_' + str(
user.id) + '/' + testPathName
fh = open(fullpath_segmented_dirty, "wb")
fh.write(rhs.decode('base64'))
fh.close()
#Image Augmentation
try:
temp_img = cv2.imread(fullpath_segmented_dirty)
height, width, channels = temp_img.shape
crop_img = temp_img[2:2 + height - 2, 2:2 + width -
2] # NOTE: its img[y: y + h, x: x + w]
fullpath_segmented_clean = fp + '/GT_USERS/USER_' + str(
user.id) + '/' + pathName
cv2.imwrite(fullpath_segmented_clean, crop_img)
except:
os.remove(fullpath_segmented_dirty)
print("Bad Request!")
response = jsonify(message="Bad Request!")
response.status_code = 400
return response
try:
os.remove(fullpath_segmented_dirty)
except OSError:
pass
except TypeError:
print("Internal Server Error")
response = jsonify(message="Internal Server Error!")
response.status_code = 500
return response
#Getting updated list of images
uid = re.escape(str(user.id))
stmt = "SELECT images.relative_orig_filepath, user_has_image.users_id, user_has_image.images_id, user_has_image.progress, users.classified, users.in_queue FROM user_has_image JOIN images ON images.id = user_has_image.images_id JOIN users ON users.id = user_has_image.users_id where users_id = :uid"
result = db.session.execute(stmt, {'uid': uid})
user_images = result.fetchall()
listClas = [None] * len(user_images)
x = 0
inQueue = 0
for rows in user_images:
listClas[x] = rows[3]
if (rows[3] == 0):
inQueue = inQueue + 1
x = x + 1
done = len(user_images) - inQueue
print(done)
print(inQueue)
user_info = {
'classified': done,
'in_queue': inQueue,
'full_name': user.name,
'image_info': [(dict(row.items())) for row in user_images]
}
response = jsonify(message=user_info)
response.status_code = 200
return response
#Called from the 'canvas.js' script.
# Takes the dictionairy and creates a .zip file with every important document
@app.route("/post_saveLabel/", methods=["POST"])
def saveLabel():
from StringIO import StringIO
import base64
import cv2
from matplotlib import pyplot as plt
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
rowNum = request.json['imageId']
email = request.json['email']
data1 = request.json['data1']
data2 = request.json['data2']
segPath = request.json['segPath']
user = Users.query.filter_by(email=email).first()
data2_split = data2.split("]")
if (not segPath.endswith('.jpg')) or (
not segPath.startswith('segmented')):
response = jsonify(message='Invalid File')
response.status_code = 400
return response
if (user.id != 1):
#First we find the image_id based on the row count
stmt01 = "SELECT * from user_has_image WHERE users_id = :uid ORDER BY users_id ASC LIMIT :rowNum , 1"
result = db.session.execute(stmt01, {
'uid': user.id,
'rowNum': rowNum
})
#stmt01 = "SELECT * from user_has_image WHERE users_id = 1 ORDER BY users_id ASC LIMIT 2 , 1"
#result = db.session.execute(stmt01)
theRow = result.fetchall()
imgID = theRow[0][1]
#Then we update the row since we now have the true image_id
stmt02 = "UPDATE user_has_image SET progress = 100 WHERE users_id = :uid AND images_id = :imgID"
db.session.execute(stmt02, {'uid': user.id, 'imgID': imgID})
db.session.commit()
left_seg, right_seg = segPath.split('_', 1)
left_seg = left_seg[len(left_seg) - 3:len(left_seg)]
right_seg, garb = right_seg.split('.', 1)
right_seg = right_seg[0:len(right_seg) - 9]
date_time_clean = left_seg + '_' + right_seg
right_seg = right_seg + 'dictionary'
date_time = left_seg + '_' + right_seg
# Saving the file
try:
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
fp_orig = fp + "/GT_USERS/USER_" + str(user.id)
fullpath_label = fp + "/GT_USERS/USER_" + str(
user.id) + '/labelled/' + date_time + '.json'
fh = open(fullpath_label, "wb")
fh.write(data1) #Saving the dictionary
fh.close()
fullpath_label = fp + "/GT_USERS/USER_" + str(
user.id) + '/labelled/' + date_time_clean + 'labelled.json'
fh = open(fullpath_label, "wb")
for i in range(0, len(data2_split) - 1):
fh.write(
data2_split[i]
) #Saving the integer mask (formatting for better viewing)
fh.write("]\n")
fh.close()
#Need to package everything in .zip file for download
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
fp = fp + "/GT_USERS/USER_" + str(
user.id) + '/packaged/' + date_time
# Making the directory
if not os.path.exists(fp):
os.makedirs(fp)
fp = fp + '/'
#Copying all the files
copyfile(
fp_orig + '/cropped/' +
date_time_clean[4:len(date_time_clean)] + 'cropped.jpg',
fp + date_time_clean[4:len(date_time_clean)] + 'cropped.jpg')
copyfile(
fp_orig + '/json/' +
date_time_clean[0:len(date_time_clean) - 1] + '.json',
fp + date_time_clean + '.json')
copyfile(
fp_orig + '/labelled/' + date_time_clean + 'dictionary.json',
fp + date_time_clean + 'dictionary.json')
copyfile(
fp_orig + '/labelled/' + date_time_clean + 'labelled.json',
fp + date_time_clean + 'labelled.json')
copyfile(
fp_orig + '/segmented/' + date_time_clean + 'segmented.jpg',
fp + date_time_clean + 'segmented.jpg')
#Example of how to open a JSON file to extract each row
#with open(fp+date_time_clean+'labelled.json') as json_labelled:
#d = json.load(json_labelled)
#print(d[0])
# Zip the new directory for download
make_archive(
fp_orig + '/packaged/' +
date_time_clean[0:len(date_time_clean) - 1], 'zip',
fp[0:len(fp) - 1])
# Extract the data to send over http
with open(
fp_orig + '/packaged/' +
date_time_clean[0:len(date_time_clean) - 1] + '.zip',
'r') as content_file:
content = content_file.read()
except:
print("Internal Server Error!")
response = jsonify(message="Internal Server Error!")
response.status_code = 500
return response
# File Path for the created zip file
fp_zip = fp_orig + '/packaged/' + date_time_clean[0:len(date_time_clean
) - 1] + '.zip'
fp_zip_store = 'packaged/' + date_time_clean[0:len(date_time_clean) -
1] + '.zip'
if (user.id != 1):
#Then we update the row since we now have the true image_id
stmt02 = "UPDATE user_has_image SET packaged_filepath = :pfp WHERE users_id = :uid AND images_id = :imgID"
db.session.execute(stmt02, {
'pfp': fp_zip_store,
'uid': user.id,
'imgID': imgID
})
db.session.commit()
# Not allowed to send Binary over HTTP, must be UTF-8 format (base64)
with open(fp_zip,
'rb') as fin, open(fp_orig + '/packaged/' + 'output.zip.b64',
'w') as fout:
base64.encode(fin, fout)
#Send the Base64 file and decode on the client side
return send_from_directory(fp_orig + '/packaged', 'output.zip.b64')
#Called from the 'dashboard.js' script.
# Sends back the .zip file with every important document
@app.route("/post_redownload/", methods=["POST"])
def redownload():
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
rowNum = request.json['imgID']
email = request.json['email']
user = Users.query.filter_by(email=email).first()
print("redownload")
print(rowNum)
#First we find the image_id based on the row count
stmt01 = "SELECT * from user_has_image WHERE users_id = :uid ORDER BY users_id ASC LIMIT :rowNum , 1"
result = db.session.execute(stmt01, {'uid': user.id, 'rowNum': rowNum})
theRow = result.fetchall()
imgID = theRow[0][1]
# File Path for the created zip file
#fp_zip = fp_orig+'/packaged/'+date_time_clean[0:len(date_time_clean)-1]+'.zip'
#fp_zip_store = 'packaged/'+date_time_clean[0:len(date_time_clean)-1]+'.zip'
#segmented/566_datetime2017-06-10_18-22-36_segmented.jpg
#packaged/566_datetime2017-06-10_18-22-36.zip
#Then we update the row since we now have the true image_id
stmt02 = "SELECT packaged_filepath FROM user_has_image WHERE users_id = :uid AND images_id = :imgID"
result = db.session.execute(stmt02, {'uid': user.id, 'imgID': imgID})
theZip = result.fetchall()
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
fp_orig = fp + "/GT_USERS/USER_" + str(user.id) + "/"
print(theZip[0][0])
fp_zip = fp_orig + theZip[0][0]
print(fp_zip)
# Not allowed to send Binary over HTTP, must be UTF-8 format (base64)
with open(fp_zip,
'rb') as fin, open(fp_orig + '/packaged/' + 'output.zip.b64',
'w') as fout:
base64.encode(fin, fout)
#Send the Base64 file and decode on the client side
return send_from_directory(fp_orig + '/packaged', 'output.zip.b64')
#Called from the 'dashboard.js' script.
# sends back just the zipPath
@app.route("/get_zipPath/")
def zipPath():
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
print("prior")
email = request.args.get('email')
rowNum = request.args.get('imgID')
user = Users.query.filter_by(email=email).first()
print("fetching zip")
print(rowNum)
#First we find the image_id based on the row count
stmt01 = "SELECT * from user_has_image WHERE users_id = :uid ORDER BY users_id ASC LIMIT :rowNum , 1"
result = db.session.execute(stmt01, {
'uid': str(user.id),
'rowNum': int(float(rowNum))
})
theRow = result.fetchall()
imgID = theRow[0][1]
print(imgID)
#segmented/566_datetime2017-06-10_18-22-36_segmented.jpg
#packaged/566_datetime2017-06-10_18-22-36.zip
#Then we update the row since we now have the true image_id
stmt02 = "SELECT packaged_filepath FROM user_has_image WHERE users_id = :uid AND images_id = :imgID"
result = db.session.execute(stmt02, {'uid': user.id, 'imgID': imgID})
theZip = result.fetchall()
fp_zip = theZip[0][0]
response = jsonify(message=fp_zip)
response.status_code = 200
return response
#Dynamically loads in an image, used from multiple scripts.
#Does security check in image, then returns the image
@app.route("/dyn_img/fp=/<path:path>")
def images(path):
from StringIO import StringIO
import base64
pathPass = False
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
#try:
payload = parse_token(request)
#except DecodeError:
#response = jsonify(message='Token is invalid')
#response.status_code = 401
#return response
#except ExpiredSignature:
#response = jsonify(message='Token has expired')
#response.status_code = 401
#return response
if (not (path.endswith('.jpg') or path.endswith('.png'))):
response = jsonify(message='Invalid File Extension')
response.status_code = 400
return response
if (path.startswith('groundtruth_webapp')):
pathList = path.split('/')
print(pathList[1])
if (pathList[1] == "server_images"):
pathPass = True
if not ((path.startswith('images')) or
(path.startswith('segmented')) or
(path.startswith('cropped')) or (pathPass)):
response = jsonify(message='Restricted Access')
response.status_code = 401
return response
email = request.args.get('email')
print("email:" + email)
user = Users.query.filter_by(email=email).first()
fp = os.getcwd()
fp = fp.rsplit('/', 1)[0] # go back one dir
if pathPass == False:
fullpath = fp + "/GT_USERS/USER_" + str(user.id) + '/' + path
else:
fullpath = fp + '/' + path
print(fullpath)
myimg = cv2.imread(fullpath)
#Encode the image to send over HTTP (only .jpg to save server space)
try:
encoded = cv2.imencode(".png", myimg)[1]
strImg = base64.encodestring(encoded)
return Response(strImg, direct_passthrough=True)
except ValueError:
response = jsonify(message='Internal Server Error')
response.status_code = 500
return response
#Used for the base call to the webpage to provide index file
@app.route('/')
def index():
return render_template('index.html')
#Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
# Blueprints
return app
import logging
import sys
from flask import Flask, jsonify
from app.basemodels import db
from app.countries.views import countries
from app.exceptions import InvalidUsage
from app.likes.views import likes
from app.sights.views import sights
from app.towns.views import towns
from app.users.views import users
app = Flask(__name__)
app.config.from_pyfile('config.py')
db.init_app(app)
db.app = app
db.engine.pool._use_threadlocal = True
app.register_blueprint(likes)
app.register_blueprint(countries)
app.register_blueprint(towns)
app.register_blueprint(sights)
app.register_blueprint(users)
if __name__ == '__main__':
handler = logging.FileHandler('log/api_sights.log')
log = logging.getLogger('werkzeug')
log.setLevel(logging.info)
log.addHandler(handler)
def create_app(config_filename):
app = Flask(__name__, static_folder='templates/static')
app.config.from_object(config_filename)
#Init Flask-SQLAlchemy
from app.basemodels import db
db.init_app(app)
from app.users.views import users
app.register_blueprint(users, url_prefix='/api/v1/users')
from app.baseviews import login_required, login1, mail
from flask import render_template, send_from_directory
import os
#Init Flask-Mail
mail.init_app(app)
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/<path:filename>')
def file(filename):
return send_from_directory(os.path.join(app.root_path, 'templates'),
filename)
def parse_token(req):
token = req.headers.get('Authorization').split()[1]
return jwt.decode(token, SECRET_KEY, algorithms='HS256')
@app.route("/get_json/")
def getjson():
from StringIO import StringIO
import base64
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
try:
print(request.headers.get('Authorization'))
payload = parse_token(request)
#print(payload)
except DecodeError:
response = jsonify(message='Token is invalid')
response.status_code = 401
return response
except ExpiredSignature:
response = jsonify(message='Token has expired')
response.status_code = 401
return response
segmented_filepath = request.args.get('segmented_filepath')
full_json_filepath = request.args.get('json_filepath')
#full_json_filepath = os.path.join(app.root_path, 'templates/static/images/') + json_filepath
print(full_json_filepath)
email = request.args.get('email')
print(email)
with open(full_json_filepath) as json_file:
json_data = json.load(json_file)
response = {"json_data": json_data}
#print(response)
#response.status_code = 200
return jsonify(message=response)
@app.route("/get_crop/")
def crop():
from StringIO import StringIO
import base64
import cv2
from matplotlib import pyplot as plt
if not request.headers.get('Authorization'):
response = jsonify(message='Missing accept header')
response.status_code = 401
return response
try:
print(request.headers.get('Authorization'))
payload = parse_token(request)
#print(payload)
except DecodeError:
response = jsonify(message='Token is invalid')
response.status_code = 401
return response
except ExpiredSignature:
response = jsonify(message='Token has expired')
response.status_code = 401
return response
x = request.args.get('x')
y = request.args.get('y')
w = request.args.get('w')
h = request.args.get('h')
email = request.args.get('email')
filepath = request.args.get('filepath') # original filepath
print(filepath)
try:
imDict = segmentation.getSegmentedImage(filepath, app.root_path,
int(x), int(y), int(w),
int(h))
except TypeError:
print("Image not found!")
response = jsonify(message="Image not found!")
response.status_code = 401
return response
dataJSON = json.dumps(imDict)
print(dataJSON)
# jsonify imDict and send
response = jsonify(message=dataJSON)
print(response)
response.status_code = 200
return response
#return Response(segmentedImgStr, direct_passthrough=True)
@app.route("/dyn_img/fp=/<path:path>")
def images(path):
from StringIO import StringIO
import base64
#fullpath = os.path.join(app.root_path, 'templates/static/images/') + path
# update: full path in DB:
fullpath = '/' + path
print(fullpath)
myimg = cv2.imread(fullpath)
# how do you cehck if an arbitrary variable in python is null
# supposed to be able to do 'if not nameofimg' for numpy array
# so why the compilation err
'''
try:
myimg = float(myimg)
except ValueError:
print ('nope')
return Response('nope', direct_passthrough=True)
'''
try:
#cv2.imshow('myimg', myimg)
#cv2.waitKey(0)
print(myimg.size)
# trying to check if Empty
# very easy in C++... mat.empty()
#if (myimg.size == 0)
# print("aaaaaaaaaahh img empty")
encoded = cv2.imencode(".jpg", myimg)[1]
strImg = base64.encodestring(encoded)
return Response(strImg, direct_passthrough=True)
#return render_template("test.html", img_data=urllib.quote(strImg.rstrip('\n')))
except ValueError:
return Response("Image not found!", direct_passthrough=True)
@app.route('/')
def index():
return render_template('index.html')
#Auth API
app.register_blueprint(login1, url_prefix='/api/v1/')
# Blueprints
return app
