Add files via upload

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app --log-file -

app.py

@@ -0,0 +1,132 @@
+import plotly
+import plotly.plotly as py
+import plotly.graph_objs as go
+import json
+import hashlib
+from flask import Flask, render_template, request, redirect, url_for
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, Date, ForeignKey
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from dao.orm.model import *
+from dao.credentials import *
+from dao.db import PostgresDb
+from forms.dashboard_form import DashboardForm
+from forms.users_form import *
+from flask_app import *
+from execute_sql_file import *
+
+
+Base = declarative_base()
+
+app = Flask(__name__)
+
+from users import *
+from documents import *
+from templates import *
+from fields import *
+
+@app.route('/', methods=['GET', 'POST'])
+def root():
+    return render_template('index.html')
+
+
+# @app.route('/search', methods=['GET', 'POST'])
+# def search():
+#    search_form = SearchForm()
+#
+#    if request.method == 'GET':
+#        return render_template('search.html', form=search_form, result=None)
+#    else:
+#        return render_template('search.html', form=search_form, result=search_form.get_result())
+
+
+@app.route("/dashboard", methods=['GET', 'POST'])
+def dashboard():
+    db = PostgresDb()
+
+    form = DashboardForm()
+
+    username = form.username.data
+
+    template_fields = user_template_field_count(username)
+
+    templates = []
+    field_counts = []
+
+    for (temp, field_count) in template_fields.items():
+        templates.append(temp.template_name)
+        field_counts.append(field_count)
+
+    bar = go.Bar(
+        x=templates,
+        y=field_counts
+    )
+
+    dates = user_document_upload_date(username)
+
+    x = []
+    y = []
+
+    for (date, document_count) in dates.items():
+        x.append(date)
+        y.append(document_count)
+
+    scatter = go.Scatter(
+        x=x,
+        y=y,
+    )
+
+    data = [bar, scatter]
+
+    ids = [0, 1]
+    names = ["Template field count", "Field and templates count for each user"]
+    graph_json = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder)
+    return render_template('dashboard.html', form=form, form_name="Username", action="dashboard", username=username,
+                           graphJSON=graph_json, ids=ids, names=names)
+
+
+def user_template_field_count(username):
+    db = PostgresDb()
+
+    if not username:
+        template_fields = db.sqlalchemy_session.query(Templates, Fields).join(Fields).all()
+        temp = db.sqlalchemy_session.query(Templates).all()
+    else:
+        template_fields = db.sqlalchemy_session.query(Templates, Fields).join(Users).filter(
+            Users.username == username).join(Fields).all()
+        temp = db.sqlalchemy_session.query(Templates).join(Users).filter(Users.username == username).all()
+
+    templates = {}
+
+    for t in temp:
+        templates[t] = 0
+
+    for (template, field_count) in template_fields:
+        key = template
+        templates[key] += 1
+
+    return templates
+
+
+def user_document_upload_date(username):
+    db = PostgresDb()
+
+    if not username:
+        documents = db.sqlalchemy_session.query(Documents).all()
+    else:
+        documents = db.sqlalchemy_session.query(Documents).join(Users, Users.user_id == Documents.user_id).filter(
+            Users.username == username).all()
+
+    documents_upload_date = {}
+
+    for document in documents:
+        key = document.document_upload_date
+        if key in documents_upload_date:
+            documents_upload_date[key] += 1
+        else:
+            documents_upload_date[key] = 1
+
+    return documents_upload_date

documents.py

@@ -0,0 +1,113 @@
+import datetime
+import hashlib
+import uuid
+
+from flask import *
+from sqlalchemy.exc import DatabaseError
+
+from flask_app import *
+
+from dao.db import *
+from dao.orm.model import *
+from forms.documents_form import *
+
+
+@app.route('/documents', methods=['GET'])
+def documents():
+    db = PostgresDb()
+
+    result = db.sqlalchemy_session.query(Documents).all()
+    return render_template('documents.html', documents=result)
+
+
+@app.route('/new_document', methods=['GET', 'POST'])
+def new_document():
+    form = DocumentsForm()
+    if request.method == 'POST':
+        if not form.validate():
+            return render_template('documents_form.html', form=form, form_name="New document", action="new_document",
+                                   method='POST')
+        else:
+            name = form.document_name.data
+            user_id = form.user_id.data
+
+            document = Documents(
+                user_id=user_id,
+                document_name=name,
+                document_file_path='/{}/{}_{}.doc'.format(user_id, name, uuid.uuid1()),
+                document_upload_date=datetime.date.today()
+            )
+
+            db = PostgresDb()
+            db.sqlalchemy_session.add(document)
+            try:
+                db.sqlalchemy_session.commit()
+            except DatabaseError as e:
+                db.sqlalchemy_session.rollback()
+                print(e)
+                return redirect('/documents')
+
+            return redirect('/documents')
+
+    return render_template('documents_form.html', form=form, form_name="New document", action="new_document")
+
+
+@app.route('/edit_document', methods=['GET', 'POST'])
+def edit_document():
+    form = DocumentsForm()
+
+    if request.method == 'GET':
+
+        document_id = request.args.get('document_id')
+        db = PostgresDb()
+        document = db.sqlalchemy_session.query(Documents).filter(Documents.document_id == document_id).one()
+
+        form.user_id.data = document.user_id
+        form.document_name.data = document.document_name
+
+        return render_template('documents_form.html', form=form, form_name="Edit document",
+                               action="edit_document?document_id=" + request.args.get('document_id'))
+    else:
+        if not form.validate():
+            return render_template('documents_form.html', form=form, form_name="Edit document",
+                                   action="edit_document?document_id=" + request.args.get('document_id'))
+        else:
+            db = PostgresDb()
+
+            document = db.sqlalchemy_session.query(Documents).filter(Documents.document_id == request.args.get('document_id')).one()
+
+            name = form.document_name.data
+            user_id = form.user_id.data
+
+            document.user_id = user_id,
+            document.document_name = name,
+            document.document_file_path = '/{}/{}_{}.doc'.format(user_id, name, uuid.uuid1()),
+            document.document_upload_date = datetime.date.today()
+
+            try:
+                db.sqlalchemy_session.commit()
+            except DatabaseError as e:
+                db.sqlalchemy_session.rollback()
+                print(e)
+                return redirect('/documents')
+
+            return redirect('/documents')
+
+
+@app.route('/delete_document', methods=['POST'])
+def delete_document():
+    document_id = request.form['document_id']
+
+    db = PostgresDb()
+
+    result = db.sqlalchemy_session.query(Documents).filter(Documents.document_id == document_id).one()
+
+    db.sqlalchemy_session.delete(result)
+    try:
+        db.sqlalchemy_session.commit()
+    except DatabaseError as e:
+        db.sqlalchemy_session.rollback()
+        print(e)
+        return redirect('/documents')
+
+    return redirect('/documents')

