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 + " >"