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 DeliveryUserModel(UserModel): # table name __tablename__ = 'delivery_users' user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), primary_key=True) balance = db.Column(db.Integer, nullable=False) picture = db.Column(db.String(256), nullable=False) __mapper_args__ = { 'polymorphic_identity': 'delivery_users', } # class constructor def __init__(self, data): """ Class constructor """ super(DeliveryUserModel, self).__init__(data) self.balance = data.get('balance') self.picture = data.get('picture') @staticmethod def get_user(user_id): response = DeliveryUserModel.query.get(user_id) if not response: raise NotFoundException("Invalid ID") return response @staticmethod def get_delivery(user_id): response = DeliveryUserModel.query.get(user_id) if not response: raise NotFoundException("Invalid ID") return response
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 BlackListToken(db.Model): """ Token Model for storing JWT Tokens """ __tablename__ = 'blacklist_token' id = db.Column(db.Integer, primary_key=True, autoincrement=True) token = db.Column(db.Text, unique=True, nullable=False) blacklisted_on = db.Column(db.DateTime, nullable=False) def __init__(self, token): self.token = token self.blacklisted_on = datetime.datetime.now() def __repr__(self): return '<id: token: {}'.format(self.token) @staticmethod def check_blacklist(auth_token): res = BlackListToken.query.filter_by(token=str(auth_token)).first() if res: return True else: return False
class Requests(db.Model): __tablename__ = "requests" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(100)) book_id = db.Column(db.Integer, db.ForeignKey("books.id")) created_on = db.Column(db.DateTime, server_default=db.func.now()) updated_on = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now()) def __repr__(self): return "<User id={}, email={}>, book={}".format( self.id, self.email, self.book.id) @property def serialize(self): """Return object data in serializeable format""" return { "id": self.id, "email": self.email, "book_id": self.book_id, "timestamp": self.created_on, }
class Tags(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) name = db.Column(db.String(80), nullable=False, unique=True) slug = db.Column(db.String(200), nullable=False, unique=True) def __repr__(self): return '<Tags %r>' % self.name
class Records(db.Model): __tablename__ = 'records' __table_args__ = {'extend_existing': True} uuid = db.Column(UUID(as_uuid=True), primary_key=True) country_iso = db.Column(db.String(100), index=True) country_name = db.Column(db.String(100)) date = db.Column(DATE) confirmed = db.Column(db.INTEGER) deaths = db.Column(db.INTEGER) recovered = db.Column(db.INTEGER) def __repr__(self): return f'<Record ID: {self.uuid}, ISO: {self.country_iso}, Country: {self.country_name}, Date: {self.date}, {self.confirmed, self.deaths, self.deaths}>'
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 Brand(db.Model): brand_id = db.Column(db.BIGINT(), primary_key=True, nullable=False) brand_name = db.Column(db.String(511), nullable=False) email = db.Column(db.String(255)) phone = db.Column(db.String(15)) address = db.Column(db.String(511)) archived = db.Column(db.Boolean(), nullable=False, default=False) def __repr__(self): return '<Brand %r>' % self.brand_name
class Employee(db.Model): id = db.Column(db.Integer, primary_key=True) department_id = db.Column(db.Integer, db.ForeignKey("department.id")) name = db.Column(db.String(250)) surname = db.Column(db.String(250)) slug = db.Column(db.String(250)) salary = db.Column(db.Integer) birth_date = db.Column(db.Date) def __init__(self, *args, **kwargs): super(Employee, self).__init__(*args, **kwargs) self.slug = slugify(self.name + self.surname) def __repr__(self): return f"<Employee : name: {self.name}, surname: {self.surname}, department: {self.department_id}>"
class User(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) name = db.Column(db.String(120), nullable=False) surname = db.Column(db.String(120), nullable=False) email = db.Column(EmailType, unique=True, nullable=False) def save_to_db(self): db.session.add(self) db.session.commit() @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 return_all(cls): def to_json(x): return { 'username': x.username, 'password': x.password } return {'users': list(map(to_json, User.query.all()))} @classmethod def delete_all(cls): try: num_rows_deleted = db.session.query(cls).delete() db.session.commit() return {'message': f'{num_rows_deleted} row(s) deleted'} except Exception as e: return {'message': 'Something went wrong'} @staticmethod def generate_hash(password): return sha256.hash(password) @staticmethod def verify_hash(password, hash): return sha256.verify(password, hash)
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 CronBuild(db.Model): cron_key = db.Column(db.String(32), primary_key=True) cron_exp = db.Column(db.String(32)) build_description = db.Column(db.Text) commands = db.Column(db.Text) job_id = db.Column(db.Integer, db.ForeignKey("job.id")) node_id = db.Column(db.Integer, db.ForeignKey("node.id")) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) def to_dict(self): return { 'cron_key': self.cron_key, 'cron_exp': self.cron_exp, 'build_description': self.build_description, 'commands': self.commands, 'job_id': self.job_id, 'node_id': self.node_id, 'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S") } def __repr__(self): return f"<cron_key {self.cron_key}>"
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) author_id = db.Column(db.Integer, db.ForeignKey("user.id")) text = db.Column(db.Text, nullable=False) uuid = db.Column(db.String(255), unique=True) date = db.Column(db.Date, default=datetime.date.today()) time = db.Column(db.Time, default=datetime.datetime.now().time()) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.uuid = str(uuid.uuid4()) def __repr__(self): return f"<Post: id={self.id}, author_id={self.author_id}>, text={self.text}, uuid={self.uuid}" def json(self): return { "id": self.id, "author_id": self.author_id, "text": self.text, "uuid": self.uuid, "date": str(self.date), "time": str(self.time) }
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 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()
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 ProductImagesModel(db.Model): __tablename__ = 'productimages' id = db.Column(db.Integer, primary_key=True) product_image = db.Column(db.String, default='default_product.jpg') product_id = db.Column(db.Integer, db.ForeignKey('products.id'))
from src.app import db movie_genre_table = db.Table( 'movie_genre', db.Model.metadata, db.Column('movie_id', db.Integer, db.ForeignKey('movies.id')), db.Column('genre_id', db.Integer, db.ForeignKey('genres.id'))) 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:
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 FeedModel(db.Model, BaseModel): """Feed Model""" __tablename__ = 'feed' # Define crypto symbols CRYPTO_SYMBOLS = (CryptoSymbols.ALQO, ) # Define crypto symbols enum for symbol field CRYPTO_SYMBOLS_ENUM = ENUM(*CRYPTO_SYMBOLS, name="symbol") id = db.Column(db.Integer, primary_key=True) symbol = db.Column(CRYPTO_SYMBOLS_ENUM, index=True, nullable=False) data = db.Column(db.JSON()) totals = db.Column(db.JSON()) date_added = db.Column(db.DateTime(), default=datetime.datetime.utcnow, index=True) # Define our table index Index("symbol_date_added_index", symbol, date_added) @staticmethod def get_custom_date_data( crypto_symbol, start_date, end_date, ): """ Get custom date data :param crypto_symbol: :param start_date: :param end_date: :return feed models: """ # Set date format date_format = "%Y-%m-%d" # Parse dates start_date = datetime.datetime.strptime(start_date, date_format) end_date = datetime.datetime.strptime(end_date, date_format) # Get start_date and end_date difference in days delta = end_date - start_date # If 30 days or under the process by day if int(delta.days) <= 30: # Create subquery subquery = db.session.query(SA_FUNC.max( FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= start_date, FeedModel.date_added <= end_date).group_by( SA_FUNC.date_part('day', FeedModel.date_added)).subquery() # If a year or under, then process by month elif int(delta.days) < 365: # Create subquery subquery = db.session.query(SA_FUNC.max( FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= start_date, FeedModel.date_added <= end_date).group_by( SA_FUNC.date_part('month', FeedModel.date_added)).subquery() # If a year or over, then process by year elif int(delta.days) >= 365: # Create subquery subquery = db.session.query(SA_FUNC.max( FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= start_date, FeedModel.date_added <= end_date).group_by( SA_FUNC.date_part('year', FeedModel.date_added)).subquery() # Process query feed_models = db.session.query(FeedModel).filter( FeedModel.date_added.in_(subquery)).order_by(FeedModel.date_added) return feed_models @staticmethod def get_all_data(crypto_symbol): """Get all data limited to 100 rows by default :param crypto_symbol: :return feed models: """ # Search for earliest date feed_model = db.session.query( SA_CAST(SA_FUNC.min(FeedModel.date_added), SA_TYPES.Date).label("date_added")).filter( FeedModel.symbol == crypto_symbol).first() # Set start date with earliest date_start = feed_model.date_added # Build subquery subquery = db.session.query(SA_FUNC.max(FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= date_start).group_by( SA_CAST(FeedModel.date_added, SA_TYPES.Date)).subquery() # Process query feed_models = db.session.query(FeedModel).filter( FeedModel.date_added.in_(subquery)).order_by( FeedModel.date_added).limit(100) # Return models return feed_models @staticmethod def get_last_year_data(crypto_symbol): """Get last year data :param crypto_symbol: :return feed models: """ date_today = datetime.date.today() # Set date 1 year ago from date_today date_1_year_ago = date_today - datetime.timedelta(year=1) # Build subquery subquery = db.session.query(SA_FUNC.max(FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= date_1_year_ago).group_by( SA_CAST(FeedModel.date_added, SA_TYPES.Date)).subquery() # Process query feed_models = db.session.query(FeedModel).filter( FeedModel.date_added.in_(subquery)).order_by(FeedModel.date_added) return feed_models @staticmethod def get_last_30_days_data(crypto_symbol): """Get last 30 days data :param crypto_symbol: :return feed models: """ date_today = datetime.date.today() # Set date 30 days from today date_30_days_ago = date_today - datetime.timedelta(days=30) # Build subquery subquery = db.session.query(SA_FUNC.max(FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= date_30_days_ago).group_by( SA_CAST(FeedModel.date_added, SA_TYPES.Date)).subquery() # Process query feed_models = db.session.query(FeedModel).filter( FeedModel.date_added.in_(subquery)).order_by(FeedModel.date_added) return feed_models @staticmethod def get_last_7_days_data(crypto_symbol): """Get last 7 days data :param crypto_symbol: :return feed models: """ # Set today's date date_today = datetime.date.today() date_7_days_ago = date_today - datetime.timedelta(days=7) # Build subquery subquery = db.session.query(SA_FUNC.max(FeedModel.date_added)).filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= date_7_days_ago).group_by( SA_CAST(FeedModel.date_added, SA_TYPES.Date)).subquery() # Process query feed_models = db.session.query(FeedModel).filter( FeedModel.date_added.in_(subquery)).order_by(FeedModel.date_added) return feed_models @staticmethod def get_last_24_hours(crypto_symbol): """Get last 24 hours :param crypto_symbol: :return feed models: """ # Get today's date date_today = datetime.date.today() # Get date 12 hours ago date_24_hours_ago = date_today - datetime.timedelta(hours=24) # Process query result = FeedModel.query.filter( FeedModel.symbol == crypto_symbol, FeedModel.date_added >= date_24_hours_ago).first() feed_models = [result] return feed_models
class UrlImageMapping(db.Model): id = db.Column(db.Integer, primary_key=True) job_id = db.Column(db.String(100)) task_id = db.Column(db.Integer) site_url = db.Column(db.String(2000)) image_url = db.Column(db.String(2000))
from marshmallow_sqlalchemy import ModelSchema from src.comics.models import Comics, ComicsSchema from src.app import db from marshmallow import fields # from sqlalchemy.ext.declarative import declarative_base # Base = declarative_base() creator_comics = db.Table( 'creator_comics', db.Column('creator_id', db.Integer, db.ForeignKey('creator.id')), db.Column('comics_id', db.Integer, db.ForeignKey('comics.id'))) 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
class Pegawai(db.Model): """Model untuk generate tabel pegawai""" __tablename__ = 'pegawai' id = db.Column(db.BigInteger, primary_key=True, autoincrement=True) nip = db.Column(db.BigInteger, unique=True, nullable=False) nik = db.Column(db.BigInteger, unique=True) gelar_depan = db.Column(db.String(255)) gelar_belakang = db.Column(db.String(255)) nama = db.Column(db.String(255), nullable=False) avatar = db.Column(db.Text) tempat_lahir = db.Column(db.String(255)) tanggal_lahir = db.Column(db.Date) jenis_kelamin = db.Column(db.SmallInteger) aktif_status = db.Column(db.SmallInteger, nullable=False) created_at = db.Column(db.DateTime, nullable=False) updated_at = db.Column(db.DateTime, nullable=False) def __init__( self, nip, nama, aktif_status, avatar=None, nik=None, gelar_depan=None, gelar_belakang=None, tempat_lahir=None, tanggal_lahir=None, jenis_kelamin=None, ): self.nip = nip self.nik = nik self.gelar_depan = gelar_depan self.gelar_belakang = gelar_belakang self.nama = nama self.avatar = avatar self.tempat_lahir = tempat_lahir self.tanggal_lahir = tanggal_lahir self.jenis_kelamin = jenis_kelamin self.aktif_status = aktif_status self.created_at = datetime.datetime.now() self.updated_at = datetime.datetime.now() def encode_auth_token(self, pegawai): """ Generates auth token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(seconds=float(app.config['JWT_TTL'])), 'iat': datetime.datetime.utcnow(), 'sub': pegawai } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS512') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Decode auth token :params auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlackListToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please login again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please login again.' except jwt.InvalidTokenError: return 'Invalid token. Please login again.'
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 Connection(db.Model): id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, default=datetime.now) room_code = db.Column(db.String(8), db.ForeignKey('room.code'))
class UserModel(BaseModel): # table name __tablename__ = 'users' user_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128), nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) phone_number = db.Column(db.Integer, nullable=False) role = db.Column(db.String(128), nullable=False) password = db.Column(db.String(128), nullable=True) latitude = db.Column(db.Float, nullable=True) longitude = db.Column(db.Float, nullable=True) firebase_uid = db.Column(db.String(128), unique=True, nullable=False) favourPoints = db.Column(db.Integer, nullable=False) token = db.Column(db.String(128), unique=True, nullable=False) state = db.Column(db.String(128), nullable=False) current_order = db.Column(db.Integer, nullable=True) rating = db.Column(db.Float, nullable=False) reviews = db.Column(db.Integer, nullable=False) fcm_token = db.Column(db.String(128), nullable=True) created_at = db.Column(db.DateTime) last_login = db.Column(db.DateTime) __mapper_args__ = {'polymorphic_identity': 'users'} # class constructor def __init__(self, data): """ Class constructor """ self.name = data.get('name') self.email = data.get('email') self.phone_number = data.get('phone_number') self.role = data.get('role') self.password = data.get('password') self.latitude = data.get("latitude", None) self.longitude = data.get("longitude", None) self.firebase_uid = data.get('firebase_uid') self.favourPoints = data.get("favourPoints", 30) self.token = secrets.token_hex(32) self.state = data.get('state', 'free') self.current_order = None self.rating = 0.0 self.reviews = 0 self.fcm_token = None self.created_at = datetime.datetime.utcnow() self.last_login = datetime.datetime.utcnow()
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()