Jason
263 lines
8.9 KiB
Python
263 lines
8.9 KiB
Python
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}>'
|