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() }