class Posts(db.Model): id = db.Column(db.Integer, primary_key=True) deleted = db.Column(db.Boolean, default=False) deleted_at = db.Column(db.DateTime, default=None) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) title = db.Column(db.String(200), nullable=False) thumbnail = db.Column(db.Text) slug = db.Column(db.String(200), nullable=False, unique=True) brief = db.Column(db.Text, nullable=False) content = db.Column(db.Text, nullable=False) last_edited_at = db.Column(db.DateTime) user = db.relationship('Users', backref=db.backref('posts', lazy=True)) votes = db.relationship("Votes", back_populates="post") tags = db.relationship('Tags', secondary=post_tags, lazy='subquery', backref=db.backref('posts', lazy=True)) def __repr__(self): return '<Posts %r>' % self.title
class EventModel(db.Model): __tablename__ = 'events' id = db.Column(db.Integer, primary_key=True) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) owner = db.relationship('UserModel', foreign_keys=[owner_id]) community_id = db.Column(db.Integer, db.ForeignKey('communities.id'), nullable=False) community = db.relationship('CommunityModel', foreign_keys=[community_id]) title = db.Column(db.String(120), nullable=False) description = db.Column(db.Text, nullable=True) start = db.Column(db.DateTime()) end = db.Column(db.DateTime()) def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'owner': fields.Nested(UserModel.get_marshaller()), 'title': fields.String, 'description': fields.String, 'start': fields.DateTime, 'end': fields.DateTime, } @classmethod def delete_by_id(cls, event_id): event = db.session.query(cls).filter(cls.id == event_id).first() if event: db.session.delete(event) db.session.commit() else: raise NoData @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def find_by_community(cls, community_id, from_datetime, to_datetime): return cls.query.filter_by(community_id=community_id). \ filter(EventModel.end >= from_datetime, EventModel.start <= to_datetime).all() @classmethod def find_next_n_by_community(cls, community_id, n): return cls.query.filter_by(community_id=community_id). \ filter(EventModel.end >= datetime.datetime.utcnow()).order_by(EventModel.start.asc()).limit(n).all()
class Professor(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), unique=False, nullable=False) surname = db.Column(db.String(30), unique=False, nullable=False) # Rank of the teacher eg. PhD... merits = db.Column(db.String(20), unique=False, nullable=False) # Relationship for foreign key in a different table study_classes = db.relationship('StudyClass', backref='professor') discipline = db.relationship('Discipline', backref='professor') def __repr__(self): return f'{self.merits} {self.name} {self.surname}'
class StudyClass(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(10), unique=True, nullable=False) year_of_study = db.Column(db.String(2), unique=False, nullable=False) schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id')) professor_id = db.Column(db.Integer, db.ForeignKey('professor.id')) schedule = db.relationship('Schedule', backref=db.backref('classes', lazy=True)) discipline = db.relationship('Discipline', backref='study_class') def __repr__(self): return f'{self.name} {self.year_of_study}'
class Creator(db.Model): __tablename__ = 'creator' id = db.Column(db.Integer(), primary_key=True) firstName = db.Column(db.String(100)) middleName = db.Column(db.String(100)) lastName = db.Column(db.String(100)) suffix = db.Column(db.String(100)) fullName = db.Column(db.String(100)) modified = db.Column(db.DateTime()) comics = db.relationship(Comics, secondary=creator_comics, backref=db.backref('creators', lazy=True)) def __init__(self, id, firstName, middleName, lastName, suffix, fullName, modified, comics): self.id = id self.firstName = firstName self.middleName = middleName self.lastName = lastName self.suffix = suffix self.fullName = fullName self.modified = modified self.comics = comics def create(self): db.session.add(self) db.session.commit() return self
class UserModel(db.Model,UserMixin): '''user model : representing user information in sql table''' __tablename__='users' id=db.Column(db.Integer,primary_key=True) email=db.Column(db.String(50),unique=True,nullable=False) password=db.Column(db.String(256),nullable=False) mobile_no=db.Column(db.String(10),nullable=False) billing_address=db.Column(db.Text,nullable=True) delivery_address=db.Column(db.Text,nullable=True) products=db.relationship('ProductModel',backref='user',lazy=True,cascade='all,delete') def __init__(self,email,password,mobile_no): self.email=email self.password=bcrypt.generate_password_hash(password).decode('utf-8') self.mobile_no=mobile_no def update_password(self,password): '''update password''' self.password=bcrypt.generate_password_hash(password).decode('utf-8') def __repr__(self): return f"hello i am {self.email}" def check_password(self,password): '''check users password''' return bcrypt.check_password_hash(self.password,password)
class Role(db.Model): __tablename__ = "roles" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True) default = db.Column(db.Boolean, default=True, index=True) permissions = db.Column(db.Integer) users = db.relationship("User", backref="role", lazy="dynamic") def __init__(self, **kwargs): super(Role, self).__init__(**kwargs) if self.permissions is None: self.permissions = 0 @staticmethod def insert_roles(): roles = { "User": [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE], "Moderator": [ Permission.FOLLOW, Permission.COMMENT, Permission.WRITE, Permission.MODERATE, ], "Administrator": [ Permission.FOLLOW, Permission.COMMENT, Permission.WRITE, Permission.MODERATE, Permission.ADMIN, ], } default_role = "User" for r in roles: role = Role.query.filter_by(name=r).first() if role is None: role = Role(name=r) role.reset_permissions() for perm in roles[r]: role.add_permission(perm) role.default = role.name == default_role db.session.add(role) db.session.commit() def add_permission(self, perm): if not self.has_permission(perm): self.permissions += perm def remove_permission(self, perm): if self.has_permission(perm): self.permissions -= perm def reset_permissions(self): self.permissions = 0 def has_permission(self, perm): return self.permissions & perm == perm def __repr__(self): return f"<Role {self.name}>"
class Comments(db.Model): id = db.Column(db.Integer, primary_key=True) deleted = db.Column(db.Boolean, default=False) deleted_at = db.Column(db.DateTime, default=None) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False) content = db.Column(db.Text, nullable=False) post = db.relationship('Posts', backref=db.backref('comments', lazy=True)) user = db.relationship('Users', backref=db.backref('comments', lazy=True)) def __repr__(self): return '<Comment %r>' % self.content
class Votes(db.Model): id = db.Column(db.Integer, primary_key=True) deleted = db.Column(db.Boolean, default=False) deleted_at = db.Column(db.DateTime, default=None) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) vote = db.Column(db.Boolean, default=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False) post = db.relationship("Posts", uselist=False, back_populates="votes") user = db.relationship('Users', backref=db.backref('votes', lazy=True)) def __repr__(self): return '<Vote %r>' % self.vote
class TourPassengerLinkModel(db.Model): __tablename__ = 'tour_passenger_link' tour_id = db.Column(db.Integer, db.ForeignKey('tours.id'), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) tour = db.relationship('TourModel') user = db.relationship('UserModel') time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) def persist(self): db.session.add(self) db.session.commit()
class Schedule(db.Model): id = db.Column(db.Integer, primary_key=True) # This is where the schedule is written for every week's day schedule = db.Column(db.String(1000), unique=False, nullable=True) disciplines = db.relationship('Discipline', backref='schedule') def __repr__(self): return f'{self.schedule}'
class Goal(db.Model): __tablename__ = 'goals' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) description = db.Column(db.String(255)) icon = db.Column(db.String(255)) teachers = db.relationship('Teacher', secondary=teacher_goals, back_populates='goals')
class ProductModel(db.Model): __tablename__ = 'products' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) price = db.Column(db.Integer, nullable=False) description = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) images = db.relationship('ProductImagesModel', backref='product', lazy=True, cascade="all,delete")
class Hat(db.Model): __tablename__ = 'hat' id = db.Column(db.Integer, primary_key=True) hat_number = db.Column(db.String(100), index=True, unique=True, nullable=False) created_at = db.Column(db.DateTime, default=datetime.now()) # Virtual property names = db.relationship('Name', backref='hat')
class CarModel(db.Model): __tablename__ = 'cars' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), nullable=False) make = db.Column(db.String(120), nullable=False) model = db.Column(db.String(120), nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) owner = db.relationship('UserModel', back_populates='cars') def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'name': fields.String, 'make': fields.String, 'model': fields.String, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'owner': fields.Nested(UserModel.get_marshaller()) } @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def return_all(cls): return CarModel.query.all() @classmethod def return_all_for_user(cls, user_id): return CarModel.query.filter(cls.owner_id == user_id).all() @classmethod def delete_all(cls): db.session.query(cls).delete() db.session.commit() @classmethod def delete_by_id(cls, id): car = db.session.query(cls).filter(cls.id == id).first() if car: db.session.delete(car) db.session.commit() else: raise NoData
class Teacher(db.Model): __tablename__ = 'teachers' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) about = db.Column(db.Text) rating = db.Column(db.Float) picture = db.Column(db.String(255)) price = db.Column(db.Integer) goals = db.relationship('Goal', secondary=teacher_goals, back_populates='teachers') free = db.Column(JSON)
class Department(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) slug = db.Column(db.String(255)) employees = db.relationship("Employee") def __init__(self, *args, **kwargs): super(Department, self).__init__(*args, **kwargs) self.generate_slug() def generate_slug(self): if self.name: self.slug = slugify(self.name) def __repr__(self): return f"<Department : name={self.name}, id={self.id}>"
class Student(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), unique=False, nullable=False) surname = db.Column(db.String(30), unique=False, nullable=False) address = db.Column(db.String(200), unique=False, nullable=True) year_of_study = db.Column(db.String(2), unique=False, nullable=True) adm_score = db.Column(db.Float, unique=False, nullable=False) # Current exam scores for all past years and semesters scores = db.Column(db.String(200), unique=False, nullable=True) # Foreign key to a StudyClass instance study_class_id = db.Column(db.Integer, db.ForeignKey('study_class.id')) # Foreign key relationship study_class = db.relationship('StudyClass', backref=db.backref('students', lazy=True)) def __repr__(self): return f'{self.name} {self.surname} {self.address} {self.adm_score} {self.scores}'
class Job(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.Text) description = db.Column(db.Text) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) builds = db.relationship('Build', backref='job', lazy=False) def to_dict(self): return { 'id': self.id, 'title': self.title, 'description': self.description, 'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S") } def __repr__(self): return f"<id {self.id}, description : {self.description}>"
class OrderModel(BaseModel): # table name __tablename__ = 'orders' order_id = db.Column(db.Integer, primary_key=True) shop_id = db.Column(db.Integer, nullable=False) products = db.relationship('OrderProductsModel', backref='order', lazy=True) latitud = db.Column(db.Float, nullable=False) longitud = db.Column(db.Float, nullable=False) payWithPoints = db.Column(db.Boolean, nullable=False) favourPoints = db.Column(db.Integer, nullable=False) state = db.Column(db.String(128), nullable=False) price = db.Column(db.Float,nullable = False) delivery_price = db.Column(db.Float) delivery_pay = db.Column(db.Float) user_id = db.Column(db.Integer, db.ForeignKey('normal_users.user_id'), nullable=False) delivery_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), nullable=True) created_at = db.Column(db.DateTime) modified_at = db.Column(db.DateTime) delivery_review = db.Column(db.Float, nullable = True) shop_review = db.Column(db.Float, nullable = True) discount = db.Column(db.Boolean, nullable=False) # class constructor def __init__(self, data): """ Class constructor """ self.shop_id = data.get('shop_id') self.latitud = data.get('latitude') self.longitud = data.get('longitude') self.payWithPoints = data.get('payWithPoints') self.favourPoints = data.get('favourPoints', 0) self.state = data.get('state') self.user_id = data.get('user_id') self.delivery_id = data.get('delivery_id', None) self.price = data.get("price") self.created_at = datetime.datetime.utcnow() self.modified_at = datetime.datetime.utcnow() self.delivery_review = None self.shop_review = None self.discount = data.get("discount", False)
class Node(db.Model): id = db.Column(db.Integer, primary_key=True) workspace = db.Column(db.Text) ip_addr = db.Column(db.Text) port = db.Column(db.Integer) user = db.Column(db.String(64)) password = db.Column(db.String(64)) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) builds = db.relationship('Build', backref='node', lazy = False) def to_dict(self): return { 'id' : self.id, 'workspace' : self.workspace, 'ip_addr': self.ip_addr, 'user' : self.user, 'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S") } def __repr__(self): return f"<id {self.id}, @IP : {self.ip_addr}>"
class CommunityModel(db.Model): __tablename__ = 'communities' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(120), nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) users = db.relationship( 'UserModel', secondary='community_user_link', secondaryjoin='and_(CommunityUserLinkModel.user_id == UserModel.id, ' 'CommunityUserLinkModel.invitation_accepted == True)') car_id = db.Column(db.Integer, db.ForeignKey('cars.id'), unique=True) car = db.relationship("CarModel", backref=db.backref("community", uselist=False)) is_favourite = None def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'name': fields.String, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'users': fields.List(fields.Nested(UserModel.get_marshaller())), 'car': fields.Nested(CarModel.get_marshaller()) } @staticmethod def get_detailed_marshaller(): return { 'id': fields.Integer, 'name': fields.String, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'users': fields.List(fields.Nested(UserModel.get_marshaller())), 'car': fields.Nested(CarModel.get_marshaller()), 'is_deletable': fields.Boolean, 'is_editable': fields.Boolean } @staticmethod def add_is_fav_to_marshaller(marshaller): marshaller['is_favourite'] = fields.Boolean return marshaller @classmethod def find_by_car_id(cls, id): return cls.query.filter_by(car_id=id).first() @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def return_all(cls): return CommunityModel.query.all() @classmethod def delete_all(cls): db.session.query(cls).delete() db.session.commit() @classmethod def delete_by_id(cls, id): community = db.session.query(cls).filter(cls.id == id).first() if community: db.session.delete(community) db.session.commit() else: raise NoData
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) email = db.Column(db.String(120), nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) cars = db.relationship("CarModel", back_populates="owner") communities = db.relationship("CommunityModel", secondary='community_user_link') tours = db.relationship("TourModel", secondary='tour_passenger_link') reset_password_hash = db.Column(db.String(120), nullable=True, default=None) reset_password_hash_created = db.Column(db.DateTime(timezone=True), default=None, nullable=True) def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'username': fields.String, 'email': fields.String, 'time_created': fields.DateTime, 'time_updated': fields.DateTime } @staticmethod def generate_hash(password): return sha256.hash(password) @staticmethod def verify_hash(password, hash): return sha256.verify(password, hash) @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_email(cls, email): return cls.query.filter_by(email=email).first() @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def find_by_reset_password_hash(cls, hash): return cls.query.filter_by(reset_password_hash=hash).first() @classmethod def return_all(cls): return UserModel.query.all() @classmethod def delete_all(cls): db.session.query(cls).delete() db.session.commit() @classmethod def search_by_username(cls, username, excluded_username): return cls.query \ .filter(UserModel.username.like('%' + username + '%')) \ .filter(UserModel.username != excluded_username) \ .order_by(UserModel.username) \ .limit(10) \ .all()
class TourModel(db.Model): __tablename__ = 'tours' id = db.Column(db.Integer, primary_key=True) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) owner = db.relationship('UserModel', foreign_keys=[owner_id]) community_id = db.Column(db.Integer, db.ForeignKey('communities.id'), nullable=False) community = db.relationship('CommunityModel') start_km = db.Column(db.DECIMAL(precision=(10, 1)), nullable=False) end_km = db.Column(db.DECIMAL(precision=(10, 1))) start_time = db.Column(db.DateTime(), nullable=False) end_time = db.Column(db.DateTime()) parking_position = db.Column(db.String(120)) comment = db.Column(db.String(120)) is_force_finished = db.Column(db.Boolean) force_finished_by_id = db.Column(db.Integer, db.ForeignKey('users.id')) force_finished_by = db.relationship('UserModel', foreign_keys=[force_finished_by_id]) payoff_id = db.Column(db.Integer, db.ForeignKey('payoffs.id')) is_open = db.Column(db.Boolean, default=True) passengers = db.relationship('UserModel', secondary='tour_passenger_link') def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'start_time': fields.DateTime, 'end_time': fields.DateTime, 'owner': fields.Nested(UserModel.get_marshaller()), 'community': fields.Nested(CommunityModel.get_marshaller()), 'start_km': fields.String, 'end_km': fields.String, 'parking_position': fields.String, 'comment': fields.String, 'is_force_finished': fields.Boolean, 'force_finished_by': fields.Nested(UserModel.get_marshaller(), allow_null=True), 'is_open': fields.Boolean, 'passengers': fields.Nested(UserModel.get_marshaller()) } @classmethod def delete_by_id(cls, id): tour = db.session.query(cls).filter(cls.id == id).first() if tour: db.session.delete(tour) db.session.commit() else: raise NoData @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def find_finished_by_community(cls, community_id): return cls.query \ .filter_by(community_id=community_id) \ .filter(TourModel.end_km.isnot(None)) \ .order_by(TourModel.end_time.desc()) \ .all() @classmethod def find_finished_and_open_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id, is_open=True).filter( TourModel.end_km.isnot(None)).all() @classmethod def find_finished_by_user(cls, user_id): return cls.query.filter_by(owner_id=user_id).filter( TourModel.end_km.isnot(None)).all() @classmethod def find_running_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id).filter( TourModel.end_km.is_(None)).all() @classmethod def find_running_by_user(cls, user_id): return cls.query.filter_by(owner_id=user_id).filter( TourModel.end_km.is_(None)).all() @classmethod def find_newest_tour_for_community(cls, community_id): return cls.query.filter_by(community_id=community_id).order_by( TourModel.end_km.desc()).first()
class TaskModel(db.Model): __tablename__ = 'tasks' id = db.Column(db.Integer, primary_key=True) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) owner = db.relationship('UserModel', foreign_keys=[owner_id]) community_id = db.Column(db.Integer, db.ForeignKey('communities.id'), nullable=False) community = db.relationship('CommunityModel') km_interval = db.Column(db.Integer, nullable=True) km_next_instance = db.Column(db.DECIMAL(precision=10, scale=1), nullable=True) time_interval = db.Column(db.Interval, nullable=True) time_next_instance = db.Column(db.DateTime(), nullable=True) name = db.Column(db.String(120)) description = db.Column(db.String(120)) instances = db.relationship("TaskInstanceModel", cascade="all, delete") is_reocurrent = db.Column(db.Boolean, nullable=False, default=True) def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'time_next_instance': fields.DateTime, 'time_interval': TimedeltaDays, 'owner': fields.Nested(UserModel.get_marshaller()), 'community': fields.Nested(CommunityModel.get_marshaller()), 'name': fields.String, 'description': fields.String, 'km_interval': fields.Integer, 'km_next_instance': fields.Float, 'km_to_next_instance': fields.Float, 'is_reocurrent': fields.Boolean } @classmethod def delete_by_id(cls, task_id): task = db.session.query(cls).filter(cls.id == task_id).first() if task: db.session.delete(task) db.session.commit() else: raise NoData @classmethod def find_by_id(cls, task_id): return cls.query \ .filter_by(id=task_id) \ .first() @classmethod def return_all(cls): return cls.query \ .filter_by(is_reocurrent=True) \ .all() @classmethod def find_by_community(cls, community_id): return cls.query \ .filter_by(community_id=community_id) \ .filter_by(is_reocurrent=True) \ .all()
class CommunityUserLinkModel(db.Model): __tablename__ = 'community_user_link' community_id = db.Column(db.Integer, db.ForeignKey('communities.id'), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) is_owner = db.Column(db.Boolean, default=True) invitation_accepted = db.Column(db.Boolean, default=True) community = db.relationship('CommunityModel') user = db.relationship('UserModel') is_favourite = db.Column(db.Boolean, default=False, nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) def add_to_session(self): db.session.add(self) def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'community': fields.Nested(CommunityModel.get_marshaller()), 'time_created': fields.DateTime, 'time_updated': fields.DateTime, } @classmethod def find_by_user_and_community(cls, user_id, community_id): return cls.query.filter_by(user_id=user_id, community_id=community_id).first() @classmethod def find_favourite_by_user(cls, user_id): return cls.query.filter_by(user_id=user_id, is_favourite=True).first() @classmethod def find_by_user(cls, user_id): return cls.query.filter_by(user_id=user_id).all() @classmethod def find_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id).all() @classmethod def find_open_invitations_by_user(cls, user_id): return cls.query.filter_by(user_id=user_id, invitation_accepted=False).all() @classmethod def find_open_invitations_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id, invitation_accepted=False).all() def delete(self): db.session.delete(self) db.session.commit()
class Movie(db.Model): __tablename__ = 'movies' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(50), nullable=False) description = db.Column(db.String(10000), nullable=False) duration = db.Column(db.Integer, nullable=False) poster = db.Column(db.String(1000), nullable=False) rating = db.Column(db.Float, nullable=False) year = db.Column(db.Integer, nullable=False) genre = db.relationship('Genre', secondary=movie_genre_table) director = db.Column(db.String(50), nullable=True) def update(self, id=None, name=None, description=None, duration=None, poster=None, rating=None, year=None, genre=None, director=None): if name is not None: self.name = name if description is not None: self.description = description if duration is not None: self.duration = duration if poster is not None: self.poster = poster if rating is not None: self.rating = rating if year is not None: self.year = year if genre is not None: for genre_dict in genre: genre_id = genre_dict.get('id') genre_in_db = Genre.query.get(genre_id) if genre_in_db == None: self.genre.append(Genre.load(genre_dict)) else: self.genre.append(genre_in_db) if director is not None: self.director = director @classmethod def load(cls, movie_dict): movie_model = Movie(name=movie_dict.get('name'), description=movie_dict.get('description'), duration=movie_dict.get('duration'), poster=movie_dict.get('poster'), rating=movie_dict.get('rating'), year=movie_dict.get('year'), director=movie_dict.get('director')) # Retrieve the json list of Genres of the movie # If the genre already exists in database then append it to genres list of Movie model for genre_dict in movie_dict.get('genre'): genre_id = genre_dict.get('id') genre_in_db = Genre.query.get(genre_id) if genre_in_db == None: movie_model.genre.append(Genre.load(genre_dict)) else: movie_model.genre.append(genre_in_db) return movie_model def dump(self): return { 'id': self.id, 'name': self.name, 'description': self.description, 'duration': self.duration, 'poster': self.poster, 'rating': self.rating, 'year': self.year, 'genre': [g.dump() for g in self.genre], 'director': self.director }
class Room(db.Model): id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, default=datetime.now) code = db.Column(db.String(8), unique=True) connections = db.relationship('Connection', backref='room')
class User(UserMixin, db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(64), unique=True, index=True) username = db.Column(db.String(64), unique=True, index=True) role_id = db.Column(db.Integer, db.ForeignKey("roles.id")) password_hash = db.Column(db.String(128)) confirmed = db.Column(db.Boolean, default=False) name = db.Column(db.String(64)) location = db.Column(db.String(64)) about_me = db.Column(db.Text()) housemates = db.Column(db.Text()) significant_others = db.Column(db.Text()) my_five = db.Column(db.Text()) member_since = db.Column(db.DateTime(), default=datetime.utcnow) last_seen = db.Column(db.DateTime(), default=datetime.utcnow) avatar_hash = db.Column(db.String(32)) posts = db.relationship("Post", backref="author", lazy="dynamic") followed = db.relationship( "Follow", foreign_keys=[Follow.follower_id], backref=db.backref(name="follower", lazy="joined"), lazy="dynamic", cascade="all, delete-orphan", ) followers = db.relationship( "Follow", foreign_keys=[Follow.followed_id], backref=db.backref(name="followed", lazy="joined"), lazy="dynamic", cascade="all, delete-orphan", ) @staticmethod def add_self_follows(): # this is used as a script to go back and add self follows if they are missing for user in User.query.all(): if not user.is_following(user): user.follow(user) db.session.add(user) db.session.commit() def __init__(self, **kwargs): super(User, self).__init__(**kwargs) if not self.role: if self.email == current_app.config["MYQ5_ADMIN"]: self.role = Role.query.filter_by(name="Administrator").first() if not self.role: self.role = Role.query.filter_by(default=True).first() if not self.email and not self.avatar_hash: self.avatar_hash = self.gravatar_hash() self.follow(self) @property def followed_posts(self): return Post.query.join(Follow, Follow.followed_id == Post.author_id).filter( Follow.follower_id == self.id) @property def followed_users(self): return User.query.join(Follow, Follow.followed_id == User.id).filter( Follow.follower_id == self.id) @property def password(self): raise AttributeError("password is not a readable attribute") @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def generate_confirmation_token(self, expiration=3600): s = Serializer(current_app.config["SECRET_KEY"], expiration) return s.dumps({"confirm": self.id}).decode("utf-8") def confirm(self, token): s = Serializer(current_app.config["SECRET_KEY"]) try: data = s.loads(token.encode("utf-8")) except Exception: return False if data.get("confirm") != self.id: return False self.confirmed = True db.session.add(self) return True def generate_reset_token(self, expiration=3600): s = Serializer(current_app.config["SECRET_KEY"], expiration) return s.dumps({"reset": self.id}).decode("utf-8") @staticmethod def reset_password(token, new_password): s = Serializer(current_app.config["SECRET_KEY"]) try: data = s.loads(token.encode("utf-8")) except: return False user = User.query.get(data.get("reset")) if user is None: return False user.password = new_password db.session.add(user) return True def generate_email_change_token(self, new_email, expiration=3600): s = Serializer(current_app.config["SECRET_KEY"], expiration) return s.dumps({ "change_email": self.id, "new_email": new_email }).decode("utf-8") def change_email(self, token): s = Serializer(current_app.config["SECRET_KEY"]) try: data = s.loads(token.encode("utf-8")) except: return False if data.get("change_email") != self.id: return False new_email = data.get("new_email") self.avatar_hash = self.gravatar_hash() if new_email is None: return False if self.query.filter_by(email=new_email).first() is not None: return False self.email = new_email db.session.add(self) return True def can(self, perm): return self.role is not None and self.role.has_permission(perm) def is_administrator(self): return self.can(Permission.ADMIN) def ping(self): self.last_seen = datetime.utcnow() db.session.add(self) def gravatar_hash(self): return hashlib.md5(self.email.lower().encode("utf-8")).hexdigest() def gravatar(self, size=100, default="identicon", rating="g"): url = "https://secure.gravatar.com/avatar" gravatar_hash = self.avatar_hash or self.gravatar_hash() return f"{url}/{gravatar_hash}?s={size}&d={default}&r={rating}" def follow(self, user): if not self.is_following(user): f = Follow(follower=self, followed=user) db.session.add(f) def unfollow(self, user): f = self.followed.filter_by(followed_id=user.id).first() if f: db.session.delete(f) def is_following(self, user): if user.id is None: return False return self.followed.filter_by(followed_id=user.id).first() is not None def is_followed_by(self, user): if user.id is None: return False return self.followers.filter_by( follower_id=user.id).first() is not None def __repr__(self): return f"<User {self.username}>"
class DebtModel(db.Model): __tablename__ = 'debts' id = db.Column(db.Integer, primary_key=True) is_settled = db.Column(db.Boolean, default=False) amount = db.Column(db.DECIMAL(10, 2), nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) debtee_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) debtee = db.relationship('UserModel', foreign_keys=[debtee_id]) recepient_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) recepient = db.relationship('UserModel', foreign_keys=[recepient_id]) payoff_id = db.Column(db.Integer, db.ForeignKey('payoffs.id'), nullable=False) community_id = db.Column(db.Integer, db.ForeignKey('communities.id'), nullable=False) def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'debtee': fields.Nested(UserModel.get_marshaller()), 'recepient': fields.Nested(UserModel.get_marshaller()), 'is_settled': fields.Boolean, 'amount': fields.Float } @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def find_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id).all() @classmethod def find_unsettled_by_community(cls, community_id): return cls.query.filter_by(community_id=community_id, is_settled=False).all() @classmethod def find_unsettled_by_user(cls, user_id): return cls.query.filter(((DebtModel.recepient_id == user_id) | (DebtModel.debtee_id == user_id)), DebtModel.is_settled == False).all() @classmethod def find_unsettled_by_payoff(cls, payoff_id): return cls.query.filter_by(payoff_id=payoff_id, is_settled=False).all()