class Project(db.Model):
"""Project Class contains link to the user that interact with this project,
the top level tasks related to id"""
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
name = db.Column(db.String(80))
description = db.Column(db.String(250))
tasks = db.relationship('Task', secondary=project_tasks, lazy='subquery',
backref=db.backref('project', lazy=True))
users = db.relationship('User', secondary=project_users, lazy='subquery',
backref=db.backref('project', lazy=True))
def add_task(self, name, description, end_time):
"""Adds a new Task to this Project"""
self.tasks.append(
Task(name=name, description=description, end_time=end_time)
)
db.session.update(self)
db.session.commit()
def add_user(self, em_usname):
"""Adds existing user to thihs project"""
user = User.query.filter_by(email=em_usname).first()
if not user:
user = User.query.filter_by(username=em_usname).first()
if user:
self.users.append(user)
db.session.update(self)
db.session.commit()
else:
raise Exception()
class Student(db.Model, User):
classrooms = db.relationship("Classroom", secondary=students, \
backref=db.backref("students", lazy=True) )
submissions = db.relationship("Submission", backref="student", lazy=True)
def __init__(self, name, email, password):
self.user_type = "student"
self.name = name
self.email = email
self.password = generate_hash(password)
self.verified = False
def get_classes(self):
return self.classrooms
def get_submissions(self):
return self.submissions
def enroll_in_class(self, code):
classroom = Classroom.query.filter_by(code=code).first()
if classroom is None:
return False
self.classrooms.append(classroom)
return True
class Race(db.Model):
__tablename__ = 'races'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
description = db.Column(db.Text)
created_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
nullable=False)
updated_at = db.Column(db.DateTime)
# This is the connection for many to many relationship between race and units
units = db.relationship('Unit',
secondary=race_units,
backref=db.backref('race', lazy='dynamic'))
def __init__(self, name, description):
self.name = name
self.description = description
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'id': self.id,
'name': self.name,
'description': self.description,
'units': self.units,
'created_at': dump_datetime(self.created_at)
}
def __repr__(self):
return '<Race %r>' % self.name
class Task(db.Model):
__tablename__ = 'task'
"""Task class contains subTasks"""
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
name = db.Column(db.String(80))
description = db.Column(db.String(80))
end_time = db.Column(db.Date())
supertask = db.Column(db.Integer, db.ForeignKey('task.id'))
tasks = db.relationship('Task', cascade="all", backref=db.backref(
"parent", remote_side='Task.id'))
questionnaires = db.relationship(
'Questionnaire', backref='taks', lazy=True)
class Movie(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text())
director_id = db.Column(db.Integer, db.ForeignKey('directors.id'))
tags = db.relationship('Tag',
secondary='movie_tags',
backref=db.backref('movies', lazy='dynamic'))
#GOT WEIRD ERROR WHEN 'Tag' was 'tag'
#WHAT DOES SECONDARY DO? WHAT DOES LAZY DO?
def __init__(self, title, director_id):
self.title = title
self.director_id = director_id
class Task(db.Model):
"""Task class contains subTasks"""
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(db.Float(), default=time(), primary_key=True)
name = db.Column(db.String(80))
description = db.Column(db.String(80))
end_time = db.Column(db.Date())
tasks = db.relationship('Task',
secondary=sub_tasks,
lazy='subquery',
backref=db.backref('super_task', lazy=True))
def add_task(self, name, description, end_time):
"""Adds subtasks to this taks"""
self.tasks.append(
Task(name=name, description=description, end_time=end_time))
db.session.update(self)
db.session.commit()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(db.Float(),
default=time(),
unique=True,
nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
tasks = db.relationship('Task',
secondary=user_tasks,
lazy='subquery',
backref=db.backref('users', lazy=True))
def add_task(self, id):
task = Task.query.filter_by(id=id).first()
if task:
self.tasks.append(task)
db.session.update(self)
db.session.commit()
else:
raise Exception()
def get_index_data(self):
tasks = []
projects = []
for count, task in enumerate(
sorted(self.tasks, key=(lambda x: x.end_time))):
if count >= 5:
break
else:
tasks.append(task)
for count, project in enumerate(
sorted(self.project, key=(lambda x: x.name))):
if count >= 5:
break
else:
projects.append(project)
return {
'tasks': ['t1', 't2', 't3', 't4', 't5'],
'projects': ['p1', 'p2', 'p3']
}
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
email = db.Column(db.String(120), unique=True)
username = db.Column(db.String(25), unique=True)
password = db.Column(db.String(36))
brands = db.relationship('Brand',
secondary=user_brands,
backref=db.backref("users", lazy='dynamic'),
lazy='dynamic')
status = db.Column(db.Integer, default=1)
admin = db.Column(db.Integer, default=0)
created = db.Column(db.DateTime)
updated = db.Column(db.DateTime)
def __init__(self, name=None, email=None, username=None, passwd=None):
self.name = name
self.email = email
self.username = username
self.password = passwd
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
def __repr__(self):
return '<User %r>' % (self.name)
def is_authenticated(self):
return not type(self) is AnonymousUserMixin
def is_active(self):
return self.status == 1
def is_admin(self):
return self.admin == 1
def is_anonymous(self):
return type(self) is AnonymousUserMixin
def get_id(self):
return unicode(self.id)
class User(db.Model, UserMixin):
# Default fields for Flask-Security
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
# Extra user fields
username = db.Column(db.String(100), unique=True)
# Confirmable field for Flask-Security
confirmed_at = db.Column(db.DateTime)
# Trackable fields for Flask-Security
last_login_at = db.Column(db.DateTime)
current_login_at = db.Column(db.DateTime)
last_login_ip = db.Column(db.String(50))
current_login_ip = db.Column(db.String(50))
login_count = db.Column(db.Integer)
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
changed_at = db.Column(
db.DateTime(), default=datetime.now(), onupdate=datetime.now())
email = db.Column(db.String(80), unique=True, nullable=False)
name = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
tasks = db.relationship('Task', secondary=user_tasks, lazy='subquery',
backref=db.backref('users', lazy=True))
def add_task(self, id):
task = Task.query.filter_by(id=id).first()
if task:
self.tasks.append(task)
db.session.update(self)
db.session.commit()
else:
raise Exception()
def get_project_grid(self, n):
grid = []
for i in range(0, len(self.project), n):
grid.append(self.project[i:i + n])
return grid
def get_index_data(self):
tasks = []
projects = []
for count, task in enumerate(sorted(self.tasks, key=(lambda x: x.end_time))):
if count >= 5:
break
else:
tasks.append(task)
for count, project in enumerate(sorted(self.project, key=(lambda x: x.name))):
if count >= 5:
break
else:
projects.append(project)
return {'tasks': tasks, 'projects': projects}
class Folder(db.Model):
__tablename__ = "folder"
id = db.Column(db.Integer, primary_key=True)
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
parent_folder_id = db.Column(db.Integer, db.ForeignKey('folder.id'))
mailchimp_id = db.Column(db.String(10), nullable=True)
name = db.Column(db.String(200))
folder_type = db.Column(db.String(200))
children = db.relationship('Folder',
cascade="all",
backref=db.backref("parent", remote_side="Folder.id"))
created = db.Column(db.DateTime)
created_by = db.Column(db.String(10))
updated = db.Column(db.DateTime)
updated_by = db.Column(db.String(10))
def __init__(self, name, parent=None):
self.name = name
self.parent_folder_id = parent
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
def append(self, nodename):
self.children[nodename] = TreeNode(nodename, parent=self)
def __repr__(self):
return "TreeNode(name=%r, id=%r, parent_id=%r)" % (
self.name,
self.id,
self.parent_id
)
def drawBreadCrumb(self, breadcrumb, lvl=0):
if lvl < 0:
breadcrumb = '<li><a href="/folder/%s">%s</a></li>\n%s' % (self.id, self.name, breadcrumb)
else:
breadcrumb = '<li><strong>%s</strong></li>\n%s' % (self.name, breadcrumb)
if self.parent != None:
return self.parent.drawBreadCrumb(breadcrumb, lvl - 1)
return breadcrumb
def drawFolderTree(self, current_folder, cls="js-folder-context"):
a_classes = ""
li_classes = ""
tree = ""
try:
if self.id == current_folder.id:
li_classes += " jstree-open "
a_classes = " jstree-clicked "
elif self.child_is_current(current_folder):
li_classes += " jstree-open "
tree = "<li class='%s %s' id='%s' title='%s'><a class='%s' href='/folder/%s'>%s</a>" % (cls, li_classes, self.id, self.name, a_classes, self.id, self.name)
if self.children:
tree = '%s\n<ul>' % tree
for child in self.children:
tree = '%s\n%s' % (tree, child.drawFolderTree(current_folder, cls))
tree = '%s</ul>\n' % tree
tree = '%s</li>' % tree
except:
pass
return tree
def child_is_current(self, current_folder):
for child in self.children:
if child.id == current_folder.id:
return True
elif child.children:
return child.child_is_current(current_folder)
return False