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