first commit

Author: [email protected]

.gitignore

@@ -0,0 +1,5 @@
+/.idea/
+/app/prod.db
+/app/static/temp/
+/app/static/images/
+/start.sh

app/__init__.py

@@ -0,0 +1,29 @@
+from config import Config
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_login import LoginManager
+
+
+db = SQLAlchemy()
+login_manager = LoginManager()
+login_manager.login_view = 'login'
+
+
+def create_app(config_class=Config):
+    app = Flask(__name__)
+    app.config.from_object(config_class)
+
+    db.init_app(app)
+    login_manager.init_app(app)
+
+    from app.default import bp as default_bp
+    from app.login import bp as login_bp
+    from app.part_creation import bp as part_creation_bp
+    from app.prod_recording import bp as prod_recording_bp
+
+    app.register_blueprint(default_bp)
+    app.register_blueprint(login_bp)
+    app.register_blueprint(part_creation_bp)
+    app.register_blueprint(prod_recording_bp)
+
+    return app

app/default/__init__.py

@@ -0,0 +1,5 @@
+from flask import Blueprint
+
+bp = Blueprint('default', __name__, template_folder="templates")
+
+from app.default import routes

app/default/models.py

@@ -0,0 +1,152 @@
+from app import db, login_manager
+from flask_login import UserMixin
+from werkzeug.security import generate_password_hash, check_password_hash
+
+"""Association table, storing which users are working on which groups of products"""
+association_table = db.Table('users_batches',
+                             db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
+                             db.Column('batch_id', db.Integer, db.ForeignKey('batch.id')))
+
+
+class User(db.Model, UserMixin):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(64), index=True, unique=True)
+    email = db.Column(db.String(120), index=True, unique=True)
+    password_hash = db.Column(db.String(128))
+    admin = db.Column(db.Boolean)
+
+    recorded_data = db.relation('ProdData')
+
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+
+    def __repr__(self):
+        return '<User {}>'.format(self.username)
+
+
+class PartType(db.Model):
+    """Used to store different types of products"""
+    id = db.Column(db.Integer, primary_key=True)
+    part_name = db.Column(db.String)
+
+    steps = db.relationship('Step')
+
+    def clone_part_type(self):
+        # Get next ID
+        new_part_name = self.part_name + "(copy)"
+        new_part_type = PartType(part_name=new_part_name)
+        db.session.add(new_part_type)
+        db.session.commit()
+        for step in self.steps:
+            step.clone_step(part_type_id=new_part_type.id)
+        return new_part_type
+
+
+class Batch(db.Model):
+    """Used to store batches of parts"""
+    # Set sqlite autoincrement to true for sqlite to stop it reusing IDs after deletion
+    __table_args__ = {'sqlite_autoincrement': True}
+    id = db.Column(db.Integer, primary_key=True)
+    batch_number = db.Column(db.String, nullable=False)
+    part_type_id = db.Column(db.Integer, db.ForeignKey('part_type.id'), nullable=False)
+    completed = db.Column(db.Boolean, default=False)
+    created_timestamp = db.Column(db.Integer)
+    last_edit_timestamp = db.Column(db.Integer)
+    completed_timestamp = db.Column(db.Integer)
+
+    users = db.relationship('User', secondary=association_table, lazy='dynamic', backref=db.backref('batches'))
+    parts = db.relationship('Part')
+    csvs = db.relationship('Csv')
+    part_type = db.relationship('PartType', backref=db.backref('batches'))
+
+
+class ProdData(db.Model):
+    """ Holds the data recorded for each part/step during production"""
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    part_id = db.Column(db.Integer, db.ForeignKey('part.id'))
+    field_id = db.Column(db.Integer, db.ForeignKey('field.id'))
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
+
+    field_data = db.Column(db.String)
+
+
+class Part(db.Model):
+    """Used to store basic information about a single product"""
+    id = db.Column(db.Integer, primary_key=True)
+    relative_id = db.Column(db.Integer)  # The id to quickly identify the part within a batch, usually starting at 1
+    batch_id = db.Column(db.Integer, db.ForeignKey('batch.id'))
+    last_edit_timestamp = db.Column(db.Integer)
+
+    data = db.relationship('ProdData')
+
+
+class Field(db.Model):
+    """ Specifies which fields of data should appear for each step"""
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    step_id = db.Column(db.Integer, db.ForeignKey('step.id'))
+    field_name = db.Column(db.String)
+    batch_wide = db.Column(db.Boolean)  # True if the data field counts for all the parts in the batch
+
+    data = db.relationship('ProdData')
+
+    def clone_field(self, new_step_id):
+        new_field = Field(step_id=new_step_id,
+                          field_name=self.field_name,
+                          batch_wide=self.batch_wide)
+        db.session.add(new_field)
+        db.session.commit()
+
+
+class Csv(db.Model):
+    """Data saved in csv format"""
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    batch_id = db.Column(db.Integer, db.ForeignKey('batch.id'))
+    step_id = db.Column(db.Integer, db.ForeignKey('step.id'))
+    body = db.Column(db.String)
+    uploaded_timestamp = db.Column(db.Integer)
+
+
+class Step(db.Model):
+    """Holds the information for each step for each type of part"""
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    part_type_id = db.Column(db.Integer, db.ForeignKey('part_type.id'))
+    step_number = db.Column(db.Integer)
+    step_title = db.Column(db.String)
+    step_instructions = db.Column(db.String)
+    step_image = db.Column(db.String)
+    csv_upload = db.Column(db.Boolean)
+    csv_id = db.Column(db.Integer, db.ForeignKey('csv.id'))
+
+    fields = db.relationship('Field')
+
+    def clone_step(self, part_type_id):
+        new_step = Step(part_type_id=part_type_id,
+                        step_number=self.step_number,
+                        step_title=self.step_title,
+                        step_instructions=self.step_instructions,
+                        step_image=self.step_image)
+        db.session.add(new_step)
+        db.session.commit()
+        for field in self.fields:
+            field.clone_field(new_step.id)
+
+
+@login_manager.user_loader
+def load_user(id):
+    return User.query.get(int(id))
+
+
+def copy_row(model, row, ignored_columns=[]):
+    copy = model()
+
+    for col in row.__table__.columns:
+        if col.name not in ignored_columns:
+            try:
+                copy.__setattr__(col.name, getattr(row, col.name))
+            except Exception as e:
+                print(e)
+                continue
+    return copy

