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 Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', back_populates='image')
answer_id = db.Column(db.Integer, db.ForeignKey('answers.id'))
answer = db.relationship('Answer', back_populates='images')
def serialize(self):
return {'id': self.id, 'path': self.path, 'userId': self.user_id, \
'answerId': self.answer_id}
class Classroom(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
desc = db.Column(db.String(80), nullable=True)
code = db.Column(db.String(CLASS_CODE_LENGTH), nullable=False, unique=True)
teacher_id = db.Column(db.Integer, db.ForeignKey("teacher.id"))
student_ids = db.Column(db.Integer, db.ForeignKey("student.id"))
assignments = db.relationship("Assignment", backref="classroom", lazy=True)
def __init__(self, name, desc, teacher):
self.name = name
self.desc = desc
self.code = self.generate_class_code()
self.teacher = teacher
def generate_class_code(self):
code = "".join(choices(ascii_letters, k=CLASS_CODE_LENGTH))
while True:
if Classroom.query.filter_by(code=code).first() is None:
break
code = "".join(choices(ascii_letters, k=CLASS_CODE_LENGTH))
return code
def enroll_student(self, student):
self.students.append(student)
def remove_student(self, student):
if student in self.students:
self.students.remove(student)
return True
return False
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 FormField(db.Model):
__tablename__ = "form_field"
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey('form_group.id'))
name = db.Column(db.String(100))
label = db.Column(db.String(100))
rank = db.Column(db.Integer, default=1)
required = db.Column(db.Boolean, default=True)
create = db.Column(db.Boolean, default=True)
update = db.Column(db.Boolean, default=True)
search = db.Column(db.Boolean, default=False)
export = db.Column(db.Boolean, default=True)
tag = db.Column(db.String(20))
field_type = db.Column(db.String(20))
max_length = db.Column(db.Integer, default=1)
default_value = db.Column(db.String(200), nullable=True)
options = db.relationship("FormFieldOption",
backref="form_field",
lazy="dynamic")
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class ListMergeField(db.Model):
__tablename__ = "list_merge_field"
id = db.Column(db.Integer, primary_key=True)
list_id = db.Column(db.Integer, db.ForeignKey('list.id'))
mailchimp_id = db.Column(db.Integer)
tag = db.Column(db.String(20))
name = db.Column(db.String(200))
type = db.Column(db.String(20))
required = db.Column(db.Boolean, default=True)
default_value = db.Column(db.String(200), nullable=True)
public = db.Column(db.Boolean, default=True)
display_order = db.Column(db.Integer, default=0)
choices = db.relationship("ListMergeFieldChoice",
lazy="dynamic",
cascade="all,delete")
size = db.Column(db.Integer, default=0)
default_country = db.Column(db.String(5), nullable=True)
phone_format = db.Column(db.String(50), nullable=True)
date_format = db.Column(db.String(50), nullable=True)
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class Campaign(db.Model):
__tablename__ = "campaign"
id = db.Column(db.Integer, primary_key=True)
mailchimp_id = db.Column(db.String(100))
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
folder_id = db.Column(db.Integer, db.ForeignKey("folder.id"))
email_id = db.Column(db.Integer, db.ForeignKey("email.id"))
segment_id = db.Column(db.Integer, db.ForeignKey("segment.id"))
list_id = db.Column(db.Integer, db.ForeignKey("list.id"))
name = db.Column(db.String(200))
type = db.Column(db.String(50), default="regular")
status = db.Column(db.String(50), default="save")
emails_sent = db.Column(db.Integer, default=0)
send_time = db.Column(db.TIMESTAMP, nullable=True)
content_type = db.Column(db.String(100))
# Recipients
segment_text = db.Column(db.Text)
recipient_count = db.Column(db.Integer, default=0)
# Settings
subject_line = db.Column(db.String(200))
from_name = db.Column(db.String(200))
reply_to = db.Column(db.String(200))
authenticate = db.Column(db.Boolean, default=True)
auto_footer = db.Column(db.Boolean, default=True)
inline_css = db.Column(db.Boolean, default=True)
template_id = db.Column(db.Integer, db.ForeignKey("template.id"))
# Tracking
track_opens = db.Column(db.Boolean, default=True)
track_clicks = db.Column(db.Boolean, default=True)
# Delivery Status
delivery_status_enabled = db.Column(db.Boolean)
can_cancel = db.Column(db.Boolean)
delivery_status = db.Column(db.String(200))
ds_emails_sent = db.Column(db.Integer)
ds_emails_canceled = db.Column(db.Integer)
# Schedule
schedule_time = db.Column(db.TIMESTAMP)
# Activity
activity = db.relationship("ListSubscriberActivity", backref="campaign", lazy="dynamic", cascade="all,delete")
# Screen Filters
is_user_initiated = db.Column(db.Boolean, default=False)
is_rtm = db.Column(db.Boolean, default=False)
# MMC Default
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class SensorNode(db.Model):
__tablename__ = "sensor_node"
id = db.Column(db.Integer, primary_key=True)
mac = db.Column(db.Integer, nullable=False)
name = db.Column(db.String, nullable=True)
location = db.Column(db.String, nullable=True)
sensors = db.relationship("Sensor", backref="sensor_node", lazy='joined')
class Module(db.Model):
__tablename__ = 'modules'
def __init__(self, name):
self.name = name
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
user = db.relationship('User', back_populates='module', uselist=False)
subject = db.relationship('Subject',
back_populates='module',
uselist=False)
def serialize(self):
return {'id': self.id, 'name': self.name}
class Director(db.Model):
__tablename__ = 'directors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text())
movies = db.relationship('Movie', backref='director', lazy='dynamic') # WHAT IS THIS DOING?
def __init__ (self, name):
self.name = name
class Sensor(db.Model):
__tablename__ = "sensor"
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Integer)
threshold = db.Column(db.Float, nullable=False)
greater_than_or_eq = db.Column(db.Boolean, nullable=False, default=True)
sensor_node_id = db.Column(db.Integer, db.ForeignKey("sensor_node.id"))
readings = db.relationship("SensorReading",
backref="sensor",
lazy='dynamic')
class Topic(db.Model):
__tablename__='topics'
def __init__(self, name, description, subject_id):
self.name = name
self.description = description
self.subject_id = subject_id
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(200))
subject_id = db.Column(db.Integer, db.ForeignKey('subjects.id'))
subject = db.relationship('Subject', back_populates='topics')
questions = db.relationship('Question', back_populates='topic', uselist=False)
def serialize(self):
return {'id': self.id, 'name': self.name, 'description': self.description, \
'subjectId': self.subject_id}
class StudentYear(db.Model):
__tablename__ = 'student_years'
def __init__(self, id, description):
self.id = id
self.description = description
id = db.Column(db.Integer, primary_key=True, autoincrement=False)
description = db.Column(db.String(10))
user = db.relationship('User',
back_populates='student_year',
uselist=False)
subject = db.relationship('Subject',
back_populates='student_year',
uselist=False)
def serialize(self):
return {'id': self.id, 'description': self.description}
class Comment(db.Model):
__tablename__='comments'
def __init__(self, text, answer_id, user_id):
self.text = text
self.answer_id = answer_id
self.user_id = user_id
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
timestamp = db.Column(db.DateTime(), nullable=False, server_default=func.now())
answer_id = db.Column(db.Integer, db.ForeignKey('answers.id'), nullable=False)
answer = db.relationship('Answer', back_populates='comments')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates='comments')
def serialize(self):
return {'id': self.id, 'text': self.text, 'timestampStr': self.timestamp, \
'answerId': self.answer_id, 'userId': self.user_id }
class Grade(db.Model):
__tablename__ = 'grades'
value = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime(), server_default=func.now())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
primary_key=True)
user = db.relationship('User', back_populates='grades')
answers = db.relationship('Answer',
secondary=AnswerGrade,
back_populates='grades')
def serialize(self):
return {
'value': self.value,
'timestampStr': self.timestamp,
'userId': self.user_id
}
class Teacher(db.Model, User):
classrooms = db.relationship("Classroom", backref="teacher", lazy=True)
def __init__(self, name, email, password):
self.user_type = "teacher"
self.name = name
self.email = email
self.password = generate_hash(password)
self.verified = False
def get_classes(self):
return Classroom.query.filter_by(teacher_id=self.id).all()
class Author(db.Model):
__tablename__ = 'authors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text())
books = db.relationship('Book', backref='author', lazy='dynamic', cascade='all, delete-orphan')
def __init__(self, name):
self.name = name
def __repr__(self):
return 'id: {}, name: {}'.format(self.id, self.name)
class UserStatus(db.Model):
__tablename__ = 'user_statuses'
def __init__(self, id, description):
self.id = id
self.description = description
id = db.Column(db.Integer, primary_key=True, autoincrement=False)
description = db.Column(db.String(50))
user = db.relationship('User', back_populates='user_status', uselist=False)
def serialize(self):
return {'id': self.id, 'description': self.description}
class ImportDefinition(db.Model):
__tablename__ = "import_definition"
id = db.Column(db.Integer, primary_key=True)
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
folder_id = db.Column(db.Integer, db.ForeignKey("folder.id"))
name = db.Column(db.String(200))
file_path = db.Column(db.String(1024))
file_delimiter = db.Column(db.String(1), default=",")
target_type = db.Column(db.String(200))
target_folder_id = db.Column(db.Integer, db.ForeignKey("folder.id"), nullable=True)
target_list_id = db.Column(db.Integer, db.ForeignKey("list.id"), nullable=True)
import_type = db.Column(db.Integer, default=1) # 1 = Add/Update, 2 = Add Only, 3 = Update Only
system_definition = db.Column(db.Boolean, default=False)
notify_addresses = db.Column(db.String(1024), nullable=True)
mappings = db.relationship("ImportFieldMapping", backref="import_definition", lazy="dynamic")
activity = db.relationship("ImportActivity", lazy="dynamic")
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class Answer(db.Model):
__tablename__ = 'answers'
def __init__(self, text, question_id, user_id, is_pinned, grade):
self.text = text
self.question_id = question_id
self.user_id = user_id
self.is_pinned = is_pinned
self.average_grade = grade
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(500), nullable=False)
is_pinned = db.Column(db.Boolean)
average_grade = db.Column(db.Float)
timestamp = db.Column(db.DateTime(),
nullable=False,
server_default=func.now())
question_id = db.Column(db.Integer,
db.ForeignKey('questions.id'),
nullable=False)
question = db.relationship('Question', back_populates='answers')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates='answers')
comments = db.relationship('Comment', back_populates='answer')
images = db.relationship('Image', back_populates='answer')
grades = db.relationship('Grade',
secondary=AnswerGrade,
back_populates='answers')
def serialize(self):
return {'id': self.id, 'text': self.text, 'isPinned': self.is_pinned, 'averageGrade': self.average_grade, \
'timestampStr': self.timestamp, 'questionId': self.question_id, 'userId': self.user_id, \
'grades': [x.serialize() for x in self.grades] }
class VariateCampaign(db.Model):
__tablename__ = "variate_campaign"
id = db.Column(db.Integer, primary_key=True)
mailchimp_id = db.Column(db.String(100))
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
folder_id = db.Column(db.Integer, db.ForeignKey("folder.id"))
segment_id = db.Column(db.Integer, db.ForeignKey("segment.id"))
list_id = db.Column(db.Integer, db.ForeignKey("list.id"))
name = db.Column(db.String(200))
status = db.Column(db.String(50), default="save")
send_time = db.Column(db.TIMESTAMP, nullable=True)
#Settings
subject_line = db.Column(db.String(200))
from_name = db.Column(db.String(200))
reply_to = db.Column(db.String(200))
schedule_time = db.Column(db.TIMESTAMP)
#Variate Settings
winning_combination_id = db.Column(db.String)
winning_campaign_id = db.Column(db.String)
winner_criteria = db.Column(db.String(10), default="opens")
wait_time = db.Column(db.Integer, default=60)
test_size = db.Column(db.Integer, default=10)
test_type = db.Column(db.String, default="subject_line")
test_combinations = db.Column(db.Integer, default=2)
combinations = db.relationship("VariateCampaignCombination", lazy="dynamic", cascade="all,delete")
activity = db.relationship("ListSubscriberActivity", backref="ab_test", lazy="dynamic", cascade="all,delete")
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class Consultation(db.Model):
__tablename__='consultations'
def __init__(self, date, time, proffessor_id):
self.date = date
self.time = time
self.proffessor_id = proffessor_id
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(50), nullable=False)
time = db.Column(db.String(50))
subject_id = db.Column(db.Integer, db.ForeignKey('subjects.id'))
subject = db.relationship('Subject', back_populates='consultations')
professor_id = db.Column(db.Integer, db.ForeignKey('users.id'))
professor = db.relationship('User', back_populates='consultations')
students = db.relationship('User', secondary=ConsultationsStudents,\
back_populates='consultations_stud')
def serialize(self):
return {'id': self.id, 'date': self.date, 'time': self.time, 'professor': self.professor.serialize(),\
'subjectId': self.subject_id}
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 Conversation(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
second_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
messages = db.relationship('Message', backref="conversation")
def __init__(self, first_user_id, second_user_id):
self.first_user_id = first_user_id
self.second_user_id = second_user_id
def __repr__(self):
return '<Conversation %r between user %r and user %r>' % (
self.id, self.first_user_id, self.second_user_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 FormGroup(db.Model):
__tablename__ = "form_group"
id = db.Column(db.Integer, primary_key=True)
form_type = db.Column(db.String(50))
name = db.Column(db.String(50))
rank = db.Column(db.Integer, default=1)
fields = db.relationship("FormField",
backref="form_group",
lazy="dynamic",
order_by="asc(FormField.rank)")
fieldset_on_form = db.Column(db.Boolean, default=True)
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
class Brand(db.Model):
__tablename__ = 'brand'
__table_args__ = {'useexisting': True}
id = db.Column(db.Integer, primary_key=True)
client = db.Column(db.String(100))
mid = db.Column(db.Integer)
api_user = db.Column(db.String(50))
api_key = db.Column(db.String(50))
api_dc = db.Column(db.String(10))
tools = db.relationship('Tool', secondary=brand_tools, lazy='dynamic')
status = db.Column(db.Integer, default=1)
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):
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
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'))
