class User(Model):
"""
This model holds information about a user registered
"""
__tablename__ = "user"
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80), nullable=False)
password = Column(db.String(128))
email = Column(db.String(100), nullable=False, unique=True)
date = Column(db.DateTime, default=datetime.now())
votes = db.relationship("Vote", backref=db.backref("user"))
type = Column(db.String(50), default="remote")
def __init__(self, name, email, password, _type="remote"):
"""
Initializes the user instance
"""
self.name = name
self.email = email
if password:
self.password = Bcrypt().generate_password_hash(password).decode()
self.type = _type
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<User %r>" % self.name
def to_json(self):
"""
Returns a JSON object
:return: user JSON object
"""
user_json = {"name": self.name, "email": self.email, "date": self.date}
return user_json
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
def verify_password(self, password):
"""
Verify the password
:param password: password for verification
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()
class StudentClassSchedule(db.Model):
"""tbd"""
__tablename__ = "student_class_schedule"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
student_id = db.Column(db.Integer, db.ForeignKey('student.id'), nullable=False)
class_schedule_id = db.Column(db.Integer, db.ForeignKey('class_schedule.id'), nullable=False)
# define a relationship to Student
student = db.relationship("Student",
backref=db.backref("student_class_schedule", order_by=id))
# define a relationship to Class Schedule
class_schedule = db.relationship("ClassSchedule",
backref=db.backref("student_class_schedule", order_by=id))
def __repr__(self):
"""Provide helpful representation when printed."""
return "<StudentClassSchedule student_id = {} class_schedule_id = {}>".format(self.student_id, self.class_schedule_id)
class ClassSchedule(db.Model):
"""tbd"""
__tablename__ = "class_schedule"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=True)
day_of_week = db.Column(db.String(9), nullable=False)
time = db.Column(db.Time, nullable=False)
coach_id = db.Column(db.Integer, db.ForeignKey('coach.id'), nullable=True)
coach = db.relationship("Coach",
backref=db.backref("class_schedule", order_by=id))
def __repr__(self):
"""Provide helpful representation when printed."""
return "<ClassSchedule id={} day_of_week={} time={}>".format(
self.id, self.day_of_week, self.time)
class ClassInstance(db.Model):
"""tbd"""
__tablename__ = "class_instance"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
class_schedule_id = db.Column(db.Integer,
db.ForeignKey('class_schedule.id'),
nullable=True)
date = db.Column(db.DateTime, nullable=False)
notes = db.Column(db.String(500), nullable=True)
substitute_coach_id = db.Column(db.Integer,
db.ForeignKey('coach.id'),
nullable=True)
# define a relationship to Coach
substitute_coach = db.relationship("Coach",
backref=db.backref(
"substituted_classes", order_by=id))
def __repr__(self):
"""Provide helpful representation when printed."""
return "<ClassInstance id={} date={}>".format(self.id, self.date)
class DeploymentEntity(BaseEntity):
"""Deployment entity"""
__tablename__ = "deployments"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(255), nullable=False, index=True)
name = db.Column(db.String(255), nullable=False)
status = db.Column(db.String(30), nullable=False)
modified = db.Column(db.DateTime, default=datetime.utcnow)
days_duration = db.Column(db.Integer, nullable=False)
data_url = db.Column(db.String(1000), nullable=True)
onedata_access_token = db.Column(db.String(255), nullable=True)
olinip = db.Column(db.String(50), nullable=True)
vnc_password = db.Column(db.String(255), nullable=True)
template_id = db.Column(db.Integer,
db.ForeignKey('templates.id'),
nullable=False)
template = db.relationship('TemplateEntity',
backref=db.backref('deployments', lazy=True))
def set_id(self, deployment_id: int) -> "DeploymentEntity":
self.id = deployment_id
return self
def get_id(self) -> int:
return self.id
def set_user_id(self, user_id: str) -> "DeploymentEntity":
self.user_id = user_id
return self
def get_user_id(self) -> str:
return self.user_id
def set_name(self, deployment_name: str) -> "DeploymentEntity":
self.name = deployment_name
return self
def get_name(self) -> str:
return self.name
def set_status(self, deployment_status: str) -> "DeploymentEntity":
self.status = deployment_status
return self
def get_status(self) -> str:
return self.status
def set_modified(self, modified_datetime: datetime) -> "DeploymentEntity":
self.modified = modified_datetime
return self
def get_modified(self) -> datetime:
return self.modified
def set_days_duration(self,
deployment_days_duration: int) -> "DeploymentEntity":
self.days_duration = deployment_days_duration
return self
def get_days_duration(self) -> int:
return self.days_duration
def set_data_url(self, deployment_data_url: str) -> "DeploymentEntity":
self.data_url = deployment_data_url
return self
def get_data_url(self) -> str:
return self.data_url
def set_onedata_access_token(
self, deployment_onedata_access_token: str) -> "DeploymentEntity":
self.onedata_access_token = deployment_onedata_access_token
return self
def get_onedata_access_token(self) -> str:
return self.onedata_access_token
def set_olinip(self, deployment_olinip: str) -> "DeploymentEntity":
self.olinip = deployment_olinip
return self
def get_olinip(self) -> str:
return self.olinip
def set_vnc_password(self,
deployment_vnc_password: str) -> "DeploymentEntity":
self.vnc_password = deployment_vnc_password
return self
def get_vnc_password(self) -> str:
return self.vnc_password
def set_template_id(self,
deployment_template_id: int) -> "DeploymentEntity":
self.template_id = deployment_template_id
return self
def get_template_id(self) -> int:
return self.template_id
def is_running(self) -> bool:
return self.status in const.STATUSES_RUNNING
def is_past(self) -> bool:
return not self.is_running()
def is_deleting(self) -> bool:
return self.status == const.STATUS_TO_DELETE
def to_dict(self) -> dict:
return {
"id": self.get_id(),
"user_id": self.get_user_id(),
"name": self.get_name(),
"status": self.get_status(),
"modified": self.get_modified().isoformat(),
"days_duration": self.get_days_duration(),
"data_url": self.get_data_url(),
"onedata_access_token": self.get_onedata_access_token(),
"olinip": self.get_olinip(),
"vnc_password": self.get_vnc_password(),
"template_id": self.get_template_id()
}
class User(Model):
"""
This model holds information about a user registered
"""
__tablename__ = "user"
id = Column(db.Integer, primary_key=True)
name = Column(db.String(80), nullable=False)
password = Column(db.String(128))
verification_token = Column(db.String(128), nullable=False, unique=True)
email = Column(db.String(100), nullable=False, unique=True)
date = Column(db.DateTime, default=datetime.now())
votes = db.relationship("Vote", backref=db.backref("user"))
type = Column(db.String(50), default="remote")
role = Column(db.String(10), default="user")
def __init__(self, name, email, password, role="user", _type="remote"):
"""
Initializes the user instance
"""
self.name = name
self.email = email
self.verification_token = User.generate_token()
if password:
self.password = User.generate_password_hash(password)
self.type = _type
self.role = role
def __repr__(self):
"""
Returns the object reprensentation
"""
return "<User %r>" % self.name
def to_json(self):
"""
Returns a JSON object
:return: user JSON object
"""
user_json = {"name": self.name, "email": self.email, "date": self.date}
return user_json
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_user_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_verification_token(cls, verification_token):
return cls.query.filter_by(
verification_token=verification_token).first()
@classmethod
def verify_admin(cls, email):
"""
Verify admin role
"""
try:
query = cls.query.filter_by(email=email, role="admin").first()
return query
except Exception as err:
print("Error: ", err)
@staticmethod
def generate_token():
"""
Returns a random token
"""
return uuid4().hex
@staticmethod
def generate_password_hash(password):
"""
Returns hash of password
"""
return Bcrypt().generate_password_hash(password).decode()
def verify_password(self, password):
"""
Verify the password
:param password: password for verification
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""
Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()