class AccountSettingsModel(db.Model):
__tablename__ = 'account_settings'
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)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
auto_load_parking_place_gps_location = db.Column(db.Boolean, default=False)
parking_place_required = db.Column(db.Boolean, default=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,
'auto_load_parking_place_gps_location': fields.Boolean,
'parking_place_required': fields.Boolean
}
@classmethod
def find_by_user_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
class EventModel(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', foreign_keys=[owner_id])
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
nullable=False)
community = db.relationship('CommunityModel', foreign_keys=[community_id])
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
start = db.Column(db.DateTime())
end = db.Column(db.DateTime())
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'owner': fields.Nested(UserModel.get_marshaller()),
'title': fields.String,
'description': fields.String,
'start': fields.DateTime,
'end': fields.DateTime,
}
@classmethod
def delete_by_id(cls, event_id):
event = db.session.query(cls).filter(cls.id == event_id).first()
if event:
db.session.delete(event)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_community(cls, community_id, from_datetime, to_datetime):
return cls.query.filter_by(community_id=community_id). \
filter(EventModel.end >= from_datetime, EventModel.start <= to_datetime).all()
@classmethod
def find_next_n_by_community(cls, community_id, n):
return cls.query.filter_by(community_id=community_id). \
filter(EventModel.end >= datetime.datetime.utcnow()).order_by(EventModel.start.asc()).limit(n).all()
class CarModel(db.Model):
__tablename__ = 'cars'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
make = db.Column(db.String(120), nullable=False)
model = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', back_populates='cars')
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'name': fields.String,
'make': fields.String,
'model': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
'owner': fields.Nested(UserModel.get_marshaller())
}
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def return_all(cls):
return CarModel.query.all()
@classmethod
def return_all_for_user(cls, user_id):
return CarModel.query.filter(cls.owner_id == user_id).all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def delete_by_id(cls, id):
car = db.session.query(cls).filter(cls.id == id).first()
if car:
db.session.delete(car)
db.session.commit()
else:
raise NoData
class Creator(db.Model):
__tablename__ = 'creator'
id = db.Column(db.Integer(), primary_key=True)
firstName = db.Column(db.String(100))
middleName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
suffix = db.Column(db.String(100))
fullName = db.Column(db.String(100))
modified = db.Column(db.DateTime())
comics = db.relationship(Comics,
secondary=creator_comics,
backref=db.backref('creators', lazy=True))
def __init__(self, id, firstName, middleName, lastName, suffix, fullName,
modified, comics):
self.id = id
self.firstName = firstName
self.middleName = middleName
self.lastName = lastName
self.suffix = suffix
self.fullName = fullName
self.modified = modified
self.comics = comics
def create(self):
db.session.add(self)
db.session.commit()
return self
class TourPassengerLinkModel(db.Model):
__tablename__ = 'tour_passenger_link'
tour_id = db.Column(db.Integer,
db.ForeignKey('tours.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
tour = db.relationship('TourModel')
user = db.relationship('UserModel')
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
def persist(self):
db.session.add(self)
db.session.commit()
class 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 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 CommunityUserLinkModel(db.Model):
__tablename__ = 'community_user_link'
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
is_owner = db.Column(db.Boolean, default=True)
invitation_accepted = db.Column(db.Boolean, default=True)
community = db.relationship('CommunityModel')
user = db.relationship('UserModel')
is_favourite = db.Column(db.Boolean, default=False, nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
def add_to_session(self):
db.session.add(self)
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'community': fields.Nested(CommunityModel.get_marshaller()),
'time_created': fields.DateTime,
'time_updated': fields.DateTime,
}
@classmethod
def find_by_user_and_community(cls, user_id, community_id):
return cls.query.filter_by(user_id=user_id,
community_id=community_id).first()
@classmethod
def find_favourite_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id, is_favourite=True).first()
@classmethod
def find_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id).all()
@classmethod
def find_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).all()
@classmethod
def find_open_invitations_by_user(cls, user_id):
return cls.query.filter_by(user_id=user_id,
invitation_accepted=False).all()
@classmethod
def find_open_invitations_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id,
invitation_accepted=False).all()
def delete(self):
db.session.delete(self)
db.session.commit()
class 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 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 TourModel(db.Model):
__tablename__ = 'tours'
id = db.Column(db.Integer, primary_key=True)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
owner = db.relationship('UserModel', foreign_keys=[owner_id])
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
nullable=False)
community = db.relationship('CommunityModel')
start_km = db.Column(db.DECIMAL(precision=(10, 1)), nullable=False)
end_km = db.Column(db.DECIMAL(precision=(10, 1)))
start_time = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime())
parking_position = db.Column(db.String(120))
comment = db.Column(db.String(120))
is_force_finished = db.Column(db.Boolean)
force_finished_by_id = db.Column(db.Integer, db.ForeignKey('users.id'))
force_finished_by = db.relationship('UserModel',
foreign_keys=[force_finished_by_id])
payoff_id = db.Column(db.Integer, db.ForeignKey('payoffs.id'))
is_open = db.Column(db.Boolean, default=True)
passengers = db.relationship('UserModel', secondary='tour_passenger_link')
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id':
fields.Integer,
'time_created':
fields.DateTime,
'time_updated':
fields.DateTime,
'start_time':
fields.DateTime,
'end_time':
fields.DateTime,
'owner':
fields.Nested(UserModel.get_marshaller()),
'community':
fields.Nested(CommunityModel.get_marshaller()),
'start_km':
fields.String,
'end_km':
fields.String,
'parking_position':
fields.String,
'comment':
fields.String,
'is_force_finished':
fields.Boolean,
'force_finished_by':
fields.Nested(UserModel.get_marshaller(), allow_null=True),
'is_open':
fields.Boolean,
'passengers':
fields.Nested(UserModel.get_marshaller())
}
@classmethod
def delete_by_id(cls, id):
tour = db.session.query(cls).filter(cls.id == id).first()
if tour:
db.session.delete(tour)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_finished_by_community(cls, community_id):
return cls.query \
.filter_by(community_id=community_id) \
.filter(TourModel.end_km.isnot(None)) \
.order_by(TourModel.end_time.desc()) \
.all()
@classmethod
def find_finished_and_open_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id,
is_open=True).filter(
TourModel.end_km.isnot(None)).all()
@classmethod
def find_finished_by_user(cls, user_id):
return cls.query.filter_by(owner_id=user_id).filter(
TourModel.end_km.isnot(None)).all()
@classmethod
def find_running_by_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).filter(
TourModel.end_km.is_(None)).all()
@classmethod
def find_running_by_user(cls, user_id):
return cls.query.filter_by(owner_id=user_id).filter(
TourModel.end_km.is_(None)).all()
@classmethod
def find_newest_tour_for_community(cls, community_id):
return cls.query.filter_by(community_id=community_id).order_by(
TourModel.end_km.desc()).first()
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow)
cars = db.relationship("CarModel", back_populates="owner")
communities = db.relationship("CommunityModel", secondary='community_user_link')
tours = db.relationship("TourModel", secondary='tour_passenger_link')
reset_password_hash = db.Column(db.String(120), nullable=True, default=None)
reset_password_hash_created = db.Column(db.DateTime(timezone=True), default=None, nullable=True)
def persist(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_marshaller():
return {
'id': fields.Integer,
'username': fields.String,
'email': fields.String,
'time_created': fields.DateTime,
'time_updated': fields.DateTime
}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_reset_password_hash(cls, hash):
return cls.query.filter_by(reset_password_hash=hash).first()
@classmethod
def return_all(cls):
return UserModel.query.all()
@classmethod
def delete_all(cls):
db.session.query(cls).delete()
db.session.commit()
@classmethod
def search_by_username(cls, username, excluded_username):
return cls.query \
.filter(UserModel.username.like('%' + username + '%')) \
.filter(UserModel.username != excluded_username) \
.order_by(UserModel.username) \
.limit(10) \
.all()
class TaskInstanceModel(db.Model):
__tablename__ = 'task_instances'
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)
task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'), nullable=False)
task = db.relationship('TaskModel', foreign_keys=[task_id])
km_created_at = db.Column(db.DECIMAL(precision=10, scale=1), nullable=True)
is_open = db.Column(db.Boolean)
community_id = db.Column(db.Integer,
db.ForeignKey('communities.id'),
nullable=False)
community = db.relationship('CommunityModel')
time_finished = db.Column(db.DateTime(), nullable=True)
finished_by = db.relationship('UserModel')
finished_by_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=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_finished':
fields.DateTime,
'task':
fields.Nested(TaskModel.get_marshaller()),
'is_open':
fields.Boolean,
'km_created_at':
fields.Float,
'finished_by':
fields.Nested(UserModel.get_marshaller(), allow_null=True)
}
@classmethod
def delete_by_id(cls, task_instance_id):
task = db.session.query(cls).filter(cls.id == task_instance_id).first()
if task:
db.session.delete(task)
db.session.commit()
else:
raise NoData
@classmethod
def find_by_id(cls, task_instance_id):
return cls.query.filter_by(id=task_instance_id).first()
@classmethod
def find_by_task(cls, task_id):
return cls.query \
.filter_by(task_id=task_id) \
.all()
@classmethod
def find_by_community(cls, community_id):
return cls.query \
.filter_by(community_id=community_id) \
.all()