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