class Currency(db.Model):
__tablename__: str = 'currency'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
denote = db.Column(db.String(100), unique=True, nullable=False)
foods = db.relationship('Food', backref='currency', lazy=True)
created_timestamp = db.Column(db.DateTime, default=datetime.now())
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.String(36), primary_key=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(255), nullable=False, unique=True)
roles = db.relationship('Role',
secondary='user_roles',
lazy='subquery',
backref=db.backref('users', lazy=True))
class Beer(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
sku = db.Column(db.String(255), unique=True, nullable=False)
price = db.Column(db.DECIMAL(precision=8, scale=2), nullable=False)
image = db.Column(db.String(255), unique=False, nullable=True)
time_created = db.Column(db.DateTime, default=datetime.utcnow)
time_modified = db.Column(db.DateTime, onupdate=datetime.utcnow)
def __repr__(self):
return '<Beer %r>' % (self.username, )
@staticmethod
def create(name, sku, price, image):
if isinstance(image, str):
image = image.strip()
if not image:
image = None
beer = Beer()
beer.name = name
beer.sku = sku
beer.price = price
beer.image = image
db.session.add(beer)
db.session.commit()
return beer
def modify(self, name, price, image):
if isinstance(image, str):
image = image.strip()
if not image:
image = None
self.name = name
self.price = price
self.image = image
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def seed(db):
Beer.create(
'Бургаско', 123456, 1.19,
'https://cdncloudcart.com/15635/products/images/206/bira-burgasko-svetlo-500-ml-ken-image_5e24491fc2a15_800x800.jpeg?1579436338'
)
Beer.create(
'Загорка', 123457, 2.00,
'https://shami.bg/uploads/2019/06/38b3674a0aaee5a32c1193d8cab7104b.png'
)
Beer.create(
'Tuborg', 123458, 1.50,
'https://cdn.nokovandson.com/crop/276/490/480//I0/I0pLF5nGwJ.png')
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 User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(90), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
level = db.Column(db.SMALLINT, nullable=False, default=0)
user_detail = db.relationship(UserDetail, uselist=False, backref='user')
posts = db.relationship(Post, uselist=False, backref='user')
class User(db.Model, UserMixin):
from datetime import datetime
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime(), default=datetime.now())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
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 User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
# category_access_id = db.Column(db.Integer, db.ForeignKey("category_access.id"))
username = db.Column(db.String(90), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255), nullable=False)
user_detail = db.relationship('UserDetail', uselist=False, backref='user')
food_feed_backs = db.relationship('FoodFeedBack',
backref='user',
lazy=True)
created_time = db.Column(db.DateTime, default=datetime.now())
def __serialize__(self, detail=False):
if detail:
social_medias = []
for social_media in self.user_detail.social_medias:
social_medias.append({
"provider": social_media.provider,
"uid": social_media.uid,
"image": social_media.image
})
addresses = []
for address in self.user_detail.addresses:
addresses.append({
"name": address.name,
"latitude": address.latitude,
"longitude": address.longitude,
"address": address.address,
"note": address.note
})
data = {
"id": self.id,
"username": self.username,
"fullname": self.user_detail.fullname,
"email": self.email,
"phone": self.user_detail.phone_number,
"rating": self.user_detail.ratting,
"image": self.user_detail.image,
"social": social_medias,
"addresses": addresses
}
else:
data = {
"id": self.id,
"username": self.username,
"email": self.email,
"driver_id": self.user_detail.driver_id
}
return data
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 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 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 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 Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
name = db.Column(db.String(64), nullable=False, unique=True)
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 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 CertificateGiver(db.Model):
__tablename__: str = 'certificate_giver'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
certificates = db.relationship('Certificate',
uselist=False,
backref='certificate_giver',
lazy=True)
time_created = 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 Cidade(db.Model):
id_cidade = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(64), nullable=False)
uf = db.Column(db.String(2), nullable=False)
categorias = db.relationship(Categoria, backref='cidade', cascade='delete')
def __init__(self, nome=None, uf=None):
self.nome = nome
self.uf = uf
def __repr__(self):
return '%s - %s' % (self.nome, self.uf)
@property
def serialize(self):
return {'id_cidade': self.id_cidade, 'nome': self.nome, 'uf': self.uf}
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 CategoryAccess(db.Model):
__tablename__ = 'category_access'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
root_access = db.Column(db.Boolean, default=False)
add_user = db.Column(db.Boolean, default=False)
delete_user = db.Column(db.Boolean, default=False)
edit_user = db.Column(db.Boolean, default=False)
add_job = db.Column(db.Boolean, default=True)
delete_job = db.Column(db.Boolean, default=False)
update_job = db.Column(db.Boolean, default=False)
show_job = db.Column(db.Boolean, default=True)
show_user = db.Column(db.Boolean, default=True)
print_job = db.Column(db.Boolean, default=True)
check_job = db.Column(db.Boolean, default=True)
service_job = db.Column(db.Boolean, default=True)
accept_job = db.Column(db.Boolean, default=False)
users = db.relationship(User, backref='category_access', lazy=True)
def __serialize__(self, id=None):
data = {
"id": self.id,
"name": self.name,
"root_access": self.root_access,
"add_user": self.add_user,
"delete_user": self.delete_user,
"edit_user": self.edit_user,
"add_job": self.add_job,
"delete_job": self.delete_job,
"update_job": self.update_job,
"show_job": self.show_job,
"print_job": self.print_job,
"check_job": self.check_job,
"service_job": self.service_job
}
if id:
ca = CategoryAccess.query.filter_by(id=id).first()
if not ca:
return None
data = {
"id": ca.id,
"name": ca.name,
"root_access": ca.root_access,
"add_user": ca.add_user,
"delete_user": ca.delete_user,
"edit_user": ca.edit_user,
"add_job": ca.add_job,
"delete_job": ca.delete_job,
"update_job": ca.update_job,
"show_job": ca.show_job,
"print_job": ca.print_job,
"check_job": ca.check_job,
"service_job": ca.service_job
}
return data
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 Device(db.Model):
device_id = db.Column(db.String(36), primary_key=True)
last_query = db.Column(db.DateTime, nullable=False, default=db.func.current_timestamp())
def __init__(self, device_id=''):
if device_id:
self.device_id = device_id
# set date to the year beginning for new devices
self.last_query = datetime(2017, 1, 1)
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 User(PkModel):
"""A user for the website"""
__tablename__ = "users"
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(254), unique=True, nullable=False)
# password is stored as a hashed value
password = Column(db.LargeBinary(128), nullable=False)
first_name = Column(db.String(), nullable=True)
last_name = Column(db.String(), nullable=True)
active = Column(db.Boolean(), default=False)
def __init__(self, username, email, password, **kwargs):
"""Constructor"""
super().__init__(username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password"""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password"""
return bcrypt.check_password_hash(self.password, value)
@classmethod
def get_by_username(cls, search):
return cls.query.filter_by(username=search).first()
@property
def full_name(self):
"""Full user name"""
return f"{self.first_name} {self.last_name}"
def __repr__(self):
"""Represents instance as a unique string."""
return f"<User({self.username})>"
class User(db.Model, BaseModel):
__tablename__ = "users"
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(100), unique=True, index=True, nullable=False)
_password = db.Column(db.String(128), nullable=False)
def __init__(self, name, email, password, **kwargs):
super(User, self).__init__(**kwargs)
""" Create a new User """
self.name = name
self.email = email
self._password = bcrypt.hashpw(password.encode(),
bcrypt.gensalt()).decode()
def __repr__(self):
return "User::{}".format(self.id)
def check_password(self, password: str):
return bcrypt.checkpw(password=password.encode(),
hashed_password=self._password.encode())
class Role(PkModel):
"""A specific user role with various permissions"""
__tablename__ = "roles"
name = Column(db.String(100), unique=True, nullable=False)
def __init__(self, name, **kwargs):
"""Constructor"""
super().__init__(name=name, **kwargs)
def __repr__(self):
"""Represents instance as a unique string."""
return f"<Role({self.name})>"
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 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 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
