class SuccessStoryLike(db.Model):
__tablename__ = "success_story_like"
id = db.Column(db.Integer, primary_key=True)
success_story_id = db.Column(db.ForeignKey('successstory.id'))
user_id = db.Column(db.ForeignKey('user.id'))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False)
service = db.relationship('Service', backref=db.backref('subscription', lazy='dynamic'))
last_read = db.Column(INTEGER(unsigned=True), db.ForeignKey('message.id'), default=0)
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
last_message = Message.query.order_by(Message.id.desc()).first()
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow()
self.last_read = last_message.id if last_message else 0
def __repr__(self):
return '<Subscription {}>'.format(self.id)
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.id > self.last_read)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int((self.timestamp_created - datetime.utcfromtimestamp(0)).total_seconds()),
"timestamp_checked": int((self.timestamp_checked - datetime.utcfromtimestamp(0)).total_seconds())
}
return data
class GoalLike(db.Model):
__tablename__ = "goal_like"
id = db.Column(db.Integer, primary_key=True)
goal_id = db.Column(db.ForeignKey('goal.id'))
user_id = db.Column(db.ForeignKey('user.id'))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
class TodoProtocolAssociation(DatabaseModel):
__tablename__ = "todoprotocolassociations"
todo_id = db.Column(db.Integer,
db.ForeignKey("todos.id"),
primary_key=True)
protocol_id = db.Column(db.Integer,
db.ForeignKey("protocols.id"),
primary_key=True)
class DecisionCategoryAssociation(DatabaseModel):
__tablename__ = "decisioncategoryassociations"
decision_id = db.Column(db.Integer,
db.ForeignKey("decisions.id"),
primary_key=True)
decisioncategory_id = db.Column(db.Integer,
db.ForeignKey("decisioncategories.id"),
primary_key=True)
class LikeProtocolAssociation(DatabaseModel):
__tablename__ = "likeprotocolassociations"
like_id = db.Column(db.Integer,
db.ForeignKey("likes.id"),
primary_key=True)
protocol_id = db.Column(db.Integer,
db.ForeignKey("protocols.id"),
primary_key=True)
class LikeTodoAssociation(DatabaseModel):
__tablename__ = "liketodoassociations"
like_id = db.Column(db.Integer,
db.ForeignKey("likes.id"),
primary_key=True)
todo_id = db.Column(db.Integer,
db.ForeignKey("todos.id"),
primary_key=True)
class LikeDecisionAssociation(DatabaseModel):
__tablename__ = "likedecisionassociations"
like_id = db.Column(db.Integer,
db.ForeignKey("likes.id"),
primary_key=True)
decision_id = db.Column(db.Integer,
db.ForeignKey("decisions.id"),
primary_key=True)
class Poster(db.Model):
id = db.Column(db.Integer, primary_key=True)
hex_string = db.Column(db.String(4), nullable=False)
ip_address = db.Column(db.String(15), nullable=False)
thread = db.Column(db.Integer,
db.ForeignKey("thread.id", ondelete="CASCADE"),
nullable=False)
slip = db.Column(db.Integer, db.ForeignKey("slip.id"), nullable=True)
class Grows(db.Model):
__tablename__ = 'grows'
__table_args__ = (db.PrimaryKeyConstraint(
'farm_id', 'produce_id', name='OneFarmOneProduceOneEntry_CK'), )
farm_id = db.Column('farm_id', db.Integer, db.ForeignKey("farms.id"))
produce_id = db.Column('produce_id', db.Integer,
db.ForeignKey('produces.id'))
class Reply(db.Model):
reply_from = db.Column(db.Integer,
db.ForeignKey("post.id"),
nullable=False,
primary_key=True)
reply_to = db.Column(db.Integer,
db.ForeignKey("post.id"),
nullable=False,
primary_key=True)
class Quote(db.Model):
__tablename__ = 'quotes'
id = db.Column(db.Integer, primary_key=True)
quote_caption = db.Column(db.Text, unique=True, nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey('characters.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
class FavoriteQuote(db.Model):
__tablename__ = 'favorite_quotes'
__table_args__ = (db.UniqueConstraint('quote_id', 'user_id'), )
id = db.Column(db.Integer, primary_key=True)
quote_id = db.Column(db.Integer,
db.ForeignKey('quotes.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
class Post(db.Model):
post_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
message = db.Column(db.String(5000))
url = db.Column(db.String(120))
settings = db.Column(db.SmallInteger)
publish_date = db.Column(db.DateTime)
publisher_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
group_id = db.Column(db.Integer, db.ForeignKey('group.group_id'))
seen_by = db.relationship('User', secondary=seen)
comments = db.relationship('Comment', backref='post', lazy='dynamic')
#backrefs
#publisher -> submitted by
#group -> submitted in
def __init__(self, post):
self.message = post.message
self.url = post.url
self.settings = post.settings
self.publisher_id = post.publisher_id
self.group_id = post.group_id
self.publish_date = datetime.now()
def __repr__(self):
return '<Post %r>' % self.post_id
def get_hot_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_trending_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_new_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_post(self, post_id): # -> post
return Post.query.filter(Post.post_id == post_id).first()
def create_post(self, post): # -> post_id
temp = Post(post)
db.session.add(temp)
db.commit()
return temp.post_id
def get_front_page(self, user_id): # -> post_id []
user = User.query.filter(User.user_id == user_id).first()
result = []
for group in user.subscribed_groups:
result.append([post.post_id for post in group.posts])
return result
class Post(OutputMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(4096), nullable=False)
subject = db.Column(db.String(64), nullable=True)
thread = db.Column(db.Integer, db.ForeignKey("thread.id"), nullable=False)
datetime = db.Column(db.DateTime,
nullable=False,
default=_datetime.datetime.utcnow)
poster = db.Column(db.Integer, db.ForeignKey("poster.id"), nullable=False)
media = db.Column(db.Integer, db.ForeignKey("media.id"), nullable=True)
spoiler = db.Column(db.Boolean, nullable=True)
class ClassSession(db.Model):
__tablename__ = "class_sessions"
id = db.Column(db.Integer, primary_key=True)
class_id = db.Column(db.Integer, db.ForeignKey('classes.id'))
dateTime = db.Column(db.Date, nullable=False)
coach_id = db.Column(db.Integer, db.ForeignKey('athletes.id'))
coach = db.relationship('Athlete',
primaryjoin='Athlete.id==ClassSession.coach_id')
def __init__(self, dateTime, coach_id):
self.coach_id = coach_id
self.dateTime = dateTime
class Show(db.Model):
__tablename__ = 'shows'
venue_id = db.Column(db.Integer,
db.ForeignKey('venues.id', ondelete='CASCADE'),
primary_key=True)
artist_id = db.Column(db.Integer,
db.ForeignKey('artists.id', ondelete='CASCADE'),
primary_key=True)
start_time = db.Column(db.DateTime, primary_key=True)
def __repr__(self):
return f"<Show artist={self.artist.id} venue={self.venue.id} " \
f"start_time={self.start_time.isoformat()}> "
class Price(db.Model):
__tablename__ = 'prices'
__table_args__ = (
db.PrimaryKeyConstraint('produce_id', 'unit_id', name='OneFarmerOneFarmOneEntry_CK'),
)
produce_id = db.Column('produce_id', db.Integer, db.ForeignKey("produces.id"), nullable=False)
unit_id = db.Column('unit_id', db.Integer, db.ForeignKey("units.id"), nullable=False)
price = db.Column('price', db.Float, nullable=False)
def __init__(self, produce_id, unit_id, price):
self.produce_id = produce_id;
self.unit_id = unit_id
self.price = price
class Statement(db.Model):
__tablename__ = "statements"
id = db.Column(db.Integer, primary_key=True)
speaker_id = db.Column(db.Integer, db.ForeignKey("speakers.id"))
topic_id = db.Column(db.Integer, db.ForeignKey("topics.id"))
insertion_time = db.Column(db.DateTime)
executed = db.Column(db.Boolean)
execution_time = db.Column(db.DateTime)
is_meta = db.Column(db.Boolean, default=False)
is_current = db.Column(db.Boolean, default=False)
def __init__(self,
speaker_id,
topic_id,
insertion_time=None,
executed=False,
execution_time=None,
is_meta=False,
is_current=False):
self.speaker_id = speaker_id
self.topic_id = topic_id
self.insertion_time = insertion_time or datetime.now()
self.executed = executed
self.execution_time = execution_time or datetime.now()
self.is_meta = is_meta
self.is_current = is_current
def __repr__(self):
return "<Statement(id={}, speaker={}, topic_id={}, insertion_time={}, executed={}, execution_time={}, is_meta={}, is_current={})>".format(
self.id, self.speaker, self.topic_id, self.insertion_time,
self.executed, self.execution_time, self.is_meta, self.is_current)
def done(self):
if self.executed:
return False
self.executed = True
self.is_current = False
self.execution_time = datetime.now()
if self.topic.sorted_statements(
) is not None and self.topic.sorted_statements():
self.topic.sorted_statements()[0].is_current = True
return True
def undo(self):
if not self.executed:
return False
self.topic.sorted_statements()[0].is_current = False
self.executed = False
self.is_current = True
class UserGoal(db.Model):
__tablename__ = 'usergoal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
goal_id = db.Column(db.Integer, db.ForeignKey('goal.id'))
likes = db.Column(db.Integer, default=0)
lat = db.Column(db.Float)
long = db.Column(db.Float)
date_target = db.Column(db.DateTime)
privacy = db.Column(db.SmallInteger)
list_id = db.Column(db.ForeignKey('list.id'))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
ug_likes = db.relationship('UserGoalLike', backref=db.backref('usergoal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
class Comment(db.Model):
comment_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.post_id'))
reply_to = db.Column(db.Integer, db.ForeignKey('comment.comment_id'))
message = db.Column(db.String(5000))
publish_date = db.Column(db.DateTime)
votes = db.relationship('User', secondary=vote)
#backrefs
#post
def __init__(self, comment):
self.message = comment.message
self.reply_to = comment.reply_to
self.user_id = comment.user_id
self.post_id = comment.post_id
self.publish_date = datetime.now()
def __repr__(self):
return '<Comment %r>' % self.comment_id
def get_popular_comments(self, post_id): # -> comment[]
post = Post.query.filter(Post.post_id == post_id).first()
return [comment.comment_id for comment in post.comments]
def get_newest_comments(self, post_id): # -> comment[]
post = Post.query.filter(Post.post_id == post_id).first()
return [comment.comment_id for comment in post.comments]
def get_trending_comments(self, post_id): # -> comment[]
post = Post.query.filter(Post.post_id == post_id).first()
return [comment.comment_id for comment in post.comments]
def write_comment(self, comment): # -> comment_id
temp = Comment(comment)
db.session.add(temp)
db.session.commit()
return temp.comment_id
def vote_comment(self, is_upvote, comment_id, user_id):
vote.insert().values(is_upvote=is_upvote,
comment_id=comment_id,
user_id=user_id,
time=datetime.now())
db.session.commit()
return True
class Booking(db.Model):
__tablename__ = 'mimir_bookings'
identifier = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=False, nullable=False)
start = db.Column(db.DateTime, nullable=False, default=datetime.now)
end = db.Column(db.DateTime, nullable=False, default=datetime.now)
cell_colour = db.Column(db.String(255), unique=False, nullable=False)
timetable_id = db.Column(db.Integer,
db.ForeignKey('mimir_timetables.identifier'))
timetable = db.relationship('Timetable', back_populates="bookings")
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
@property
def duration(self):
return abs(self.end - self.start).total_seconds() / 3600
@property
def timetable_name(self):
if timetable is not None:
return timetable.name
return "Not Set"
@property
def serialize(self):
return {
'id': self.identifier,
'booking': self.name,
'timetable': self.timetable.name,
'timetable_id': self.timetable_id,
'start_time': self.start,
'end_time': self.end,
'duration': self.duration,
'cell_colour': self.cell_colour
}
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('subscription',
lazy='dynamic'))
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow() - timedelta(minutes=30)
def __repr__(self):
return '<Subscription %r>' % self.id
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.timestamp_created > self.timestamp_checked)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int(self.timestamp_created.strftime('%s')),
"timestamp_checked": int(self.timestamp_checked.strftime('%s'))
}
return data
class Message(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('message', lazy='dynamic'))
text = db.Column(db.TEXT, nullable=False)
title = db.Column(db.VARCHAR)
level = db.Column(TINYINT, nullable=False, default=0)
link = db.Column(db.TEXT, nullable=False, default='')
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
def __init__(self, service, text, title=None, level=0, link=''):
self.service = service
self.text = text
self.title = title
self.level = level
self.link = link
def __repr__(self):
return '<Message %r>' % self.id
def as_dict(self):
return {
"service": self.service.as_dict(),
"message": self.text,
"title": self.title,
"link": self.link,
"level": self.level,
"timestamp": int(self.timestamp_created.strftime('%s'))
}
class Goal(db.Model):
__tablename__ = 'goal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(256), nullable=False)
cat_id = db.Column(db.Integer, default=1)
image_url = db.Column(db.String(130))
no_added = db.Column(db.Integer, default=1)
no_completed = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
user_goals = db.relationship('UserGoal', backref="goal", cascade="all, delete-orphan", lazy='dynamic')
g_likes = db.relationship('GoalLike', backref=db.backref('goal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
@property
def serialize(self):
return {
'id': self.id,
'user_id': self.user_id,
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'name': self.name,
'cat_id': self.cat_id,
'image_url': self.image_url,
'no_added': self.no_added,
'no_completed': self.no_completed,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class DefaultTOP(DatabaseModel):
__tablename__ = "defaulttops"
__model_name__ = "defaulttop"
id = db.Column(db.Integer, primary_key=True)
protocoltype_id = db.Column(db.Integer, db.ForeignKey("protocoltypes.id"))
name = db.Column(db.Text)
number = db.Column(db.Integer)
description = db.Column(db.Text)
localtops = relationship("LocalTOP",
backref=backref("defaulttop"),
cascade="all, delete-orphan")
def get_parent(self):
return self.protocoltype
def is_at_end(self):
return self.number > 0
def get_localtop(self, protocol):
return LocalTOP.query.filter_by(defaulttop_id=self.id,
protocol_id=protocol.id).first()
def get_top(self, protocol):
localtop = self.get_localtop(protocol)
top = TOP(protocol_id=protocol.id,
name=self.name,
description=getattr(localtop, "description", ""))
return top
class Post(db.Model):
from models import User, Category
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140), nullable=False)
slug = db.Column(db.String(140), nullable=False, unique=True)
text = db.Column(db.Text, nullable=False)
photo = db.Column(db.String(255), unique=True)
is_published = db.Column(db.Boolean,
nullable=False,
default=False,
server_default='0')
user_id = db.Column(db.Integer,
db.ForeignKey(User.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey(Category.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
published_at = db.Column(db.DateTime, default=datetime.now())
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy="dynamic"))
comments = db.relationship('Comment',
secondary=post_comments,
backref=db.backref('post', lazy="dynamic"))
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def is_owner(self):
return self.author == current_user
def __repr__(self):
return f'<Post #{self.id} {self.title}>'
class Works(db.Model):
__tablename__ = 'works'
__table_args__ = (db.PrimaryKeyConstraint(
'user_id', 'farm_id', name='OneFarmerOneFarmOneEntry_CK'), )
user_id = db.Column('user_id',
db.Integer,
db.ForeignKey("users.id"),
nullable=False)
farm_id = db.Column('farm_id',
db.Integer,
db.ForeignKey("farms.id"),
nullable=False)
def __init__(self, user_id, farm_id):
self.id = user_id
self.farm_id = farm_id
class List(db.Model):
__tablename__ = "list"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.ForeignKey('user.id'))
name = db.Column(db.String(128), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
goals = db.relationship('UserGoal', backref="list", lazy='dynamic')
class DecisionCategory(DatabaseModel):
__tablename__ = "decisioncategories"
__model_name__ = "decisioncategory"
id = db.Column(db.Integer, primary_key=True)
protocoltype_id = db.Column(db.Integer, db.ForeignKey("protocoltypes.id"))
name = db.Column(db.Text)
def get_parent(self):
return self.protocoltype
