class Address(db.Model): id = db.Column(db.Integer(), primary_key=True) street_address = db.Column(db.String(255)) postal_code = db.Column(db.Integer()) city = db.Column(db.String(100)) state = db.Column(db.String(100)) country = db.Column(db.String(100))
class User_info(db.Model): """ Model for more specific user information Attributes ------------------ user_id : int user id from db created_at :str created date and time from db phone : int user phone number from db """ user_id = db.Column(db.Integer(), ForeignKey('user.id'), primary_key=True) created_at = db.Column(db.DateTime()) phone = db.Column(db.Integer()) def __init__(self, user_id, created_at, phone): """ Initialize User_Info model """ self.user_id = user_id self.created_at = created_at self.phone = phone
class Account(db.Model): id = db.Column(db.Integer(), primary_key=True) user = db.Column(db.Integer()) label = db.Column(db.String(255)) bank = db.Column(db.String(255)) iban = db.Column(db.String(34), unique=True) bic = db.Column(db.String(12)) projected_date = db.Column(db.Date()) def __init__(self, user, label, bank, iban, bic, projected_date): self.user = user['id'] self.label = label self.bank = bank self.iban = iban self.bic = bic self.projected_date = projected_date @staticmethod def get_accounts(user): return Account.query.filter_by(user=user['id']).all() @staticmethod def get_account_by_id(id): account = Account.query.filter_by(id=id) if account: return account else: return None @staticmethod def get_projected_date(id): account = Account.query.filter_by(id=id).first() return account.projected_date
class UsersRoles(db.Model): __tablename__ = 'users_roles' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
class File(db.Model): __bind_key__ = 'wehomeproperty' id = db.Column(db.Integer(), index=True, primary_key=True) # 0 => s3 file type = db.Column(db.Integer()) is_active = db.Column(db.Boolean(), default=True, index=True) foreign_id = db.Column(db.Integer(), nullable=False, index=True) # like report's item id and itme id item_id = db.Column(db.Integer(), nullable=False, index=True) filename = db.Column(db.String(255)) # the raw name of upload raw_name = db.Column(db.String(255)) created_at = db.Column(db.DateTime(), default=datetime.datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now) __table_args__ = ( db.Index("idx_foreign_id_item_id_type_is_active", "foreign_id", 'item_id', 'type', 'is_active'), ) def __init__(self, type, foreign_id, item_id, filename, raw_name, is_active=True): self.type = type self.foreign_id = foreign_id self.item_id = item_id self.filename = filename self.is_active = is_active self.raw_name = raw_name
class Offer(db.Model): id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) asal = db.Column(db.String(255)) tujuan = db.Column(db.String(255)) fee = db.Column(db.Integer()) time = db.Column(db.DateTime()) passenger = db.Column(db.Integer) color = db.Column(db.Integer) @staticmethod def get_all_offers(): offers = Offer.query.all() offers = { x.id: { 'user_id': x.user_id, 'asal': x.asal, 'tujuan': x.tujuan, 'fee': x.fee, 'time': x.time, 'passenger': x.passenger, 'passengers': [y.id for y in x.passenger_list], 'color': x.color } for x in offers } return offers
class Image(db.Model): id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False) data = db.Column(db.LargeBinary()) categories = db.Column(db.String(255)) public = db.Column(db.Integer()) file_name = db.Column(db.String(255)) def __init__(self, user_id, file_name, data, categories=None, public=0): self.data = data self.categories = categories self.public = public self.user_id = User.query.get(user_id).id self.file_name = file_name @staticmethod def get_all_public_images(): images = Image.query.filter(Image.public == 1) return images @staticmethod def get_allowed_images_from_user(queried_user, querying_user): if queried_user == querying_user: return Image.query.filter(Image.user_id == querying_user) else: return Image.query.filter((Image.user_id == queried_user) & Image.public)
class RecurringGroup(db.Model): id = db.Column(db.Integer(), primary_key=True) account_id = db.Column(db.Integer()) label = db.Column(db.String(255)) amount = db.Column(db.DECIMAL(19, 2)) start_date = db.Column(db.Date()) end_date = db.Column(db.Date()) recurrence_day = db.Column(db.Integer()) recurrence_month = db.Column(db.Integer()) def __init__(self, account_id, label, amount, start_date, end_date, recurrence_day, recurrence_month): self.account_id = account_id self.label = label self.amount = amount self.start_date = start_date self.end_date = end_date self.recurrence_day = recurrence_day self.recurrence_month = recurrence_month @staticmethod def get_groups(account_ids): if not isinstance(account_ids, (list)): account_ids = [account_ids] return RecurringGroup.query.filter( RecurringGroup.account_id.in_(account_ids)).all()
class Picture(db.Model): __bind_key__ = 'wehomeproperty' id = db.Column(db.Integer(), index=True, primary_key=True) # type 0: avatar 1 => linkinde url type = db.Column(db.Integer()) picturable_id = db.Column(db.Integer()) filename = db.Column(db.String(255)) created_at = db.Column(db.DateTime(), default=datetime.datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now) __table_args__ = ( db.Index("idx_type_picturable_id", "type", "picturable_id"), ) def __init__(self, type, picturable_id, filename): self.type = type self.picturable_id = picturable_id self.filename = filename @staticmethod def get_filename_with_user_id(user_id): picture = Picture.query.filter_by(type=0, picturable_id=user_id).order_by(Picture.id.desc()).first() if picture: return picture.filename return None
class Person(db.Model): id = db.Column(db.Integer(), primary_key=True) first_name = db.Column(db.String(255)) last_name = db.Column(db.String(255)) email = db.Column(db.String(120), unique=True, nullable=False) phone_number = db.Column(db.String(50)) password = db.Column(db.String(255), nullable=False) address_id = db.Column(db.Integer(), db.ForeignKey('address.id')) job_id = db.Column(db.Integer(), db.ForeignKey('job.id')) stage_id = db.Column(db.Integer(), db.ForeignKey('stage.id')) def __init__(self, first_name, last_name, email, phone_number, password, address_id, job_id, stage_id): self.first_name = first_name self.last_name = last_name self.email = email self.phone_number = phone_number self.active = True self.password = Person.hashed_password(password) self.address_id = address_id self.job_id = job_id self.stage_id = stage_id @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password).decode("utf-8") @staticmethod def get_person_with_email_and_password(email, password): person = Person.query.filter_by(email=email).first() if person and bcrypt.check_password_hash(person.password, password): return person else: return None
class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.Binary(60), nullable=False) bodyweight = db.Column(db.Integer()) one_rep_max = db.relationship("OneRepMax") imperial = db.Column(db.Boolean()) sessions = db.relationship("UserSession", lazy="dynamic") def __init__(self, email, password, imperial=True, bodyweight=-1): self.email = email self.active = True self.password = User.hashed_password(password) self.imperial = imperial self.bodyweight = bodyweight @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password) @staticmethod def get_user_with_email_and_password(email, password): user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): return user else: return None
class Product(db.Model): id = db.Column(db.Integer(), primary_key=True) product_name = db.Column(db.String(255)) product_description = db.Column(db.Text()) category_id = db.Column(db.Integer(), db.ForeignKey('category.id'), nullable=False) pre_approved = db.Column(db.Boolean())
class Room(db.Model): id = db.Column(db.Integer(), primary_key=True, nullable=False) office_id = db.Column(db.Integer(), db.ForeignKey('office.id'), primary_key=True, nullable=False) room_name = db.Column(db.String(100)) elevator_accessible = db.Column(db.Boolean())
class OneRepMax(db.Model): __tablename__ = "one_rep_max" id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) grip = db.Column(db.String()) left_hand = db.Column(db.Integer()) right_hand = db.Column(db.Integer()) combined = db.Column(db.Integer())
class UserSet(db.Model): __tablename__ = "user_set" id = db.Column(db.Integer(), primary_key=True) workout_id = db.Column(db.Integer(), db.ForeignKey("user_session.id")) reps = db.relationship("UserRep") rest = db.Column(db.Integer()) ordinal = db.Column(db.Integer()) completed = db.Column(db.Boolean()) effort_level = db.Column(db.Integer())
class UserSession(db.Model): __tablename__ = "user_session" id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) date = db.Column(db.Date()) sets = db.relationship("UserSet") note = db.Column(db.Text()) grip = db.Column(db.String(255)) program = db.Column(db.Integer(), db.ForeignKey("program_template.id"))
class Request(db.Model): id = db.Column(db.Integer(), primary_key=True) person_id = db.Column(db.Integer(), db.ForeignKey('person.id'), nullable=False) product_id = db.Column(db.Integer(), db.ForeignKey('product.id'), nullable=False) request_justfication = db.Column(db.Text()) request_date = db.Column(db.DateTime())
class Edge(db.Model): __tablename__ = 'edge' id = db.Column(db.Integer(), primary_key=True) source = db.Column(db.Integer(), db.ForeignKey('node.id'), nullable=False) target = db.Column(db.Integer(), db.ForeignKey('node.id'), nullable=False) crawlerId = db.Column(db.Integer(), db.ForeignKey('crawler.id'), nullable=False) def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Message(db.Model): __tablename__ = "message" id = db.Column(db.Integer(), primary_key=True) event = db.Column(db.Integer(), nullable=True) text = db.Column(db.String(1024)) author = db.Column(db.Integer, ForeignKey('user.id'), nullable=False) outgoing_to = db.Column(db.Integer, ForeignKey('user.id'), nullable=True) broadcast_to = db.Column(db.String( 2048)) # XXX? in Postgres this would work better as an array, # but for now, I'm just storing it as a string, and splitting # it on output since I'm trying to get as far as possible without # requiring Postgres timestamp = db.Column(db.Integer()) parent = db.Column(db.Integer, ForeignKey('message.id'), nullable=True) def __init__(self, text="", author="", outgoing_to=None, broadcast_to="", timestamp="", parent=None, event=None): self.text = text self.author = author self.outgoing_to = outgoing_to self.broadcast_to = broadcast_to self.timestamp = timestamp self.parent = parent self.event = event def as_dict(self): return { 'id': self.id, 'text': self.text, 'author': self.author, 'outgoing_to': self.outgoing_to, 'broadcast_to': filter(None, self.broadcast_to.split('|')), 'timestamp': self.timestamp, 'parent': self.parent, 'event': self.event, } def get_responses(): return User.query.filter_by(parent=self.id) @staticmethod def get_new(): return Message.query.all() @staticmethod def get_for_event(event): return User.query.filter_by(event=event.id, parent=null)
class Administrator(db.Model): __bind_key__ = 'wehomeproperty' id = db.Column(db.Integer(), index=True, primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey("user.id", ondelete="CASCADE"), nullable=False, index=True, unique=True) created_at = db.Column(db.DateTime(), default=datetime.datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now) @staticmethod def is_user_admin(user_id): admin = Administrator.query.filter_by(user_id=user_id).first() return admin is not None
class UserTags(db.Model): __tablename__ = "user_tag" id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), ForeignKey('user.id')) tag_id = db.Column(db.Integer(), ForeignKey('tag.id')) tag = relationship("Tag", primaryjoin="and_(UserTags.tag_id==Tag.id)", backref="user_tags") def __init__(self, user_id, tag_id): self.user_id = user_id self.tag_id = tag_id
class Wallet(db.Model, DictSerializable): id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) address = db.Column(db.String(255), unique=True) guid = db.Column(db.String(255), unique=True) def __init__(self, user_id, address, guid): self.user_id = user_id self.address = address self.guid = guid @staticmethod def get_user_wallet(user_id): return Wallet.filter_by(user_id=user_id).first()
class Dates(db.Model): __tablename__ = 'dates' id = db.Column(db.Integer(), primary_key=True) day = db.Column(db.Integer(), nullable=False) year = db.Column(db.Integer(), nullable=False) userId = db.Column(db.Integer(), nullable=False) x1 = db.Column(db.VARCHAR(3000)) x2 = db.Column(db.VARCHAR(3000)) x3 = db.Column(db.VARCHAR(3000)) x4 = db.Column(db.VARCHAR(3000)) x5 = db.Column(db.VARCHAR(3000)) x6 = db.Column(db.VARCHAR(3000)) summary = db.Column(db.VARCHAR(3000)) journal = db.Column(db.VARCHAR(3000)) def __init__(self, userId, day, year, x1, x2, x3, x4, x5, x6, summary, journal): self.day = day self.year = year self.userId = userId self.x1 = x1 self.x2 = x2 self.x3 = x3 self.x4 = x4 self.x5 = x5 self.x6 = x6 self.summary = summary self.journal = journal def serialize(self): return { 'day': self.day, 'year': self.year, 'userId': self.userId, 'x1': self.x1, 'x2': self.x2, 'x3': self.x3, 'x4': self.x4, 'x5': self.x5, 'x6': self.x6, 'summary': self.summary, 'journal': self.journal, } @staticmethod def get_user_journal_on_date(userId, startDate, endDate, year): data = Dates.query.filter(Dates.userId == userId, Dates.year == year, Dates.day >= startDate, Dates.day <= endDate).all() return data
class Node(db.Model): __tablename__ = 'node' id = db.Column(db.Integer(), primary_key=True) url = db.Column(db.String(255), unique=False, nullable=False) level = db.Column(db.Integer(), nullable=False) crawlerId = db.Column(db.Integer(), db.ForeignKey('crawler.id'), nullable=False) __table_args__ = (db.UniqueConstraint('url', 'crawlerId', name='_url_crawlerId_uc'), ) def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Restaurant(db.Model): __tablename__ = 'restaurant' id = db.Column(db.Integer(), primary_key=True) grubhub_id = db.Column(db.String(20), unique=True, index=True) info = db.Column(db.Text(), nullable=False) menu = db.Column(db.Text(), nullable=False) def __init__(self, grubhub_id, info, menu): self.grubhub_id = grubhub_id if isinstance(info, str): self.info = info else: self.info = json.dumps(info) if isinstance(menu, str): self.menu = menu else: self.menu = json.dumps(menu) def info_json(self): info = json.loads(self.info) info['id'] = self.grubhub_id return info def menu_json(self): return json.loads(self.menu)
class ChallengeFollower(db.Model): id = db.Column(db.Integer(), primary_key=True) challenge_instance_id = db.Column(db.Integer(), db.ForeignKey("challenge_instance.id"), nullable=False) challenge_instance = db.relationship('ChallengeInstance') follower_id = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=False) follower = db.relationship('User') date_joined = db.Column(db.DateTime(), nullable=False) def __init__(self, challenge, follower): self.challenge_instance = challenge self.follower = follower self.date_joined = datetime.datetime.now()
class Location(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(255), unique=True) def __init__(self, name): self.active = True self.name = name
class User(db.Model): __tablename__ = 'User' id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255)) def __init__(self, username, email, password): self.username = username self.email = email self.active = True self.password = User.hashed_password(password) @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password).decode("utf-8") @staticmethod def get_user_with_email_and_password(email, password): user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): return user else: return None @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, password): return user else: return None
class Event(db.Model): __tablename__ = "event" id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(255)) description = db.Column(db.Text()) verified = db.Column(db.Boolean) active = db.Column(db.Boolean) def __init__(self, name="", description=""): self.name = name self.description = description self.verified = False self.active = True def as_dict(self): return { 'id': self.id, 'name': self.name, 'description': self.description, 'verified': self.verified, 'active': self.active, } def update(self, values): for key, value in values.iteritems(): self.__setattr__(key, value) try: db.session.add(self) db.session.commit() return self except IntegrityError: return None
class User(db.Model): 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(255)) last_name = db.Column(db.String(255)) def __init__(self, first_name, last_name, email, password): self.first_name = first_name self.last_name = last_name self.email = email self.active = True self.password = User.hashed_password(password) @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password).decode("utf-8") @staticmethod def get_user_by_id(user_id): user = User.query.filter_by(id=user_id).first() return user @staticmethod def get_user_with_email_and_password(email, password): user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): return user else: return None