class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(24), unique=True, nullable=False)
nickname = db.Column(db.String(24))
location = db.Column(db.String)
password = db.Column(db.String(160), nullable=False)
recovery_token = db.Column(db.String(160))
email = db.Column(db.String(64), nullable=False)
notes = db.Column(db.Text)
coins = db.Column(db.Integer)
stardust = db.Column(db.Integer)
buddy_pokemon_id = db.Column(db.Integer, db.ForeignKey('user_pokemon.id'))
bag_size = db.Column(db.Integer)
pokemon_storage_size = db.Column(db.Integer)
team_id = db.Column(db.Integer, db.ForeignKey('team.id'))
created = db.Column(db.TIMESTAMP(timezone=True), server_default=db.func.now())
last_modified = db.Column(db.TIMESTAMP(timezone=True), onupdate=db.func.now())
pokemon = db.relationship('UserPokemon', primaryjoin='User.id==UserPokemon.user_id')
team = db.relationship('Team')
def __repr__(self):
return repr_gen(self, ['username', 'nickname', 'location', 'email', 'notes', 'coins', 'stardust',
'buddy_pokemon_id', 'bag_size', 'pokemon_storage_size', 'team_id', 'created',
'last_modified'])
class Order(BaseModel):
state = db.Column(db.Integer, default=ORDER_PENDING)
expected_time_arrival = db.Column(db.DateTime)
orderitems = db.relationship("OrderItem", backref="order")
def total_price(self):
if not self.orderitems:
return 0
return sum([
orderitem.item.price * orderitem.quantity
for orderitem in self.orderitems
])
def serializable(self):
return {
'id': self.id,
'state': self.state,
'total_price': self.total_price()
}
@classmethod
def find_by_restaurant_id(cls, restaurant_id):
result = cls.query.filter(cls.restaurant_id == restaurant_id)
if result.count() > 0:
return [order.serializable() for order in result]
return []
class User(BaseModel):
email = db.Column(db.String(140), index=True, unique=True)
name = db.Column(db.String(140), index=True)
phone = db.Column(db.String(140))
password_hash = db.Column(db.String(128))
activated_on = db.Column(db.DateTime)
name = db.Column(db.String(140), nullable=True)
profile_url = db.Column(db.String(220), nullable=True)
reset_pw_token = db.Column(db.String(70), nullable=True)
is_admin = db.Column(db.Boolean(), default=False)
manages = db.relationship("Restaurant",
secondary=restaurants_managers,
back_populates='managers')
def is_activated(self):
return self.activated_on is not None
def is_manager_of(self, restaurant):
return restaurant.id in [rst.id
for rst in self.manages]
def activate(self, token):
if self.is_activated():
return True
try:
user_email = jwt.decode(token,
current_app.config['JWT_SECRET_KEY'],
algorithms=current_app.config['JWT_ALG']
)['user_email']
if user_email == self.email:
self.activated_on = datetime.utcnow()
return True
except jwt.ExpiredSignature:
# TODO: log this
return False
except jwt.InvalidTokenError:
# TODO: log this
return False
return False
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def serializable(self):
return {'id': self.id,
'name': self.name,
'email': self.email}
@classmethod
def find_by_email(cls, email):
result = cls.query.filter(cls.email == email)
if result.count() == 1:
return result.first()
return None
def __repr__(self):
return '<User {}>'.format(self.email)
class Restaurant(BaseModel):
name = db.Column(db.String(140), index=True, nullable=False)
cname = db.Column(db.String(50), unique=True, nullable=False)
address = db.Column(db.String(140))
phone = db.Column(db.String(20))
image_url = db.Column(db.String(140))
url = db.Column(db.String(140))
managers = db.relationship("User",
secondary=restaurants_managers,
back_populates='manages')
def serializable(self):
return {
'id': self.id,
'address': self.address,
'image_url': self.image_url,
'url': self.url,
'cname': self.cname,
'name': self.name
}
@classmethod
def find_by_cname(cls, cname):
result = cls.query.filter(cls.cname == cname)
if result.count() == 1:
return result.first()
return None
def __repr__(self):
return '<Restaurant {}>'.format(self.name)
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 Pokemon(db.Model):
__tablename__ = 'pokemon'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
height = db.Column(db.Numeric(5, 2))
weight = db.Column(db.Numeric(5, 2))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False)
stamina = db.Column(db.Integer, nullable=False)
attack = db.Column(db.Integer, nullable=False)
defense = db.Column(db.Integer, nullable=False)
cp_gain = db.Column(db.Numeric(5, 2), nullable=False)
cp_max = db.Column(db.Integer, nullable=False)
buddy_distance = db.Column(db.Numeric(5, 2), nullable=False)
fast_attacks = db.relationship('Attack', secondary='pokemon_attack',
primaryjoin='and_(Pokemon.id==PokemonAttack.pokemon_id, '
'Attack.attack_speed_id==1)')
charge_attacks = db.relationship('Attack', secondary='pokemon_attack',
primaryjoin='and_(Pokemon.id==PokemonAttack.pokemon_id, '
'Attack.attack_speed_id==2)')
category = db.relationship('Category')
egg = db.relationship('Egg', secondary='pokemon_egg', back_populates='pokemon')
evolves_to = db.relationship('Pokemon', secondary='pokemon_evolution', back_populates='evolves_from',
primaryjoin='Pokemon.id==PokemonEvolution.from_pokemon_id',
secondaryjoin='Pokemon.id==PokemonEvolution.to_pokemon_id')
evolves_from = db.relationship('Pokemon', secondary='pokemon_evolution', back_populates='evolves_to',
primaryjoin='Pokemon.id==PokemonEvolution.to_pokemon_id',
secondaryjoin='Pokemon.id==PokemonEvolution.from_pokemon_id')
types = db.relationship('Type', secondary='pokemon_type', back_populates='pokemon')
def __repr__(self):
return repr_gen(self, ['name', 'description', 'height', 'weight', 'category_id',
'stamina', 'attack', 'defense', 'cp_gain', 'cp_max', 'buddy_distance'])
class Attack(db.Model):
__tablename__ = 'attack'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
type_id = db.Column(db.Integer, db.ForeignKey('type.id'), nullable=False)
power = db.Column(db.Integer, nullable=False)
energy = db.Column(db.Integer, nullable=False)
cooldown_time = db.Column(db.Numeric(5, 2), nullable=False)
attack_speed_id = db.Column(db.Integer, db.ForeignKey('attack_speed.id'), nullable=False)
pokemon = db.relationship('Pokemon', secondary='pokemon_attack', back_populates='attacks')
speed = db.relationship('AttackSpeed', back_populates='attacks')
type = db.relationship('Type')
def __repr__(self):
return repr_gen(self, ['name', 'description', 'type_id', 'power', 'energy', 'cooldown_time', 'attack_speed_id'])
class Type(db.Model):
__tablename__ = 'type'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
pokemon = db.relationship('Pokemon', secondary='pokemon_type', back_populates='types')
strong_against = db.relationship('Type', secondary='type_effectiveness',
primaryjoin='Type.id==TypeEffectiveness.from_type_id',
secondaryjoin='and_(Type.id==TypeEffectiveness.to_type_id, '
'TypeEffectiveness.effectiveness_id==2)')
weak_against = db.relationship('Type', secondary='type_effectiveness',
primaryjoin='Type.id==TypeEffectiveness.from_type_id',
secondaryjoin='and_(Type.id==TypeEffectiveness.to_type_id, '
'TypeEffectiveness.effectiveness_id==1)')
def __repr__(self):
return repr_gen(self, ['name', 'description'])
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 Egg(db.Model):
__tablename__ = 'egg'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
pokemon = db.relationship('Pokemon', secondary='pokemon_egg', back_populates='egg')
def __repr__(self):
return repr_gen(self, ['name', 'description'])
class AttackSpeed(db.Model):
__tablename__ = 'attack_speed'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
attacks = db.relationship('Attack', back_populates='speed')
def __repr__(self):
return repr_gen(self, ['name', 'description'])
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
players = db.relationship('Player', backref='teams', lazy=True)
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Team %r>' % self.name
class CommunityQuestion(db.Model):
__tablename__ = 'community_questions'
question_id = db.Column(db.Integer, primary_key=True)
question_title = db.Column(db.String(1000), nullable=False)
question = db.Column(db.String(10000), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
comments = db.relationship('CommunityComment',
backref='community_comments')
date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def get_comments(self):
return self.comments
class HammockLocation(SurrogatePK, Model, ModelSerializer):
"""Hammock Location model."""
__tablename__ = 'hammock_location'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uuid = db.Column(db.String)
title = db.Column(db.String)
capacity = db.Column(db.BigInteger)
photo = db.Column(db.String)
latitude = db.Column(db.Float)
longitude = db.Column(db.Float)
description = db.Column(db.String)
user_uuid = db.Column(db.Integer, db.ForeignKey('users.id'))
date_created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
comments = db.relationship('Comment',
backref='location_comment',
lazy='dynamic',
foreign_keys='[Comment.location_uuid]')
def __init__(self,
title=None,
capacity=None,
photo=None,
latitude=None,
longitude=None,
description=None,
user_uuid=None,
comments=[]):
"""Define what will be loaded up on model instantiation here"""
self.uuid = gen_uuid()
self.title = title
self.capacity = capacity
self.photo = photo
self.latitude = latitude
self.longitude = longitude
self.description = description
self.user_uuid = user_uuid
self.comments = comments
def __repr__(self):
return '<HammockLocation {}:{}>'.format(self.uuid, self.title)
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 Latest(db.Model, Model):
channel_info_id = db.Column(db.Integer, db.ForeignKey("channel_info.id"))
channel_info = db.relationship("ChannelInfo",
backref='latest',
lazy="subquery")
data = db.Column(db.String())
@classmethod
def cache_new_request(cls, data):
model = cls()
model.created = model.updated = datetime.utcnow()
model.data = data
return model
class UserPokemon(db.Model):
__tablename__ = 'user_pokemon'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
pokemon_id = db.Column(db.Integer, db.ForeignKey('pokemon.id'), nullable=False)
name = db.Column(db.String(24))
notes = db.Column(db.Text)
height = db.Column(db.Numeric(5, 2))
weight = db.Column(db.Numeric(5, 2))
stamina = db.Column(db.Integer)
attack = db.Column(db.Integer)
defense = db.Column(db.Integer)
cp = db.Column(db.Integer)
hp = db.Column(db.Integer)
power_up_stardust = db.Column(db.Integer)
power_up_candy = db.Column(db.Integer)
fast_attack_id = db.Column(db.Integer, db.ForeignKey('attack.id'))
charge_attack_id = db.Column(db.Integer, db.ForeignKey('attack.id'))
appraisal_overall_id = db.Column(db.Integer, db.ForeignKey('appraisal_overall.id'))
appraisal_stats_id = db.Column(db.Integer, db.ForeignKey('appraisal_stats.id'))
appraisal_size_id = db.Column(db.Integer, db.ForeignKey('appraisal_size.id'))
caught_location = db.Column(db.String)
caught_date = db.Column(db.Date)
created = db.Column(db.TIMESTAMP(timezone=True), server_default=db.func.now())
last_modified = db.Column(db.TIMESTAMP(timezone=True), onupdate=db.func.now())
user = db.relationship('User', foreign_keys=[user_id], back_populates='pokemon')
pokemon = db.relationship('Pokemon')
fast_attack = db.relationship('Attack', foreign_keys=[fast_attack_id])
charge_attack = db.relationship('Attack', foreign_keys=[charge_attack_id])
appraisal_overall = db.relationship('AppraisalOverall')
appraisal_stats = db.relationship('AppraisalStats')
appraisal_size = db.relationship('AppraisalSize')
appraisal_iv = db.relationship('AppraisalIv', secondary='user_pokemon_appraisal_iv')
def __repr__(self):
return repr_gen(self, ['user_id', 'pokemon_id', 'name', 'notes', 'height', 'weight', 'stamina', 'attack',
'defense', 'cp', 'hp', 'power_up_stardust', 'power_up_candy', 'fast_attack_id',
'charge_attack_id', 'appraisal_overall_id', 'appraisal_stats_id', 'caught_location',
'caught_date', 'created', 'last_modified'])
class Document(db.Model):
__tablename__ = 'documents'
graph_ref = db.Column(db.String(100), primary_key=True)
document_title = db.Column(db.String(1000))
user_evaluations = db.relationship('Evaluation',
backref='documents',
lazy=True)
def __init__(self, graph_ref):
self.graph_ref = graph_ref
def add_user_evaluation(self, user_evaluation):
self.user_evaluations.append(user_evaluation)
def get_user_evaluations(self):
return self.user_evaluations
def remove_user_evaluation(self, user_evaluation):
self.user_evaluations.remove(user_evaluation)
class User(BaseModel):
"""
Model for User
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, unique=True)
added = db.Column(db.DateTime, default=dt.utcnow)
watches = db.relationship(LegoSet, secondary=watch_table)
def __init__(self, email, *args):
super().__init__(*args)
self.email = email
def to_dict(self):
return {
'id': self.id,
'email': self.email,
'added': self.added,
'watches': list(map(lambda w: w.to_dict(), self.watches))
}
class LegoSet(BaseModel):
"""
Model for watched Lego set
"""
__tablename__ = 'legoset'
# Equal to the official lego Set Number
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
image = db.Column(db.String(255))
url = db.Column(db.String(255))
added = db.Column(db.DateTime, default=dt.utcnow)
stock_levels = db.relationship(StockLevel, uselist=True, order_by="StockLevel.datetime")
def __init__(self, legoset, *args):
super().__init__(*args)
self.id = legoset['id']
self.title = legoset['title']
self.image = legoset['image']
self.url = legoset['url']
def cull_stock(self):
""" Limit stock_levels to 30 datapoints """
if len(self.stock_levels) > 30:
# Stock levels already sorted by date
# Keep only the most recent 29
self.stock_levels[:] = self.stock_levels[-30:]
self.save()
def to_dict(self):
return {
'id': self.id,
'title': self.title,
'image': self.image,
'url': self.url,
'added': self.added,
'stock_levels': list(map(lambda s: s.to_dict(), self.stock_levels))
}
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 User(db.Model):
__tablename__ = 'users'
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100),
unique=True,
nullable=False,
index=True)
pwd = db.Column(db.String(500))
email = db.Column(db.String(100))
phone = db.Column(db.String(30))
year = db.Column(db.Integer())
lang = db.Column(db.String(10), default='EN')
opened_documents = db.relationship('Document',
secondary=user_opened_documents)
validated_documents = db.relationship('Document',
secondary=user_validated_documents)
scholar_questions = db.relationship('ScholarQuestion',
backref='users',
lazy=True)
user_searches = db.relationship('UserSearch', backref='users', lazy=True)
document_evaluations = db.relationship('Evaluation',
backref='users',
lazy=True)
badges = db.relationship('Badge', secondary=user_badges)
level_number = db.Column(db.Integer, db.ForeignKey('levels.level_number'))
level = db.relationship('Level', back_populates='users')
experience = db.Column(db.Integer)
user_questions = db.relationship('CommunityQuestion', backref='users')
user_comments = db.relationship('CommunityComment', backref='users')
user_image = db.Column(db.Integer)
def __init__(self, username, pwd, email, year):
self.username = username
self.pwd = generate_password_hash(pwd)
self.email = email
self.year = year
self.user_image = random.randint(0, 9)
def __repr__(self):
return '<User {}>'.format(self.user_id)
def get_user_id(self):
return self.user_id
def set_password(self, pwd):
self.pwd = generate_password_hash(pwd)
def check_password(self, pwd):
return check_password_hash(self.pwd, pwd)
def add_opened_document(self, opened_document):
self.opened_documents.append(opened_document)
def get_opened_documents(self):
return self.opened_documents
def remove_opened_document(self, opened_document):
self.opened_documents.remove(opened_document)
def get_validated_documents(self):
return self.validated_documents
def add_validated_document(self, validated_document):
self.validated_documents.append(validated_document)
def remove_validated_document(self, validated_document):
self.validated_documents.remove(validated_document)
def add_scholar_question(self, scholar_question):
self.scholar_questions.append(scholar_question)
def get_scholar_questions(self):
return self.scholar_questions
def remove_scholar_question(self, scholar_question):
self.scholar_questions.remove(scholar_question)
def get_user_searches(self):
return self.user_searches
def add_user_search(self, user_search):
self.user_searches.append(user_search)
def remove_user_search(self, user_search):
self.user_searches.remove(user_search)
def add_document_evaluation(self, document_evaluation):
self.document_evaluations.append(document_evaluation)
def get_document_evaluations(self):
return self.document_evaluations
def remove_document_evaluation(self, document_evaluation):
self.document_evaluations.remove(document_evaluation)
def add_badge(self, badge):
self.badges.append(badge)
def get_badges(self):
return self.badges
def remove_badge(self, badge):
self.badges.remove(badge)
def add_experience(self, experience):
self.experience += experience
while self.experience >= self.level.next_stage:
new_level = Level.query.get(self.level.level_number + 1)
if not new_level:
break
self.experience -= self.level.next_stage
self.level = new_level
def remove_experience(self, experience):
self.experience -= experience
while self.experience < 0:
previous_level = Level.query.get(self.level.level_number - 1)
if not previous_level:
self.experience = 0
break
self.experience += previous_level.next_stage
self.level = previous_level
def get_level(self):
return self.level
def set_level(self, level):
self.level = level
self.experience = 0
class Level(db.Model):
__tablename__ = 'levels'
level_number = db.Column(db.Integer, primary_key=True)
next_stage = db.Column(db.Integer)
users = db.relationship('User', back_populates='level')
class Category(BaseModel):
"""Class for categories db table."""
__tablename__ = 'categories'
name = db.Column(db.String(255), unique=True, nullable=False)
favorites = db.relationship('Favorite',
backref='category',
cascade='save-update, delete',
lazy='dynamic')
@property
def favorites_count(self):
return self.favorites.count()
@property
def rankings(self):
next_rank = self.favorites_count + 2
rankings = list(range(1, next_rank))
ordinal = lambda n: "%d%s" % (n, "tsnrhtdd"[(n / 10 % 10 != 1) *
(n % 10 < 4) * n % 10::4])
return [dict(id=each, name=ordinal(each)) for each in rankings]
def get_child_relationships(self):
return (self.favorites, )
def __repr__(self):
return f'<Category: {self.name}>'
def save(self):
"""
"""
instance = super(Category, self).save()
Audit.log_save(instance, 'category',
f'New category with name {instance.name} was added')
return instance
def update(self, **kwargs):
"""
"""
instance = super(Category, self).update(**kwargs)
Audit.log_update(
instance, 'category',
f'Category with id {instance.id} was updated with new changes')
return instance
def delete(self):
""" Delete a Category """
if self.favorites.count() > 0:
raise ValidationError(
{
'message':
ERROR_MESSAGES['DELETING_RELATED_OBJECTS'].format(
'Category', 'Favorites'),
}, 400)
status = super(Category, self).delete()
Audit.log_delete(self, 'category',
f'Category with name {self.name} was removed')
return status
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()
class OrderItem(BaseModel):
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
quantity = db.Column(db.Integer)
item = db.relationship("Item")
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()
}
