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
