class JobHistory(db.Model):
__tablename__ = 'job_history'
id = db.Column(db.Integer, primary_key=True)
job_id = db.Column(db.Integer, db.ForeignKey('job.id'))
user_detail_id = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
name = db.Column(db.String(255))
time_created = db.Column(db.DateTime, default=datetime.now())
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
content = db.Column(db.TEXT)
status = db.Column(db.SmallInteger)
class RideAccepted(Notification):
_nid = db.Column('nid', db.Integer, db.ForeignKey('notification.nid'), primary_key=True)
_user = db.relationship('User')
_user_id = db.Column(db.ForeignKey('user.uid'))
_ride = db.relationship('Ride')
_ride_id = db.Column(db.ForeignKey('ride.rid'))
__tablename__ = 'notification$ride_accepted'
__mapper_args__ = {
'polymorphic_identity': 'ride_accepted'
}
def __init__(self, ride, user):
Notification.__init__(self)
self._ride = ride
self._user = user
def get_type(self):
return 'RIDE_ACCEPTED'
def get_data(self):
return {
'user': self._user.get_public_view(),
'ride': self._ride.get_view()
}
class FoodHistory(db.Model):
__tablename__ = 'food_history'
id = db.Column(db.Integer, primary_key=True)
food_id = db.Column(db.Integer, db.ForeignKey('food.id'))
user_detail_id = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
action_name = db.Column(db.String(255))
time_created = db.Column(db.DateTime, default=datetime.now())
class FoodFeedBack(db.Model):
__tablename__: str = 'food_feed_back'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
food_id = db.Column(db.Integer, db.ForeignKey('food.id'), nullable=False)
comment = db.Column(db.Text)
ratting = db.Column(db.SmallInteger)
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class UserRole(db.Model):
__tablename__ = 'user_roles'
user_id = db.Column(db.String(36),
db.ForeignKey('users.id', ondelete='CASCADE'),
primary_key=True)
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'),
primary_key=True)
class Anunciante(db.Model):
guid_anunciante = db.Column(db.String(36), primary_key=True)
id_cidade = db.Column(db.Integer,
db.ForeignKey('cidade.id_cidade'),
nullable=False)
id_categoria = db.Column(db.Integer,
db.ForeignKey('categoria.id_categoria'),
nullable=False)
razao_social = db.Column(db.Text, nullable=False)
nome_fantasia = db.Column(db.Text, nullable=False)
telefone = db.Column(db.Text)
celular = db.Column(db.Text)
logradouro = db.Column(db.Text)
numero = db.Column(db.Text)
bairro = db.Column(db.Text)
data_cadastro = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
email = db.Column(db.Text)
senha = db.Column(db.Text)
picture_file = db.Column(db.Text)
def __init__(self,
guid_anunciante=None,
nome_fantasia=None,
categoria=None):
self.guid_anunciante = guid_anunciante or self.cria_novo_uuid()
self.nome_fantasia = nome_fantasia or ''
self.razao_social = nome_fantasia or ''
self.data_cadastro = datetime.datetime.now()
if categoria:
self.id_categoria = categoria.id_categoria
self.id_cidade = categoria.id_cidade
def cria_novo_uuid(self):
return str(uuid.uuid1())
def __repr__(self):
return '<Advertiser: %s>' % (self.nome_fantasia)
@property
def serialize(self):
return {
'guid_anunciante': self.guid_anunciante,
'id_cidade': self.id_cidade,
'id_categoria': self.id_categoria,
'razao_social': self.razao_social,
'nome_fantasia': self.nome_fantasia,
'telefone': self.telefone,
'celular': self.celular,
'logradouro': self.logradouro,
'numero': self.numero,
'bairro': self.bairro,
'data_cadastro': self.data_cadastro,
'email': self.email,
'picture_file': self.picture_file
}
class Order(db.Model):
__tablename__: str = 'order'
id = db.Column(db.Integer, primary_key=True)
payment_method_id = db.Column(db.Integer,
db.ForeignKey('payment_method.id'))
total = db.Column(db.Float, default=0.0)
paid = db.Column(db.Boolean, default=False)
state = db.Column(db.String(30), default="In Progress")
notes = db.Column(db.Text)
user_detail_id = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
driver_id = db.Column(db.Integer, db.ForeignKey('driver.id'))
order_time = db.Column(db.DateTime, default=datetime.now())
cart = db.relationship('Cart', uselist=False, backref='order')
order_loc = db.relationship('OrderLocationTracked',
uselist=False,
backref='order_loc')
deliver_to = db.relationship('OrderLocationTracked',
uselist=False,
backref='deliver_to')
created_timestamp = db.Column(db.DateTime, default=datetime.now())
def get(self, detail=False):
carts = []
if detail:
for cart in self.cart.cart_items:
carts.append({
"item": cart.food.__serialize__(with_img=True),
"count": cart.qty,
"note": cart.note
})
else:
for cart in self.cart.cart_items:
carts.append({
"item": cart.food.name,
"count": cart.qty,
"note": cart.note
})
data = {
"id": self.id,
"orders": carts,
"payment": self.payment_method_id,
"total": self.total,
"paid": self.paid,
"state": self.state,
"driver": "belum ada driver"
}
if self.driver:
drv = {
"id": self.driver,
"name": self.driver.user_detail.fullname,
"image": self.driver.user_detail.image,
"phone": self.driver.user_detail.phone_number,
"rating": self.driver.ratting
}
data.update({"driver": drv})
return data
class CartItem(db.Model):
__tablename__: str = 'cart_item'
id = db.Column(db.Integer, primary_key=True)
note = db.Column(db.TEXT)
qty = db.Column(db.BigInteger)
cart_id = db.Column(db.Integer, db.ForeignKey('cart.id'))
food_id = db.Column(db.Integer, db.ForeignKey('food.id'))
packages = db.relationship('Package', backref='cart', lazy=True)
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), unique=True)
page_type = db.Column(db.Integer, db.ForeignKey('page_type.id'))
writer = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
content = db.Column(db.TEXT)
status = db.Column(db.SmallInteger)
categories = db.relationship(Category, secondary=category_tag, backref='post')
comments = db.relationship(Comment, backref='post', lazy=True)
class Publicacao(db.Model):
guid_publicacao = db.Column(db.String(36), primary_key=True)
guid_anunciante = db.Column(db.String(36), db.ForeignKey('anunciante.guid_anunciante'), nullable=False)
id_categoria = db.Column(db.Integer, db.ForeignKey('categoria.id_categoria'), nullable=False)
titulo = db.Column(db.Text, nullable=False)
descricao = db.Column(db.Text, nullable=False)
data_publicacao = db.Column(db.DateTime, nullable=False, default=db.func.current_timestamp())
data_validade = db.Column(db.DateTime, nullable=False)
publicado = db.Column(db.Boolean, unique=False, default=False)
anunciante = db.relationship('Anunciante')
imagens = db.relationship('ImagemPublicacao', cascade='delete')
def add_image(self, image_filename):
image = ImagemPublicacao()
image.guid_publicacao = self.guid_publicacao
image.caminho = image_filename
db.session.add(image)
def __init__(self):
self.guid_publicacao = str(uuid.uuid1())
def __repr__(self):
return '<Publicacao: %s>' % (self.titulo)
@property
def serialize(self):
return {
'guid_publicacao': self.guid_publicacao,
'guid_anunciante': self.guid_anunciante,
'id_categoria': self.id_categoria,
'titulo': self.titulo,
'descricao': self.descricao,
'data_publicacao': self.data_publicacao.strftime('%Y-%m-%d %H:%M:%S'),
'data_validade': self.data_validade.strftime('%Y-%m-%d %H:%M:%S'),
'publicado': self.publicado,
'anunciante': {
'guid_anunciante': self.guid_anunciante,
'razao_social': self.anunciante.razao_social,
'nome_fantasia': self.anunciante.nome_fantasia,
'logradouro': self.anunciante.logradouro,
'numero': self.anunciante.numero,
'telefone': self.anunciante.telefone,
'celular': self.anunciante.celular,
'email': self.anunciante.email,
'id_categoria': self.anunciante.id_categoria
},
'imagens': [imagem.caminho for imagem in self.imagens]
}
class Addresses(db.Model):
__tablename__: str = 'addresses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
latitude = db.Column(db.Float, default=0.0)
longitude = db.Column(db.Float, default=0.0)
address = db.Column(db.Text)
note = db.Column(db.Text)
accuracy = db.Column(db.Float, default=0.0)
user_id = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
store_id = db.Column(db.Integer, db.ForeignKey('store.id'))
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class WikiPageVersion(db.Model):
__tablename__ = 'wiki_page_version'
(
STATUS_NOT_CURRENT,
STATUS_CURRENT,
) = range(2)
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text)
status = db.Column(db.Integer, default=STATUS_CURRENT, index=True)
wiki_page_id = db.Column(db.Integer,
db.ForeignKey('wiki_page.id'),
index=True)
def __repr__(self):
return '<WikiPageVersion %s>' % self.id
@classmethod
def condition_status_current(cls):
return cls.status == WikiPage.STATUS_CURRENT
@classmethod
def condition_status_not_current(cls):
return cls.status == WikiPage.STATUS_NOT_CURRENT
class UserDetail(db.Model):
__tablename__ = 'user_detail'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
desc = db.Column(db.TEXT)
photo = db.Column(db.TEXT)
linkedin = db.Column(db.TEXT)
class OrderBeer(db.Model):
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'), nullable=False)
sku = db.Column(db.String(255), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
time_created = db.Column(db.DateTime, default=datetime.utcnow)
time_modified = db.Column(db.DateTime, onupdate=datetime.utcnow)
class Cart(db.Model):
# relationship with order
__tablename__: str = 'cart'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
cart_items = db.relationship('CartItem', backref='cart', lazy=True)
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class SocialMedia(db.Model):
__tablename__ = 'social_media'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.TEXT)
image = db.Column(db.TEXT)
provider = db.Column(db.String(90))
link = db.Column(db.TEXT)
user_id = db.Column(db.Integer, db.ForeignKey('user_detail.id'))
created_time = db.Column(db.DateTime, default=datetime.now())
class Certificate(db.Model):
id = db.Column(db.Integer, primary_key=True)
__tablename__: str = 'certificate'
issuer_id = db.Column(db.Integer,
db.ForeignKey('certificate_giver.id'),
nullable=False)
date = db.Column(db.DateTime, default=datetime.now())
number = db.Column(db.Integer, nullable=False)
foods = db.relationship('Food', backref='certificate', lazy=True)
class UserDetail(db.Model):
__tablename__ = 'user_detail'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
driver_id = db.Column(db.Integer, db.ForeignKey('driver.id'))
fullname = db.Column(db.String(90))
phone_number = db.Column(db.BigInteger, unique=True)
# work_start_time = db.Column(db.DateTime, default=datetime.now())
activate = db.Column(db.Boolean, default=True)
ratting = db.Column(db.BigInteger)
image = db.Column(db.Text)
created_time = db.Column(db.DateTime, default=datetime.now())
orders = db.relationship('Order', backref='user_detail')
addresses = db.relationship('Addresses', backref='user', lazy=True)
social_medias = db.relationship('SocialMedia', backref='user', lazy=True)
# job_history = db.relationship('FoodHistory', backref='user_detail')
def __serialize__(self, id=None):
if not id:
return {
"id": self.id,
"user_id": self.user_id,
"fullname": self.fullname,
"address": self.address,
"phone_number": self.phone_number,
"work_start_time": self.work_start_time,
"activate": self.activate,
"created_time": self.created_time
}
user = UserDetail.query.get(id)
if not user:
return None
return {
"id": user.id,
"user_id": user.user_id,
"fullname": user.fullname,
# "address": user.address,
"phone_number": user.phone_number,
"work_start_time": user.work_start_time,
"activate": user.activate,
"created_time": user.created_time
}
class Citizen(db.Model):
__tablename__ = "citizen"
# Keys
citizen_id = db.Column(db.Integer, primary_key=True)
import_id = db.Column(db.Integer,
db.ForeignKey('import.import_id'),
primary_key=True)
# Demographics
town = db.Column(db.String(256))
street = db.Column(db.String(256))
building = db.Column(db.String(256))
apartment = db.Column(db.Integer)
name = db.Column(db.String(256))
birth_date = db.Column(db.DateTime)
gender = db.Column(db.String(6))
as_left_edges = db.relationship(
"Relative",
cascade="save-update, merge, delete, delete-orphan",
backref='left_citizen',
primaryjoin=(Relative.left_id == citizen_id) &
(Relative.import_id == import_id))
as_right_edges = db.relationship(
"Relative",
cascade="save-update, merge, delete, delete-orphan",
backref='right_citizen',
primaryjoin=(Relative.right_id == citizen_id) &
(Relative.import_id == import_id))
__mapper_args__ = {"polymorphic_identity": "citizen"}
# left_id = db.Column(db.Integer, db.ForeignKey('citizen.citizen_id', name="a"), primary_key=True)
# left_import_id = db.Column(db.Integer, db.ForeignKey('citizen.import_id', name="a"), primary_key=True)
# right_id = db.Column(db.Integer, db.ForeignKey('citizen.citizen_id', name="b"), primary_key=True)
# right_import_id = db.Column(db.Integer, db.ForeignKey('citizen.import_id', name="b"), primary_key=True)
#right_import_id = db.Column(db.Integer, primary_key=True)
#left_citizen = db.relationship(Citizen,
# primaryjoin=(left_id==Citizen.citizen_id) & (import_id == Citizen.import_id),
# back_populates='as_left_edges')
#right_citizen = db.relationship(Citizen,
# primaryjoin=(right_id==Citizen.citizen_id) & (import_id == Citizen.import_id),
# back_populates='as_right_edges')
# def __init__(self, c1, c2):
# if (c1.citizen_id < c2.citizen_id):
# self.left_citizen = n1
# self.right_citizen = n2
# else:
# self.left_citizen = n2
# self.right_citizen = n1
class OrderLocationTracked(db.Model):
__tablename__: str = 'order_location_tracked'
id = db.Column(db.Integer, primary_key=True)
latitude = db.Column(db.Float, default=0.0)
longitude = db.Column(db.Float, default=0.0)
accuracy = db.Column(db.Float, default=0.0)
is_pinned = db.Column(db.Boolean, default=False)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class Notification(db.Model):
_nid = db.Column('nid', db.Integer, primary_key=True)
_owner = db.Column(db.ForeignKey('user.uid'))
_date = db.Column(db.DateTime)
_seen = db.Column(db.Boolean)
_type = db.Column(db.String(30))
__tablename__ = 'notification'
__mapper_args__ = {
'polymorphic_on': _type,
'polymorphic_identity': 'base'
}
def __init__(self):
self._date = datetime.now()
self._seen = False
def __eq__(self, other):
if not isinstance(other, Notification): return False
return abs(self.get_date() - other.get_date()) < timedelta(seconds=10)
def __hash__(self):
return self._nid
def get_nid(self):
return self._nid
def get_date(self):
return self._date
def get_seen(self):
return self._seen
def set_seen(self):
self._seen = True
def get_timestamp(self):
return mktime(self._date.timetuple())
def get_view(self):
return {
'nid': self.get_nid(),
'data': self.get_data(),
'type': self.get_type(),
'seen': self.get_seen(),
'timestamp': int(self.get_timestamp() * 1000)
}
class RideRequest(Notification):
_nid = db.Column('nid',
db.Integer,
db.ForeignKey('notification.nid'),
primary_key=True)
_user = db.relationship('User')
_user_id = db.Column(db.ForeignKey('user.uid'))
_ride = db.relationship('Ride')
_ride_id = db.Column(db.ForeignKey('ride.rid'))
_district = db.Column('district', db.String(30))
_complement = db.Column('complement', db.String(30))
__tablename__ = 'notification$ride_request'
__mapper_args__ = {'polymorphic_identity': 'ride_request'}
def __init__(self, ride, user, district, complement):
Notification.__init__(self)
self._ride = ride
self._user = user
self._district = district
self._complement = complement
def get_type(self):
return 'RIDE_REQUEST'
def get_data(self):
return {
'ride': self._ride.get_view(),
'user': self._user.get_public_view(),
'district': self._district,
'complement': self._complement
}
class FriendAccepted(Notification):
_nid = db.Column('nid',
db.Integer,
db.ForeignKey('notification.nid'),
primary_key=True)
_user = db.relationship('User')
_user_id = db.Column(db.ForeignKey('user.uid'))
__tablename__ = 'notification$friend_accepted'
__mapper_args__ = {'polymorphic_identity': 'friend_accepted'}
def __init__(self, user):
Notification.__init__(self)
self._user = user
def get_type(self):
return 'NEW_FRIEND'
def get_data(self):
return {'user': self._user.get_public_view()}
class RideFound(Notification):
_nid = db.Column('nid',
db.Integer,
db.ForeignKey('notification.nid'),
primary_key=True)
_ride = db.relationship('Ride')
_ride_id = db.Column(db.ForeignKey('ride.rid'))
__tablename__ = 'notification$ride_found'
__mapper_args__ = {'polymorphic_identity': 'ride_found'}
def __init__(self, ride):
Notification.__init__(self)
self._ride = ride
def get_type(self):
return 'RIDE_FOUND'
def get_data(self):
return {'ride': self._ride.get_view()}
class Passenger(db.Model):
_pid = db.Column('pid', db.Integer, primary_key=True)
_ride = db.Column(db.ForeignKey('ride.rid'))
_user = db.relationship('User')
_user_id = db.Column(db.ForeignKey('user.uid'))
_district = db.Column(db.String(30))
_complement = db.Column(db.String(30))
def __init__(self, user, district, complement):
self._user = user
self._district = district
self._complement = complement
def get_user(self):
return self._user
def get_district(self):
return self._district
def get_complement(self):
return self._complement
class ImagemPublicacao(db.Model):
__tablename__ = 'publicacao_imagem'
guid_imagem = db.Column(db.String(36), primary_key=True)
guid_publicacao = db.Column(db.String(36), db.ForeignKey('publicacao.guid_publicacao', ondelete='CASCADE'), nullable=False)
caminho = db.Column(db.String(64))
def __init__(self):
self.guid_imagem = str(uuid.uuid1())
def __repr__(self):
return '<ImagemPublicacao: %s>' % (self.caminho)
class Driver(db.Model):
__tablename__: str = 'driver'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
unique=True)
ratting = db.Column(db.Integer, default=0)
id_card_img = db.Column(db.Text)
no_id_card = db.Column(db.Text)
user_detail = db.relationship('UserDetail',
uselist=False,
backref='driver')
orders = db.relationship('Order', lazy='subquery', backref='driver')
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class Job(db.Model):
__tablename__ = 'job'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
description = db.Column(db.TEXT)
start_time = db.Column(db.Date, default=datetime.now())
deadline = db.Column(db.Date)
done = db.Column(db.Boolean, default=False)
accepted = db.Column(db.Boolean, default=False)
nilai_material = db.Column(db.String(255))
nilai_jasa = db.Column(db.String(255))
job_location = db.Column(db.String(255))
no_spk = db.Column(db.String(255), unique=True)
given_by = db.Column(db.String(255))
category_id = db.Column(db.Integer, db.ForeignKey("job_category.id"))
sub_job = db.relationship(SubJob, backref='job')
history = db.relationship(JobHistory, backref='job')
users = db.relationship('User', secondary=user_jobs, lazy='subquery', backref='job')
time_created = db.Column(db.DateTime, default=datetime.now())
def __serialize__(self):
data = {
"id": self.id,
"name": self.name,
"description": self.description,
"start_time": self.start_time,
"deadline": self.deadline,
"done": self.done,
"given_by": self.given_by,
"job_location": self.job_location,
"no_spk": self.no_spk,
"accepted": self.accepted,
"nilai": {
"material": self.nilai_material,
"jasa": self.nilai_jasa
},
"category": {
"id": self.job_category.id,
"name": self.job_category.name
}
}
return data
class Categoria(db.Model):
id_categoria = db.Column(db.Integer, primary_key=True)
id_cidade = db.Column(db.Integer,
db.ForeignKey('cidade.id_cidade',
ondelete='CASCADE'),
nullable=False)
descricao = db.Column(db.Text, nullable=False)
imagem = db.Column(db.Text)
anunciantes = db.relationship('Anunciante', backref='categoria')
def __init__(self, descricao=None, cidade=None, imagem=None):
self.descricao = descricao
self.cidade = cidade
self.imagem = imagem
def __repr__(self):
return '<Categoria {0}: {1}>'.format(self.id_categoria,
self.descricao.encode('utf8'))
def __unicode__(self):
return u'Categoria {0}: {1}'.format(self.id_categoria, self.descricao)
