server.py

import flask
import configparser

from dataclasses import dataclass
from datetime import date, datetime
from flask import Flask, jsonify, request
from flask.globals import session
from flask_sqlalchemy import SQLAlchemy
from flask_httpauth import HTTPBasicAuth
from werkzeug.security import generate_password_hash, check_password_hash
from flask import send_file
from sqlalchemy import ForeignKey, desc
from sqlalchemy.orm import relationship
from flask_cors import CORS

app = Flask(__name__, static_url_path='',
 static_folder='static')
auth = HTTPBasicAuth()

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database/database.db'
db = SQLAlchemy(app)

# TODO: remove allow all cors, once GUI development finishes or allow in other branch
CORS(app)

config = configparser.ConfigParser()
# Sets default config, if ini is missing
# If you want to change any of these settings,
# please rename the "config.ini.example" to "config.ini" and change them there
#
# The settings below are the default in case the config.ini is missing
config['SETTINGS'] = {
 'port': 5000,
 'host': '0.0.0.0',
 'usePassword': False,
 'user': 'admin',
 'unlock_password': 'supersecret'
}

# user config
# Overwrites local config with file (if exists)
config.read('config/config.ini')

users = {
 str(config['SETTINGS']['user']): generate_password_hash(str(config['SETTINGS']['unlock_password'])),
}


# Model
@dataclass
class LogEntry(db.Model):
 __tablename__ = 'logentry'
 id: int
 dateObj: datetime

 id = db.Column(db.Integer, primary_key=True)
 dateObj = db.Column(
 db.DateTime, unique=False, nullable=False)
 log_posts = relationship("Post", cascade="all,delete", backref="LogEntry")


@dataclass
class Post(db.Model):
 __tablename__ = 'post'
 id: int
 log_FK_id: int
 elapsedTime: int
 learnMethod: str
 comment: str

 id = db.Column(db.Integer, primary_key=True)
 log_FK_id = db.Column(db.Integer, ForeignKey(LogEntry.id))
 elapsedTime = db.Column(db.Integer, unique=False, nullable=False)
 learnMethod = db.Column(db.String, unique=False, nullable=False)
 comment = db.Column(db.String, unique=False, nullable=False)


# Routes
@app.route("/")
def entry():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')
 return app.send_static_file('index.html')
 # commands = Command.query.all()
 # return jsonify(commands)


@app.route("/login")
@auth.login_required
def login():
 return flask.redirect('/')


@app.route("/loggedIn")
def loggedIn():
 return str(isLoggedIn())


@app.route("/logs")
def logs():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')
 logentries = LogEntry.query.order_by(desc(LogEntry.dateObj)).all()
 return jsonify(logentries)


@app.route("/totalTime")
def totalTime():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 logid = request.args.get('logid', default=0, type=int)
 if(logid):

 results = (db.session.query(Post.id, Post.log_FK_id, Post.elapsedTime,
 Post.learnMethod, Post.comment).join(LogEntry).filter(LogEntry.id == logid)).all()
 row_as_dict = []
 totaltime = 0
 for row in results:
 try:
 totaltime += int(row.elapsedTime)
 except:
 return "One or more elapsedTime seems wrong"
 return str(totaltime)
 else:
 return "no log id given"


# creates a new entry for current date. use '/addLog?manual=YYYY-MM-DD' to insert already past days
# also catch "dateAlreadyExist", when a day already exists
@app.route("/addLog")
def addLog():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 logs = LogEntry.query.all()
 # format: yyyy-mm-dd
 addManualDay = request.args.get('manual', default="", type=str)
 isManual = addManualDay != ""
 if(isManual):
 newDate = datetime.fromisoformat(addManualDay)
 db.session.add(LogEntry(dateObj=newDate))
 else:
 db.session.add(LogEntry(
 dateObj=datetime.now()))

 localDateObj = datetime.utcnow()
 if(isManual):
 localDateObj = datetime.fromisoformat(addManualDay)
 for item in logs:

 # check if date is already present
 if(item.dateObj.day == localDateObj.day and item.dateObj.month == localDateObj.month and item.dateObj.year == localDateObj.year):
 return ("dateAlreadyExist")

 # logentries = LogEntry.query.all()
 db.session.commit()
 logentries = LogEntry.query.order_by(desc(LogEntry.dateObj)).all()
 return jsonify(logentries)


