class Point(db.Model):
__tablename__ = "points"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
date = db.Column(DateTime, default=datetime.datetime.utcnow)
smell = db.Column(db.Boolean(), nullable=False)
taste = db.Column(db.Boolean(), nullable=False)
latitude = db.Column(db.Float(), nullable=False)
longitude = db.Column(db.Float(), nullable=False)
class Properties(db.Model):
__tablename__ = 'Properties'
property_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
address_l1 = db.Column(db.String(200))
address_l2 = db.Column(db.String(200))
city = db.Column(db.String(200))
state = db.Column(db.String(2))
zipcode = db.Column(db.String(20))
type = db.Column(db.String(50))
beds = db.Column(db.Numeric())
baths = db.Column(db.Numeric())
sale_price = db.Column(db.Integer)
rent_price = db.Column(db.Integer)
for_sale = db.Column(db.Boolean())
for_rent = db.Column(db.Boolean())
is_public = db.Column(db.Boolean(), default=False)
status = db.Column(db.String(100))
area = db.Column(db.Integer)
notes = db.Column(db.String(2000))
date_posted = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
images = db.relationship('PropertyImgs',
backref='property',
lazy='dynamic',
order_by='PropertyImgs.date_added')
history = db.relationship('History',
backref='property',
lazy='dynamic',
order_by='History.date.desc()')
def __init__(self, input):
columns = Properties.__table__.columns
for c in columns:
if c.key in input:
setattr(self, c.key, input[c.key])
def add_image(self, image):
if not self.has_image(image):
self.images.append(image)
def remove_image(self, image):
if self.has_image(image):
self.images.remove(image)
def has_image(self, image):
return self.images.filter(
PropertyImgs.img_id == image.img_id).count() > 0
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(256))
email = db.Column(db.String(256), unique=True, nullable=False)
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
last_login = db.Column(db.DateTime)
timezone = db.Column(db.String(255))
is_active = db.Column(db.Boolean())
is_superuser = db.Column(db.Boolean())
created_races = relationship('Race')
race_follows = relationship('RaceFollow')
class modelChat(db.Model):
__tablename__ = 'chat'
id_chat = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, db.ForeignKey('user.id'))
mensagem = db.Column(db.Text())
data_hora = db.Column(db.DateTime())
activate = db.Column(db.Boolean())
chat_and_usuario = db.relationship('modelUsuario')
class UserRightsModel(TimestampMixinModel, db.Model):
"""Table de gestion des droits des utilisateurs de GeoNature-citizen"""
__tablename__ = "t_users_rights"
__table_args__ = {"schema": "gnc_core"}
id_user_right = db.Column(db.Integer, primary_key=True)
id_user = db.Column(db.Integer, db.ForeignKey(UserModel.id_user), nullable=False)
id_module = db.Column(
db.Integer, db.ForeignKey(ModulesModel.id_module), nullable=True
)
id_module = db.Column(
db.Integer, db.ForeignKey(ProgramsModel.id_program), nullable=True
)
right = db.Column(db.String(150), nullable=False)
create = db.Column(db.Boolean(), default=False)
read = db.Column(db.Boolean(), default=False)
update = db.Column(db.Boolean(), default=False)
delete = db.Column(db.Boolean(), default=False)
class Asesi(db.Model):
__tablename__ = 'Asesi'
idAsesi = db.Column(db.Integer, primary_key=True, autoincrement=True)
NamaLengkap = db.Column(db.String(64), nullable=False)
TempatLahir = db.Column(db.String(255), nullable=False)
JenisKelamin = db.Column(db.String(1), nullable=False)
Kebangsaan = db.Column(db.String(64), nullable=False)
Alamat = db.Column(db.String(255), nullable=False)
KodePos = db.Column(db.String(8), nullable=False)
NoHP = db.Column(db.String(13), nullable=False)
NoHPRumah = db.Column(db.String(13))
NoHPKantor = db.Column(db.String(13))
Email = db.Column(db.String(64))
PendidikanTerakhir = db.Column(db.String(128))
StatusBekerja = db.Column(db.Boolean())
NamaPerusahaan = db.Column(db.String(128), nullable=False)
Jabatan = db.Column(db.String(128))
AlamatPerusahaan = db.Column(db.String(255))
KodePosPerusahaan = db.Column(db.String(8))
NoTeleponPerusahaan = db.Column(db.String(13))
NoFaxPerusahaan = db.Column(db.String(32))
EmailPerusahaan = db.Column(db.String(64))
Skema = db.Column(db.Integer, db.ForeignKey('Skema.idSkema'))
def __init__(self, nama, tempat, kelamin, bangsa, alamat, pos, nohp, rumah,
kantor, email, pendidikan, statuskerja, pekerjaan, Skema):
self.NamaLengkap = nama
self.TempatLahir = tempat
self.JenisKelamin = kelamin
self.Kebangsaan = bangsa
self.alamat = alamat
self.KodePos = pos
self.NoHP = nohp
self.NoHPRumah = rumah
self.NoHPKantor = kantor
self.Email = email
self.PendidikanTerakhir = pendidikan
self.StatusKompeten = False
self.StatusBekerja = statuskerja
self.bekerja = pekerjaan
self.Skema = Skema
def __repr__(self):
return self.NamaLengkap
def cekKompeten(self):
return self.StatusKompeten
def setDataPerusahaan(self, nama, jabatan, alamat, pos, telepon, fax,
email):
self.NamaPerusahaan = nama
self.Jabatan = jabatan
self.AlamatPerusahaan = alamat
self.KodePosPerusahaan = pos
self.NoTeleponPerusahaan = telepon
self.NoFaxPerusahaan = fax
self.EmailPerusahaan = email
class User(db.Model, UserMixin):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
creation_date = db.Column(db.DateTime(), default=datetime.utcnow)
last_login = db.Column(db.DateTime(), default=datetime.utcnow)
is_deleted = db.Column(db.Boolean(), default=False)
is_validated = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
comments = db.relationship('TimedComment', backref='user', lazy='dynamic')
def __init__(self, username, email, password, **kwargs):
self.username = username
self.email = email
self.password = password
def __repr__(self):
return self.username
# Flask-Login integration
def is_authenticated(self):
return True
def is_active(self): # line 37
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
# Required for administrative interface
def __unicode__(self):
return self.username
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), unique=True, nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
# children = db.relationship
def __init__(self, email):
self.email = email
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
active = db.Column(db.Boolean(), default=False, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
def __init__(self, username, email):
self.username = username
self.email = email
self.created_at = datetime.datetime.utcnow()
class Users(UserMixin, db.Model):
__tablename__ = 'Users'
id = db.Column(db.Integer, primary_key=True)
first = db.Column(db.String(100))
last = db.Column(db.String(100))
email = db.Column(db.String(100))
password = db.Column(db.String(80))
is_master = db.Column(db.Boolean(), default=False)
is_admin = db.Column(db.Boolean(), default=False)
is_verified = db.Column(db.Boolean(), default=False)
join_date = db.Column(db.DateTime(), default=datetime.utcnow)
is_deleted = db.Column(db.Boolean(), default=False)
delete_date = db.Column(db.DateTime(), default=datetime.utcnow)
history_subj = db.relationship("History",
backref='user_info',
foreign_keys=[History.user_id],
order_by='History.date.desc()',
passive_deletes="all")
history_target = db.relationship("History",
backref='tgt_info',
foreign_keys=[History.tgt_user_id],
cascade_backrefs=False)
history = db.relationship(
'History',
primaryjoin=
"or_(Users.id == History.user_id, Users.id == History.tgt_user_id)",
order_by='History.date.desc()')
# query_class = QueryWithSoftDelete
def __init__(self, email):
self.email = email
class modelUsuario(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nome_usuario = db.Column(db.String(80))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
data_nascimento = db.Column(db.DateTime())
sexo = db.Column(db.String(1))
telefone = db.Column(db.String(25))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('modelRole',
secondary=roles_users,
backref=db.backref('user', lazy='dynamic'))
class Pendaftaran(db.Model):
__tablename__ = 'Pendaftaran'
noPendaftaran = db.Column(db.Integer, primary_key=True, autoincrement=True)
Tanggal = db.Column(db.Date(), nullable=False)
Status = db.Column(db.Boolean(), nullable=False)
asesi = db.Column(db.Integer,
db.ForeignKey('Asesi.idAsesi'),
nullable=False)
admin = db.Column(db.Integer, db.ForeignKey('Admin.kode'), nullable=False)
def __init__(self, asesi):
self.tanggal = db.func.now()
self.Status = False
self.asesi = asesi
def setStatus(self, status):
self.status = status
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def __init__(self, username="", email=""):
self.username = username
self.email = email
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
first_name = db.Column(db.String(150))
last_name = db.Column(db.String(150))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users)
applications = db.relationship('Application', backref='user')
@classmethod
def authenticate(cls, args):
user = User.query.filter_by(email=args['email']).first()
if user and verify_password(args['password'], user.password):
return user
return False
def name(self):
return '{} {}'.format(self.first_name, self.last_name)
class History(db.Model):
__tablename__ = 'History'
history_id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String(20))
user_id = db.Column(db.Integer, db.ForeignKey('Users.id'))
tgt_user_id = db.Column(db.Integer, db.ForeignKey('Users.id'))
tgt_prop_id = db.Column(db.Integer,
db.ForeignKey('Properties.property_id'))
tgt_acn_id = db.Column(db.Integer, db.ForeignKey('Associations.acn_id'))
tgt_file_id = db.Column(db.Integer, db.ForeignKey('Files.file_id'))
tgt_about_id = db.Column(db.Integer,
db.ForeignKey('AboutInfo.aboutinfo_id'))
is_deleted = db.Column(db.Boolean(), default=False)
date = db.Column(db.DateTime(), default=datetime.utcnow)
content = db.relationship('HistoryContent',
backref='row_content',
lazy='dynamic')
# user = db.relationship('Users', backref='history', lazy='dynamic')
# tgt_user = db.relationship('Users', backref='history', lazy='dynamic')
def __init__(self, type, user_id, **kwargs):
self.type = type
self.user_id = user_id
# if 'content' in kwargs:
# self.content = kwargs['content']
if 'tgt_prop_id' in kwargs:
self.tgt_prop_id = kwargs['tgt_prop_id']
if 'tgt_user_id' in kwargs:
self.tgt_user_id = kwargs['tgt_user_id']
if 'tgt_acn_id' in kwargs:
self.tgt_acn_id = kwargs['tgt_acn_id']
if 'tgt_file_id' in kwargs:
self.tgt_file_id = kwargs['tgt_file_id']
if 'tgt_about_id' in kwargs:
self.tgt_about_id = kwargs['tgt_about_id']
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 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
"""
manage comment likes
"""
def add_like(self, user):
if not self.is_liked_by_user(user):
self.liked_by.append(user)
def remove_like(self, user):
if self.is_liked_by_user(user):
self.liked_by.remove(user)
def is_liked_by_user(self, user):
return self.liked_by.filter(User.id == user.id).count() > 0
class Homeowner(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(100))
imageURL = db.Column(db.String(250), nullable=True)
phoneNumber = db.Column(db.String(15))
isComplete = db.Column(db.Boolean())
def __init__(self, **kwargs):
"""**kwargs firstName, lastName, email, password, phoneNumber"""
self.firstName = kwargs.get("firstName", "")
self.lastName = kwargs.get("lastName", "")
self.email = kwargs.get("email", "")
self.password = kwargs.get("password", "")
self.imageURL = None
self.phoneNumber = kwargs.get("phoneNumber", "")
self.isComplete = False
def generatePasswordHash(self, password):
self.password = generate_password_hash(password)
def verifyPassword(self, password):
return check_password_hash(self.password, password)
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError as e:
print(e)
db.session.rollback()
db.session.close()
return False
def close_session(self):
db.session.close()
def update(self):
rows = Homeowner.query.filter(Homeowner.email == self.email).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 delete(self):
try:
Homeowner.query.filter(Homeowner.email == self.email).delete()
db.session.commit()
db.session.close()
return True
except IntegrityError:
print("Error")
db.session.rollback()
db.session.close()
return False
def toDict(self):
return {
Homeowner.firstName: self.firstName,
Homeowner.lastName: self.lastName,
Homeowner.email: self.email,
Homeowner.password: self.password,
Homeowner.imageURL: self.imageURL,
Homeowner.phoneNumber: self.phoneNumber
}
def toJson(self):
return {
"firstName":
self.firstName,
"lastName":
self.lastName,
"email":
self.email,
"phoneNumber":
self.phoneNumber,
"imageURL":
self.imageURL,
"homeownerLocation":
HomeownerLocation.query.filter(
HomeownerLocation.homeownerId == self.id).first().toJson()
if HomeownerLocation.query.filter(
HomeownerLocation.homeownerId == self.id).first() else None
}
def getAuthToken(self):
return {"authToken": self.generate_auth_token().decode("utf-8")}
def getId(self):
return {"homeownerId": self.id}
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
return Homeowner.query.get(data['id'])
except SignatureExpired:
return None
except BadSignature:
return None # invalid token
def __repr__(self):
return "< Homeowner: " + self.firstName + " " + self.lastName + " >"
class User(db.Model, UserMixin):
__table_args__ = {'extend_existing': True}
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
modified_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
display_name = db.Column(db.String(120))
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
new_user = db.Column(db.Boolean(), default=True)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer, default=0)
# Other columns
roles = db.relationship('Role',
secondary=users_roles,
backref=db.backref('roles', lazy='dynamic'))
def __init__(self,
email=None,
password=None,
display_name=None,
first_name=None,
last_name=None,
active=False,
new_user=False):
if email:
self.email = email.lower()
if password:
self.set_password(password)
if display_name:
self.display_name = display_name
if first_name:
self.first_name = first_name
if last_name:
self.last_name = last_name
if active:
self.active = active
if new_user:
self.new_user = new_user
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def add_role(self, role):
self.roles.append(role)
def add_roles(self, roles):
for role in roles:
self.add_role(role)
def get_roles(self):
for role in self.roles:
yield role
def to_json(self):
return dict(id=self.id,
email=self.email,
displayName=self.display_name)
class Tenant(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(100))
lastName = db.Column(db.String(100))
email = db.Column(db.String(120), index=True, unique=True)
phoneNumber = db.Column(db.String(15))
password = db.Column(db.String(100))
isApproved = db.Column(db.Boolean())
imageURL = db.Column(db.String(250), nullable=True)
houseId = db.Column(db.Integer(), nullable=False)
def __init__(self, **tenantData):
self.firstName = tenantData.get("firstName", "")
self.lastName = tenantData.get("lastName", "")
self.email = tenantData.get("email", "")
self.password = tenantData.get("password", "")
self.phoneNumber = tenantData.get("phoneNumber", "")
self.isApproved = False
self.houseId = 0
self.imageURL = None
def generatePasswordHash(self, password):
self.password = generate_password_hash(password)
def verifyPassword(self, password):
return check_password_hash(self.password, password)
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except IntegrityError:
db.session.rollback()
return False
def update(self):
rows = Tenant.query.filter(Tenant.email == self.email).update(self.toDict(), synchronize_session=False)
if rows == 1:
try:
db.session.commit()
return True
except OperationalError:
db.session.rollback()
return False
return False
def toDict(self):
return {
Tenant.firstName: self.firstName,
Tenant.lastName: self.lastName,
Tenant.email: self.email,
Tenant.password: self.password,
Tenant.isApproved: self.isApproved,
Tenant.phoneNumber: self.phoneNumber,
Tenant.imageURL: self.imageURL
}
def getId(self):
return {
"tenantId": self.id
}
def toJson(self):
return {
"tenantId": self.id,
"firstName": self.firstName,
"lastName": self.lastName,
"email": self.email,
"isApproved": self.isApproved,
"houseId": self.houseId,
"phoneNumber": self.phoneNumber,
"imageURL": self.imageURL
}
def getAuthToken(self):
return {
"authToken": self.generate_auth_token().decode("utf-8"),
}
def generate_auth_token(self, expiration = 600):
s = Serializer(app.config['SECRET_KEY'], expires_in = expiration)
return s.dumps({ 'id': self.id })
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
return Tenant.query.get(data['id'])
except SignatureExpired:
return None
except BadSignature:
return None # invalid token
def __repr__(self):
return "< Tenant: " + self.firstName + " " + self.lastName + " >"
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 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 Utility(db.Model):
id = db.Column(db.Integer(), primary_key=True)
heat = db.Column(db.Boolean())
electricity = db.Column(db.Boolean())
water = db.Column(db.Boolean())
internet = db.Column(db.Boolean())
houseId = db.Column(db.Integer(), nullable=False, unique=True)
def __init__(self, **utilityData):
self.heat = utilityData.get("heat", "") == "True"
self.electricity = utilityData.get("electricity", "") == "True"
self.water = utilityData.get("water", "") == "True"
self.internet = utilityData.get("internet", "") == "True"
self.houseId = utilityData.get("houseId", "0")
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):
rows = Utility.query.filter(Utility.houseId == self.houseId).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 {
Utility.heat: self.heat,
Utility.electricity: self.electricity,
Utility.water: self.water,
Utility.internet: self.internet,
Utility.houseId: self.houseId
}
def toJson(self):
return [{
"name": "Heat",
"responsibilityOf": "Tenant" if self.heat else "Homeowner"
}, {
"name":
"Electricity",
"responsibilityOf":
"Tenant" if self.electricity else "Homeowner"
}, {
"name": "Water",
"responsibilityOf": "Tenant" if self.water else "Homeowner"
}, {
"name": "Internet",
"responsibilityOf": "Tenant" if self.internet else "Homeowner"
}]
def __repr__(self):
return "<Utility " + str(self.water) + " >"
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.Text(), nullable=False)
scan_quota = db.Column(db.Integer(), default=31)
is_admin = db.Column(db.Boolean(), default=False)
has_premium = db.Column(db.Boolean(), default=False)
token = db.Column(db.Text())
invoices = db.relationship('Invoice', backref='user', lazy=True, cascade="all,delete")
scans = db.relationship('Scan', backref='user', lazy=True, cascade="all,delete")
def __repr__(self):
return '{id} - {name}'.format(id=self.id, name=self.name)
def __init__(self, name, email, password):
if self.exists(email):
return
self.name = name
self.email = email
self.password = generate_password_hash(password, method="pbkdf2:sha256", salt_length=8)
db.session.add(self)
db.session.commit()
return
@staticmethod
def decode_token(token):
try:
tk = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
except jwt.ExpiredSignatureError:
return False
except Exception as e:
return False
usertoken = User.query.filter_by(email=tk['user_email']).first()
if not usertoken:
return False
return usertoken
@staticmethod
def fetch(email=None, id=None):
if not email and not id:
raise 'Required params: Email or Id'
if email:
return User.query.filter_by(email=email).first()
if id:
return User.query.get(id)
@staticmethod
def exists(email):
return User.query.filter_by(email=email).first()
@staticmethod
def delete(user):
db.session.delete(user)
db.session.commit()
return
def check_password(self, password_to_compare):
return check_password_hash(self.password, password_to_compare)
def generate_session_token(self, expires_in=3600):
# DO NOT rename 'exp' flag. This is used inside jwt.encode() to verify if the token has expired.
token = jwt.encode({'user_email': self.email, 'id' : self.id ,
'exp': time() + expires_in}, app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
self.token = token
db.session.commit()
return token
def delete_token(self):
self.token = None
db.session.add(self)
db.session.commit()
def start_new_scan(self, checkpoints, url, alias):
Scan(self.id, url, alias, checkpoints)
self._reduce_scan_quota()
return
def add_premium(self):
self.has_premium = True
db.session.add(self)
db.session.commit()
return
def remove_premium(self):
self.has_premium = False
db.session.add(self)
db.session.commit()
return
def _reduce_scan_quota(self):
self.scan_quota -= 1
db.session.add(self)
db.session.commit()
return
class Amenity(db.Model):
id = db.Column(db.Integer(), primary_key=True)
airConditioning = db.Column(db.Boolean())
gas = db.Column(db.Boolean())
guestParking = db.Column(db.Boolean())
storage = db.Column(db.Boolean())
onSiteLaundry = db.Column(db.Boolean())
houseId = db.Column(db.Integer(), nullable=False, unique=True)
def __init__(self, **amenityData):
self.airConditioning = amenityData.get("airConditioning", "") == "True"
self.gas = amenityData.get("gas", "") == "True"
self.guestParking = amenityData.get("guestParking", "") == "True"
self.storage = amenityData.get("storage", "") == "True"
self.onSiteLaundry = amenityData.get("onSiteLaundry", "") == "True"
self.houseId = amenityData.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):
print(self.toDict())
rows = Amenity.query.filter(Amenity.houseId == self.houseId).update(
self.toDict())
print(rows)
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 {
Amenity.airConditioning: self.airConditioning,
Amenity.gas: self.gas,
Amenity.guestParking: self.guestParking,
Amenity.storage: self.storage,
Amenity.onSiteLaundry: self.onSiteLaundry,
Amenity.houseId: self.houseId
}
def toJson(self):
return [{
"name": "Air Conditioning",
"includedInRent": self.airConditioning
}, {
"name": "Gas",
"includedInRent": self.gas
}, {
"name": "On Site Laundry",
"includedInRent": self.onSiteLaundry
}, {
"name": "Storage",
"includedInRent": self.storage
}, {
"name": "Guest Parking",
"includedInRent": self.guestParking
}]
def __repr__(self):
return "<Amenity " + str(self.airConditioning) + " >"