app/default/routes.py

@@ -0,0 +1,153 @@
+from app import db
+from app.prod_recording.export import recreate_csv_log, create_csv_from_data
+from app.default import bp
+from app.default.models import User, Batch, PartType
+from datetime import datetime
+from time import time
+from flask import render_template, request, redirect, url_for, abort, send_file
+from flask_login import current_user, login_required
+
+
+
+@bp.route('/')
+def default():
+    db.create_all()
+    if len(User.query.all()) == 0:
+        base_admin = User(username="admin", admin=True)
+        base_admin.set_password("password")
+        db.session.add(base_admin)
+    db.session.commit()
+    return redirect(url_for('login.login'))
+
+
+@bp.route('/index')
+@login_required
+def index():
+    """ The default page """
+    if current_user.is_authenticated:
+        user = {'username': current_user.username, 'id': current_user.id}
+    else:
+        user = {'username': "nobody"}
+    return render_template('index.html', title='Home', user=user)
+
+
+
+@bp.route('/home', methods=['GET', 'POST'])
+@login_required
+def home():
+    """ The default page for a logged-in user
+
+    This will show the user the batches they are currently working on, as well as the option to start a new batch
+    """
+
+    if request.method == "POST":
+        try:
+            action = request.form["action"]
+        except Exception as e:
+            print(e)
+            abort(400)
+            return
+
+        if action == "completeBatch":
+            # Mark the batch as completed
+            completed_batch = Batch.query.get_or_404(request.form["batchId"])
+            completed_batch.completed = True
+            completed_batch.completed_timestamp = time()
+            db.session.commit()
+
+    batches = current_user.batches
+    batches_in_progress = []
+    for b in batches:
+        if not b.completed:
+            batches_in_progress.append(b)
+    admin = current_user.admin
+    nav_bar_title = "Home - " + current_user.username
+    return render_template('home.html',
+                           nav_bar_title=nav_bar_title,
+                           batches=batches_in_progress,
+                           admin=admin)
+
+
+@bp.route('/adminhome', methods=['GET', 'POST'])
+@login_required
+def admin_home():
+    """The home page for a logged-in admin"""
+    if not current_user.admin:
+        return redirect(url_for('default.home'))
+
+    # By default, get batches from the current month
+    # This is overwritten if the user provides dates in a post request
+    now = datetime.now()
+    requested_month = now.month
+    requested_year = now.year
+
+    if request.method == "POST":
+        try:
+            action = request.form["action"]
+        except Exception as e:
+            print(e)
+            abort(400)
+            return
+
+        if action == "alterDates":
+            # Changes the month for which batches to show
+            requested_month = int(request.form["month"])
+            requested_year = int(request.form["year"])
+
+        if action == "newPartType":
+            # Create a new part type
+            part_type = PartType()
+            db.session.add(part_type)
+            db.session.commit()
+            return redirect(url_for("part_creation.create_part_type", part_type_id=part_type.id))
+        if action == "copyPartType":
+            # Create a new part type using an older part type as template
+            part_type = PartType.query.get_or_404(request.form["partTypeId"])
+            part_type_copy = part_type.clone_part_type()
+            return redirect(url_for("part_creation.create_part_type", part_type_id=part_type_copy.id))
+
+        if action == "deletePartType":
+            # Delete a part type
+            delete_part_type = PartType.query.get_or_404(request.form["partTypeId"])
+            db.session.delete(delete_part_type)
+            db.session.commit()
+        if action == "deleteBatch":
+            # Delete a batch
+            delete_batch = Batch.query.get_or_404(request.form["batchId"])
+            db.session.delete(delete_batch)
+            db.session.commit()
+
+        if action == "downloadData":
+            # Download a batch's data in the form of a CSV file
+            batch_id = request.form["batchId"]
+            filepath = create_csv_from_data(batch_id)
+            new_file_name = "batch_{batch}_data.csv".format(batch=batch_id)
+            return send_file(filename_or_fp=filepath, cache_timeout=-1, as_attachment=True,
+                             attachment_filename=new_file_name)
+
+        if action == "downloadCsv":
+            # Download any CSV data that has been uploaded for a batch
+            batch_id = request.form["batchId"]
+            filepath = recreate_csv_log(batch_id)
+            new_file_name = "batch_{batch}_log.csv".format(batch=batch_id)
+            return send_file(filename_or_fp=filepath, cache_timeout=-1, as_attachment=True,
+                             attachment_filename=new_file_name)
+
+    requested_batches_start = datetime(year=requested_year, month=requested_month, day=1, hour=0).timestamp()
+    requested_batches_end = datetime(year=requested_year, month=requested_month + 1, day=1, hour=0).timestamp()
+    batches = Batch.query.filter(Batch.created_timestamp.between(requested_batches_start, requested_batches_end))
+
+    # Send all of the parts to the page
+    part_types = PartType.query.all()
+    users = User.query.all()
+
+    nav_bar_title = "Admin Home"
+
+    return render_template('adminhome.html',
+                           requested_year=requested_year,
+                           requested_month=requested_month,
+                           current_year=now.year,
+                           nav_bar_title=nav_bar_title,
+                           part_types=part_types,
+                           users=users,
+                           batches=batches)