@app.route("/addPost", methods=['GET', 'POST', 'PATCH'])
def addPost():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 if request.method == 'POST':
 if(request.form['logid']):
 logid = request.form['logid']
 elapsedTime = request.form['elapsedTime']
 learnMethod = request.form['learnMethod']
 comment = request.form['comment']

 db.session.add(Post(
 log_FK_id=logid,
 elapsedTime=elapsedTime,
 learnMethod=learnMethod,
 comment=comment,
 ))

 db.session.commit()

 results = (db.session.query(Post.id, Post.log_FK_id, Post.elapsedTime,
 Post.learnMethod, Post.comment).join(LogEntry).filter(LogEntry.id == logid)).all()

 row_as_dict = []
 for row in results:
 row_as_dict.append(dict_from_row(row))
 # row_as_dict.append(dict(row))

 # posts = Post.query.all()
 return jsonify(row_as_dict)

 return jsonify("no id was given")
 elif request.method == 'PATCH':
 if(request.form['id']):
 id = request.form['id']
 logid = request.form['logid']
 elapsedTime = request.form['elapsedTime']
 learnMethod = request.form['learnMethod']
 comment = request.form['comment']
 # find element
 element = Post.query.get(id)

 if(element):
 element.log_FK_id = logid
 element.elapsedTime = elapsedTime
 element.learnMethod = learnMethod
 element.comment = comment
 db.session.add(element)
 db.session.commit()

 return "OK"
 else:
 return "Use post request"


# outputs posts by logid with /getPosts?logid=<id>
@ app.route("/getPosts")
def getPosts():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 logid = request.args.get('logid', default=0, type=int)

 # results = Post.query.join(LogEntry).all()
 results = (db.session.query(Post.id, Post.log_FK_id, Post.elapsedTime,
 Post.learnMethod, Post.comment).join(LogEntry).filter(LogEntry.id == logid)).all()

 row_as_dict = []
 for row in results:
 row_as_dict.append(dict_from_row(row))

 return jsonify(row_as_dict)


@app.route("/deletePost")
def deleteLog():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 postid = request.args.get('id', default=0, type=int)
 if(postid == 0):
 return "no post id was passed"
 else:
 logs = Post.query.all()
 for item in logs:
 if(item.id == postid):
 db.session.delete(item)
 db.session.commit()

 results = (db.session.query(Post.id, Post.log_FK_id, Post.elapsedTime,
 Post.learnMethod, Post.comment).join(LogEntry).filter(LogEntry.id == item.log_FK_id)).all()
 row_as_dict = []
 for row in results:
 row_as_dict.append(dict_from_row(row))
 return jsonify(row_as_dict)

 return "no item to be deleted"

@app.route("/exportDatabase")
def exportDB():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 return send_file('./database/database.db', as_attachment=True)


@app.route("/export")
def export():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 import csv
 x = date.today()
 currentDate = str(x)
 filename = 'JapaneseLogExport-'+currentDate+'.csv'
 outfile = open('export/'+filename, 'w', newline='')
 outcsv = csv.writer(outfile)
 records = db.engine.execute(
 "SELECT substr(dateObj, 0,11) as date , elapsedTime, learnMethod, comment from post, logentry where logentry.id == post.log_FK_id order by date")
 outcsv.writerows(records)

 outfile.close()
 return send_file('./export/'+filename, as_attachment=True)


@app.route("/deleteLog")
def deletePost():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 logid = request.args.get('logid', default=0, type=int)
 if(logid == 0):
 return "no logid was passed"
 else:
 logs = LogEntry.query.all()
 for item in logs:
 if(item.id == logid):
 db.session.delete(item)
 db.session.commit()
 logentries = LogEntry.query.order_by(
 desc(LogEntry.dateObj)).all()
 return jsonify(logentries)
 return "no item to be deleted"

# shows all possible learnmethods that were entered so far (for autocompletion in frontend)


@ app.route("/getLearnMethods")
def getLearnMethods():
 if(not isLoggedIn() and checkPassReq()):
 return flask.redirect('/login')

 results = (db.session.query(Post.learnMethod).join(LogEntry)).all()

 data = []
 for row in results:
 data.append([x for x in row][0])

 return jsonify(list(dict.fromkeys(data)))


# logic


def dict_from_row(row):
 return dict(zip(row.keys(), row))


def checkPassReq():
 cmp1 = bool(str(config['SETTINGS']['usePassword']).lower() == "true")
 return cmp1


def isLoggedIn():
 x = auth.get_auth()
 return not (x == None)


# user auth

@auth.verify_password
def verify_password(username, password):
 if username in users and \
 check_password_hash(users.get(username), password):
 return username