Sample to Donor

services/web/app/FormEnum.py

@@ -10,7 +10,7 @@
 class FormEnum(Enum):
     @classmethod
     def choices(cls):
-        return [(choice.name, choice) for choice in cls]
+        return [(choice.name, str(choice)) for choice in cls]
 
     def __str__(self):
         return str(self.value)

services/web/app/__init__.py

@@ -29,7 +29,7 @@
 from .patientconsentform import pcf as pcf_blueprint
 from .processing import processing as processing_blueprint
 from .storage import storage as storage_blueprint
-
+from .procedure import procedure as procedure_blueprint
 
 def create_app():
     app = Flask(__name__, instance_relative_config=True)
@@ -55,6 +55,7 @@ def create_app():
     from app.storage import models as storage_models
     from app.attribute import models as attribute_models
     from app.donor import models as donor_models
+    from app.procedure import models as procedure_models
 
     app.register_blueprint(misc_blueprint)
     app.register_blueprint(auth_blueprint)
@@ -67,6 +68,7 @@ def create_app():
     app.register_blueprint(donor_blueprint, url_prefix="/donors")
     app.register_blueprint(pcf_blueprint, url_prefix="/pcf")
     app.register_blueprint(storage_blueprint, url_prefix="/storage")
+    app.register_blueprint(procedure_blueprint, url_prefix="/procedures")
 
     from app.errors import error_handlers
 

services/web/app/auth/routes.py

@@ -19,6 +19,7 @@ def login():
         user = db.session.query(User).filter(User.email == form.email.data).first()
         if user is not None and user.verify_password(form.password.data):
             login_user(user)
+            flash("Successfuly logged in.")
             return redirect(url_for("misc.index"))
         else:
             flash("Incorrect email or password.")

services/web/app/donor/forms.py

@@ -24,7 +24,7 @@ class DonorCreationForm(FlaskForm):
     death_date = DateField("Date of Death")
     weight = DecimalField("Weight (kg)")
     height = DecimalField("Height (cm)")
-    # site ?
+
     race = SelectField("Race", choices=RaceTypes.choices())
 
     submit = SubmitField("Submit")

services/web/app/procedure/__init__.py

@@ -0,0 +1,5 @@
+from flask import Blueprint
+
+procedure = Blueprint("procedures", __name__)
+
+from . import routes

services/web/app/procedure/forms.py

@@ -0,0 +1,17 @@
+from flask_wtf import FlaskForm
+from wtforms import (
+    FileField,
+    StringField,
+    SubmitField,
+    DecimalField,
+    BooleanField,
+)
+from wtforms.validators import DataRequired
+
+class DiagnosticProcedureCreationForm(FlaskForm):
+    name = StringField("Name", validators=[DataRequired()])
+    version = DecimalField("Version")
+    description = StringField("Description")
+    from_file = BooleanField("From File")
+    json_file = FileField("Upload (*)")
+    submit = SubmitField("Submit")

services/web/app/procedure/models.py

@@ -0,0 +1,95 @@
+from app import db
+
+class DiagnosticProcedureClass(db.Model):
+    __versioned__ = {}
+    __tablename__ = "diagnostic_procedure_classes"
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    name = db.Column(db.String)
+    version = db.Column(db.String)
+    description = db.Column(db.String)
+
+
+    author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+    updater_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+
+    creation_date = db.Column(db.DateTime, server_default=db.func.now(), nullable=False)
+    update_date = db.Column(
+        db.DateTime,
+        server_default=db.func.now(),
+        server_onupdate=db.func.now(),
+        nullable=False,
+    )
+
+class DiagnosticProcedureVolume(db.Model):
+    __versioned__ = {}
+    __tablename__ = "diagnostic_procedure_volumes"
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    code = db.Column(db.String(5))
+    name = db.Column(db.String)
+
+    author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+    updater_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+
+    class_id = db.Column(db.Integer, db.ForeignKey("diagnostic_procedure_classes.id"))
+
+    creation_date = db.Column(db.DateTime, server_default=db.func.now(), nullable=False)
+    update_date = db.Column(
+        db.DateTime,
+        server_default=db.func.now(),
+        server_onupdate=db.func.now(),
+        nullable=False,
+    )
+
+class DiagnosticProcedureSubheading(db.Model):
+    __versioned__ = {}
+    __tablename__ = "diagnostic_procedure_subheadings"
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    code = db.Column(db.String(5))
+    subheading = db.Column(db.String())
+
+    # Website linking to page?
+    reference = db.Column(db.String(256))
+
+    volume_id = db.Column(db.Integer, db.ForeignKey("diagnostic_procedure_volumes.id"))
+
+    author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+    updater_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+
+    creation_date = db.Column(db.DateTime, server_default=db.func.now(), nullable=False)
+    update_date = db.Column(
+        db.DateTime,
+        server_default=db.func.now(),
+        server_onupdate=db.func.now(),
+        nullable=False,
+    )
+
+class DiagnosticProcedure(db.Model):
+    __versioned__ = {}
+    __tablename__ = "diagnostic_procedures"
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    code = db.Column(db.String(5))
+    procedure = db.Column(db.String())
+
+    # Website linking to page?
+    reference = db.Column(db.String(256))
+
+    subheading_id = db.Column(db.Integer, db.ForeignKey("diagnostic_procedure_subheadings.id"))
+
+    author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+    updater_id = db.Column(db.Integer, db.ForeignKey("users.id"))
+
+    creation_date = db.Column(db.DateTime, server_default=db.func.now(), nullable=False)
+    update_date = db.Column(
+        db.DateTime,
+        server_default=db.func.now(),
+        server_onupdate=db.func.now(),
+        nullable=False,
+    )

