class TASK(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
desc = db.Column(db.Text)
ctime = db.Column(db.DateTime, nullable=False)
wtime = db.Column(db.DateTime, nullable=False)
etime = db.Column(db.DateTime)
status = db.Column(db.Integer)
color = db.Column(db.String(10), default='#FFF')
user_id = db.Column(db.Integer, db.ForeignKey('USER.id'))
tasks = db.relationship('USER', backref='task')
class Playlist(db.Model):
"""
Connects the spotify user with the playlist
"""
id = db.Column(db.Integer, primary_key=True)
spotify_id = db.Column(db.String(length=64), nullable=False, unique=True)
spotify_user = db.Column(db.Integer,
db.ForeignKey(SpotifyUser.id, ondelete="CASCADE"))
max_song_length = db.Column(db.BigInteger, nullable=False, default=0)
__mapper_args__ = {"order_by": id}
class User(db.Model, UserMixin):
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=True)
email = db.Column(db.String(120), unique=True, nullable=True)
image_file = db.Column(db.String(20), nullable=True, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
#User dpeneds on Employee
emp_id = db.Column(db.String(20), db.ForeignKey('employee.emp_id'), nullable=False)
def __repr__(self):
return f"User('{self.id}','{self.username}','{self.email}', '{self.image_file}, '{self.password}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Report(db.Model):
id = db.Column(db.Integer, primary_key=True)
tms = db.Column(db.DateTime, index=True, default=datetime.now)
id_server = db.Column(db.Integer, db.ForeignKey('server.id'))
# id_agent = db.Column(db.Integer, db.ForeignKey('agent.id'))
agent = db.Column(db.String(50))
status = db.Column(db.String(20))
desc = db.Column(db.String())
def __repr__(self):
return f'<Report {self.agent} {self.status} {self.tms} >'
class UserExtension(db.Model):
"""SqlAlchemy model that holds all extensions to a User object
Attributes
----------
user_id : int
id of User
location_id : int
foreign key of location relation
location : Location
location relation
"""
__tablename__ = 'user_extension_association_table'
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
location_id = db.Column(db.Integer,
db.ForeignKey('location.id'),
primary_key=True)
location = db.relationship(Location)
class UploadedResource(ModelBase):
"""
UploadedResource model handles documents, files and photos uploaded to Amazon S3.
"""
__tablename__ = 'uploaded_resource'
filename = db.Column(db.String)
file_type = db.Column(db.String)
user_filename = db.Column(db.String)
reference = db.Column(db.String)
credit_transfer_id = db.Column(db.Integer,
db.ForeignKey("credit_transfer.id"))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
kyc_application_id = db.Column(db.Integer,
db.ForeignKey('kyc_application.id'))
@hybrid_property
def file_url(self):
return get_file_url(self.filename)
class SubSubCategory(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(15))
sub_category_id = db.Column(db.Integer, db.ForeignKey('sub_category.id'))
# To query for all products for a given sub_cat.
# products = db.relationship('Product', backref='product', lazy='dynamic')
products = db.relationship(
'Product', backref='sub_sub_category', lazy='dynamic')
def __repr__(self):
return '<SubSubCategory {}>'.format(self.name)
class SiteModel(TimestampMixinModel, ObserverMixinModel, db.Model):
"""Table des sites"""
__tablename__ = "t_sites"
__table_args__ = {"schema": "gnc_sites"}
id_site = 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),
nullable=False)
program = relationship("ProgramsModel")
name = db.Column(db.String(250))
id_type = db.Column(db.Integer,
db.ForeignKey(SiteTypeModel.id_typesite),
nullable=False)
site_type = relationship("SiteTypeModel")
geom = db.Column(Geometry("POINT", 4326))
def __repr__(self):
return "<Site {0}>".format(self.id_site)
class QuestionModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text(), nullable=False)
marks = db.Column(db.Integer, nullable=False)
course_id = db.Column(db.Integer,
db.ForeignKey("course_model.id"),
nullable=False)
options = db.relationship("OptionModel", backref="question", lazy=True)
def __repr__(self):
return f"{self.id} | {self.text} | {self.options}"
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
# has a date of being posted
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
elderly_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
task_doer_id = db.Column(db.Integer, db.ForeignKey('user.id'))
elderly = db.relationship("User", foreign_keys=[elderly_id])
task_doer = db.relationship("User", foreign_keys=[task_doer_id])
def to_dict(self):
return {
"id": self.id,
"title": self.title,
"date_posted": self.date_posted,
"content": self.content,
"elderly_id": self.elderly_id,
"task_doer_id": self.task_doer_id,
"elderly_name": self.elderly.name,
"task_doer_name": (self.task_doer.name if self.task_doer else None)
}
@staticmethod
def task_to_dict(task):
return {
"id": task.id,
"title": task.title,
"date_posted": task.date_posted,
"content": task.content,
"elderly_id": task.elderly_id,
"task_doer_id": task.task_doer_id,
"elderly_name": task.elderly.name,
"task_doer_name": (task.task_doer.name if task.task_doer else None)
}
class Pair(db.Model):
'''
비교쌍 관리 테이블
'''
__tablename__ = 'pair_tbl'
pairID = db.Column(db.Integer, primary_key=True, autoincrement=True)
'''비교쌍 번호 '''
originID = db.Column(db.Integer,
db.ForeignKey('origin_tbl.originID'),
nullable=False)
'''원본 번호 '''
compID = db.Column(db.Integer,
db.ForeignKey('compare_tbl.compID'),
nullable=False)
'''비교본 번호 '''
projID = db.Column(db.Integer,
db.ForeignKey('project_tbl.projID'),
nullable=False)
'''프로젝트 번호 '''
similarity = db.Column(db.Float, default=0)
'''유사도'''
modifyDate = db.Column(db.TIMESTAMP, nullable=True)
'''수정날짜'''
def __init__(self, originID, compID, projID):
self.originID = originID
self.compID = compID
self.projID = projID
def __repr__(self):
return '<Pair %r>' % self.pairID
def serialize(self, originFile, compareFile):
return {
'pairID': self.pairID,
'originID': self.originID,
'originFile': originFile,
'compID': self.compID,
'compareFile': compareFile,
'similarity': self.similarity,
'modifyDate': self.modifyDate
}
class Game(db.Model):
__tablename__ = 'games'
id = db.Column(db.Integer, primary_key=True)
igdb_id = db.Column(db.BigInteger, nullable=False)
name = db.Column(db.String(255), nullable=False)
summary = db.Column(db.Text)
rating = db.Column(db.SmallInteger)
series_id = db.Column(db.Integer, db.ForeignKey('series.id'))
series = db.relationship('Series',
backref=db.backref('series', uselist=False))
developer_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
developer = db.relationship('Company',
backref=db.backref('developer', uselist=False))
publisher_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
publisher = db.relationship('Company',
backref=db.backref('publisher', uselist=False))
release_date = db.Column(db.BigInteger)
genres = db.relationship('Genres', secondary=games_genres)
cover = db.Column(db.String(255))
screenshots = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.now())
class Registry(db.Model, UserMixin):
__tablename__ = 'registro'
id_registro = db.Column(db.Integer,
db.ForeignKey('especialista.id_especialista'),
primary_key=True)
fecha_registro = db.Column(db.DateTime, nullable=True)
specialist = db.relationship("Specialist", back_populates="registry")
def __repr__(self):
return f'<Registry {self.id_registro}, {self.fecha_registro}>'
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
def __repr__(self):
return "<Bookmark {}>".format(self.url)
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(250))
application_id = db.Column(db.Integer, db.ForeignKey('application.id'))
def __init__(self, args):
self.description = args['description']
self.application_id = args['application_id']
def __repr__(self):
return '<Note {}>'.format(self.id)
class User_LevelRecord(db.Model):
__tablename__ = 'users_levelRecord'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
levelID = db.Column(db.Integer, db.ForeignKey('levels.levelID'), nullable=False)
account = db.Column(db.String(12), db.ForeignKey('users.account'), nullable=False)
record_time = db.Column(db.Integer, nullable=False)
levelsMsg = db.relationship("Level", back_populates="usrRecoed")
def __init__(self, levelID, account, record_time):
self.levelID = levelID
self.account = account
self.record_time = record_time
def __repr__(self):
users_levelRecord = '<Level_Props> '
users_levelRecord += 'id: %r\n' % (self.id)
users_levelRecord += 'levelID: %r\n' % (self.levelID)
users_levelRecord += 'account: %r\n' % (self.account)
users_levelRecord += 'record_time: %r\n' % (self.record_time)
return users_levelRecord
class Task(db.Model):
__tablename__ = 'task'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(30), nullable=False)
status = db.Column(db.Integer, nullable=False, default=0)
from_user_id = db.Column(db.Integer, nullable=False)
time = db.Column(db.String(10),
nullable=False,
default=str(datetime.now().strftime('%Y-%m-%d')))
ownerId = db.Column(db.Integer, db.ForeignKey('user.id'))
owner = db.relationship('User', backref=db.backref('tasks'))
class KUK(db.Model):
__tablename__ = 'KUK'
idKUK = db.Column(db.Integer, primary_key=True, autoincrement=True)
Pertanyaan = db.Column(db.String(255), nullable=False)
elemen = db.Column(db.Integer, db.ForeignKey('ElemenKompetensi.idElemen'))
def __init__(self, Pertanyaan, elemen):
self.Pertanyaan = Pertanyaan
self.elemen = elemen
def __repr__(self):
return self.idKUK
class CourseQuestionAnswer(db.Model):
__tablename__ = 'course_question_answer'
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column(db.Integer, db.ForeignKey('course.id'))
question = db.Column(db.String(1000), nullable=False)
answer = db.Column(db.String(1000), nullable=False)
course = db.relationship("Course",
back_populates="course_question_answers")
def __repr__(self):
return f"CourseQuestionAnswer[course_id, question, answer]('{self.course_id}, {self.question}, {self.answer}')"
class Record(db.Model):
__tablename__ = "record"
record_id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey("patient.patient_id"),
nullable=False)
date = db.Column(db.Date, nullable=False, default=datetime.date.today)
stage = db.Column(db.String(20), nullable=False)
appointments = db.relationship('Appointment', backref='record')
def __repr__(self):
return f"<Record %{self.record_id} {self.patient_id} {self.date}>"
class UserBettingHistory(db.Model):
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey(Users.id))
fixture_id = db.Column(db.Integer, db.ForeignKey(Fixtures.id))
user = db.relationship(Users,
backref=db.backref('user_betting_history',
uselist=True,
cascade='delete,all'))
fixture = db.relationship(Fixtures,
backref=db.backref('user_betting_history',
uselist=True,
cascade='delete,all'))
def my_dict(self):
return {
"id": self.id,
"user_id": self.user_id,
"fixture_id": self.fixture_id,
"score": self.score
}
class User_Props(db.Model):
__tablename__ = 'users_props'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
account = db.Column(db.String(12), db.ForeignKey('users.account'), nullable=False)
propsID = db.Column(db.Integer, db.ForeignKey('props.propsID'), nullable=False)
propsNumber = db.Column(db.Integer, nullable=False)
propMsg = db.relationship("Prop", back_populates="usersMsg")
def __init__(self, account, propsID, propsNumber):
self.account = account
self.propsID = propsID
self.propsNumber = propsNumber
def __repr__(self):
user_props = '<User_Props> '
user_props += 'id: %r\n' % (self.id)
user_props += 'account: %r\n' % (self.account)
user_props += 'propsID: %r\n' % (self.propsID)
user_props += 'propsNumber: %r\n' % (self.propsNumber)
return user_props
class Bot(db.Model):
__tablename__ = 'bots'
id = db.Column(db.Integer, primary_key=True)
team_id = db.Column(db.Integer, db.ForeignKey('teams.id'), nullable=False)
team = db.relationship("Team", foreign_keys=team_id, back_populates="bots")
name = db.Column(db.String(128), nullable=False)
s3_key = db.Column(db.String(256), nullable=False)
def __init__(self, team, name, s3_key):
self.team = team
self.name = name
self.s3_key = s3_key
class Reading(db.Model):
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Float, nullable=False)
sensor_id = db.Column(db.Integer, db.ForeignKey('sensor.id'))
created_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self, value, sensor_id):
self.value = value
self.sensor_id = sensor_id
def __repr__(self):
return '<Reading %r>' % self.id
class Journey(db.Model):
""" Journey data schema """
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
journey_name = db.Column(db.String(128), index=True)
start_location = db.Column(db.String(128), index=True)
start_date = db.Column(db.DateTime, index=True)
end_date = db.Column(db.DateTime, index=True)
stops = db.relationship('Stop', backref='author', lazy='dynamic')
def __repr__(self):
return "ID: {} | User ID: {} | Start Date: {} | End Date: {}".format(self.id, self.user_id, self.start_date, self.end_date)
class UserRightsModel(TimestampMixinModel, db.Model):
"""Table de gestion des droits des utilisateurs de GeoNature-citizen"""
__tablename__ = "t_users_rights"
__table_args__ = {"schema": "gnc_core"}
id_user_right = db.Column(db.Integer, primary_key=True)
id_user = db.Column(db.Integer,
db.ForeignKey(UserModel.id_user),
nullable=False)
id_module = db.Column(db.Integer,
db.ForeignKey(ModulesModel.id_module),
nullable=True)
id_program = db.Column(db.Integer,
db.ForeignKey(ProgramsModel.id_program,
ondelete="CASCADE"),
nullable=True)
right = db.Column(db.String(150), nullable=False)
create = db.Column(db.Boolean(), default=False)
read = db.Column(db.Boolean(), default=False)
update = db.Column(db.Boolean(), default=False)
delete = db.Column(db.Boolean(), default=False)
class Stop(db.Model):
""" Stop data schema """
id = db.Column(db.Integer, primary_key=True)
journey_id = db.Column(db.Integer, db.ForeignKey('journey.id'))
stop_name = db.Column(db.String(128), index=True)
arrival_date = db.Column(db.DateTime, index=True)
departure_date = db.Column(db.DateTime, index=True)
notes = db.Column(db.Text, index=True)
itinerary = db.Column(db.LargeBinary)
def __repr__(self):
return "ID: {} | Stop: {}".format(self.id, self.stop_name)
class DeviceInfo(ModelBase):
__tablename__ = 'device_info'
serial_number = db.Column(db.String)
unique_id = db.Column(db.String)
brand = db.Column(db.String)
model = db.Column(db.String)
height = db.Column(db.Integer)
width = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
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),
nullable=False)
cd_nom = db.Column(db.Integer,
db.ForeignKey(Taxref.cd_nom),
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))
