class Reply(db.Model):
__tablename__ = 'reply_content'
id = db.Column(db.Integer, primary_key=True)
letter_id = db.Column(db.Integer, db.ForeignKey('letter_content.id'))
reply_from_id = db.Column(db.Integer, db.ForeignKey('user_info.id'))
title = db.Column(db.String, nullable=False)
reply_date = db.Column(db.Date, nullable=False)
reply_content = db.Column(db.Text, nullable=True)
# 0 means unread, 1 means read.
read_status = db.Column(db.Integer, nullable=False)
def __init__(self,
reply_from_id,
title,
reply_content,
reply_date,
letter_id,
read_status=0):
self.reply_from_id = reply_from_id
self.title = title
self.reply_content = reply_content
self.reply_date = reply_date
self.read_status = read_status
self.letter_id = letter_id
def __repr__(self):
return '<letter %r>' % (self.title)
class Ingroup(db.Model):
id = db.Column(db.Integer, primary_key=True)
myuser = db.Column(db.Integer, db.ForeignKey('user.id'))
gp = db.Column(db.String(64), db.ForeignKey('group.groupname'))
pg = db.Column(db.String(140))
time = db.Column(db.DateTime, index=True, default=datetime.utcnow)
event = db.Column(db.String(250))
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
gr = db.Column(db.String(64), db.ForeignKey('group.groupname'))
ev = db.Column(db.String(140))
participants = db.Column(db.Integer)
organiser = db.Column(db.Integer, db.ForeignKey('user.username'))
location = db.Column(db.String(1024))
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
us = db.Column(db.String(64), db.ForeignKey('user.username'))
def __repr__(self):
return '<Comment {}>'.format(self.body)
class UserTrack(db.Model):
""" All tracks for a user """
__tablename__ = 'user_track'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.String, db.ForeignKey('users.id'), nullable=False)
track_uri = db.Column(db.String,
db.ForeignKey('tracks.uri'),
nullable=False)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender = db.Column(db.String(64), db.ForeignKey('user.username'))
msg = db.Column(db.String(700), index=True)
reciever = db.Column(db.String(64), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return '<Message {}>'.format(self.body)
class Stata(db.Model):
__tablename__ = 'stata'
stata_id = db.Column(db.Integer, primary_key=True)
mc = db.Column(db.Integer)
kills = db.Column(db.Integer)
deaths = db.Column(db.Integer)
cbills = db.Column(db.Integer)
exp_points = db.Column(db.Integer)
wins = db.Column(db.Integer)
losses = db.Column(db.Integer)
timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow())
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, mc, kills, deaths, cbills, exp_points, wins, losses,
timestamp, user_id):
self.mc = mc
self.kills = kills
self.deaths = deaths
self.cbills = cbills
self.exp_points = exp_points
self.wins = wins
self.losses = losses
self.timestamp = timestamp
self.user_id = user_id
def __repr__(self):
return '<Post %r>' % (self.body)
class Task(db.Model):
__tablename__ = "tasks"
task_id = db.Column(db.Integer, primary_key=True) # will autoincrement
name = db.Column(db.String, nullable=False)
due_date = db.Column(db.Date, nullable=False)
priority = db.Column(db.Integer, nullable=False)
posted_date = db.Column(db.Date, default=datetime.datetime.utcnow())
status = db.Column(db.Integer)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id')) # binds values frm this field to the
# values found in the corresponding id field in users table
def __init__(self, name, due_date, priority, posted_date, status, user_id):
self.name = name
self.due_date = due_date
self.priority = priority
self.posted_date = posted_date
self.status = status
self.user_id = user_id
def __repr__(self):
return '<name {0}>'.format(self.name)
class LetterToJuliet(db.Model):
__tablename__ = 'letter_content'
id = db.Column(db.Integer, primary_key=True)
# need foreign key to connect to user
from_id = db.Column(db.Integer, db.ForeignKey('user_info.id'))
title = db.Column(db.String, nullable=False)
sent_date = db.Column(db.Date, nullable=False)
content = db.Column(db.Text, nullable=False)
# 0 means no_reply, 1 means reply.
reply_status = db.Column(db.Integer, nullable=False)
def __init__(self,
from_id,
title,
content,
sent_date,
reply_id=None,
reply_status=0):
self.from_id = from_id
self.title = title
self.content = content
self.sent_date = sent_date
self.reply_status = reply_status
def __repr__(self):
return '<letter %r>' % (self.title)
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True)
userid = db.Column(db.Integer, db.ForeignKey('user.id'))
groupname = db.Column(db.String(64), index=True)
adminId = db.Column(db.Integer)
def __repr__(self):
return '<Group {}>'.format(self.groupname)
def addMember(self, user):
if not self.is_member(user):
self.members.append(user)
def is_member(self, user):
return self.members.filter(group.c.self.userid == user.id).count() > 0
def removeMember(self, user):
if self.is_member(user):
self.members.remove(user)
def grouppost(self):
gname = self.groupname
groupusers = Group.query.filter(Group.groupname == gname).all()
#groupusers = groupusers.items
#print(groupusers)
for mem in groupusers:
groupposts = Post.query.filter(mem.userid == Post.user_id)
return groupposts.order_by(Post.timestamp.desc())
class User(db.Model):
__tablename__ = "users"
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False, unique=True)
family_pk = db.Column(db.Integer,
db.ForeignKey('family.pk'),
nullable=True)
class GroceryList(HasItems, db.Model):
__tablename__ = "grocery_list"
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
family_pk = db.Column(db.Integer, db.ForeignKey('family.pk'))
__table_args__ = (db.UniqueConstraint('name',
'family_pk',
name='_name_family_pk'), )
class Post(SearchableMixin, db.Model):
__searchable__ = ['body']
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
commentS = db.relationship('Comment', backref='POst', lazy='dynamic')
#def get_comments(self):
# return Comment.query.filter_by(post_id=post.id).order_by(Comment.timestamp.desc())
def __repr__(self):
return '<Post {}>'.format(self.body)
class Expense(db.Model):
__tablename__ = "expenses"
id = db.Column(db.Integer, primary_key=True)
month = db.Column(db.String, nullable=False)
name = db.Column(db.String, nullable=False)
amount = db.Column(db.Float, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, month, name, amount, user_id):
self.month = month
self.name = name
self.amount = amount
self.user_id = user_id
def __repr__(self):
return '<name {0}>'.format(self.name)
class videoComment(db.Model):
__tablename__ = 'videoComments'
comment_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
comment = db.Column(db.String, nullable=False)
video_id = db.Column(db.Integer, db.ForeignKey('videos.video_id'))
def __init__(self, name, email, comment, video_id):
self.name = name
self.email = email
self.comment = comment
self.video_id = video_id
def __repr__(self):
return self.comment
class Short_Answer_Question(db.Model):
__tablename__ = 'short_answer_questions'
id = db.Column(db.Integer, primary_key=True)
question = db.Column(db.Text, nullable=False)
answer = db.Column(db.Text)
subject_id = db.Column(db.Integer, db.ForeignKey('subjects.id'))
subject = db.relationship('Subject',
backref=db.backref('short_answer_questions',
lazy='dynamic'))
def __init__(self, subject, question, answer=None):
self.question = question
self.answer = answer
self.subject = subject
def __repr__(self):
return 'SAQuestion %r>' % self.question[:10]
class Task(db.Model):
__tablename__ = "tasks"
task_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
due_date = db.Column(db.Date, nullable=False)
priority = db.Column(db.Integer, nullable=False)
posted_date = db.Column(db.Date, default=datetime.datetime.utcnow())
status = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, name, due_date, priority, posted_date, status, user_id):
self.name = name
self.due_date = due_date
self.priority = priority
self.posted_date = posted_date
self.status = status
self.user_id = user_id
def __repr__(self):
return '<name {0}>'.format(self.name)
class FTasks(db.Model):
__tablename__ = "ftasks"
task_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
due_date = db.Column(db.Date, nullable=False)
priority = db.Column(db.Integer, nullable=False)
posted_date = db.Column(db.Date, nullable=False)
status = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, name, due_date, priority, posted_date, status, user_id):
self.name = name
self.due_date = due_date
self.priority = priority
self.posted_date = posted_date
self.status = status
self.user_id = user_id
def __repr__(self):
return '<name %r>' % (self.body)
class TimeEntry(db.Model):
__tablename__ = 'entries'
entry_id = db.Column(db.Integer, primary_key=True)
cal_date = db.Column(db.Date, nullable=False)
clock_in = db.Column(db.DateTime)
lunch_out = db.Column(db.DateTime)
lunch_in = db.Column(db.DateTime)
clock_out = db.Column(db.DateTime)
shift = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, cal_date, clock_in, lunch_out, lunch_in, clock_out,
shift, user_id):
self.cal_date = cal_date
self.clock_in = clock_in
self.clock_out = clock_out
self.shift = shift
self.user_id = user_id
def __repr__(self):
return '<clocked in: %r>' % self.clock_in
class Task(db.Model):
__tablename__ = 'tasks'
task_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
due_date = db.Column(db.Date, nullable=False)
priority = db.Column(db.Integer, nullable=False)
status = db.Column(db.Integer)
posted_at = db.Column(db.Date, default=datetime.utcnow())
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
def __init__(self, attributes):
self.name = attributes["name"]
self.due_date = attributes["due_date"]
self.priority = attributes["priority"]
self.status = attributes["status"]
self.posted_at = attributes["posted_at"]
self.user_id = attributes["user_id"]
def __repr__(self):
return "<name %r>" % (self.name)
class Item(db.Model):
__tablename__ = "item"
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
quantity = db.Column(db.Integer)
date_bought = db.Column(db.Date)
family_pk = db.Column(db.Integer,
db.ForeignKey('family.pk'),
nullable=False)
discriminator = db.Column(db.String)
parent_id = db.Column(db.Integer)
__table_args__ = (db.UniqueConstraint('name',
'family_pk',
name='_name_family_pk'), )
@property
def parent(self):
"""Provides in-Python access to the "parent" by choosing
the appropriate relationship. """
return getattr(self, "parent_%s" % self.discriminator)
class Model(db.Model):
__tablename__ = "models"
id = db.Column(db.Integer, primary_key=True)
exp_name = db.Column(db.String, nullable=False)
time_simulation = db.Column(db.Integer, nullable=False)
time_simulation_unit = db.Column(db.String, nullable=False)
#integration_time = db.Column(db.Integer, nullable=False)
initial_date = db.Column(db.Date, default=datetime.utcnow())
initial_hour_hour = db.Column(db.Integer, nullable=False)
initial_hour_minute = db.Column(db.Integer, nullable=False)
center_point_latitude = db.Column(db.Float, nullable=False)
center_point_longitude = db.Column(db.Float, nullable=False)
number_points_x_y = db.Column(db.Integer, nullable=False)
distance_x_y = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, exp_name, time_simulation, time_simulation_unit, initial_date,
initial_hour_hour, initial_hour_minute, center_point_latitude, center_point_longitude, number_points_x_y, distance_x_y, user_id):
self.exp_name = exp_name
self.time_simulation = time_simulation
self.time_simulation_unit = time_simulation_unit
#self.integration_time = integration_time
self.initial_date = initial_date
self.initial_hour_hour = initial_hour_hour
self.initial_hour_minute = initial_hour_minute
self.center_point_latitude = center_point_latitude
self.center_point_longitude = center_point_longitude
self.number_points_x_y = number_points_x_y
self.distance_x_y = distance_x_y
self.user_id = user_id
def __repr__(self):
return '<Model {0}>'.format(self.exp_name)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender = db.Column(db.String(64), db.ForeignKey('user.username'))
msg = db.Column(db.String(700), index=True)
reciever = db.Column(db.String(64), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
from views import db
from datetime import datetime
user_pkentifier = db.Table(
'user_pkentifier',
db.Column('family_pk', db.Integer, db.ForeignKey('family.pk')),
db.Column('user_pk', db.Integer, db.ForeignKey('users.pk')),
)
class User(db.Model):
__tablename__ = "users"
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False, unique=True)
family_pk = db.Column(db.Integer,
db.ForeignKey('family.pk'),
nullable=True)
class Family(db.Model):
__tablename__ = "family"
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
members = db.relationship("User",
secondary=user_pkentifier,
backref="family")
fridge = db.relationship("Fridge", uselist=False, backref="family")
grocery_lists = db.relationship("GroceryList", backref="family")
class Like(db.Model):
id = db.Column(db.Integer, primary_key=True)
liker = db.Column(db.String(64), db.ForeignKey('user.username'))
po = db.Column(db.Integer, db.ForeignKey('post.id'))
class Fridge(HasItems, db.Model):
__tablename__ = "fridge"
pk = db.Column(db.Integer, primary_key=True)
family_pk = db.Column(db.Integer, db.ForeignKey('family.pk'))
@classmethod
def reindex(cls):
for obj in cls.query:
add_to_index(cls.__tablename__, obj)
pwd_context = CryptContext(
schemes=["pbkdf2_sha512"],
default="pbkdf2_sha512",
all__vary_rounds=0.2,
pbkdf2_sha512__default_rounds=8000,
)
followers = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
#group = db.Table('Groups',
# db.Column('userid',db.Integer,db.ForeignKey('user.id')),
# db.Column('groupname',db.String(64),index=True,unique=True))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
last_message_read_time = db.Column(db.DateTime)
