import datetime
from flask_security import UserMixin
from sqlalchemy import ForeignKeyConstraint
from project.server.helpers.encrypter import encrypt_password
from project.server.managers.database import db
from project.server.models.auth_role import Role
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('auth_users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('auth_roles.id')),
)
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "auth_users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime(), nullable=False)
confirmed = db.Column(db.Boolean, nullable=False, default=False)
confirmed_on = db.Column(db.DateTime, nullable=True)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
class Image(db.Model):
""" Image Model for storing image related details """
__tablename__ = 'sys_image'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
updated_on = db.Column(db.DateTime, nullable=True, default=datetime.now())
image_path = db.Column(db.String(255), nullable=False)
filename = db.Column(db.String(255), nullable=False)
dataset_id = db.Column(db.Integer,
db.ForeignKey('ai_dataset.id',
ondelete='CASCADE',
onupdate="cascade"),
nullable=True)
attributes_id = db.Column(db.Integer,
db.ForeignKey('ai_attribute.id',
ondelete='CASCADE'),
nullable=True,
default=1)
annotation_id = db.Column(db.Integer,
db.ForeignKey('ai_annotation.id',
ondelete='CASCADE'),
nullable=True,
default=1)
categories_id = db.Column(db.Integer,
db.ForeignKey('ai_category.id',
ondelete='CASCADE'),
nullable=True,
default=1)
annotation_path = db.Column(db.String(255), nullable=True, default='NULL')
flagging = db.Column(db.String(255), nullable=True, default='NULL')
license = db.Column(db.String(255), nullable=True, default='NULL')
width = db.Column(db.Float, nullable=True, default='1')
height = db.Column(db.Float, nullable=True, default='1')
dataset = db.relationship(Dataset,
primaryjoin=dataset_id == Dataset.id,
post_update=True)
attribute = db.relationship(Attribute,
primaryjoin=attributes_id == Attribute.id,
post_update=True)
category = db.relationship(Category,
primaryjoin=categories_id == Category.id,
post_update=True)
annotation = db.relationship(Annotation,
primaryjoin=annotation_id == Annotation.id,
post_update=True,
uselist=True)
def __init__(self,
updated_on,
image_path,
filename,
dataset_id,
attributes_id=None,
categories_id=None,
annotation_id=None):
self.updated_on = updated_on
self.image_path = image_path
self.filename = filename
if dataset_id is not None:
self.dataset = Dataset.query.get_or_404(dataset_id)
if attributes_id is not None:
self.attribute = Attribute.query.get_or_404(attributes_id)
if annotation_id is not None:
self.annotation = Annotation.query.get_or_404(annotation_id)
if categories_id is not None:
self.category = Category.query.get_or_404(categories_id)
def from_json(self, json):
self.id = json.get('image_id', None)
self.updated_on = json.get('updated_on', None)
self.image_path = json.get('image_path', None)
self.dataset = json.get('dataset', None)
return self
def to_dictionary(self):
obj = {
'image_id': self.id,
'updated_on': self.updated_on,
'image_path': self.image_path,
'filename': self.filename,
'dataset_id': self.dataset_id,
# 'agent': [get_json_clean_response(self.agent)],
'annotation': get_json_clean_response(self.annotation),
'attributes': [get_json_clean_response(self.attribute)],
'categories': [get_json_clean_response(self.category)]
}
return obj
class Inference(db.Model):
""" Models Model for storing model related details """
__tablename__ = "ai_inference"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
updated_on = db.Column(db.DateTime(), nullable=False)
agent_id = db.Column(db.Integer,
db.ForeignKey('ai_agent.id'),
nullable=True)
file_name = db.Column(db.String(255), nullable=False)
file_path = db.Column(db.String(255), nullable=False)
tag = db.Column(db.String(255), nullable=False)
model_id = db.Column(db.Integer,
db.ForeignKey('ai_models.id'),
nullable=False)
camera_id = db.Column(db.Integer,
db.ForeignKey('sys_camera.id'),
nullable=False)
dataset = db.Column(db.String(255), nullable=True)
confidence = db.Column(db.Float, nullable=False)
label = db.Column(db.String(255), nullable=False)
def __init__(self, updated_on, agent_id, file_name, file_path, tag,
model_id, camera_id, dataset, confidence, label):
self.updated_on = updated_on
self.agent_id = agent_id
self.file_name = file_name
self.file_path = file_path
self.tag = tag
self.model_id = model_id
self.camera_id = camera_id
self.dataset = dataset
self.confidence = confidence
self.label = label
def from_json(self, json):
self.id = json.get('inference_id', None)
self.updated_on = json.get('updated_on', None)
self.agent_id = json.get('agent_id', None)
self.file_name = json.get('file_name', None)
self.file_path = json.get('file_path', None)
self.tag = json.get('tag', None)
self.model_id = json.get('model_id', None)
self.camera_id = json.get('camera_id', None)
self.dataset = json.get('dataset', None)
self.confidence = json.get('confidence', None)
self.label = json.get('label', None)
return self
def to_dictionary(self):
obj = {
'id': self.id,
'updated_on': self.updated_on,
'agent_id': self.agent_id,
'file_name': self.file_name,
'file_path': self.file_path,
'tag': self.tag,
'model_id': self.model_id,
'camera_id': self.camera_id,
'dataset': self.dataset,
'confidence': self.confidence,
'label': self.label
}
return obj
class Camera(db.Model):
""" Camera Model for storing camera related details """
__tablename__ = 'sys_camera'
id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True)
camera_id = db.Column(db.String(255), nullable=True)
updated_on = db.Column(db.DateTime(), nullable=True)
camera_type = db.Column(db.String(255), nullable=True)
frame_rate = db.Column(db.String(255), nullable=True)
resolution = db.Column(db.Float, nullable=True)
color = db.Column(db.String(255), nullable=True)
shutter_speed = db.Column(db.Boolean, nullable=True)
exposure = db.Column(db.String(255), nullable=True)
image_size_H = db.Column(db.Boolean, nullable=True)
image_size_W = db.Column(db.String(255), nullable=True)
image_size_C = db.Column(db.String(255), nullable=True)
spot_name = db.Column(db.String(255), nullable=True)
weight_file = db.Column(db.String(255), nullable=True)
threshold = db.Column(db.String(255), nullable=True)
orientation = db.Column(db.String(255), nullable=True)
current_status = db.Column(db.Boolean, nullable=True)
agent_id = db.Column(db.Integer, db.ForeignKey("ai_agent.id", ondelete='CASCADE'), nullable=True)
models_id = db.Column(db.Integer, db.ForeignKey("ai_models.id", ondelete='CASCADE'), nullable=True)
agent = db.relationship(Agent, primaryjoin=agent_id == Agent.id)
model = db.relationship(Models, primaryjoin=models_id == Models.id)
# inference_id = db.Column(db.Integer, db.ForeignKey("ai_inference.id"), nullable=True)
# inference = db.relationship(Inference, primaryjoin=inference_id == Inference.id)
def __init__(self, camera_id, updated_on, camera_type, frame_rate, resolution, color, shutter_speed, exposure,
image_size_H,
image_size_W, image_size_C, spot_name, weight_file, threshold, orientation):
self.camera_id = camera_id
self.updated_on = updated_on
self.camera_type = camera_type
self.frame_rate = frame_rate
self.resolution = resolution
self.color = color
self.shutter_speed = shutter_speed
self.exposure = exposure
self.image_size_H = image_size_H
self.image_size_W = image_size_W
self.image_size_C = image_size_C
self.spot_name = spot_name
self.weight_file = weight_file
self.threshold = threshold
self.orientation = orientation
self.model = Models.query.all()
# self.inference = Inference.query.all()
def from_json(self, json):
self.camera_id = json.get('camera_id', None)
self.updated_on = json.get('updated_on', None)
self.camera_type = json.get('camera_type', None)
self.frame_rate = json.get('frame_rate', None)
self.resolution = json.get('resolution', None)
self.color = json.get('color', None)
self.shutter_speed = json.get('shutter_speed', None)
self.exposure = json.get('exposure', None)
self.image_size_H = json.get('image_size_H', None)
self.image_size_W = json.get('image_size_W', None)
self.image_size_C = json.get('image_size_C', None)
self.spot_name = json.get('spot_name', None)
self.weight_file = json.get('weight_file', None)
self.threshold = json.get('threshold', None)
self.orientation = json.get('orientation', None)
return self
def to_dictionary(self):
obj = {
'camera_id': self.camera_id,
'updated_on': self.updated_on,
'camera_type': self.camera_type,
'frame_rate': self.frame_rate,
'resolution': self.resolution,
'color': self.color,
'shutter_speed': self.shutter_speed,
'exposure': self.exposure,
'image_size_H': self.image_size_H,
'image_size_W': self.image_size_W,
'image_size_C': self.image_size_C,
'weight_file': self.weight_file,
'threshold': self.threshold,
'orientation': self.orientation,
'model': [get_json_clean_response(self.model)],
# 'inference': [get_json_clean_response(self.inference)]
}
return obj
from datetime import datetime
from project.server.managers.database import db
from project.server.models.ai_models import Models
from project.server.models.ai_inference import Inference
from project.server.helpers.serialize import get_json_clean_response
ai_agent = db.Table(
'ai_agent',
db.Column('id',
db.Integer(),
primary_key=True,
nullable=False,
autoincrement=True),
db.Column('camera_id', db.Integer(), db.ForeignKey('sys_camera.id')),
db.Column('model_id', db.Integer(), db.ForeignKey('ai_models.id')),
db.Column('environment', db.String(255), nullable=False),
db.Column('user', db.String(255), nullable=True),
db.Column('session', db.String(255), nullable=True),
db.Column('project', db.String(255), nullable=True),
db.Column('description', db.String(255), nullable=True),
db.Column('inference', db.String(255), nullable=True))
class Camera(db.Model):
""" Camera Model for storing camera related details """
__tablename__ = 'sys_camera'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)