class CIValueJson(Model):
__tablename__ = "c_value_json"
ci_id = db.Column(db.Integer, db.ForeignKey('c_cis.id'), nullable=False)
attr_id = db.Column(db.Integer, db.ForeignKey('c_attributes.id'), nullable=False)
value = db.Column(db.JSON, nullable=False)
ci = db.relationship("CI", backref="c_value_json.ci_id")
attr = db.relationship("Attribute", backref="c_value_json.attr_id")
class CIValueDateTime(Model):
__tablename__ = "c_value_datetime"
ci_id = db.Column(db.Integer, db.ForeignKey('c_cis.id'), nullable=False)
attr_id = db.Column(db.Integer, db.ForeignKey('c_attributes.id'), nullable=False)
value = db.Column(db.DateTime, nullable=False)
ci = db.relationship("CI", backref="c_value_datetime.ci_id")
attr = db.relationship("Attribute", backref="c_value_datetime.attr_id")
class PreferenceShowAttributes(Model):
__tablename__ = "c_preference_show_attributes"
uid = db.Column(db.Integer, index=True, nullable=False)
type_id = db.Column(db.Integer, db.ForeignKey("c_ci_types.id"), nullable=False)
attr_id = db.Column(db.Integer, db.ForeignKey("c_attributes.id"))
order = db.Column(db.SmallInteger, default=0)
ci_type = db.relationship("CIType", backref="c_preference_show_attributes.type_id")
attr = db.relationship("Attribute", backref="c_preference_show_attributes.attr_id")
class CITypeRelation(Model):
__tablename__ = "c_ci_type_relations"
parent_id = db.Column(db.Integer, db.ForeignKey("c_ci_types.id"), nullable=False)
child_id = db.Column(db.Integer, db.ForeignKey("c_ci_types.id"), nullable=False)
relation_type_id = db.Column(db.Integer, db.ForeignKey("c_relation_types.id"), nullable=False)
parent = db.relationship("CIType", primaryjoin="CIType.id==CITypeRelation.parent_id")
child = db.relationship("CIType", primaryjoin="CIType.id==CITypeRelation.child_id")
relation_type = db.relationship("RelationType", backref="c_ci_type_relations.relation_type_id")
class User(db.Model):
"""
This model holds information about a user registered
"""
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
username = db.Column(db.String(80), unique=True, nullable=False,)
password = db.Column(db.String(128))
email = db.Column(db.String(100), nullable=False, unique=True)
date = db.Column(db.DateTime,
default=datetime.now())
thumbnail = db.Column(db.String(1500),
default='https://react.semantic-ui.com/images/avatar/large/elliot.jpg')
projects = db.relationship('Project',
backref='user',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
project_members = db.relationship('ProjectMember',
backref='user',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
def __init__(self, name, username, email, password=None):
"""
Initializes the user instance
"""
self.name = name
self.username = username
self.email = email
if password:
self.password = User.generate_password_hash(password)
def __repr__(self):
"""
Returns the object reprensentation of user
"""
return "<User %r>" % self.name
@staticmethod
def generate_password_hash(password):
"""
Returns hash of password
"""
return Bcrypt().generate_password_hash(password,10).decode()
def verify_password(self, password):
"""
Verify the password
"""
return Bcrypt().check_password_hash(self.password, password)
class CIRelation(Model):
__tablename__ = "c_ci_relations"
first_ci_id = db.Column(db.Integer, db.ForeignKey("c_cis.id"), nullable=False)
second_ci_id = db.Column(db.Integer, db.ForeignKey("c_cis.id"), nullable=False)
relation_type_id = db.Column(db.Integer, db.ForeignKey("c_relation_types.id"), nullable=False)
more = db.Column(db.Integer, db.ForeignKey("c_cis.id"))
first_ci = db.relationship("CI", primaryjoin="CI.id==CIRelation.first_ci_id")
second_ci = db.relationship("CI", primaryjoin="CI.id==CIRelation.second_ci_id")
relation_type = db.relationship("RelationType", backref="c_ci_relations.relation_type_id")
class CIIndexValueText(Model):
__tablename__ = "c_value_index_texts"
ci_id = db.Column(db.Integer, db.ForeignKey('c_cis.id'), nullable=False)
attr_id = db.Column(db.Integer, db.ForeignKey('c_attributes.id'), nullable=False)
value = db.Column(db.String(128), nullable=False)
ci = db.relationship("CI", backref="c_value_index_texts.ci_id")
attr = db.relationship("Attribute", backref="c_value_index_texts.attr_id")
__table_args__ = (db.Index("text_attr_value_index", "attr_id", "value"),)
class Team(db.Model):
"""
This model holds information about a team in a project
"""
__tablename__ = "team"
id = db.Column(db.Integer, primary_key=True)
team_name = db.Column(db.String(80), nullable=False,)
role = db.Column(db.String(128),
default = 'Member')
project_id = db.Column(db.Integer,
db.ForeignKey('project.id', ondelete="cascade", onupdate="cascade"),
nullable=False)
team_members = db.relationship('ProjectMember',
backref='team',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
def __init__(self, team_name, role, project_id):
"""
Initializes the team instance
"""
self.team_name = team_name
self.role = role
self.project_id = project_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Team %r>" % self.team_name
class TextChoice(Model):
__tablename__ = 'c_choice_texts'
attr_id = db.Column(db.Integer, db.ForeignKey('c_attributes.id'), nullable=False)
value = db.Column(db.Text, nullable=False)
attr = db.relationship("Attribute", backref="c_choice_texts.attr_id")
class Project(db.Model):
"""
This model holds information about a project and its admin
"""
__tablename__ = "project"
id = db.Column(db.Integer, primary_key=True)
project_name = db.Column(
db.String(80),
nullable=False,
)
project_description = db.Column(db.String(128), default='Image labelling')
admin_id = db.Column(db.Integer,
db.ForeignKey('user.id',
ondelete="cascade",
onupdate="cascade"),
nullable=False)
labels = db.relationship('Label',
backref='project',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
images = db.relationship('Image',
backref='project',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
models = db.relationship('MLClassifier',
backref='project',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
def __init__(self, project_name, project_description, admin_id):
"""
Initializes the project instance
"""
self.project_name = project_name
self.project_description = project_description
self.admin_id = admin_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Project(project_name='%s', project_id='%s', project_description='%s')>" % (
self.project_name, self.id, self.project_description)
class Image(db.Model):
"""
This model holds information about an image in a project
"""
__tablename__ = "image"
id = db.Column(db.Integer, primary_key=True)
imagename = db.Column(
db.String(128),
nullable=False,
)
image_url = db.Column(
db.String(80),
nullable=False,
)
height = db.Column(db.Integer)
width = db.Column(db.Integer)
labelled = db.Column(db.Boolean, default=False)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
nullable=False)
labelsdata = db.relationship('LabelData',
backref='image',
lazy=True,
cascade="all, delete-orphan")
labels = db.relationship('Label',
secondary=labels,
lazy='subquery',
backref=db.backref('image', lazy=True))
def __init__(self, imagename, image_url, height, width, labelled,
project_id):
"""
Initializes the image instance
"""
self.imagename = imagename
self.image_url = image_url
self.height = height
self.width = width
self.labelled = labelled
self.project_id = project_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Image %r>" % self.imagename
class Subprefeitura(db.Model):
codigo = db.Column(db.Integer,
primary_key=True,
comment='Código da subprefeitura (2003 a 2012)')
nome = db.Column(db.String(25),
nullable=False,
comment='Nome da subprefeitura')
feiras = db.relationship('Feira', lazy='select', backref='subprefeitura')
class CI(Model):
__tablename__ = "c_cis"
type_id = db.Column(db.Integer, db.ForeignKey("c_ci_types.id"), nullable=False)
status = db.Column(db.Enum(*CIStatusEnum.all(), name="status"))
heartbeat = db.Column(db.DateTime, default=lambda: datetime.datetime.now())
ci_type = db.relationship("CIType", backref="c_cis.type_id")
class Label(db.Model):
"""
This model holds information about a label
"""
__tablename__ = "label"
id = db.Column(db.Integer, primary_key=True)
labelname = db.Column(
db.String(128),
nullable=False,
)
label_type = db.Column(
db.String(80),
nullable=False,
)
count = db.Column(db.Integer, default=0)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
nullable=False)
labelsdata = db.relationship('LabelData',
backref='label',
lazy=True,
cascade="all, delete-orphan")
models = db.relationship("MLModel",
secondary=model_has_label,
backref=db.backref("labels", lazy="dynamic"))
def __init__(self, labelname, label_type, count, project_id):
"""
Initializes the label instance
"""
self.labelname = labelname
self.label_type = label_type
self.count = count
self.project_id = project_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Label %r>" % self.labelname
@classmethod
def find_by_id_in_project(cls, _id, project_id):
result = cls.query.filter_by(id=_id, project_id=project_id).first()
return result
class Distrito(db.Model):
codigo = db.Column(db.Integer,
primary_key=True,
comment='Código do distrito conforme IBGE')
nome = db.Column(db.String(18),
nullable=False,
comment='Distrito municipal')
feiras = db.relationship('Feira', lazy='select', backref='distrito')
class RolePermission(Model):
__tablename__ = "acl_role_permissions"
rid = db.Column(db.Integer, db.ForeignKey('acl_roles.id'))
resource_id = db.Column(db.Integer, db.ForeignKey('acl_resources.id'))
group_id = db.Column(db.Integer, db.ForeignKey('acl_resource_groups.id'))
perm_id = db.Column(db.Integer, db.ForeignKey('acl_permissions.id'))
perm = db.relationship("Permission", backref='acl_role_permissions.perm_id')
class Label(db.Model):
"""
This model holds information about a label
"""
__tablename__ = "label"
id = db.Column(db.Integer, primary_key=True)
label_name = db.Column(
db.String(128),
nullable=False,
)
label_type = db.Column(
db.String(80),
nullable=False,
)
created_at = db.Column(db.DateTime, default=datetime.now())
count = db.Column(db.Integer, default=0)
project_id = db.Column(db.Integer,
db.ForeignKey('project.id',
ondelete="cascade",
onupdate="cascade"),
nullable=False)
labeldata = db.relationship('LabelData',
backref='label',
lazy=True,
cascade="all, save-update, delete",
passive_deletes=True)
models = db.relationship("MLClassifier",
secondary=model_has_label,
backref=db.backref("labels", lazy="dynamic"))
def __init__(self, label_name, label_type, project_id):
"""
Initializes the label instance
"""
self.label_name = label_name
self.label_type = label_type
self.project_id = project_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Label %r>" % self.label_name
class Project(db.Model):
"""
This model holds information about a project and its admin
"""
__tablename__ = "project"
id = db.Column(db.Integer, primary_key=True)
projectname = db.Column(
db.String(80),
nullable=False,
)
projectdescription = db.Column(db.String(128), default='Image labelling')
admin_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
labels = db.relationship('Label',
backref='project',
lazy=True,
cascade="all, delete-orphan")
images = db.relationship('Image',
backref='project',
lazy=True,
cascade="all, delete-orphan")
models = db.relationship('MLModel',
backref='project',
lazy=True,
cascade="all, delete-orphan")
def __init__(self, projectname, projectdescription, admin_id):
"""
Initializes the project instance
"""
self.projectname = projectname
self.projectdescription = projectdescription
self.admin_id = admin_id
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<Project %r>" % self.projectname
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class CITypeAttribute(Model):
__tablename__ = "c_ci_type_attributes"
type_id = db.Column(db.Integer, db.ForeignKey("c_ci_types.id"), nullable=False)
attr_id = db.Column(db.Integer, db.ForeignKey("c_attributes.id"), nullable=False)
order = db.Column(db.Integer, default=0)
is_required = db.Column(db.Boolean, default=False)
default_show = db.Column(db.Boolean, default=True)
attr = db.relationship("Attribute", backref="c_ci_type_attributes.attr_id")
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=db.func.current_timestamp() )
languages = db.relationship('Language', backref='users', lazy=True)
learned_words = db.relationship('LearnedWords', backref='users', lazy=True)
@validates('username')
def validate_username(self, key, username):
user = db.session.query(User).filter(User.username==username).first()
if user is not None:
raise AssertionError(f'{username} already exists in db')
else:
return username
class SSLSetting(Model):
__tablename__ = 'ssl_setting'
key = db.Column(db.String(50), unique=True)
value = db.Column(db.Text)
desc = db.Column(db.String(255), nullable=True)
ssl_type_id = db.Column(db.Integer, db.ForeignKey('ssl_type.id'))
ssl_type = db.relationship('SSLType', backref=db.backref('ssl_setting'), lazy='subquery', foreign_keys=[ssl_type_id])
def __str__(self):
return '<Setting %r>' % self.key
class CIType(Model):
__tablename__ = "c_ci_types"
name = db.Column(db.String(32), nullable=False)
alias = db.Column(db.String(32), nullable=False)
unique_id = db.Column(db.Integer, db.ForeignKey("c_attributes.id"), nullable=False)
enabled = db.Column(db.Boolean, default=True, nullable=False)
is_attached = db.Column(db.Boolean, default=False, nullable=False)
icon_url = db.Column(db.String(256), default='', nullable=False)
order = db.Column(db.SmallInteger, default=0, nullable=False)
unique_key = db.relationship("Attribute", backref="c_ci_types.unique_id")
class CartItem(db.Model):
__tablename__ = 'cart_items'
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer, db.ForeignKey('books.id'), nullable=False)
cart_id = db.Column(db.Integer, db.ForeignKey('cart.id'), nullable=False)
book = db.relationship(
'Book',
backref=db.backref('cart_items', uselist=False))
created_at = db.Column(db.DateTime, default=datetime.now(pytz.utc))
def __repr__(self):
return '<CartItem {}>'.format(self.id)
class CustomTopic(BaseModel, Serializable):
__public__ = ['id', 'name']
name = db.Column(TEXT, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
feeds = db.relationship('Feed', secondary=custom_topic_feed)
@classmethod
def for_user(cls, user):
return cls.query.filter(
cls.user_id == (user.id if isinstance(user, User) else user))
class Deploy(Model):
__tablename__ = 'deploys'
app_id = db.Column(db.Integer, db.ForeignKey('apps.id'))
env_id = db.Column(db.Integer, db.ForeignKey('environments.id'))
host_ids = db.Column(db.Text)
extend = db.Column(db.Integer, db.ForeignKey('deploy_extends.id'))
is_audit = db.Column(db.Boolean)
rst_notify = db.Column(db.String(255), nullable=True)
app = db.relationship('App',
backref=db.backref('deploy'),
foreign_keys=[app_id])
env = db.relationship('Environment',
backref=db.backref('deploy'),
foreign_keys=[env_id])
create_at = db.Column(db.String(20), default=human_datetime)
create_by = db.Column(db.Integer, db.ForeignKey('users.id'))
updated_at = db.Column(db.String(20))
updated_by = db.Column(db.Integer, db.ForeignKey('users.id'))
def __str__(self):
return '<Deoploy %r>' % self.app
@property
def extend_obj(self):
cls = DeployExtend1 if self.extend == '1' else DeployExtend2
return cls.query.filter(deploy=self).first()
def to_dict(self, *args, **kwargs):
deploy = super().to_dict(*args, **kwargs)
deploy['app_name'] = self.app.name if hasattr(self,
'app_name') else None
deploy['host_ids'] = json.loads(self.host_ids)
deploy['rst_notify'] = json.loads(self.rst_notify)
deploy.update(self.extend_obj.to_dict())
return deploy
class User(BaseModel):
email = db.Column(db.String(255), unique=True, nullable=False)
username = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer(), nullable=False, default=0)
feeds = db.relationship('Feed',
secondary=user_feed,
lazy='dynamic',
backref=db.backref('users', lazy='dynamic'))
custom_topics = db.relationship('CustomTopic', lazy=True)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.password = (bcrypt.generate_password_hash(
self.password).decode('utf-8'))
class Category(db.Model):
"""
DB model representing a category associated with a building
"""
__tablename__ = 'categories'
cat_id = db.Column('cat_id', Integer, primary_key=True, autoincrement=True)
# TODO: DB table doesn't but should have foriegn key- lying here to SQL Alchemy
b_id = db.Column('b_id', Text, ForeignKey("buildings.b_id"), nullable=False)
cat_name = db.Column('cat_name', Text, nullable=False)
# TODO: update when the table has a proper foriegn key constraint
# building relationship - this is a more complex as there is not a proper foreign key and the b_id column types differ
buildings = db.relationship('Building', backref=('categories'), primaryjoin=cast(remote(Building.b_id), Text) == foreign(b_id))
class AcmeDns(Model):
__tablename__ = 'acme_dns'
user = db.Column(db.String(50),nullable=True)
key = db.Column(db.String(50),nullable=True)
acme_dns_type_id = db.Column(db.Integer, db.ForeignKey('acme_dns_type.id'))
acme_dns_type = db.relationship('AcmeDnsType', backref=db.backref('acme_dns'), lazy='subquery', foreign_keys=[acme_dns_type_id])
created_at = db.Column(db.String(20), default=human_datetime)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
deleted_at = db.Column(db.String(20), nullable=True)
deleted_by = db.Column(db.Integer, db.ForeignKey('users.id'))
def __str__(self):
return '<Dns %r>' % self.user
class Cart(db.Model):
__tablename__ = 'cart'
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customers.id'))
cart_items = db.relationship('CartItem',
uselist=True,
foreign_keys='CartItem.cart_id',
backref='cart',
lazy='dynamic',
cascade='all, delete-orphan')
created_at = db.Column(db.DateTime, default=datetime.now(pytz.utc))
def __repr__(self):
return '<Cart {}>'.format(self.id)
class SSL(Model):
__tablename__ = 'ssls'
name = db.Column(db.String(20),nullable=False)
ssl_type_id = db.Column(db.Integer, db.ForeignKey('ssl_type.id'))
ssl_type = db.relationship('SSLType', backref=db.backref('ssl'), lazy='subquery', foreign_keys=[ssl_type_id])
cer = db.Column(db.Text)
key = db.Column(db.Text)
expiration = db.Column(db.String(20), nullable=True)
created_at = db.Column(db.String(20), default=human_datetime)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
deleted_at = db.Column(db.String(20), nullable=True)
deleted_by = db.Column(db.Integer, db.ForeignKey('users.id'))
def __str__(self):
return '<SSL %r>' % self.name