services/web/app/procedure/routes.py

@@ -0,0 +1,79 @@
+from flask import redirect, abort, render_template, url_for, session, request, jsonify
+from flask_login import current_user, login_required
+
+from .models import *
+from .. import db
+
+from . import procedure
+from .forms import DiagnosticProcedureCreationForm
+
+import json
+
+from .views import DiagnosticProceduresIndexView, DiagnosticProcedureView
+
+@procedure.route("/")
+@login_required
+def index():
+    procedures = DiagnosticProceduresIndexView()
+    return render_template("procedure/index.html", procedures=procedures)
+
+@procedure.route("/view/LIMBDIAG-<procedure_id>")
+@login_required
+def view(procedure_id):
+    dpv = DiagnosticProcedureView(procedure_id)
+    return render_template("procedure/view.html", dpv=dpv)
+
+@procedure.route("/new", methods=["GET", "POST"])
+def new():
+    form = DiagnosticProcedureCreationForm()
+    if form.validate_on_submit():
+        dpc = DiagnosticProcedureClass(
+            name = form.name.data,
+            version = form.version.data,
+            description = form.version.data,
+            author_id = current_user.id,
+        )
+
+        db.session.add(dpc)
+        db.session.flush()
+
+        if form.from_file.data == True:
+            data = json.load(form.json_file.data)
+            for volume, data in data.items():
+                dpv = DiagnosticProcedureVolume(
+                    code = volume,
+                    name = data["title"],
+                    author_id = current_user.id,
+                    class_id = dpc.id
+                )
+
+                db.session.add(dpv)
+                db.session.flush()
+
+                for sh_code, subheading in data["subheadings"].items():
+                    dpsh = DiagnosticProcedureSubheading(
+                        code = sh_code,
+                        subheading = subheading["heading"],
+                        author_id = current_user.id,
+                        volume_id = dpv.id
+                    )
+
+                    db.session.add(dpsh)
+                    db.session.flush()
+
+                    for code, descr in subheading["codes"].items():
+                        dp = DiagnosticProcedure(
+                            code = code,
+                            procedure = descr,
+                            author_id = current_user.id,
+                            subheading_id = dpsh.id
+                        )
+
+                        db.session.add(dp)
+
+
+        db.session.commit()
+        return redirect(url_for("procedures.index"))
+
+
+    return render_template("procedure/new.html", form=form)

services/web/app/procedure/views.py

@@ -0,0 +1,66 @@
+from .. import db
+from .models import DiagnosticProcedureClass, DiagnosticProcedureVolume, DiagnosticProcedureSubheading, DiagnosticProcedure
+from ..auth.views import UserView
+
+def DiagnosticProceduresIndexView() -> dict:
+    data = {}
+
+    for procedure in db.session.query(DiagnosticProcedureClass).all():
+        data[procedure.id] = {
+            "name": procedure.name,
+            "version": procedure.version,
+            "upload_date": procedure.creation_date,
+            "update_date": procedure.update_date,
+            "user_information": UserView(procedure.author_id),
+        }
+
+    return data
+
+def DiagnosticProcedureView(proc_id) -> dict:
+    proc = db.session.query(DiagnosticProcedureClass).filter(DiagnosticProcedureClass.id == proc_id).first_or_404()
+
+    volumes = db.session.query(DiagnosticProcedureVolume).filter(DiagnosticProcedureVolume.class_id == proc_id).all()
+
+    data = {
+        "id": proc.id,
+        "name": proc.name,
+        "version": proc.version,
+        "upload_date": proc.creation_date,
+        "update_date": proc.update_date,
+        "user_information": UserView(proc.author_id),
+        "volumes" : {}
+    }
+
+    for volume in volumes:
+        data["volumes"][volume.id] = {
+            "code" : volume.code,
+            "name" : volume.name,
+            "subheadings": {}
+        }
+
+        subheadings = db.session.query(DiagnosticProcedureSubheading).filter(DiagnosticProcedureSubheading.volume_id == volume.id).all()
+
+        for sh in subheadings:
+
+
+            diagnostic_procs = db.session.query(DiagnosticProcedure).filter(DiagnosticProcedure.subheading_id == sh.id).all()
+
+            codes = {}
+
+            for proc in diagnostic_procs:
+                codes[proc.id] = {
+                    "code": proc.code,
+                    "procedure": proc.procedure
+                }
+
+            data["volumes"][volume.id]["subheadings"][sh.id] = {
+                "code": sh.code,
+                "subheading": sh.subheading,
+                "codes": codes
+            }
+
+
+
+
+    return data
+