class User(db.Model):
""" Data model for a user. """
__tablename__ = "users"
user_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
email = db.Column(db.String(64), nullable=False)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
created_on = db.Column(db.DateTime, nullable=False)
modified_on = db.Column(db.DateTime, nullable=False)
# need an active field to mark if a user is active or not
active = db.Column(db.Boolean, nullable=False, default=True)
pronouns = db.Column(db.String(300), nullable=True)
phone_number = db.Column(db.String(60), nullable=False)
twitter_handle = db.Column(db.String(100), nullable=True)
facebook_handle = db.Column(db.String(100), nullable=True)
addresses = db.relationship("Address",
backref=db.backref("addresses",
order_by=user_id))
payment_option = db.relationship(
"Payment_Option",
backref=db.backref("user_payment_options"),
uselist=False)
# requests = db.relationship("Request", backref=db.backref("requests",
# order_by=user_id))
# offers = db.relationship("Offer", backref=db.backref("offers",
# order_by=user_id))
def __repr__(self):
return f"""<User user_id={self.user_id}
email={self.email}
first_name={self.name}
last_name={self.name}>"""
@property
def to_dict_for_json(self):
json_dict = {}
json_dict['user_id'] = self.user_id
json_dict['email'] = self.email
json_dict['first_name'] = self.first_name
json_dict['last_name'] = self.last_name
json_dict['created_on'] = self.created_on.strftime(
'%b %d, %Y %H:%M:%S')
json_dict['modified_on'] = self.modified_on.strftime(
'%b %d, %Y %H:%M:%S')
json_dict['phone_number'] = self.phone_number
json_dict['twitter_handle'] = self.twitter_handle
json_dict['facebook_handle'] = self.facebook_handle
json_dict['pronouns'] = self.pronouns
json_dict['addresses'] = [
address.to_dict_for_json for address in self.addresses
]
json_dict[
'payment_option'] = self.payment_option if self.payment_option is None else self.payment_option.to_dict_for_json
return json_dict
class Gasto(db.Model):
id = db.Column(db.Integer, primary_key=True)
valor = db.Column(db.Numeric(precision=2))
__data = db.Column("data", db.Date, default=db.func.today())
motivo = db.Column(db.Unicode)
tipo_id = db.Column(db.Integer, db.ForeignKey('tipo_do_gasto.id'))
tipo = db.relationship('TipoDoGasto', backref=db.backref('gastos',
lazy='dynamic'))
pessoa_id = db.Column(db.Integer, db.ForeignKey('pessoa.id'))
pessoa = db.relationship('Pessoa', backref=db.backref('gastos',
lazy='dynamic'))
def __init__(self, valor, data, motivo, cod_tipo, cod_pessoa):
self.valor = valor
self.data = data
self.motivo = motivo
self.tipo_id = cod_tipo
self.pessoa_id = cod_pessoa
@property
def data(self):
return self.__data
@data.setter
def data(self, valor):
import datetime
print valor
dia = int(valor.split("/")[0])
mes = int(valor.split("/")[1])
ano = int(valor.split("/")[2])
self.__data = datetime.date(ano, mes, dia)
class ObservationModel(ObserverMixinModel, TimestampMixinModel, db.Model):
"""Table des observations"""
__tablename__ = "t_obstax"
__table_args__ = {"schema": "gnc_obstax"}
id_observation = db.Column(db.Integer, primary_key=True, unique=True)
uuid_sinp = db.Column(UUID(as_uuid=True), nullable=False, unique=True)
id_program = db.Column(
db.Integer,
db.ForeignKey(ProgramsModel.id_program, ondelete="SET NULL"),
nullable=False,
)
cd_nom = db.Column(db.Integer, nullable=False)
date = db.Column(db.Date, nullable=False)
count = db.Column(db.Integer)
comment = db.Column(db.String(300))
# FIXME: remove nullable prop from ObservationModel.municipality once debugged
municipality = db.Column(db.Integer,
db.ForeignKey(LAreas.id_area),
nullable=True)
geom = db.Column(Geometry("POINT", 4326))
json_data = db.Column(JSONB, nullable=True)
program_ref = db.relationship("ProgramsModel",
backref=db.backref("t_obstax",
lazy="dynamic"))
municipality_ref = db.relationship("LAreas",
backref=db.backref("l_areas",
lazy="dynamic"))
class Bets(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey(Users.id))
fixture_id = db.Column(db.Integer, db.ForeignKey(Fixtures.id))
team_id = db.Column(db.Integer, db.ForeignKey(Teams.id))
amount = db.Column(db.Integer)
user = db.relationship(Users,
backref=db.backref('bets',
uselist=True,
cascade='delete,all'))
fixture = db.relationship(Fixtures,
backref=db.backref('bets',
uselist=True,
cascade='delete,all'))
team = db.relationship(Teams,
backref=db.backref('bets',
uselist=True,
cascade='delete,all'))
def my_dict(self):
return {
"id": self.id,
"user_id": self.user_id,
"fixture_id": self.fixture_id,
"team_id": self.team_id,
"amount": self.amount
}
def __repr__(self):
return str()
class Persona(db.Model):
__tablename__ = 'persona'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
title = db.Column(db.Text)
quote = db.Column(db.Text)
job_function = db.Column(db.Text)
needs = db.Column(db.Text)
wants = db.Column(db.Text)
pain_point = db.Column(db.Text)
external = db.Column(db.Integer, default=0)
market_size = db.Column(db.Integer)
buss_val = db.Column(db.Integer)
create_date = db.Column(db.DateTime, default=datetime.utcnow)
revision = db.Column(db.Integer, default=0)
creator_id = db.Column(db.Integer)
access_group = db.Column(db.Integer)
archived = db.Column(db.Boolean, default=False)
persona_maturity = db.Column(db.Text)
persona_picture = db.Column(db.Binary)
cust_id = db.Column(db.Integer)
roles = db.relationship('PersonaRoles',
secondary='persona_roles_rel',
backref=db.backref('personas'))
products = db.relationship('Product',
secondary='pers_prod_rel',
backref=db.backref('personas'))
class Seminar(db.Model):
__tablename__ = 'seminars'
seminar_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
details = db.Column(db.UnicodeText)
start = db.Column(db.String(80))
end = db.Column(db.String(80))
capacity = db.Column(db.Integer)
status = db.Column(db.String(80))
creater = db.Column(db.String(80))
users = db.relationship('User',secondary=seminar_realation,
backref=db.backref('seminar_users_all', lazy='dynamic'))
sessions = db.relationship('Session',secondary=seminar_session,
backref=db.backref('session_all', lazy='dynamic'))
def __init__(self,title,details,start,end,capacity,status, creater):
self.title = title
self.details = details
self.start = start
self.end = end
self.capacity = capacity
self.status = status
self.creater = creater
def __repr__(self):
return '<Seminar: %r>'%self.title
class User(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
pw_hash = db.Column(db.String(80), nullable=False)
balance = db.Column(db.Numeric(10, 2), default=0)
table_names = db.relationship('TableName',
backref=db.backref('user', lazy=True))
model_names = db.relationship('ModelName',
backref=db.backref('user', lazy=True))
class Run(db.Model):
"""Contains a set of screenshot records uploaded by a diff worker."""
DATA_PENDING = 'data_pending'
DIFF_APPROVED = 'diff_approved'
DIFF_FOUND = 'diff_found'
DIFF_NOT_FOUND = 'diff_not_found'
FAILED = 'failed'
NEEDS_DIFF = 'needs_diff'
NO_DIFF_NEEDED = 'no_diff_needed'
STATES = frozenset([
DATA_PENDING, DIFF_APPROVED, DIFF_FOUND, DIFF_NOT_FOUND,
FAILED, NEEDS_DIFF, NO_DIFF_NEEDED])
DIFF_NEEDED_STATES = frozenset([DIFF_FOUND, DIFF_APPROVED])
id = db.Column(db.Integer, primary_key=True)
release_id = db.Column(db.Integer, db.ForeignKey('release.id'))
release = db.relationship('Release',
backref=db.backref('runs', lazy='select'),
lazy='joined',
join_depth=1)
name = db.Column(db.String(255), nullable=False)
# TODO: Put rigid DB constraint on uniqueness of (release_id, name)
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
status = db.Column(db.Enum(*STATES), nullable=False)
image = db.Column(db.String(100), db.ForeignKey('artifact.id'))
log = db.Column(db.String(100), db.ForeignKey('artifact.id'))
config = db.Column(db.String(100), db.ForeignKey('artifact.id'))
url = db.Column(db.String(2048))
ref_image = db.Column(db.String(100), db.ForeignKey('artifact.id'))
ref_log = db.Column(db.String(100), db.ForeignKey('artifact.id'))
ref_config = db.Column(db.String(100), db.ForeignKey('artifact.id'))
ref_url = db.Column(db.String(2048))
diff_image = db.Column(db.String(100), db.ForeignKey('artifact.id'))
diff_log = db.Column(db.String(100), db.ForeignKey('artifact.id'))
distortion = db.Column(db.Float())
tasks = db.relationship('WorkQueue',
backref=db.backref('runs', lazy='select'),
lazy='joined',
join_depth=1,
order_by='WorkQueue.created')
# For flask-cache memoize key.
def __repr__(self):
return 'Run(id=%r)' % self.id
class User(UserMixin, db.Model):
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
zid = db.Column(db.Integer, unique = True)
email = db.Column(db.String(120), unique=True)
password = db.Column(db.String(120))
role = db.Column(db.String(80))
fee = db.Column(db.Float)
events = db.relationship('Event', secondary = event_realation,
backref=db.backref('events_all', lazy='dynamic'))
seminars = db.relationship('Seminar', secondary = seminar_realation,
backref=db.backref('seminars_all', lazy='dynamic'))
sessions = db.relationship('Session', secondary = session_realation,
backref=db.backref('sessions_all', lazy='dynamic'))
def __init__(self, name, zid, email, password, role, fee):
self.name = name
self.zid = zid
self.email = email
self.password = password
self.role = role
self.fee = fee
@property
def get_zid(self):
return self.zid
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.user_id
def validate_password(self, password):
return self.password == password
def __repr__(self):
return '<User: %r>'%self.name
class Thing(db.Model):
__tablename__ = 'thing'
id = db.Column(db.Integer, primary_key=True)
# Thing can have system-defined primary_type and subtypes
# subtypes are defined by JOIN table below
main_type_id = db.Column(db.Integer,
db.ForeignKey('main_type.id'),
nullable=False)
main_type = db.relationship('MainType')
subtypes_relation = db.relationship('Subtype',
secondary='thing_subtype_association',
backref=db.backref('thing',
lazy='dynamic'))
subtypes = association_proxy('subtypes_relation', 'name')
description_how = db.Column(db.Text)
description_what = db.Column(db.Text)
# Thing can have user-defined tags
# We are going to do this with an association table for now until we figure out how to use GIN indexes
tag_relation = db.relationship('Tag',
secondary='thing_tag_association',
backref=db.backref('thing', lazy='dynamic'))
tags = association_proxy('tag_relation', 'name')
# tags = db.Column(ARRAY(db.Text), default=db.cast(array([], type_=db.Text), ARRAY(db.Text)))
# __table_args__ = (db.Index('ix_shareable_tags', tags, postgresql_using="gin"),)
notes = db.Column(db.Text)
def __init__(self,
main_type,
subtypes=[],
description_how="",
description_what="",
tags=[],
notes=""):
if tags is None:
tags = []
self.description_how = description_how
self.description_what = description_what
self.main_type = main_type
self.subtypes_relation.extend(subtypes)
self.tag_relation.extend(tags)
self.notes = notes
def __repr__(self):
return '<Thing %r>' % self.id
class PERM(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
blurb = db.Column(db.String(200))
status = db.Column(
db.Enum("Expired", "Approved", "Denied", "Cancelled", "Requested"))
submissionTime = db.Column(db.DateTime)
expirationTime = db.Column(db.DateTime)
sectionRank = db.Column(db.Integer)
showBlurb = False
studentID = db.Column(db.Integer,
ForeignKey(Student.id),
primary_key=True,
autoincrement=False)
#reference student via 'student'
student = db.relationship("Student",
backref=db.backref('PERMs',
order_by=submissionTime))
sectionID = db.Column(db.Integer,
ForeignKey(Section.id),
primary_key=True,
autoincrement=False)
#reference section via 'section'
section = db.relationship("Section",
backref=db.backref('PERMs', order_by=studentID))
def __init__(self, section, student, blurb, status, submissionTime,
expirationTime, sectionRank):
self.sectionID = section
self.studentID = student
self.blurb = blurb
self.status = status
self.submissionTime = submissionTime
self.expirationTime = expirationTime
self.sectionRank = sectionRank
def __repr__(self):
return "<PERM(id='%s', section='%s', student='%s', blurb='%s', status='%s', submissionTime='%s', expirationTime='%s', sectionRank='%s')>" % (
self.id, self.sectionID, self.studentID, self.blurb, self.status,
self.submissionTime, self.expirationTime, self.sectionRank)
def serialize(self): #lets us serialize it!!
result = {}
for key in self.__mapper__.c.keys():
k = getattr(self, key)
if (isinstance(k, datetime)):
result[key] = serialize_permtime(k)
else:
result[key] = getattr(self, key)
return result
class Game(db.Model):
"""
This model is used to represent Company entries in our database.
Attributes:
Game_ID - ID of the game object. The ID will self-increment as we add more values into the Game table.
Name - Name of the game. The IGDB API also pulls information like alternate names for the game, which may be integrated in a future project release.
Image_URL - The image for the game.
Rating - The rating the game received. This rating is pulled from IGDB, just like the other information regarding games.
Release_Year - The year the game had came out.
Associated_Companies - The companies who developed and published the game. This information will be populated using a combination of the association table and the IGDB API.
Associated_Genres - The genres associated with the game. Like companies, the information is populated using an associated table with the data retrieved from the IGDB API.
Associated_Platforms - The platforms the game was released on. This information is populated using a combination of the association table for platforms and games and the IGDB API.
"""
query_class = GameQuery
__tablename__ = 'games'
game_id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(50))
image_url = db.Column(db.String(255))
rating = db.Column(db.Float(4))
release_year = db.Column(db.Integer, db.ForeignKey('years.year_id'))
search_vector = db.Column(TSVectorType('name'))
associated_companies = db.relationship(
"Company",
secondary=association_table_game_company,
backref=db.backref("games"))
associated_genres = db.relationship("Genre",
secondary=association_table_game_genre,
backref=db.backref("games"))
associated_platforms = db.relationship(
"Platform",
secondary=association_table_game_platform,
backref=db.backref("games"))
def __init__(self,
id,
name=None,
image_url=None,
rating=0.0,
release_year=0,
search_vector=None):
self.game_id = id
self.name = name
self.image_url = image_url
self.rating = rating
self.release_year = release_year
self.search_vector = search_vector
def __repr__(self):
return '<Game: %r>' % (self.name)
class Vector(db.Model):
id = db.Column(db.Integer, primary_key=True)
constellation_id = db.Column(db.Integer, db.ForeignKey('constellation.id'))
stars = db.relationship('Star',
secondary=stars,
backref=db.backref('vectors', lazy='dynamic'))
a = db.Column(db.Integer, db.ForeignKey('star.id'))
b = db.Column(db.Integer, db.ForeignKey('star.id'))
def __init__(self, constellation_id, a, b):
self.constellation_id = constellation_id
self.a = a
self.b = b
def __repr__(self):
return "<vector: {}>".format(self.id)
def __str__(self):
return "Vector: {} to {} from constellation {}".format(
self.a, self.b, self.constellation_id)
def to_array(self):
return [self.a, self.b]
class Roles(db.Model):
__tablename__ = 'Roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(100), unique=True)
edit_date = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
emails = db.relationship('Emails',
secondary=role_email,
backref=db.backref('roles', lazy='dynamic'),
lazy='dynamic')
def __init__(self, role_name):
self.role_name = role_name
def add_email(self, email):
if not self.has_email(email):
self.emails.append(email)
def remove_email(self, email):
if self.has_email(email):
self.emails.remove(email)
def has_email(self, email):
return self.emails.filter(
Emails.email_id == email.email_id).count() > 0
class User(db.Model):
id = db.Column(db.Integer,primary_key=True)
user_name = db.Column(db.String(50))
email = db.Column(db.String(100),unique=True)
password = db.Column(db.String(80))
is_admin = db.Column(db.Boolean,default=False)
notes = db.relationship('Notes',backref=db.backref('note',lazy=True))
class Device(db.Model):
__tablename__ = 'devices'
id = db.Column(db.Integer, primary_key=True)
deviceAddress = db.Column(db.String)
name = db.Column(db.String, unique=True)
currentLat = db.Column(db.Float)
currentLng = db.Column(db.Float)
lastUpdate = db.Column(db.DateTime)
prediction = db.Column(db.String)
users = db.relationship('User',
secondary=userDevice,
backref=db.backref('device', lazy='dynamic'))
def __init__(self, deviceAddress, name):
self.deviceAddress = deviceAddress
self.name = name
def set_location(self, currentLat, currentLng):
self.currentLat = currentLat
self.currentLng = currentLng
self.lastUpdate = datetime.now()
db.session.commit()
def set_prediction(self, prediction):
self.prediction = prediction
db.session.commit()
class Section(db.Model):
#reference PERMs via 'PERMs', teach table via 'taught_by'
id = db.Column(db.Integer, primary_key=True, autoincrement=False)
sectionNum = db.Column(db.Integer)
courseID = db.Column(db.String(20), ForeignKey(Course.id))
#reference course via 'course'
course = db.relationship("Course",
backref=db.backref('sections',
order_by=sectionNum))
def __init__(self, course, sectionNum, id):
self.courseID = course
self.sectionNum = sectionNum
self.id = id
def __repr__(self):
return "<Section(sectionID='%s', courseID='%s', sectionNum ='%s')>" % (
self.id, self.courseID, self.sectionNum)
def serialize(self): #lets us serialize it!!
result = {}
for key in self.__mapper__.c.keys():
result[key] = getattr(self, key)
return result
class Event(db.Model):
__tablename__ = 'events'
event_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
details = db.Column(db.UnicodeText)
start = db.Column(db.String(80))
end = db.Column(db.String(80))
capacity = db.Column(db.Integer)
status = db.Column(db.String(80))
creater = db.Column(db.String(80))
fee = db.Column(db.Integer)
early_period = db.Column(db.Integer)
users = db.relationship('User',secondary=event_realation,
backref=db.backref('event_users_all', lazy='dynamic'))
def __init__(self,title,details,start,end,capacity,status, creater,fee, early_period):
self.title = title
self.details = details
self.start = start
self.end = end
self.capacity = capacity
self.status = status
self.creater = creater
self.fee = fee
self.early_period = early_period
def __repr__(self):
return '<Event: %r>'%self.title
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
city = db.Column(db.String(120), nullable=False)
state = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(120), nullable=False)
facebook_link = db.Column(db.String(120), nullable=False)
image_link = db.Column(db.String(), nullable=False)
website = db.Column(db.String(120), nullable=False)
seeking_venue = db.Column(db.Boolean, nullable=False)
seeking_description = db.Column(db.String(), nullable=False)
shows = db.relationship('Show',
backref="artist",
lazy=True,
cascade='all, delete')
genres = db.relationship('Genre',
secondary=artist_genres,
lazy='subquery',
backref=db.backref('artist', lazy=True))
def get_dict(self):
genres = list(map(lambda g: g.name, self.genres))
return {**self.__dict__, **{'genres': genres}}
class Role(db.Model, RoleMixin):
__table_args__ = {'extend_existing': True}
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
modified_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
name = db.Column(db.String(80), nullable=False, unique=True)
description = db.Column(db.String(255))
parents = db.relationship('Role',
secondary=roles_parents,
primaryjoin=(id == roles_parents.c.role_id),
secondaryjoin=(id == roles_parents.c.parent_id),
backref=db.backref('children', lazy='dynamic'))
def __init__(self, name, description):
RoleMixin.__init__(self)
self.name = name
self.description = description
def add_parent(self, parent):
# You don't need to add this role to parent's children set,
# relationship between roles would do this work automatically
self.parents.append(parent)
def add_parents(self, *parents):
for parent in parents:
self.add_parent(parent)
@staticmethod
def get_by_name(name):
return Role.query.filter_by(name=name).first()
class Log(db.Model):
__tablename__ = 'log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.String(100), nullable=False)
ownerId = db.Column(db.Integer, db.ForeignKey('user.id'))
owner = db.relationship('User', backref=db.backref('logs'))
class Article(db.Model):
__tablename__ = 'article'
article_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref=db.backref('articles'))
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(140))
ingredients = db.relationship('Ingredient',
secondary=ingredients,
lazy='subquery',
backref=db.backref('pages', lazy=True))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class TipoDoGasto(db.Model):
id = db.Column(db.Integer, primary_key=True)
descricao = db.Column(db.Unicode)
classificacao_id = db.Column(db.Integer,
db.ForeignKey('classificacao_do_tipo.id'))
classificacao = db.relationship('ClassificacaoDoTipo',
backref=db.backref('tipos',
lazy='dynamic'))
class Company(db.Model):
"""
This model is used to represent Company entries in our database.
Attributes:
ID - ID of the company. This variable self-increments.
Name - The name of the company.
Num_developed - The number of games this company has developed.
Image_url - The company logo from the IGDB API.
Num_published - The number of games this company has published.
Avg_rating - The average rating of all the games this company is associated with.
Year_founded - The year this company was founded.
Games - The games associated with this company. This data is retrieved using
the association table.
"""
query_class = CompanyQuery
__tablename__ = 'companies'
company_id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(50), unique=True)
num_developed = db.Column(db.Integer)
num_published = db.Column(db.Integer)
image_url = db.Column(db.String(255))
avg_rating = db.Column(db.Float)
year_founded = db.Column(db.Integer, db.ForeignKey('years.year_id'))
search_vector = db.Column(TSVectorType('name'))
associated_games = db.relationship(
"Game",
secondary=association_table_game_company,
backref=db.backref('companies'))
def __init__(self,
company_id,
name=None,
num_developed=0,
image_url="",
num_published=0,
avg_rating=0.0,
year_founded=None,
search_vector=None):
self.company_id = company_id
self.name = name
self.num_developed = num_developed
self.image_url = image_url
self.num_published = num_published
self.avg_rating = avg_rating
self.year_founded = year_founded
self.search_vector = search_vector
def __repr__(self):
return '<Company: %r>' % (self.name)
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
exif_data = db.Column(db.JSON)
tags = db.relationship('Tag', secondary=association_table, lazy='subquery',
backref=db.backref('images', lazy=True))
def add_tags(self, category_tags: Dict) -> None:
for category, tags in category_tags.items():
category_object = Category.get_or_create(category)
for tag in tags:
if tag not in [tag.name for tag in self.tags]:
tag_object = Tag.get_or_create(tag)
tag_object.category = category_object
self.tags.append(tag_object)
def update_tags(self, category_tags_to_update: Dict) -> None:
tags_to_remove = []
for current_tag in self.tags:
if current_tag.name not in flatten(category_tags_to_update.values()):
tags_to_remove.append(current_tag)
elif current_tag.category not in category_tags_to_update.keys():
tags_to_remove.append(current_tag)
[self.tags.remove(tag_to_remove) for tag_to_remove in tags_to_remove]
self.add_tags(category_tags_to_update)
db.session.add(self)
db.session.commit()
def to_json(self) -> Dict:
from server.helpers.tag_helpers import build_categorised_tags
from server.helpers.image_helpers import load_image
return {
self.id: {
'name': self.name,
'exif': self.exif_data,
"categorised_tags": build_categorised_tags(self.tags),
"location": load_image(self.name)
}
}
def __repr__(self) -> str:
return f'<Image {self.name}>'
class Ticket(db.Model):
__tablename__ = 'ticket'
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.String(20), default='OPEN')
user = db.relationship('User',
secondary=user_tickets,
lazy='subquery',
backref=db.backref('user', lazy=True,
uselist=False))
subject = db.Column(db.String(120), unique=False, nullable=False)
message = db.Column(db.String(1500))
created_on = db.Column(db.DateTime, nullable=False, default=datetime.now())
replies = db.relationship('Replies',
secondary=ticket_replies,
lazy='subquery',
backref=db.backref('replies', lazy=True))
def __repr__(self):
return "Ticket:" + self.subject
class Label(db.Model):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(50),nullable=False,unique=False)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False )
notes= db.relationship('Notes',secondary=notes_label, backref='notes')
user = db.relationship('User',backref=db.backref('label',lazy=True))
def __init__(self,name,user_id):
self.name=name
self.user_id=user_id
class Artifact(db.Model):
"""Contains a single file uploaded by a diff worker."""
id = db.Column(db.String(100), primary_key=True)
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
data = db.Column(db.LargeBinary(length=2**31))
alternate = db.Column(db.Text)
content_type = db.Column(db.String(255))
owners = db.relationship('Build', secondary=artifact_ownership_table,
backref=db.backref('artifacts', lazy='dynamic'),
lazy='dynamic')
class MailConfig(db.Model):
__tablename__ = 'mailconfig'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
fromName = db.Column(db.String(10), nullable=False)
toName = db.Column(db.String(10), nullable=False)
fromEmail = db.Column(db.String(50), nullable=False)
fromEmailKey = db.Column(db.String(30), nullable=False)
toEmail = db.Column(db.String(50), nullable=False)
ownerId = db.Column(db.Integer, db.ForeignKey('user.id'))
owner = db.relationship('User', backref=db.backref('mailconfigs'))
