class Note(db.Model):
__tablename__ = 'notes'
id = db.Column(db.Integer(), primary_key=True)
body = db.Column(db.Text(), index=True, nullable=False)
timestamp = db.Column(db.Text(), nullable=False, default=PSTNow)
list_id = db.Column(db.Integer(), db.ForeignKey("lists.id"))
def __init__(self, body, list_id):
self.body = body
self.list_id = list_id
def __repr__(self):
return f"Note(id: {self.id}, body: {self.body}, list_id: {self.list_id})"
def to_json(self):
json_note = {
"id": self.id,
"body": self.body,
"list_id": self.list_id,
"timestamp": self.timestamp,
}
return json_note
@staticmethod
def from_json(json_note):
body = json_note.get('body')
list_id = json_note.get('list_id')
if (body is None or list_id is None or body == '' or list_id == ''):
raise Exception('Note does not have a body or list_id')
return Note(body=body, list_id=list_id)
class List(db.Model):
__tablename__ = 'lists'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Text(), index=True, nullable=False)
notes = db.relationship("Note", backref="list")
user_id = db.Column(db.Integer(), db.ForeignKey("users.id"))
def __init__(self, name, user_id):
self.name = name
self.user_id = user_id
def __repr__(self):
return f"List(id: {self.id}, name: {self.name}, user_id: {self.user_id})"
def to_json(self):
json_list = {
"id": self.id,
"name": self.name,
"user_id": self.user_id,
}
return json_list
@staticmethod
def from_json(json_list):
name = json_list.get('name')
user_id = json_list.get('user_id')
if name is None or name == '' or user_id is None or user_id == '':
raise Exception('List does not have a name or User ID')
return List(name=name, user_id=user_id)
class Unit(db.Model):
unitID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
departmentID = db.Column(db.Integer(),
db.ForeignKey('department.departmentID'),
nullable=False)
unitname = db.Column(db.String(32), nullable=False)
class Note(db.Model):
noteID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
author = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
text = db.Column(db.String(250))
date = db.Column(db.DateTime())
class IncidentRequestPriority(db.Model):
requestID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
username = db.Column(db.String(32), db.ForeignKey('account.username'))
priority = db.Column(db.String(2), nullable=False)
severity = db.Column(db.String(2), nullable=False)
impact = db.Column(db.String(2), nullable=False)
reason = db.Column(db.String(250))
timeRequested = db.Column(db.DateTime())
class User(db.Model):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
profile = db.Column(db.Integer, db.ForeignKey('profile.id'))
schedule = db.Column(db.Integer, db.ForeignKey('schedule.id'))
is_admin = db.Column(db.Boolean)
created_on = db.Column(db.DateTime)
expiration_date = db.Column(db.DateTime)
def __init__(self, username, password):
self.username = username
self.active = True
self.password = User.hashed_password(password)
self.created_on = datetime.utcnow()
self.is_admin = True
self.expiration_date = None
self.schedule = None
@staticmethod
def hashed_password(password):
return bcrypt.generate_password_hash(password).decode('utf-8')
@staticmethod
def get_user_with_username_and_password(username, password):
user = User.query.filter_by(username=username).first()
if user and bcrypt.check_password_hash(user.password.encode('utf-8'), password):
return user
else:
return None
class Role(db.Model, RoleMixin):
__tablename__ = 'Role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
return self.name
class IncidentUpdate(db.Model):
updateID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
technicianID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
# priority = db.Column(db.String(2), nullable=False)
# severity = db.Column(db.String(2), nullable=False)
# impact = db.Column(db.String(2), nullable=False)
description = db.Column(db.String(250))
updateType = db.Column(db.String(32))
timeSpent = db.Column(db.Integer(), nullable=False)
date = db.Column(db.DateTime())
class Incident(db.Model):
incidentID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
raisedID = db.Column(db.String(32), db.ForeignKey('account.username'))
affectedID = db.Column(db.String(32), db.ForeignKey('account.username'))
investigatingDepartmentID = db.Column(
db.Integer(), db.ForeignKey('department.departmentID'))
investigatingTechnicianID = db.Column(db.String(32),
db.ForeignKey('account.username'))
description = db.Column(db.String(250))
timeRaised = db.Column(db.DateTime())
priority = db.Column(db.String(2), nullable=False)
severity = db.Column(db.String(2), nullable=False)
impact = db.Column(db.String(2), nullable=False)
status = db.Column(db.String(32), nullable=False)
timeCompleted = db.Column(db.DateTime())
class DepartmentMember(db.Model):
username = db.Column(db.String(32),
db.ForeignKey('account.username'),
primary_key=True,
unique=True,
nullable=False)
departmentID = db.Column(db.Integer(),
db.ForeignKey('department.departmentID'),
primary_key=True,
nullable=False)
role = db.Column(db.String(32))
class Database(db.Model):
"""
Represents general information about the database
Attributes
----------
name : str
Name of the database.
size : int
size of the database, in bytes.
ttl_last_execution : datetime
Last time the ttl script ran on the database.
ttl_duration : int
duration of the last ttl script execution, in s.
backup_last_id : str
id of the last backup.
backup_duration : int
duration of the last backup execution, in s.
backup_last_execution : int
time of the end of the last backup execution.
backup_size : int
size of the last backup, in bytes.
backup_error : str
error message, if any, of the last backup.
"""
__tablename__ = 'Database'
name = db.Column(db.String(), nullable=False, primary_key=True)
size = db.Column(db.Integer(), nullable=False)
ttl_last_execution = db.Column(db.DateTime(), nullable=True)
ttl_duration = db.Column(db.Integer(), nullable=True)
backup_last_id = db.Column(db.String(), nullable=True)
backup_duration = db.Column(db.Integer(), nullable=True)
backup_last_execution = db.Column(db.Integer(), nullable=True)
backup_size = db.Column(db.Integer(), nullable=True)
backup_error = db.Column(db.String(), nullable=False)
def __init__(self, name):
self.name = name
self.size = 0
self.backup_error = ""
class Message(db.Model):
messageID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
messageText = db.Column(db.String(250))
senderID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
receiverID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
date = db.Column(db.DateTime())
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = db.Column(db.String(40), nullable=False)
preparation = db.Column(db.String())
rating = db.Column(db.Float(), default=0)
num_of_ratings = db.Column(db.Integer(), default=0)
user_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('user.id'),
nullable=False)
num_of_ingredients = db.Column(db.Integer())
ingredients = db.relationship('Ingredient',
secondary=recipe_ing,
back_populates='recipes',
lazy='dynamic')
def __repr__(self):
return f'<Recipe {self.name}>'
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column(
'project',
db.Column('index',
db.Integer(),
autoincrement=True,
nullable=False,
default=0))
# ### end Alembic commands ###
index = 0
projects = Project.query.all()
for project in projects:
index += 1
project.index = index
db.session.commit()
class TagAvgDuration(db.Model):
__tablename__ = 'tag_vs_avg_video_duration'
tag = db.Column(db.String(), primary_key=True)
video_duration = db.Column(db.Integer())
def __init__(self, tag):
self.tag = tag
def __repr__(self):
return '<tag {}>'.format(self.tag)
@property
def serialize(self):
"""
Return item in serializeable format
"""
return {"tag": self.tag, "video_duration": self.video_duration}
class ScrapyTask(db.Model):
# set table name
__tablename__ = 't_scrapy_task'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
domain = db.Column(db.String(128))
start_urls = db.Column(db.String(255))
url = db.Column(db.String(255))
album_id = db.Column(db.String(128))
rule_id = db.Column(db.String(128))
create_time = db.Column(db.TIMESTAMP())
update_time = db.Column(db.TIMESTAMP())
def __init__(self, **entries):
self.__dict__.update(entries)
def __repr__(self):
"""Define the string format for instance of ScrapyTask."""
return "<Model ScrapyTask `{}`>".format(self.id)
class Attribute(db.Model):
"""
Represents information about an attribute
Attributes
----------
name : str
Name of the attribute.
ttl_rows_deleted : int
Number of rows deleted on the last ttl session.
"""
__tablename__ = 'Attribute'
name = db.Column(db.String(), nullable=False, primary_key=True)
ttl_rows_deleted = db.Column(db.Integer(), nullable=True)
def __init__(self, name, ttl):
self.name = name
self.ttl_rows_deleted = ttl
class Scan(db.Model):
__tablename__ = 'scans'
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime(), default=datetime.datetime.now())
finished = db.Column(db.DateTime(), default=None, nullable=True)
report = db.relationship('Report', backref='scan', lazy=True, cascade="all,delete", uselist=False)
checkpoints = db.relationship('Checkpoint', backref='scan', lazy=True, cascade='all,delete')
hashid = db.Column(db.String(200), nullable=False)
userid = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable=False)
url = db.Column(db.Text())
alias = db.Column(db.String(200))
def __repr__(self):
return f'[Scan] #{self.id}'
def __init__(self, userid, url, alias, checkpoints):
reportstring = f'{url}-{str(datetime.datetime.now())}-{randint(0, 1000)}'
self.hashid = hashlib.sha256(reportstring.encode('utf-8')).hexdigest()
self.userid = userid
self.url = url
self.alias = alias
self._add_checkpoints(checkpoints)
return
def _add_checkpoints(self, checkpoints):
for checkpoint in checkpoints:
self.checkpoints.append(checkpoint)
db.session.add(self)
db.session.commit()
return
def update_scan_status(self):
self.finished = datetime.datetime.now()
db.session.add(self)
db.session.commit()
return
def add_report(self, seo, accessibility, usability, results):
Report(self.id, seo, accessibility, usability, results)
return
class Checkpoint(db.Model):
__tablename__ = 'checkpoints'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text())
wcaglevels = db.Column(db.String(20))
benefits = db.Column(db.String(40))
regex = db.Column(db.Text())
scanid = db.Column(db.Integer(), db.ForeignKey('scans.id'), nullable=True)
def __str__(self):
return f'{self.id} - {self.name}'
def __init__(self, name, wcaglevels, benefits, regex, scanid):
self.name = name
self.wcaglevels = wcaglevels
self.benefits = benefits
self.regex = regex
self.scanid = scanid
db.session.add(self)
db.session.commit()
return
class Quotes(db.Model):
__tablename__ = 'quotes'
# Primary key
id = db.Column(db.Integer, primary_key=True)
# Quote string
quote = db.Column(db.String())
# Quote hash to reduce comparison complexity between quotes (I think)
quote_hash = db.Column(db.Integer())
def __init__(self, quote, quote_hash):
self.quote = quote
self.quote_hash = quote_hash
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'quote': self.quote,
'quote_hash': self.quote_hash
}
class Invoice(db.Model):
__tablename__ = 'invoices'
id = db.Column(db.Integer, primary_key=True)
datetime = db.Column(db.DateTime(), default=datetime.datetime.now())
ispaid = db.Column(db.Boolean(), default=False)
paymentconfirmationid = db.Column(db.String(50))
discount = db.Column(db.Float(), default=0)
amountdue = db.Column(db.Float(), nullable=False)
tax = db.Column(db.Float(), nullable=False)
description = db.Column(db.Text(), nullable=False)
userid = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return f'[Invoice] #{self.id}: On: {self.datetime} Due: {self.amountdue} Paid: {self.ispaid}'
def __init__(self, amountdue, tax, description, userid):
self.amountdue = amountdue
self.tax = tax
self.description = description
self.userid = userid
db.session.add(self)
db.session.commit()
return
class modelRole(db.Model, RoleMixin):
__tablename__ = 'role'
id_tipo_usuario = db.Column(db.Integer(), primary_key=True)
descricao = db.Column(db.String(255))
class RentalUnitLocation(db.Model):
id = db.Column(db.Integer(), primary_key=True)
streetNumber = db.Column(db.Integer())
streetName = db.Column(db.String(200))
city = db.Column(db.String(100))
province = db.Column(db.String(100))
postalCode = db.Column(db.String(10))
unitName = db.Column(db.String(100))
isCondo = db.Column(db.Boolean())
houseId = db.Column(db.Integer(), nullable=False)
def __init__(self, **rentalUnitLocationData):
self.streetNumber = rentalUnitLocationData.get("streetNumber", "")
self.streetName = rentalUnitLocationData.get("streetName", "")
self.city = rentalUnitLocationData.get("city", "")
self.province = rentalUnitLocationData.get("province", "")
self.postalCode = rentalUnitLocationData.get("postalCode", "")
self.unitName = rentalUnitLocationData.get("unitName", "")
self.isCondo = rentalUnitLocationData.get("isCondo", "")
self.houseId = rentalUnitLocationData.get("houseId", "")
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError as e:
print(e)
db.session.rollback()
return False
def update(self):
RentalUnitLocation.query.update(self.toDict(),
synchronize_session=False)
db.session.commit()
def toDict(self):
return {
RentalUnitLocation.streetNumber: self.streetNumber,
RentalUnitLocation.streetName: self.streetName,
RentalUnitLocation.city: self.city,
RentalUnitLocation.province: self.province,
RentalUnitLocation.postalCode: self.postalCode,
RentalUnitLocation.unitName: self.unitName,
RentalUnitLocation.parkingSpaces: self.parkingSpaces,
RentalUnitLocation.isCondo: self.isCondo
}
def toJson(self):
return {
"streetNumber": self.streetNumber,
"streetName": self.streetName,
"city": self.city,
"province": self.province,
"postalCode": self.postalCode,
"unitName": self.unitName,
"isCondo": self.isCondo
}
def __repr__(self):
return "< Rental Unit Location: " + str(
self.streetNumber) + " " + self.streetName + " >"
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
capacity = db.Column(db.Integer())
number_players = db.Column(db.Integer())
pitch_postcode = db.Column(db.String(8))
time = db.Column(db.DateTime())
created_by = db.Column(db.Integer,
db.ForeignKey("users.id", ondelete="CASCADE"))
creator = db.relationship("User", foreign_keys=[created_by])
users = db.relationship("Enrollment")
def __init__(self, args):
self.name = args['name']
self.capacity = args['capacity']
self.number_players = args['number_players']
self.pitch_postcode = args['pitch_postcode']
self.time = args['time']
self.created_by = current_user().id
self.validate_capacity_greater_than_players()
self._update_enrollments(args)
def _update_enrollments(self, args):
args['team'] = self
enrollment = Enrollment(args)
db.session.add(enrollment)
db.session.commit()
def validate_capacity_greater_than_players(self):
if int(self.capacity) < int(self.number_players):
raise ValueError(
'Capacity have to be greater or equal than number of players')
@validates('name')
def validate_name(self, key, name):
if not name:
raise ValueError('Team name cannot be empty')
return name
@validates('capacity')
def validate_capacity(self, key, capacity):
if not capacity.isdigit():
raise ValueError('Capacity must be a number')
return capacity
@validates('number_players')
def validate_number_players(self, key, number_players):
if not number_players.isdigit():
raise ValueError('Number players must be a number')
return number_players
@validates('pitch_postcode')
def validate_pitch_postcode(self, key, pitch_postcode):
if not pitch_postcode:
raise ValueError('Postcode cannot be empty')
return pitch_postcode
@validates('time')
def validate_time(self, key, time):
try:
datetime.strptime(str(time), '%Y-%m-%d %H:%M')
except:
raise ValueError('Date or Time not valid')
return time
def __repr__(self):
return '<Team {}>'.format(self.id)
class House(db.Model):
id = db.Column(db.Integer(), primary_key=True)
homeownerId = db.Column(db.Integer())
arrangement = db.Column(db.String(10))
province = db.Column(db.String(30))
isComplete = db.Column(db.Boolean())
def __init__(self, homeownerId, **houseData):
self.homeownerId = homeownerId
self.arrangement = houseData.get("arrangement", "")
self.province = houseData.get("province", "")
self.isComplete = False
def toJson(self):
return {
"houseId":
self.id,
"homeownerId":
self.homeownerId,
"arrangement":
self.arrangement,
"province":
self.province,
"isComplete":
self.isComplete,
"rentalUnitLocation":
RentalUnitLocation.query.filter(
RentalUnitLocation.houseId == self.id).first().toJson()
if RentalUnitLocation.query.filter(
RentalUnitLocation.houseId == self.id).first() else None
}
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError:
db.session.rollback()
return False
def close_session(self):
db.session.close()
def update(self):
rows = House.query.filter(House.id == self.id).update(
self.toDict(), synchronize_session=False)
if rows == 1:
try:
db.session.commit()
db.session.close()
return True
except OperationalError:
db.session.rollback()
db.session.close()
return False
return False
def toDict(self):
return {
House.id: self.id,
House.homeownerId: self.homeownerId,
}
def getId(self):
return {"houseId": self.id}
def __repr__(self):
return "< House: House >"
class Problem(db.Model):
id = db.Column(db.Integer(), primary_key=True)
category = db.Column(db.String(25))
description = db.Column(db.String(140))
imageURL = db.Column(db.String(223), nullable=True)
status = db.Column(db.String(15))
datePosted = db.Column(db.String(20))
lastUpdated = db.Column(db.String(20))
houseId = db.Column(db.Integer())
def __init__(self, problemData):
self.category = problemData["category"]
self.description = problemData["description"]
self.datePosted = problemData["datePosted"]
self.lastUpdated = problemData["lastUpdated"]
self.status = problemData["status"]
self.houseId = problemData["houseId"]
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError:
db.session.rollback()
return False
def toDict(self):
return {
Problem.category: self.category,
Problem.description: self.description,
Problem.imageURL: self.imageURL,
Problem.status: self.status,
Problem.datePosted: self.datePosted,
Problem.lastUpdated: self.lastUpdated
}
def toJson(self):
return {
"problemId": self.id,
"category": self.category,
"description": self.description,
"imageUrl": self.imageURL,
"status": self.status,
"datePosted": self.datePosted,
"lastUpdated": self.lastUpdated,
"houseId": self.houseId
}
def update(self):
rows = Problem.query.filter(Problem.id == self.id).update(self.toDict(), synchronize_session=False)
print(self.toJson())
if rows == 1:
try:
db.session.commit()
return True
except OperationalError:
db.session.rollback()
return False
return False
def __repr__(self):
return "< Problem: " + self.category + ": " + self.description + " >"
class Film(db.Model):
"""Defining a film model."""
__tablename__ = "film"
id = db.Column(db.Integer, primary_key=True)
film_id = db.Column(db.String(64))
title = db.Column(db.String(64))
description = db.Column(db.Text())
director = db.Column(db.String(64))
producer = db.Column(db.String(64))
release_date = db.Column(db.Integer())
rt_score = db.Column(db.Integer())
species = db.Column(db.String(128))
locations = db.Column(db.String(128))
url = db.Column(db.String(128))
people = db.relationship(
"Character", backref="films",
secondary=table_film_to_character_map
)
@classmethod
def get_or_create_film(cls, film_json):
"""
Get film info or create a film if it does not exists in the db.
:param film_json: json object with film fields
:return: film object instance from the db
"""
with db.session.no_autoflush:
film_obj = Film.find_by_film_id(film_json.get("id"))
if not film_obj:
film_obj = Film(
film_id=film_json.get("id"),
title=film_json.get("title"),
description=film_json.get("description"),
director=film_json.get("director"),
producer=film_json.get("producer"),
release_date=film_json.get("release_date"),
rt_score=film_json.get("rt_score"),
url=film_json.get("url"),
)
db.session.add(film_obj)
db.session.commit()
return film_obj
@classmethod
def find_by_film_id(cls, film_id):
"""
Find db object by its film_id.
:param film_id: string id of a film
:return: sqlalchemy query object with first matching result
"""
return cls.query.filter_by(film_id=film_id).first()
def __repr__(self):
return (
f"<Film id={self.id}, film_id={self.film_id}, title={self.title} "
f"description={self.description}, director={self.director} "
f"producer={self.producer} release_date={self.release_date} "
f"rt_score={self.rt_score} species={self.species} "
f"locations={self.locations} url={self.url} "
f"people={[p.id for p in self.people]}>"
)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(64), unique=True, index=True, nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
lists = db.relationship("List", backref="user")
def __init__(self, email, password):
self.email = email.lower()
self.password_hash = generate_password_hash(password)
def __repr__(self):
return f"User(id: {self.id}, email: {self.email})"
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
@property
def password(self):
return AttributeError("Password is not a readable attribute")
@password.setter
def password(self, password):
self.password_hash = generate_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 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 Exception:
return False
user = User.query.get(data.get('reset'))
if user is None:
return False
user.password_hash = generate_password_hash(new_password)
db.session.add(user)
db.session.commit()
return True
def generate_auth_token(self, expiration):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({"id": self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except Exception:
return None
return User.query.get(data['id'])
@staticmethod
def from_json(json_user):
email = json_user.get('email')
password = json_user.get('password')
if (email is None or password is None or email == ''
or password == ''):
raise Exception('User does not have an email or password')
return User(email=email, password=password)
from server import db
from datetime import datetime
timed_comment_likes = db.Table('timed_comment_likes',
db.Column('user_id',db.Integer(),db.ForeignKey('User.id')),
db.Column('comment_id',db.Integer(),db.ForeignKey('TimedComment.id')),
db.UniqueConstraint('user_id', 'comment_id', name='like_constraint')
)
class TimedComment(db.Model):
__tablename__ = 'TimedComment'
id = db.Column(db.Integer, primary_key = True)
show_series_id = db.Column(db.Integer, db.ForeignKey('ShowSeries.id'))
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
comment_time = db.Column(db.Integer)
is_reported = db.Column(db.Boolean())
content = db.Column(db.String(200))
post_date = db.Column(db.DateTime(), default = datetime.utcnow)
parent_id = db.Column(db.Integer, db.ForeignKey('TimedComment.id'))
liked_by = db.relationship('User', secondary=timed_comment_likes, backref=db.backref('liked_timed_comments',lazy='dynamic'), lazy='dynamic')
children = db.relationship("TimedComment", backref = db.backref('parent',remote_side = id))
def __init__(self, show_series_id, user_id, comment_time, content, parent_id):
self.show_series_id = show_series_id
self.user_id = user_id
self.comment_time = comment_time
self.content = content
self.parent_id = parent_id
class HomeownerLocation(db.Model):
id = db.Column(db.Integer(), primary_key=True)
streetNumber = db.Column(db.Integer())
streetName = db.Column(db.String(200))
city = db.Column(db.String(100), )
province = db.Column(db.String(100))
postalCode = db.Column(db.String(10))
unitNumber = db.Column(db.String(10))
poBox = db.Column(db.String(10))
homeownerId = db.Column(db.Integer(), nullable=False)
def __init__(self, **homeownerLocationData):
self.streetNumber = homeownerLocationData.get("streetNumber", "")
self.streetName = homeownerLocationData.get("streetName", "")
self.city = homeownerLocationData.get("city", "")
self.province = homeownerLocationData.get("province", "")
self.postalCode = homeownerLocationData.get("postalCode", "")
self.unitNumber = homeownerLocationData.get("unitNumber", "")
self.poBox = homeownerLocationData.get("poBox", "")
self.homeownerId = homeownerLocationData.get("homeownerId", "")
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError as e:
print(e)
db.session.rollback()
return False
def update(self):
HomeownerLocation.query.filter(
HomeownerLocation.homeownerId == self.homeownerId).update(
self.toDict(), synchronize_session=False)
db.session.commit()
def delete(self):
HomeownerLocation.query.filter(
HomeownerLocation.homeownerId == self.homeownerId).delete()
db.session.commit()
def toDict(self):
return {
HomeownerLocation.streetNumber: self.streetNumber,
HomeownerLocation.streetName: self.streetName,
HomeownerLocation.city: self.city,
HomeownerLocation.province: self.province,
HomeownerLocation.postalCode: self.postalCode,
HomeownerLocation.unitNumber: self.unitNumber,
HomeownerLocation.poBox: self.poBox
}
def toJson(self):
return {
"streetNumber": self.streetNumber,
"streetName": self.streetName,
"city": self.city,
"province": self.province,
"postalCode": self.postalCode,
"unitNumber": self.unitNumber,
"poBox": self.poBox
}
def __repr__(self):
return "< Homeowner Location: " + str(
self.streetNumber) + " " + self.streetName + " >"
