class Admin(db.Model): __tablename__ = "admin" admin_id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(100)) last_name = db.Column(db.String(100)) username = db.Column(db.String(100), unique=True, nullable=False) photo_url = db.Column(db.String(100)) is_superadmin = db.Column(db.Boolean()) repetition = db.relationship("Repetition", back_populates="admin") def __init__(self, admin_id, first_name, last_name, username, photo_url, is_superadmin=False): self.admin_id = admin_id self.first_name = first_name self.last_name = last_name self.username = username self.photo_url = photo_url self.is_superadmin = is_superadmin
class Weekly(db.Model): __tablename__ = 'Weekly' weekly_id = db.Column(db.Integer, primary_key=True, autoincrement=True) cont_id = db.Column(db.ForeignKey('WorkContract.cont_id'), nullable=False, index=True) target_ym = db.Column(db.String(8), primary_key=True, nullable=False) week_num = db.Column(db.Integer) total_time = db.Column(db.Time) total_pay = db.Column(db.Integer) holy_dnum = db.Column(db.Integer) weekly_pay = db.Column(db.Integer) created_time = db.Column(db.DateTime, server_default=func.now()) updated_time = db.Column(db.DateTime) cont = db.relationship( 'WorkContract', primaryjoin='Weekly.cont_id == WorkContract.cont_id', backref='weeklies')
class UserLabel(BaseModel): __tablename__ = "user_labels" name = db.Column(db.Text) # one to many sections = db.relationship("Section", backref="label", lazy="dynamic") # foreign key user_id user_id = db.Column(db.Integer, db.ForeignKey("users.id")) color = db.Column(db.Text) def __init__(self, name, user_id, color): self.name = name self.user_id = user_id self.color = color def create_user_label(label): db.session.add(label) db.session.commit()
class PetModel(db.Model): __tablename__ = "pet" id = db.Column(db.Integer, primary_key=True, autoincrement=True) public_id = db.Column(db.String(100), unique=True, nullable=False) status = db.Column(db.Integer, nullable=False) name = db.Column(db.String(50), nullable=False) bio = db.Column(db.String(100)) birthday = db.Column(db.DateTime, nullable=True) sex = db.Column(db.String(20), nullable=False) profile_photo_fn = db.Column(db.String(50), default="pet-default-profile-photo.jpg", nullable=False) cover_photo_fn = db.Column(db.String(50), default="pet-default-cover-photo.jpg", nullable=False) registered_on = db.Column(db.DateTime, nullable=False) owner_user_username = db.Column(db.String, db.ForeignKey("owner.username"), nullable=False) group_specie_id = db.Column(db.String, db.ForeignKey("group.public_id"), nullable=False) subgroup_breed_id = db.Column(db.String, db.ForeignKey("subgroup.public_id"), nullable=False) follow_followed_rel = db.relationship("FollowModel", backref="followed", lazy=True) def __repr__(self): return "<pet '{}'>".format(self.name)
class Post(Content): __tablename__ = "post" # DATA COLUMNS id = db.Column(db.Integer, db.ForeignKey('content.id'), primary_key=True) title = db.Column(db.String(1024), nullable=False) # FOREIGN KEYS COLUMNS posted_to_board_id = db.Column(db.Integer, db.ForeignKey('board.id'), nullable=True) # RELATIONSHIPS posted_to_board = db.relationship('Board', back_populates='posts', lazy=True) # INHERITANCE __mapper_args__ = { 'polymorphic_identity': 'post', }
class Board(db.Model): __tablename__ = 'board' # DATA COLUMNS id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), index=True, nullable=False) # RELATIONSHIPS posts = db.relationship('Post', back_populates='posted_to_board', lazy='dynamic', cascade="delete") # AGGREGATED COLUMNS @hybrid_property def posts_num(self): return self.posts.count() # INHERITANCE type = db.Column(db.String(255)) __mapper_args__ = {'polymorphic_identity': 'board', 'polymorphic_on': type}
class Account(db.Model): """ SQLAlchemy model for accounts. """ id = db.Column(db.Integer, primary_key=True, autoincrement=True) created_at = db.Column(db.DateTime, nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) username = db.Column(db.String(50), nullable=False) password = db.Column(db.String(255), nullable=False) brands = db.relationship('Brand', backref='brand', lazy=True) """ Hashes and sets a password for the account. """ def set_password(self, password): self.password = flask_bcrypt.generate_password_hash(password).decode( 'utf-8') """ Check if a password matches the hashed password stored for the account. """ def check_password(self, password): return flask_bcrypt.check_password_hash(self.password, password) def __repr__(self): return f"<Account {self.email}'>"
class GroupChat(Chat): __tablename__ = "group_chat" # DATA COLUMNS id = db.Column(db.Integer, db.ForeignKey('chat.id'), primary_key=True, autoincrement=True) of_group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=False) # RELATIONSHIPS of_group = db.relationship('Group', back_populates='chat', cascade="delete") # INHERITANCE __mapper_args__ = { 'polymorphic_identity': 'group_chat', }
class Monthly(db.Model): __tablename__ = 'Monthly' monthly_id = db.Column(db.String(50), primary_key=True) cont_id = db.Column(db.ForeignKey('WorkContract.cont_id'), nullable=False, index=True) target_ym = db.Column(db.String(6)) start_mdate = db.Column(db.String(8)) end_mdate = db.Column(db.String(8)) act_work_mtime = db.Column(db.Time) cont_work_mtime = db.Column(db.Time) act_rest_mtime = db.Column(db.Time) cont_rest_mtime = db.Column(db.Time) over_mtime = db.Column(db.Time) night_mtime = db.Column(db.Time) holy_mtime = db.Column(db.Time) tardy_mtime = db.Column(db.Time) act_work_mpay = db.Column(db.Integer) cont_work_mpay = db.Column(db.Integer) over_mpay = db.Column(db.Integer) night_mpay = db.Column(db.Integer) holy_mpay = db.Column(db.Integer) tardy_mpay = db.Column(db.Integer) weekly_mpay = db.Column(db.Integer) total_mpay = db.Column(db.Integer) total_days = db.Column(db.Integer) nat_pension = db.Column(db.Integer) health_ins = db.Column(db.Integer) employment_ins = db.Column(db.Integer) income_tax = db.Column(db.Integer) tax_exempt = db.Column(db.Integer) final_pay = db.Column(db.Integer) created_time = db.Column(db.DateTime, server_default=func.now()) updated_time = db.Column(db.DateTime) cont = db.relationship( 'WorkContract', primaryjoin='Monthly.cont_id == WorkContract.cont_id', backref='monthlies')
class RoomEvent(db.Model): __tablename__ = 'scheduler_room_reservations' id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True) room_id = db.Column('room_id', db.ForeignKey('scheduler_room_resources.id'), nullable=False) category_id = db.Column('category_id', db.ForeignKey('scheduler_event_categories.id')) category = db.relationship('EventCategory', backref=db.backref('events')) title = db.Column('title', db.String(255), nullable=False) start = db.Column('start', db.DateTime(timezone=True), nullable=False) end = db.Column('end', db.DateTime(timezone=True), nullable=False) iocode_id = db.Column('iocode_id', db.ForeignKey('iocodes.id')) occupancy = db.Column('occupancy', db.Integer()) # number of sets of food/refreshment requested refreshment = db.Column('refreshment', db.Integer(), default=0) request = db.Column('request', db.Text()) # comma separated list of things approved = db.Column('approved', db.Boolean(), default=True) created_at = db.Column('created_at', db.DateTime(timezone=True), server_default=func.now()) created_by = db.Column('created_by', db.ForeignKey('staff_account.id')) updated_at = db.Column('updated_at', db.DateTime(timezone=True), server_default=None) updated_by = db.Column('updated_by', db.ForeignKey('staff_account.id')) cancelled_at = db.Column('cancelled_at', db.DateTime(timezone=True), server_default=None) cancelled_by = db.Column('cancelled_by', db.ForeignKey('staff_account.id')) approved_by = db.Column('approved_by', db.ForeignKey('staff_account.id')) approved_at = db.Column('approved_at', db.DateTime(timezone=True), server_default=None) extra_items = db.Column('extra_items', db.JSON) note = db.Column('note', db.Text()) google_event_id = db.Column('google_event_id', db.String(64)) google_calendar_id = db.Column('google_calendar_id', db.String(255))
class Alumni(db.Model): __tablename__ = "alumni" alumni_id = db.Column(db.Integer, primary_key=True, autoincrement=True) alumni_uuid = db.Column(db.String(50), unique=True) odoo_contact_id = db.Column(db.String(50), unique=True, nullable=False) email = db.Column(db.String(100), unique=True) password = db.Column(db.String(100)) user_confirmed = db.Column(db.Boolean()) allow_show_contacts = db.Column(db.Boolean()) update_form = db.relationship("UpdateForm", back_populates="alumni") def __init__(self, odoo_contact_id, email, password, allow_show_contacts): self.alumni_uuid = str(uuid.uuid4()) self.odoo_contact_id = odoo_contact_id self.email = email self.password = flask_bcrypt.generate_password_hash(password).decode() self.user_confirmed = False self.allow_show_contacts = allow_show_contacts def check_password(self, password): return flask_bcrypt.check_password_hash(self.password, password)
class Section(BaseModel): __tablename__ = "sections" name = db.Column(db.Text) # One to many with Tasks tasks = db.relationship("Task", backref="section", lazy="dynamic") # Foreign key user_label_id user_label_id = db.Column(db.Integer, db.ForeignKey("user_labels.id")) def __init__(self, name, user_label_id): self.name = name self.user_label_id = user_label_id def create_section(section): db.session.add(section) db.session.commit() def __repr__(self) -> str: if self.tasks: return "Section with name ::: {} and tasks ::: {}".format( self.name, self.tasks) else: return "Section with name ::: {}".format(self.name)
class User(db.Model, UserMixin): __tablename__ = 'sys_user' id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(80), unique=True, nullable=False, comment=u'用户名') password_hash = db.Column(db.String(128), comment="加密密码") email = db.Column(db.String(120), unique=True, comment=u'email') phone = db.Column(db.String(20), unique=True, comment=u'手机号码') avatar = db.Column(db.String(200), comment=u'头像') status = db.Column(db.Integer, default=1, comment=u'状态') lastLoginTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'最后登录时间') createTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'创建时间') createBy = db.Column(db.String(50), comment=u'创建人') updateTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'修改时间') updateBy = db.Column(db.String(50), comment=u'修改人') roles = db.relationship( 'Role', secondary=sys_user_role, backref=db.backref('users', lazy='dynamic') ) @property def role_names(self): strs = '' for i in range(len(self.roles)): strs = strs + self.roles[i].name + ',' return strs # @property # def permissions(self): # permissions = Permission.query.join(sys_role_permission).join(Role).join(sys_user_role).join(User). \ # filter( # User.id == self.id # ) # return permissions @property def menus(self): menus = Menu.query.join(sys_role_menu).join(Role).join(sys_user_role).join(User). \ filter( User.id == self.id ).order_by(Menu.type, Menu.order).all() return menus def check(self, action): permission = self.permissions.filter(Permission.action == action).first() return bool(permission) def __init__(self, username, password): self.username = username self.password = password def __init__(self, username, phone): self.username = username self.password = phone @property def password(self): return self.password_hash # raise AttributeError('不能直接获取明文密码!') @property def create_time(self): return self.createTime.strftime('%Y-%m-%d') # def auth(method): # @functools.wraps(method) # def wrapper(*args, **kwargs): # user_id = session.get('user_id') # if not user_id: # return abort(403) # return method(*args, **kwargs) # # return wrapper @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 get_id(self): return self.username def update(self): globals.db.commit() def delete(self): globals.db.delete(self) globals.db.commit() def save(self): globals.db.add(self) globals.db.commit()
class NodeModel(db.Model): __tablename__ = 'nodes' id = db.Column(db.Integer, primary_key = True) name = db.Column(db.String(200), nullable = False) address = db.Column(db.String(400), nullable = False) lat = db.Column(db.Float, nullable = False) long = db.Column(db.Float, nullable = False) manager = db.Column(db.String(200), nullable = False) key = db.Column(db.String(30), nullable = False) datas = db.relationship('DataNodesModel', backref='nodes') def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def return_all_public(cls): # fractal datas of node def to_json_data(data): return { 'aqi': data.aqi, 'pm25': data.pm25, 'pm10': data.pm10, 'created_at': data.created_at.strftime("%m/%d/%Y, %H:%M:%S") } # fractal nodes def to_json(x): return { 'name': x.name, 'address': x.address, 'lat': x.lat, 'long': x.long, 'datas': list(map(lambda y: to_json_data(y), DataNodesModel.query.filter_by(node_id = x.id).limit(10).all())) } return {'nodes': list(map(lambda x: to_json(x), NodeModel.query.all()))} @classmethod def return_all_public_current(cls): # status air 1,2,3,4,5,6 def air_status(data): if data <= 50: return { "type": 1, "info": "Tốt", "infoEng": "Good" } elif data <= 100: return { "type": 2, "info": "Vừa phải", "infoEng": "Moderate" } elif data <= 150: return { "type": 3, "info": "Không tốt cho sức khỏe với nhóm người nhạy cảm", "infoEng": "Unhealthy for Sensitive Groups" } elif data <= 200: return { "type": 4, "info": "Ô nhiễm", "infoEng": "Unhealthy" } elif data <= 300: return { "type": 5, "info": "Rất ô nhiễm", "infoEng": "Very Unhealthy" } else: return { "type": 6, "info": "Nguy hiểm", "infoEng": "Hazardous" } # fractal datas of node def to_json_data(data): return { 'aqi': data.aqi, 'pm25': data.pm25, 'pm10': data.pm10, 'status': air_status(data.aqi), 'created_at': data.created_at.strftime("%m/%d/%Y, %H:%M:%S") } # fractal nodes def to_json(x): # time 24 hours ago data24h = db.session.execute('SELECT AVG(aqi) as aqi, AVG(pm25) as pm25, AVG(pm10) as pm10, \ HOUR(created_at) as created_at FROM datas \ WHERE node_id = :node_id AND DATE_SUB(`created_at`,INTERVAL 1 HOUR) And \ created_at > DATE_SUB(NOW(), INTERVAL 1 DAY) \ GROUP BY HOUR(created_at) ORDER BY id', {'node_id': x.id}) if data24h.returns_rows == False: response_24h = [] # Convert the response to a plain list of dicts else: response_24h = [dict(row.items()) for row in data24h] # time 7 days ago data7day = db.session.execute("SELECT AVG(aqi) as aqi, AVG(pm25) as pm25, AVG(pm10) as pm10, \ DATE_FORMAT(created_at, '%d/%m') as created_at FROM datas \ WHERE node_id = :node_id AND DATE_SUB(`created_at`, INTERVAL 7 DAY) And \ created_at > DATE_SUB(NOW(), INTERVAL 7 DAY) \ GROUP BY DATE_FORMAT(created_at, '%d/%m') ORDER BY id", {'node_id': x.id}) if data7day.returns_rows == False: response_7day = [] # Convert the response to a plain list of dicts else: response_7day = [dict(row.items()) for row in data7day] try: data = to_json_data(DataNodesModel.query.filter_by(node_id = x.id).order_by(DataNodesModel.created_at.desc()).first()) except: data = '' return { 'id': x.id, 'name': x.name, 'address': x.address, 'lat': x.lat, 'long': x.long, 'data': data, '_24h': json.loads(json.dumps(response_24h, default=defaultencode)), '_7day': json.loads(json.dumps(response_7day, default=defaultencode)) } return {'nodes': list(map(lambda x: to_json(x), NodeModel.query.all()))} @classmethod def return_all_private(cls): def to_json(x): return { 'id': x.id, 'name': x.name, 'address': x.address, 'lat': x.lat, 'long': x.long, 'manager': x.manager, 'key': x.key } return {'nodes': list(map(lambda x: to_json(x), NodeModel.query.all()))} @classmethod def find_by_key(cls, key): return cls.query.filter_by(key = key).first() @classmethod def find_by_id(cls, id): return cls.query.filter_by(id = id).first() @classmethod def get_json_node_by_id(cls, id): def to_json(x): return { 'id': x.id, 'name': x.name, 'address': x.address, 'lat': x.lat, 'long': x.long, 'manager': x.manager, 'key': x.key } return {'data': to_json(cls.query.filter_by(id = id).first())} @classmethod def delete_by_id(cls, id): cls.query.filter_by(id = id).delete() db.session.commit() @staticmethod def randomString(stringLength): letters = string.ascii_letters return ''.join(random.choice(letters) for i in range(stringLength))
class Content(db.Model): __tablename__ = 'content' # DATA COLUMNS id = db.Column(db.Integer, primary_key=True, autoincrement=True) body = db.Column(db.Text(4294000000), nullable=False) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) # FOREIGN KEYS COLUMNS author_id = db.Column(db.String(255), db.ForeignKey('user.id'), nullable=False) # RELATIONSHIPS author = db.relationship('User', back_populates='published_content', lazy=True) comments = db.relationship('Comment', back_populates='commented_content', lazy='dynamic', foreign_keys='Comment.commented_content_id', cascade="delete") likes = db.relationship('Likes', back_populates='content', lazy='dynamic', cascade="delete") dislikes = db.relationship('Dislikes', back_populates='content', lazy='dynamic', cascade="delete") @hybrid_property def comments_num(self): sum = self.comments.count() if sum > 0: for content in self.comments.all(): sum += content.comments_num return sum @hybrid_property def likes_num(self): return self.likes.count() @hybrid_property def dislikes_num(self): return self.dislikes.count() @hybrid_method def liked(self, user): return db.session.query( Content.query.filter(Content.id == self.id).join(Likes).filter( Likes.user_id == user.id).exists()).scalar() @hybrid_method def disliked(self, user): return db.session.query( Content.query.filter(Content.id == self.id).join(Dislikes).filter( Dislikes.user_id == user.id).exists()).scalar() @staticmethod def get_content_with_user_data(content_query, user): return content_query.outerjoin(Likes).filter( or_(Likes.user_id == user.id, Likes.user_id == None)).outerjoin(Dislikes).filter( or_(Dislikes.user_id == user.id, Dislikes.user_id == None)).with_entities( Content, cast(func.count(Likes.user_id), sqlalchemy.Boolean).label('liked'), cast(func.count(Dislikes.user_id), sqlalchemy.Boolean).label( 'disliked')).group_by(Content.id) # INHERITANCE type = db.Column(db.String(255)) __mapper_args__ = { 'polymorphic_identity': 'content', 'polymorphic_on': type }
class User(db.Model, UserMixin): """ Description of User model. Columns ----------- :id: int [pk] :username: varchar(128) [not NULL] :password: varchar(128) [not NULL] :first_name: varchar(255) [not NULL] :last_name: varchar(255) :dob: date :email: varchar(255) [not NULL] :fb_handle: varchar(255) :g_handle: varchar(255) :medium_handle: varchar(255) :twitter_handle: varchar(255) :linkedin_handle: varchar(255) :bio: text :occupation: varchar(255) :profile_picture: int :last_login: timestamp :creation_time: timestamp :is_verified: boolean """ # Columns id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(128), unique=True, nullable=False) password = db.Column(db.String(128), nullable=False) first_name = db.Column(db.String(255), default="") last_name = db.Column(db.String(255), default="") dob = db.Column(db.DateTime) email = db.Column(db.String(255), nullable=False) fb_handle = db.Column(db.String(255)) g_handle = db.Column(db.String(255)) medium_handle = db.Column(db.String(255)) twitter_handle = db.Column(db.String(255)) linkedin_handle = db.Column(db.String(255)) profile_picture = db.Column(db.Integer) bio = db.Column(db.Text) occupation = db.Column(db.String(255)) last_login = db.Column(db.DateTime) creation_time = db.Column(db.DateTime) is_verified = db.Column(db.Boolean, default=False) # Relationships tags = db.relationship('Tag', secondary=userTagJunction, lazy='subquery', backref=db.backref("users", lazy=True)) saves = db.relationship('Post', secondary=userPostInteraction, lazy=True, backref=db.backref("savers", lazy=True)) payments = db.relationship('Payment', backref='user', lazy=True) def __init__(self, username, password, email): self.username = username self.password = generate_password_hash(password) self.email = email self.is_verified = False self.profile_picture = 1 db.session.add(self) db.session.commit() @staticmethod @login_manager.user_loader def load_user(id): return User.query.filter_by(id=id).first() def update_col(self, key, value): self.__dict__[key] = value db.session.commit() def check_password(self, password): return check_password_hash(self.password, password) def resetPassword(self, newPassword): # Pass in a hashed password self.password = generate_password_hash(newPassword) db.session.commit() def addPayment(self, data): pay = Payment(self, data.get("amount"), data.get("api_response")) self.payments.append(pay) db.session.commit() def get_id(self): return self.id # We do not need to implement update metadata. # Actually, it can be updated ad hoc by assignment without calling commit. def isVerified(self): return self.is_verified def setVerified(self): self.is_verified = True db.session.commit() def setNewTag(self, tag): self.tags.append(tag) db.session.commit() def setTagPriority(self, tag, priority): result = self.getTagPriority(tag) if result is None: self.setNewTag(tag) s = userTagJunction.update().\ values(priority=PriorityType(priority)).\ where(and_( userTagJunction.c.user_id == self.id, userTagJunction.c.keyword_id == tag.id)) db.session.execute(s) db.session.commit() def getTagPriority(self, tag): s = select([userTagJunction]).where(and_( userTagJunction.c.user_id == self.id, userTagJunction.c.keyword_id == tag.id)) result = list(db.session.execute(s)) try: return result[0]["priority"] except IndexError: return None def savePost(self, post): if post not in self.saves: self.saves.append(post) else: self.saves.remove(post) db.session.commit() def ratePost(self, post, rating): try: s = userPostInteraction.update().\ where(user_id=self.id, post_id=post.post_id).\ values(rating=rating) db.session.execute(s) except BaseException: # User has not yet saved the post so there is no entry here s = userPostInteraction.insert().\ values(save=False, rating=rating, user_id=self.id, post_id=post.post_id) db.session.execute(s) finally: db.session.commit()
class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) posts = db.relationship("Post", backref="author", lazy="dynamic") comments = db.relationship("Comment", backref="author", lazy="dynamic") about_me = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) followed = db.relationship( "User", secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref("followers", lazy="dynamic"), lazy="dynamic", ) posts_liked = db.relationship( "Post", secondary=likes, primaryjoin=(likes.c.user_id == id), secondaryjoin=(likes.c.post_id == id), backref=db.backref("likes", lazy="dynamic"), lazy="dynamic", ) messages_sent = db.relationship('Message', foreign_keys='Message.sender_id', backref='author', lazy='dynamic') messages_received = db.relationship('Message', foreign_keys='Message.recipient_id', backref='recipient', lazy='dynamic') last_message_read_time = db.Column(db.DateTime) notifications = db.relationship('Notification', backref='user', lazy='dynamic') def __repr__(self): return f"<User: {self.username}>" 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 avatar(self, size): digest = md5(self.email.lower().encode("utf-8")).hexdigest() return f"https://www.gravatar.com/avatar/{digest}?d=identicon&s={size}" def follow(self, user): if not self.is_following(user): self.followed.append(user) def unfollow(self, user): if self.is_following(user): self.followed.remove(user) def is_following(self, user): return self.followed.filter(followers.c.followed_id == user.id).count() > 0 def followed_posts(self): followed = Post.query.join( followers, (followers.c.followed_id == Post.user_id) ).filter(followers.c.follower_id == self.id) return followed.union(self.posts).order_by(Post.timestamp.desc()) def like_post(self, post): if not self.like_post.liked(post): self.posts_liked.append(post) def unlike_post(self, post): if self.liked(post): self.like_post.remove(post) def liked(self, post): return self.posts_liked.filter(likes.c.post_id==post.id).count() > 0 def get_reset_password_token(self, expires_in=600): return jwt.encode( {"reset_password": self.id, "exp": time() + expires_in}, current_app.config["SECRET_KEY"], algorithm="HS256", ) @staticmethod def verify_reset_password_token(token): try: id = jwt.decode( token, current_app.config["SECRET_KEY"], algorithms=["HS256"] )["reset_password"] except: return return User.query.get(id) def new_messages(self): last_read_time = self.last_message_read_time or datetime(1900, 1, 1) return Message.query.filter_by(recipient=self).filter( Message.timestamp > last_read_time ).count() def add_notification(self, name, data): self.notifications.filter_by(name=name).delete() n = Notification(name=name, payload_json=json.dumps(data), user=self) db.session.add(n) return n def notify_followers(self, name, data): for follower in self.followers: follower.notifications.filter_by(name=name).delete() follower.add_notification(name, data)
class sdLed(db.Model): __tablename__ = "sd32_leds" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(20), comment="Name") display_name = db.Column(db.String(50), comment="Display name") comment = db.Column(db.Text, comment="Comment") create_time = db.Column(db.DateTime, server_default=func.now(), comment="Create time") update_time = db.Column(db.DateTime, server_default=func.now(), comment="Update time") cust_id = db.Column(db.Integer, db.ForeignKey(sdCustomer.id), comment="Customer id") status = db.Column( db.Integer, server_default="0", comment="Device status flag. bit 0: warning, bit 1: error") model_id = db.Column(db.Integer, db.ForeignKey(sdDeviceModel.id), server_default="0", comment="Traffic Light model/part no") serial_no = db.Column(db.String(50), nullable=False, comment="Serial No") device = db.relationship("sdDevice", uselist=False, backref="led") __table_args__ = (db.UniqueConstraint("serial_no"), db.UniqueConstraint("cust_id", "name")) def __repr__(self): return f"<sdLed id={self.id}/name={self.name}/display_name={self.display_name}/sn={self.serial_no}>" @staticmethod def add(cust_id, led): model = db.session.query(sdDeviceModel) \ .filter(sdDeviceModel.name == led.get("model_name")).first() obj = sdLed() obj.cust_id = cust_id obj.name = led.get("name") obj.display_name = led.get("display_name") obj.comment = led.get("comment") obj.model = model obj.serial_no = led.get("serial_no") return obj @staticmethod def update(cust_id, led): model = db.session.query(sdDeviceModel) \ .filter(sdDeviceModel.name == led.get("model_name")).first() sdn = led["serial_no"] obj = db.session.query(sdLed).filter(sdLed.serial_no == sdn).first() if obj: obj.cust_id = cust_id obj.name = led.get("name") obj.display_name = led.get("display_name") obj.comment = led.get("comment") obj.model = model obj.serial_no = led.get("serial_no") else: obj = sdLed.add(cust_id, led) return obj
class Category(db.Model): __tablename__ = 'categories' id = db.Column(db.Integer, primary_key=True) type = db.Column(db.String, nullable=False) questions = db.relationship('Question', backref='cat', lazy=True)
class sdCustomer(db.Model): __tablename__ = "sd10_customers" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(20), unique=True, nullable=False, index=True, comment="Name") display_name = db.Column(db.String(50), nullable=False, comment="Display name") comment = db.Column(db.Text, comment="Comment") status = db.Column(db.Integer, nullable=False, server_default="0", comment="Status") create_time = db.Column(db.DateTime, nullable=False, server_default=func.now(), comment="Create time") update_time = db.Column(db.DateTime, nullable=False, server_default=func.now(), comment="Update time") cust_id = db.Column(db.Integer, db.ForeignKey("sd10_customers.id"), comment="Vendor of customer") vendors = db.relationship("sdCustomer", lazy="dynamic") users = db.relationship("sdUser", backref="cust", lazy="dynamic") controllers = db.relationship("sdController", backref="cust", lazy="dynamic") leds = db.relationship("sdLed", backref="cust", lazy="dynamic") device_groups = db.relationship("sdDeviceGroup", backref="cust", lazy="dynamic") schedules = db.relationship("sdSchedule", backref="cust", lazy="dynamic") codes = db.relationship("sdCode", backref="cust", lazy="dynamic") user_groups = db.relationship("sdUserGroup", backref="cust", lazy="dynamic") status_privilege = db.relationship("sdStatusPrivilege", backref="cust", lazy="dynamic") device_info = db.relationship("sdDeviceInfo", backref="cust", lazy="dynamic") cust_devices = db.relationship("sdDevice", foreign_keys="sdDevice.cust_id", backref="cust", lazy="dynamic") vendor_devices = db.relationship("sdDevice", foreign_keys="sdDevice.vendor_id", backref="vendor", lazy="dynamic") def __repr__(self): return f"<sdCustomer id={self.id}/name={self.name}/display_name={self.display_name}>" @staticmethod def search(cust_id): customer = db.session.query( sdCustomer.id).filter(sdCustomer.id == cust_id).first() return customer @staticmethod def search_by_name(cust_name): customer = sdCustomer.query.filter_by(name=cust_name).first() return customer @staticmethod def search_cust(cust_id): customer = db.session.query(sdCustomer).filter( sdCustomer.id == cust_id, sdCustomer.cust_id.is_(None)).all() return customer @staticmethod def get_vendors(cust_id): vendors = db.session.query(sdCustomer).filter( sdCustomer.cust_id == cust_id).all() return vendors @staticmethod def search_cust_obj(cust_id): customer = db.session.query(sdCustomer).filter( sdCustomer.id == cust_id).first() return customer
class Post(Base, SearchableMixin): """ Description of User model. Columns ----------- :id: int [pk] :title: Text [not NULL] :author_id: int [Foreign Key] :creation_time: DateTime [not NULL] :last_edit_time: DateTime [not NULL] :post_body: Text # Relationships :comments: Relationship -> Comments (one to many) """ # Columns id = db.Column(db.Integer, db.ForeignKey("base.id"), primary_key=True) post_id = db.Column(db.Integer, autoincrement=True, primary_key=True, unique=True) title = db.Column(db.Text, nullable=False) post_movie = db.Column(db.String(20)) tags = db.Column(db.JSON) __searchable__ = ['title', 'body', 'tags'] __mapper_args__ = { 'polymorphic_identity': 'post', 'inherit_condition': (id == Base.id) } comments = db.relationship( 'Comment', primaryjoin="(Post.post_id == Comment.parent_post_id)", backref=db.backref('post'), lazy='dynamic') def __init__(self, author_id, post_movie, title, post_body, tags): super().__init__(author_id, post_body, "post") self.title = title self.post_movie = post_movie self.tags = tags db.session.add(self) db.session.commit() def add_comment(self, author_id, comment_body): parent_post_id = self.id comment = Comment(author_id, parent_post_id, comment_body) self.comments.append(comment) db.session.commit() return comment.id def update_col(self, key, value): setattr(self, key, value) db.session.commit() def delete_post(self, post_id): post = Post.query.filter_by(id=post_id).delete() db.session.commit()
class sdUserGroup(db.Model): __tablename__ = "sd13_user_groups" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(20), comment="Name", nullable=False) display_name = db.Column(db.String(50), comment="Display name") comment = db.Column(db.Text, comment="Comment") create_time = db.Column(db.DateTime, server_default=func.now(), comment="Create time") update_time = db.Column(db.DateTime, server_default=func.now(), comment="Update time") cust_id = db.Column(db.Integer, db.ForeignKey("sd10_customers.id"), comment="Customer id") rel_dg_ug = db.relationship('sdDeviceGroup', secondary=rel_dg_ug, backref='user_groups') rel_u_ug = db.relationship('sdUser', secondary=rel_u_ug, backref='user_groups') rel_role_ug = db.relationship('sdRole', secondary=rel_role_ug, backref='user_groups') __table_args__ = (db.UniqueConstraint("cust_id", "name"),) def __repr__(self): return f"<sdUserGroup id={self.id}/name={self.name}/display_name={self.display_name}/cust_id={self.cust_id}" @staticmethod def getall(cust_id): usergroups = db.session.query(sdUserGroup).filter(sdUserGroup.cust_id == cust_id).all() return usergroups @staticmethod def add(cust_id, name, display_name, comment): obj = sdUserGroup() obj.cust_id = cust_id obj.name = name obj.display_name = display_name obj.comment = comment return obj # delete_all_users: delete all users, device groups record corresponding to the user group from m2m table @staticmethod def delete_all_users(cust_id, user_list): user_groups = db.session.query(sdUserGroup).filter(sdUserGroup.cust_id == cust_id, sdUserGroup.id.in_(user_list)).all() # TAG clear() attribute is active only without lazy = dynamic for user_group in user_groups: dg_rels = user_group.rel_dg_ug dg_rels.clear() u_rels = user_group.rel_u_ug u_rels.clear() role_rels = user_group.rel_role_ug role_rels.clear() @staticmethod def delete(cust_id, user_list): sdUserGroup.query.filter(sdUserGroup.cust_id == cust_id, sdUserGroup.id.in_(user_list)).delete(synchronize_session=False) @staticmethod def update(cust_id, group_id, new_name, new_display_name, new_comment): obj = db.session.query(sdUserGroup).filter(sdUserGroup.cust_id == cust_id, sdUserGroup.id == group_id).first() obj.name = new_name if new_name else obj.name obj.display_name = new_display_name if new_display_name else obj.display_name obj.comment = new_comment if new_comment else obj.comment return obj # user join user group @staticmethod def join_users(cust_id, user_group_id, user_list): selected_user_group = db.session.query(sdUserGroup).filter( sdUserGroup.id == user_group_id, sdUserGroup.cust_id == cust_id).first() query_obj = db.session.query(sdUser).filter(sdUser.id.in_(user_list), sdUser.cust_id == cust_id).all() selected_user_group.rel_u_ug.extend(query_obj) # user leave user group @staticmethod def leave_users(user_group_id, user_list): db.session.query(rel_u_ug).filter(rel_u_ug.c.user_group_id == user_group_id).\ filter(rel_u_ug.c.user_id.in_(user_list)).\ delete(synchronize_session=False) @staticmethod def get_status_privilege(usergroup_obj, cust_id, flag, priv_set): # status_privilege = [] for ug_obj in usergroup_obj: # get roles of user group role_ug = ug_obj.rel_role_ug for role in role_ug: # get status privilege of role, filter cust_id status_privilege = sdStatusPrivilege.get_privilege(role.id, cust_id) if flag == 2: for priv_obj in status_privilege: # get status tuple priv_set.add(priv_obj.status_to) else: for priv_obj in status_privilege: # get status tuple priv_set.add((str(priv_obj.status_from), str(priv_obj.status_to))) return priv_set @staticmethod def give_user_id_get_roles(user_id): user_obj = db.session.query(sdUser).filter(sdUser.id == user_id).first() # get user groups of users usergroup_obj = user_obj.user_groups role_set = set() # Gathering data from models using relationship for ug_obj in usergroup_obj: # get roles of user group role_ug = ug_obj.rel_role_ug for role in role_ug: # get privilege of role role_set.add(role.id) return role_set @staticmethod def give_user_id_get_auths(user_id, flag, cust_id=None): user_obj = db.session.query(sdUser).filter(sdUser.id == user_id).first() # get user groups of users usergroup_obj = user_obj.user_groups priv_set = set() # Gathering data from models using relationship if flag == 0: for ug_obj in usergroup_obj: # get roles of user group role_ug = ug_obj.rel_role_ug for role in role_ug: # get privilege of role priv = role.privileges for route in priv: # get api route priv_set.add(route.api_route) else: priv_set = sdUserGroup.get_status_privilege(usergroup_obj, cust_id, flag, priv_set) return priv_set
class LogEntity(db.Model, CRUDMixin): """ Keep track of important user actions """ __tablename__ = 'Log' id = db.Column('logID', db.Integer, primary_key=True) type_id = db.Column('logtID', db.Integer, db.ForeignKey('LogType.logtID'), nullable=False) web_session_id = db.Column('webID', db.Integer, db.ForeignKey('WebSession.webID'), nullable=False) date_time = db.Column('logDateTime', db.DateTime, nullable=False, server_default='0000-00-00 00:00:00') details = db.Column('logDetails', db.Text, nullable=False) # @OneToOne log_type = db.relationship(LogTypeEntity, uselist=False, lazy='joined') web_session = db.relationship(WebSessionEntity, uselist=False, lazy='joined') @staticmethod def get_logs(per_page=25, page_num=1): """ Helper for formating the event details """ def item_from_entity(entity): return { 'id': entity.id, 'user_email': entity.web_session.user.email if entity.web_session.user is not None else '', 'type': entity.log_type.type, 'details': entity.details, 'web_session_ip': entity.web_session.ip, 'date_time': utils.localize_est_datetime(entity.date_time), } pagination = LogEntity.query.paginate(page_num, per_page, False) items = map(item_from_entity, pagination.items) return items, pagination.pages @staticmethod def _log(log_type, session_id, details=''): """ Helper for logging """ logt = LogTypeEntity.query.filter_by(type=log_type).first() if logt is None: app.logger.error( "Developer error. Invalid log type: {}".format(log_type)) return web_session = WebSessionEntity.get_by_session_id(session_id) if web_session is None: app.logger.error( "Developer error. Invalid session id: {}".format(session_id)) return LogEntity.create(log_type=logt, date_time=datetime.datetime.now(), details=details, web_session=web_session) @staticmethod def account_created(session_id, details=''): """ Log account creation """ LogEntity._log(LOG_TYPE_ACCOUNT_CREATED, session_id, details) @staticmethod def login(session_id, details=''): """ Log successful login """ LogEntity._log(LOG_TYPE_LOGIN, session_id, details) @staticmethod def logout(session_id, details=''): """ Log logout click """ LogEntity._log(LOG_TYPE_LOGOUT, session_id, details) @staticmethod def login_error(session_id, details=''): """ Log failed login """ LogEntity._log(LOG_TYPE_LOGIN_ERROR, session_id, details) @staticmethod def account_modified(session_id, details=''): """ Log account changes """ LogEntity._log(LOG_TYPE_ACCOUNT_MODIFIED, session_id, details) def __repr__(self): """ Return a friendly object representation """ return "<LogEntity(logID: {0.id}, "\ "logtID: {0.type_id}" \ "webID: {0.web_session_id}, "\ "date_time: {0.date_time})>".format(self)
class Recipe(db.Model): __tablename__ = "recipes" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text(), nullable=False) description = db.Column(db.Text(), nullable=False) steps = db.Column(db.Text(), nullable=False) account_id = db.Column(db.Integer, db.ForeignKey( "accounts.id", ondelete="CASCADE", ), nullable=False, index=True) ingredient_amounts = db.relationship( "RecipeIngredient", backref="recipe", lazy=True, passive_deletes=True) def __init__(self, name, description, steps): self.name = name self.description = description self.steps = steps def get_ingredients(self): stmt = text(""" SELECT ri.amount AS amount, ri.amount_unit AS amount_unit, ri.group_name AS group_name, i.id AS id, i.name AS name FROM ingredients i, recipe_ingredient ri WHERE ri.recipe_id = :recipe_id AND i.account_id = :account_id AND ri.ingredient_id = i.id ORDER BY ri.id """).bindparams(recipe_id=self.id, account_id=self.account_id) return db.session().execute(stmt) def get_shopping_list_amounts(self): stmt = text(""" SELECT i.id AS id, SUM(sli.amount) AS amount, sli.amount_unit AS unit FROM ( SELECT DISTINCT i.id AS id, i.name AS name FROM ingredients i, recipe_ingredient ri WHERE i.account_id = :account_id AND i.id = ri.ingredient_id AND ri.recipe_id = :recipe_id ) i LEFT JOIN shopping_list_items sli ON sli.ingredient_id = i.id WHERE sli.account_id = :account_id GROUP BY i.id, sli.amount_unit """).bindparams(recipe_id=self.id, account_id=self.account_id) return db.session().execute(stmt) def insert_ingredients_from_form(self, form): ingredients = [] missing_ingredients = [] ingredients_by_name = {} for recipe_ingredient_form in form.ingredient_amounts: name = recipe_ingredient_form.data["name"].strip() lower_name = name.lower() existing_ingredient = ingredients_by_name.get(lower_name) if not existing_ingredient: existing_ingredient = Ingredient.query.filter( Ingredient.account_id == self.account_id, func.lower(Ingredient.name) == lower_name, ).first() if not existing_ingredient: existing_ingredient = Ingredient(name) existing_ingredient.account_id = self.account_id missing_ingredients.append(existing_ingredient) ingredients_by_name[lower_name] = existing_ingredient ingredients.append(existing_ingredient) db.session().bulk_save_objects(missing_ingredients, return_defaults=True) db.session().flush() recipe_ingredients = [] for index, recipe_ingredient_form in enumerate(form.ingredient_amounts): amount, unit = recipe_ingredient_form.parse_amount() recipe_ingredients.append(RecipeIngredient( amount=amount, amount_unit=unit, ingredient_id=ingredients[index].id, recipe_id=self.id, group_name=recipe_ingredient_form.group.data, )) db.session().bulk_save_objects(recipe_ingredients) db.session().flush()
class User(db.Model): __tablename__ = 'user' # DATA COLUMNS id = db.Column(db.String(255), primary_key=True, autoincrement=False) display_name = db.Column(db.String(255), unique=True, nullable=True) registered_on = db.Column(db.DateTime, default=datetime.utcnow) # RELATIONSHIPS published_content = db.relationship('Content', back_populates='author', lazy='dynamic') liked_content = db.relationship('Likes', back_populates='user', lazy='dynamic') disliked_content = db.relationship('Dislikes', back_populates='user', lazy='dynamic') followed_courses = db.relationship('Course', secondary=user_follows_course, back_populates='followers', lazy='dynamic') groups = db.relationship('GroupMember', back_populates='user', lazy='dynamic') sent_messages = db.relationship('Message', back_populates='sender_user', lazy='dynamic') chats_with_users = db.relationship('UsersChat', back_populates='of_user', foreign_keys='UsersChat.of_user_id', lazy='dynamic') group_invites = db.relationship('GroupInvite', foreign_keys='GroupInvite.invited_id', back_populates='invited', lazy='dynamic') devices_tokens = db.relationship('DeviceToken', back_populates='user', lazy='dynamic') @hybrid_property def joined_groups(self): return self.groups.join(Group).with_entities(Group) @hybrid_property def published_posts(self): return self.published_content.filter(Content.type == 'post') @hybrid_property def published_reviews(self): return self.published_content.filter(Content.type == 'review') @hybrid_property def published_comments(self): return self.published_content.filter(Content.type == 'comment') @hybrid_property def get_posts_feed(self): joined_groups_sq = self.joined_groups.subquery('joined_groups', True) followed_courses_sq = self.followed_courses.subquery( 'followed_courses', True) return Post.query.join( joined_groups_sq, Post.posted_to_board_id == joined_groups_sq.c.group_id).union( Post.query.join( followed_courses_sq, Post.posted_to_board_id == followed_courses_sq.c.course_id)).union( Post.query.filter(Post.posted_to_board_id == None)) @hybrid_method def chat_with_user(self, other_user): other_user_chats = other_user.chats_with_users.subquery( 'other_user_chats', True) return self.chats_with_users.join( other_user_chats, UsersChat.other_user_chat_id == other_user_chats.c.users_chat_id).with_entities(UsersChat)
class Synonym(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) synonym = db.Column(db.String(255), unique=True, nullable=False) snapshots = db.relationship("Snapshot", back_populates="synonym")
class Account(db.Model): __tablename__ = "accounts" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.Text, nullable=False, unique=True) password_hash = db.Column(db.Text, nullable=False) role = db.Column(db.Text, nullable=False) valid_roles = {"user", "admin"} recipes = db.relationship("Recipe", backref="account", lazy=True, passive_deletes=True) ingredients = db.relationship("Ingredient", backref="account", lazy=True, passive_deletes=True) shopping_list_items = db.relationship("ShoppingListItem", backref="account", lazy=True, passive_deletes=True) def is_admin(self): return self.role == "admin" def get_id(self): return str(self.id) def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def fullfills_role(self, role): """ Checks if this Account fullfills `role`. The role "user" is fullfilled by roles "user" and "admin". The role "admin" is fullfilled by role "admin". """ if self.role == role: return True return self.role == "admin" and role == "user" @staticmethod def get_top_recipe_collectors(count): stmt = text(""" SELECT accounts.username username, COUNT(recipes.id) recipe_count FROM accounts LEFT JOIN recipes ON recipes.account_id = accounts.id GROUP BY accounts.username ORDER BY COUNT(recipes.id) DESC, accounts.username LIMIT :count """).params(count=count) rows = db.session().execute(stmt) try: return rows.fetchall() finally: rows.close() @staticmethod def is_username_taken(username): return db.session().query( exists().where(Account.username == username)).scalar()
class Content(db.Model): __tablename__ = "CONTENT" id = db.Column(db.String(32), primary_key=True) companies = db.relationship("Company", secondary=association_table, back_populates="contents")
class Apartment(db.Model): __tablename__ = 'apartment' id = db.Column(db.Integer, primary_key=True) title = db.Column('title', db.String) created_at = db.Column('created_at', db.DateTime) price_usd = db.Column('price_usd', db.Integer) price_uah = db.Column('price_uah', db.Integer) description = db.Column('description', db.Text) street_name = db.Column('street_name', db.String, nullable=True) state_name = db.Column('state_name', db.String, nullable=True) city_name = db.Column('city_name', db.String, nullable=True) total_square_meters = db.Column('total_square_meters', db.Float, nullable=True) living_square_meters = db.Column('living_square_meters', db.Float, nullable=True) kitchen_square_meters = db.Column('kitchen_square_meters', db.Float, nullable=True) rooms_count = db.Column('rooms_count', db.Integer, nullable=True) floor = db.Column('floor', db.String, nullable=True) floors_count = db.Column('floors_count', db.String, nullable=True) wall_type = db.Column('wall_type', db.String, nullable=True) inspected = db.Column('inspected', db.String, nullable=True) verified_price = db.Column('verified_price', db.String, nullable=True) latitude = db.Column('latitude', db.Float, nullable=True) longitude = db.Column('longitude', db.Float, nullable=True) construction_year = db.Column('construction_year', db.String, nullable=True) heating = db.Column('heating', db.String, nullable=True) seller = db.Column('seller', db.String, nullable=True) water = db.Column('water', db.String, nullable=True) building_condition = db.Column('building_condition', db.String, nullable=True) dist_to_center = db.Column('dist_to_center', db.String, nullable=True) dist_to_railway_station = db.Column('dist_to_railway_station', db.String, nullable=True) dist_to_airport = db.Column('dist_to_airport', db.String, nullable=True) images = db.relationship("ApartmentImage") seller_info = db.relationship("SellerInfo", uselist=False) def __init__(self, title, created_at, price_usd, price_uah, description, street_name=None, state_name=None, city_name=None, total_square_meters=None, living_square_meters=None, kitchen_square_meters=None, rooms_count=None, floor=None, floors_count=None, wall_type=None, inspected=None, verified_price=None, latitude=None, longitude=None, construction_year=None, heating=None, seller=None, water=None, building_condition=None, dist_to_center=None, dist_to_railway_station=None, dist_to_airport=None): self.title = title self.created_at = created_at self.price_usd = price_usd self.price_uah = price_uah self.description = description self.street_name = street_name self.state_name = state_name self.city_name = city_name self.total_square_meters = total_square_meters self.living_square_meters = living_square_meters self.kitchen_square_meters = kitchen_square_meters self.rooms_count = rooms_count self.floor = floor self.floors_count = floors_count self.wall_type = wall_type self.inspected = inspected self.verified_price = verified_price self.latitude = latitude self.longitude = longitude self.construction_year = construction_year self.heating = heating self.seller = seller self.water = water self.building_condition = building_condition self.dist_to_airport = dist_to_airport self.dist_to_center = dist_to_center self.dist_to_railway_station = dist_to_railway_station @property def serialize(self): return { 'title': self.title, 'created_at': self.created_at, 'price_usd': self.price_usd, 'price_uah': self.price_uah, 'description': self.description, 'street_name': self.street_name, 'state_name': self.state_name, 'city_name': self.city_name, 'total_square_meters': self.total_square_meters, 'living_square_meters': self.living_square_meters, 'kitchen_square_meters': self.kitchen_square_meters, 'rooms_count': self.rooms_count, 'floor': self.floor, 'floors_count': self.floors_count, 'wall_type': self.wall_type, 'inspected': self.inspected, 'verified_price': self.verified_price, 'latitude': self.latitude, 'longitude': self.longitude, 'construction_year': self.construction_year, 'heating': self.heating, 'seller': self.seller, 'water': self.water, 'building_condition': self.building_condition, 'dist_to_airport': self.dist_to_airport, 'dist_to_center': self.dist_to_center, 'dist_to_railway_station': self.dist_to_railway_station, 'images': [i.serialize for i in self.images] if self.images else [], 'seller_info': self.seller_info.serialize if self.seller_info else None }
class UserModel(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) username = db.Column(db.String(50), unique=True) password_hash = db.Column(db.String(100)) role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False) card_lists = db.relationship('CardListModel', secondary=user_card_list, backref=db.backref('users', lazy='dynamic')) cards = db.relationship('CardModel', backref='user', lazy='dynamic') comments = db.relationship('CommentModel', backref='user', lazy='dynamic') @property def password(self): raise AttributeError('password: write-only field') @password.setter def password(self, password): self.password_hash = flask_bcrypt.generate_password_hash( password).decode('utf-8') def check_password(self, password): return flask_bcrypt.check_password_hash(self.password_hash, password) def json(self): return {'id': self.id, 'email': self.email, 'username': self.username} @staticmethod def encode_auth_token(user_id): """ Generates the Auth Token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1, seconds=5), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode(payload, key, algorithm='HS256') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Decodes the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, key, algorithms='HS256') is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please log in again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.' def __repr__(self): return f"<User name:'{self.username}', id:'{self.id}', role: {self.role}>"