class Timeframes(db.Model):
__tablename__ = 'timeframes'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime(), nullable=False)
workspace = db.Column(db.String(30), nullable=False,)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all(cls, workspace):
return cls.query.filter_by(workspace=workspace).all()
@classmethod
def get_for_this_workspace(cls, workspace, user_id):
return cls.query.filter_by(workspace=workspace, user_id=user_id).first()
@classmethod
def get_for_update(cls, workspace, user_id):
return cls.query.filter(cls.workspace == workspace, cls.user_id != user_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
adminstatus = db.Column(db.Integer, default=0)
password = db.Column(db.String(200))
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
class Task(db.Model):
__tablename__ = 'task'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(256))
priority = db.Column(db.Integer, nullable=False)
type = db.Column(db.String(32), nullable=False)
status = db.Column(db.String(32), nullable=False)
due_date = db.Column(db.Date())
start = db.Column(db.DateTime())
end = db.Column(db.DateTime())
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all(cls, user_id, type):
return cls.query.filter_by(user_id=user_id, type=type)
@classmethod
def get_by_id(cls, task_id):
return cls.query.filter_by(id=task_id).first()
@classmethod
def delete(cls, task_id):
cls.query.filter_by(id=task_id).delete()
db.session.commit()
def save(self):
db.session.add(self)
db.session.commit()
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
sheets = db.relationship('Sheet', backref='user')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Event(db.Model):
__table_name__ = "event"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
is_publish = db.Column(db.Boolean(), default=False)
event_date = db.Column(db.String(100))
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(
db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now(),
)
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
class Workspace(db.Model):
__tablename__ = 'workspace'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
size = db.Column(db.Integer())
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def get_all(cls):
return cls.query.all()
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True) # generoitu
username = db.Column(db.String(80), nullable=False,
unique=True) # käyttäjän nimi
email = db.Column(db.String(200), nullable=False,
unique=True) # sähköpostiosoite
password = db.Column(db.String(200)) # salasana
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
class Attendance(db.Model):
__tablename__ = 'event_attendance'
id = db.Column(db.Integer, primary_key=True)
meetup_user_id = db.Column(db.String())
event_id = db.Column(db.Integer,
db.ForeignKey('events.id'),
nullable=False)
did_attend = db.Column(db.Boolean())
did_rsvp = db.Column(db.Boolean())
title = db.Column(db.String())
event_host = db.Column(db.String())
rsvp_date = db.Column(db.DateTime())
date_joined_group = db.Column(db.DateTime())
def __init__(self, meetup_user_id, event_id, did_attend, did_rsvp, title,
event_host, rsvp_date, date_joined_group):
self.meetup_user_id = meetup_user_id
self.event_id = event_id
self.did_attend = did_attend
self.did_rsvp = did_rsvp
self.title = title
self.event_host = event_host
self.rsvp_date = rsvp_date
self.date_joined_group = date_joined_group
def __repr__(self):
return '<meetup_user_id {}>'.format(self.meetup_user_id)
class Sample(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp_start = db.DateTime(default=datetime.utcnow)
timestamp_end = db.DateTime()
header = db.Column(JSON)
data_captured = db.Column(JSON)
collect = db.relationship('Collect', backref='sample', lazy=True)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(200), nullable=False, unique=True)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
events = db.relationship(
'Event',
secondary=EventSignup.__tablename__,
back_populates='users',
)
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
class Personel(db.Model):
__tablename__ = 'personel'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
firstname = db.Column(db.String(80))
lastname = db.Column(db.String(80))
email = db.Column(db.String(200), nullable=False, unique=True)
phone_number = db.Column(db.String(200))
role = db.Column(db.String(80))
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
facilities = db.relationship('Facility', backref='personel')
animals = db.relationship('Animal', backref='personel')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
class Client(db.Model):
__tablename__ = 'client'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200))
admin = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
reservation = db.relationship('Reservation', backref='client')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_admin(cls, admin):
return cls.query.filter_by(admin=admin).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Reservation(db.Model):
__tablename__ = 'reservation'
id = db.Column(db.Integer, primary_key=True)
client_id = db.Column(db.Integer(), db.ForeignKey("client.id"))
workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id"))
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
@classmethod
def get_all_by_client(cls, client_id):
return cls.query.filter_by(client_id=client_id).all()
@classmethod
def get_by_id(cls, reservation_id):
return cls.query.filter_by(id=reservation_id).first()
@classmethod
def get_by_client(cls, client_id):
return cls.query.filter_by(client_id=client_id).first()
@classmethod
def get_by_workspace(cls, workspace_id):
return cls.query.filter_by(workspace_id=workspace_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Reservation(db.Model):
__tablename__ = 'reservation'
id = db.Column(db.Integer, primary_key=True) # generoitu
user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) # varauksen tekijän id
workspace_id = db.Column(db.Integer(), db.ForeignKey("workspace.id")) # työtilan id
# default lähinnä testinä, todellisuudessa ei tietty voi varata tilaa ilman aikaa
start_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # aloitusaika
# defaultend = db.func.now() + timedelta(hours=1)
# server_default= defaultend
# ilmesesti sqalkemian timestamp-hässäkkä ei ole yhteensopiva pythonin oman timestamp-hässäkän kanssa
end_time = db.Column(db.DateTime(), nullable=False, server_default=db.func.now()) # lopetusaika
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(username=id).first()
@classmethod
def get_by_user_id(cls, user_id):
return cls.query.filter_by(email=user_id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.Integer)
directions = db.Column(db.String(1000))
is_publish = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all_published(cls):
return cls.query.filter_by(is_publish=True).all()
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
items = db.relationship("Item", backref="user")
rating = db.Column(db.Float())
profile_picture = db.Column(db.String(300), default=None)
is_admin = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(), nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
#Funktio joka hakee käyttäjänimen mukaan
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
#Funktio joka hakee sähköpostin mukaan
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
# Funktio joka hakee käyttäjän id.n mukaan
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save(self):
db.session.add(self)
db.session.commit()
class Teacher(db.Model):
__tablename__ = 'teacher'
teacher_id = db.Column(db.Integer, primary_key=True)
teacher_username = db.Column(db.String(80), nullable=False, unique=True)
teacher_password = db.Column(db.String(200))
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
reservations_A = db.relationship('Reservation_A', backref='teacher')
reservations_B = db.relationship('Reservation_B', backref='teacher')
reservations_C = db.relationship('Reservation_C', backref='teacher')
reservations_D = db.relationship('Reservation_D', backref='teacher')
@classmethod
def get_by_teacher_username(cls, teacher_username):
return cls.query.filter_by(teacher_username=teacher_username).first()
def save(self):
db.session.add(self)
db.session.commit()
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(200), nullable=False)
password = db.Column(db.String(200))
is_active = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(
db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now(),
)
recipes = db.relationship("Recipe", backref="user")
avatar_image = db.Column(db.String(100), default=None)
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_by_id(cls, user_id):
return cls.query.get_or_404(user_id)
class EventSignup(db.Model):
__tablename__ = 'event_signups'
event_id = db.Column(db.Integer,
db.ForeignKey('events.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
@classmethod
def find_by_event_and_user(cls, event_id, user_id):
return cls.query \
.filter(EventSignup.event_id == event_id) \
.filter(EventSignup.user_id == user_id).first()
def delete(self):
db.session.delete(self)
db.session.commit()
class Space(db.Model):
__tablename__ = 'space'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False)
capacity = db.Column(db.Integer(), nullable=False)
created_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now())
updated_at = db.Column(db.DateTime(), nullable=False, server_default=db.func.now(), onupdate=db.func.now())
@classmethod
def get_by_id(cls, space_id):
return cls.query.filter_by(id=space_id).first()
@classmethod
def get_by_capacity(cls, space_capacity):
return cls.query.filter_by(capacity=space_capacity).all()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_spaces(cls):
return cls.query.all()
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.String(200))
directions = db.Column(db.String(100))
is_publish = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
update_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
cover_image = db.Column(db.String(100), default=None)
ingredients = db.Column(db.String(1000))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
@classmethod
def get_all_published(cls, q, page, per_page, sort, order):
keyword = f'%{q}%'
if order == 'asc':
sort_logic = asc(getattr(cls, sort))
else:
sort_logic = desc(getattr(cls, sort))
return cls.query.filter(or_(
cls.name.ilike(keyword),
cls.description.ilike(keyword),
cls.ingredients.ilike(keyword)),
cls.is_publish.is_(True)). \
order_by(sort_logic).paginate(page=page, per_page=per_page, max_per_page=20)
@classmethod
def get_all_by_user(cls, user_id, page, per_page, visibility='public'):
query = cls.query.filter_by(user_id=user_id)
if visibility == 'public':
query = cls.query.filter_by(user_id=user_id, is_publish=True)
elif visibility == 'private':
query = cls.query.filter_by(user_id=user_id, is_publish=False)
return query.order_by(desc(cls.created_at)).paginate(page=page,
per_page=per_page,
max_per_page=20)
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
user_id = db.Column(db.Integer, nullable=False)
start_time = db.Column(db.DateTime(), nullable=True)
end_time = db.Column(db.DateTime(), nullable=True)
code = db.Column(db.Text(), nullable=False)
shots = db.Column(db.Integer, nullable=False)
schema = db.Column(db.Text(), nullable=True)
status = db.Column(db.Enum(TaskStatusEnum), nullable=False)
response = db.Column(db.JSON(), nullable=True)
cost = db.Column(DECIMAL(precision=6, scale=2,
unsigned=True), nullable=True)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
firstname = db.Column(db.String(80), nullable=True, unique=False)
lastname = db.Column(db.String(80), nullable=True, unique=False)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
is_active = db.Column(db.Boolean, default=False)
#roles = db.relationship('Role', backref='user')
roles = db.relationship('Role', backref='user', lazy=True)
# https://docs.sqlalchemy.org/en/13/orm/loading_relationships.html
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
# not yet used
@property
def data(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'roles':
list(map(lambda k: {
'id': k.id,
'name': k.name
}, user.roles)),
}
def save(self):
db.session.add(self)
db.session.commit()
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(200))
num_of_servings = db.Column(db.Integer)
cook_time = db.Column(db.Integer)
directions = db.Column(db.String(1000))
is_publish = db.Column(db.Boolean(), default=False)
cover_image = db.Column(db.String(100), default=None)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
updated_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now(),
onupdate=db.func.now())
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
@classmethod
def get_all_published(cls, page, per_page):
return cls.query.filter_by(is_publish=True).order_by(
desc(cls.created_at)).paginate(page=page, per_page=per_page)
@classmethod
def get_all_by_user(cls, user_id, page, per_page, visibility='public'):
query = cls.query.filter_by(user_id=user_id)
if visibility == 'public':
query = cls.query.filter_by(user_id=user_id, is_publish=True)
elif visibility == 'private':
query = cls.query.filter_by(user_id=user_id, is_publish=False)
return query.order_by(desc(cls.created_at)).paginate(page=page,
per_page=per_page)
@classmethod
def get_by_id(cls, recipe_id):
return cls.query.filter_by(id=recipe_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Show(db.Model):
__tablename__ = 'Show'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime(), nullable=False)
venue_id = db.Column(db.Integer, db.ForeignKey('Venue.id'), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey('Artist.id'), nullable=False)
class PhoneAlarm(BaseModel):
__tablename__ = "phone_alarm"
phone_id = db.Column(db.CHAR(36),
db.ForeignKey("phone.pid"),
primary_key=True)
alarm_id = db.Column(db.Integer,
db.ForeignKey("alarm.aid"),
primary_key=True)
timestamp = db.Column(db.DateTime(), nullable=True)
status = db.Column(db.BOOLEAN, nullable=True)
alarm = relationship("Alarm", back_populates="phones")
phone = relationship("Phone", back_populates="alarms")
def serialize(self):
return {
"pid":
self.phone_id,
"aid":
self.alarm_id,
"status":
self.status,
"timestamp":
re.sub('[-:+]', '', self.timestamp.isoformat()) +
'Z' if self.timestamp is not None else None
}
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(200), nullable=False, unique=True)
password = db.Column(db.String(200), nullable=False)
is_turkuamk = db.Column(db.Boolean(), default=False)
is_admin = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
reservations = db.relationship('Reservation', backref='user')
timeframes = db.relationship('Timeframes', backref='user')
@classmethod
def get_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def get_by_id(cls, user_id):
return cls.query.filter_by(id=user_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
id = db.Column(db.String(80), primary_key=True, nullable=False)
# 1(Organisation)-to-many(User)
org_id = db.Column(db.String(80),
db.ForeignKey('organisation.id'),
nullable=False)
username = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
password = db.Column(db.String(256), nullable=False)
name = db.Column(db.String(120), nullable=False)
user_type = db.Column(db.Enum(UserType), nullable=False)
created_at = db.Column(db.DateTime(), nullable=False)
# 1(User)-to-Many(ProjectManager)
project_managers = db.relationship('ProjectManager', backref='user')
labels = db.relationship('Label', backref='user',
lazy=True) # 1(User)-to-Many(Label)
def __repr__(self):
return f"<User {self.id} | {self.username} ({self.name}) ({self.email}) | Organisation : {self.org_id}>"
def to_response(self):
return {
"orgId": self.org_id,
"username": self.username,
"email": self.email,
"userType": self.user_type.name,
"name": self.name,
"id": self.id,
"created_at": self.created_at
}
class Reservation(db.Model):
__tablename__ = 'reservation'
id = db.Column(db.Integer(), primary_key=True)
time = db.Column(db.Date(), nullable=False)
user_id = db.Column(db.Integer())
space_id = db.Column(db.Integer(), nullable=False)
created_at = db.Column(db.DateTime(),
nullable=False,
server_default=db.func.now())
@classmethod
def get_all_reservations(cls):
return cls.query.all()
@classmethod
def get_by_id(cls, reservation_id):
return cls.query.filter_by(id=reservation_id).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
@classmethod
def get_all_by_space_id(cls, space_id):
return cls.query.filter_by(space_id=space_id).all()
class Label(db.Model):
# 1(Task)-to-Many(Label)
task_id = db.Column(db.String(80),
db.ForeignKey('task.id'),
primary_key=True,
nullable=False)
# 1(Task)-to-Many(User)
user_id = db.Column(db.String(80),
db.ForeignKey('user.id'),
primary_key=True,
nullable=False)
label_data = db.Column(db.JSON(), nullable=False) # JSON
created_at = db.Column(db.DateTime(), nullable=False)
def __repr__(self):
return f"<Label | task_id : {self.task_id} | user_id : {self.user_id}>"
def to_response(self):
return {
"task_id": self.task_id,
"user_id": self.user_id,
"label_data": self.label_data,
"created_at": self.created_at
}
