SQLite and JSON toggle support added

Co-authored-by: Copilot <copilot@github.com>
This commit is contained in:
Jason
2026-05-05 16:06:52 -05:00
parent 29154bd651
commit 0632aa22e1
12 changed files with 1862 additions and 136 deletions
+262
View File
@@ -0,0 +1,262 @@
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
import json
db = SQLAlchemy()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False, index=True)
password = db.Column(db.String(255), nullable=False)
default_location = db.Column(db.String(10))
active = db.Column(db.Boolean, default=True)
super_admin = db.Column(db.Boolean, default=False)
# Permissions stored as JSON
permissions_json = db.Column(db.Text, default='{}')
location_settings_json = db.Column(db.Text, default='{}')
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@property
def permissions(self):
"""Get permissions as dictionary"""
return json.loads(self.permissions_json) if self.permissions_json else {}
@permissions.setter
def permissions(self, value):
"""Set permissions from dictionary"""
self.permissions_json = json.dumps(value)
@property
def locationSettings(self):
"""Get location settings as dictionary"""
return json.loads(self.location_settings_json) if self.location_settings_json else {}
@locationSettings.setter
def locationSettings(self, value):
"""Set location settings from dictionary"""
self.location_settings_json = json.dumps(value)
def to_dict(self):
"""Convert user to dictionary matching JSON format"""
return {
'username': self.username,
'password': self.password,
'defaultLocation': self.default_location,
'permissions': self.permissions,
'locationSettings': self.locationSettings,
'active': self.active,
'superAdmin': self.super_admin
}
def __repr__(self):
return f'<User {self.username}>'
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
product_code = db.Column(db.String(50), unique=True, nullable=False, index=True)
category = db.Column(db.String(50))
description = db.Column(db.Text)
discontinued = db.Column(db.Boolean, default=False)
location = db.Column(db.String(50))
base_type = db.Column(db.String(50))
# Store complex fields as JSON
sub_type_json = db.Column(db.Text, default='{}')
materials_json = db.Column(db.Text, default='[]')
colors_json = db.Column(db.Text, default='[]')
compatible_accessories_json = db.Column(db.Text, default='[]')
image_config_json = db.Column(db.Text, default='{}')
is_accessory = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@property
def subType(self):
return json.loads(self.sub_type_json) if self.sub_type_json else {}
@subType.setter
def subType(self, value):
self.sub_type_json = json.dumps(value)
@property
def materials(self):
return json.loads(self.materials_json) if self.materials_json else []
@materials.setter
def materials(self, value):
self.materials_json = json.dumps(value)
@property
def colors(self):
return json.loads(self.colors_json) if self.colors_json else []
@colors.setter
def colors(self, value):
self.colors_json = json.dumps(value)
@property
def compatibleAccessories(self):
return json.loads(self.compatible_accessories_json) if self.compatible_accessories_json else []
@compatibleAccessories.setter
def compatibleAccessories(self, value):
self.compatible_accessories_json = json.dumps(value)
@property
def imageConfig(self):
return json.loads(self.image_config_json) if self.image_config_json else {}
@imageConfig.setter
def imageConfig(self, value):
self.image_config_json = json.dumps(value)
def to_dict(self):
"""Convert product to dictionary matching JSON format"""
return {
'id': self.product_code,
'productCode': self.product_code,
'category': self.category,
'description': self.description,
'discontinued': self.discontinued,
'location': self.location,
'baseType': self.base_type,
'subType': self.subType,
'materials': self.materials,
'colors': self.colors,
'isAccessory': self.is_accessory,
'compatibleAccessories': self.compatibleAccessories,
'imageConfig': self.imageConfig
}
def __repr__(self):
return f'<Product {self.product_code}>'
class Location(db.Model):
__tablename__ = 'locations'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(10), unique=True, nullable=False, index=True)
name = db.Column(db.String(100), nullable=False)
active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
def to_dict(self):
"""Convert location to dictionary matching JSON format"""
return {
'code': self.code,
'name': self.name
}
def __repr__(self):
return f'<Location {self.code}: {self.name}>'
class ProductAttribute(db.Model):
__tablename__ = 'product_attributes'
id = db.Column(db.Integer, primary_key=True)
# Store all attribute data as JSON
statuses_json = db.Column(db.Text, default='[]')
product_types_json = db.Column(db.Text, default='[]')
code_modifiers_json = db.Column(db.Text, default='[]')
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@property
def statuses(self):
return json.loads(self.statuses_json) if self.statuses_json else []
@statuses.setter
def statuses(self, value):
self.statuses_json = json.dumps(value)
@property
def productTypes(self):
return json.loads(self.product_types_json) if self.product_types_json else []
@productTypes.setter
def productTypes(self, value):
self.product_types_json = json.dumps(value)
@property
def codeModifiers(self):
return json.loads(self.code_modifiers_json) if self.code_modifiers_json else []
@codeModifiers.setter
def codeModifiers(self, value):
self.code_modifiers_json = json.dumps(value)
def to_dict(self):
"""Convert attributes to dictionary matching JSON format"""
locations = Location.query.filter_by(active=True).all()
return {
'locations': [loc.to_dict() for loc in locations],
'statuses': self.statuses,
'productTypes': self.productTypes,
'codeModifiers': self.codeModifiers
}
def __repr__(self):
return f'<ProductAttribute {self.id}>'
# Additional models for other JSON files if needed
class Question(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
question_data_json = db.Column(db.Text, nullable=False)
order = db.Column(db.Integer, default=0)
active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@property
def questionData(self):
return json.loads(self.question_data_json) if self.question_data_json else {}
@questionData.setter
def questionData(self, value):
self.question_data_json = json.dumps(value)
def __repr__(self):
return f'<Question {self.id}>'
class Accessory(db.Model):
__tablename__ = 'accessories'
id = db.Column(db.Integer, primary_key=True)
accessory_data_json = db.Column(db.Text, nullable=False)
category = db.Column(db.String(50))
active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@property
def accessoryData(self):
return json.loads(self.accessory_data_json) if self.accessory_data_json else {}
@accessoryData.setter
def accessoryData(self, value):
self.accessory_data_json = json.dumps(value)
def __repr__(self):
return f'<Accessory {self.id}>'