execute_sql_file.py

@@ -0,0 +1,9 @@
+from dao.db import PostgresDb
+
+
+def execute_sql(path):
+    with open(path) as fp:
+        db = PostgresDb()
+        engine = db.sqlalchemy_engine
+        text = fp.read()
+        engine.execute(text)

fields.py

@@ -0,0 +1,104 @@
+import datetime
+import hashlib
+import uuid
+
+from flask import *
+from sqlalchemy.exc import DatabaseError
+
+from flask_app import *
+
+from dao.db import *
+from dao.orm.model import *
+from forms.fields_form import *
+
+
+@app.route('/fields', methods=['GET'])
+def fields():
+    db = PostgresDb()
+
+    result = db.sqlalchemy_session.query(Fields).all()
+    return render_template('fields.html', fields=result)
+
+
+@app.route('/new_field', methods=['GET', 'POST'])
+def new_field():
+    form = FieldsForm()
+    if request.method == 'POST':
+        if not form.validate():
+            return render_template('fields_form.html', form=form, form_name="New field", action="new_field",
+                                   method='POST')
+        else:
+            field = Fields(
+                template_id=form.template_id.data,
+                field_name=form.field_name.data,
+                field_content=form.field_content.data,
+            )
+
+            db = PostgresDb()
+            db.sqlalchemy_session.add(field)
+            try:
+                db.sqlalchemy_session.commit()
+            except DatabaseError as e:
+                db.sqlalchemy_session.rollback()
+                print(e)
+                return redirect('/fields')
+
+            return redirect('/fields')
+
+    return render_template('fields_form.html', form=form, form_name="New field", action="new_field")
+
+
+@app.route('/edit_field', methods=['GET', 'POST'])
+def edit_field():
+    form = FieldsForm()
+
+    if request.method == 'GET':
+
+        field_id = request.args.get('field_id')
+        db = PostgresDb()
+        field = db.sqlalchemy_session.query(Fields).filter(Fields.field_id == field_id).one()
+
+        form.template_id.data = field.template_id
+        form.field_name.data = field.field_name
+        form.field_content.data = field.field_content
+
+        return render_template('fields_form.html', form=form, form_name="Edit field", action="edit_field?field_id=" + request.args.get('field_id'))
+    else:
+        if not form.validate():
+            return render_template('fields_form.html', form=form, form_name="Edit field", action="edit_field?field_id=" + request.args.get('field_id'))
+        else:
+            db = PostgresDb()
+
+            field = db.sqlalchemy_session.query(Fields).filter(Fields.field_id == request.args.get('field_id')).one()
+
+            field.template_id = form.template_id.data
+            field.field_name = form.field_name.data
+            field.field_content = form.field_content.data
+
+            try:
+                db.sqlalchemy_session.commit()
+            except DatabaseError as e:
+                db.sqlalchemy_session.rollback()
+                print(e)
+                return redirect('/fields')
+
+            return redirect('/fields')
+
+
+@app.route('/delete_field', methods=['POST'])
+def delete_field():
+    field_id = request.form['field_id']
+
+    db = PostgresDb()
+
+    result = db.sqlalchemy_session.query(Fields).filter(Fields.field_id == field_id).one()
+
+    db.sqlalchemy_session.delete(result)
+    try:
+        db.sqlalchemy_session.commit()
+    except DatabaseError as e:
+        db.sqlalchemy_session.rollback()
+        print(e)
+        return redirect('/fields')
+
+    return redirect('/fields')

flask_app.py

@@ -0,0 +1,4 @@
+from flask import Flask
+
+app = Flask(__name__)
+app.secret_key = 'development key'

local_run.py

@@ -0,0 +1,6 @@
+from app import *
+
+
+if __name__ == '__main__':
+    app.debug = True
+    app.run()