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 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 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 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 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 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 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 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 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 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 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 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 Import(db.Model): __tablename__ = "import" import_id = db.Column(db.Integer, primary_key=True) citizens = db.relationship( "Citizen", cascade="save-update, merge, delete, delete-orphan") __mapper_args__ = {"polymorphic_identity": "import"}
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 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 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 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 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 Store(db.Model): __tablename__ = 'store' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(90), unique=True) description = db.Column(db.TEXT) img = db.Column(db.TEXT) lat = db.Column(db.Float, default=0.0) lang = db.Column(db.Float, default=0.0) foods = db.relationship('Food', backref='store') addresses = db.relationship('Addresses', backref='store') owner = db.Column(db.Integer, db.ForeignKey('user.id')) time_created = db.Column(db.DateTime, default=datetime.now()) def __serialize__(self): data = { "id": self.id, "name": self.name, "description": self.description, "lat": self.lat, "lang": self.lang } return data
class Order(db.Model): id = db.Column(db.Integer, primary_key=True) owner_id = db.Column(db.Integer) beers = db.relationship('OrderBeer', backref='order') is_open = db.Column(db.Boolean, default=True) time_created = db.Column(db.DateTime, default=datetime.utcnow) time_modified = db.Column(db.DateTime, onupdate=datetime.utcnow) @staticmethod def get_opened_order(owner_id): order = Order.query.filter_by(owner_id=owner_id, is_open=True).first() if order is None: order = Order() order.owner_id = owner_id order.is_open = True db.session.add(order) db.session.commit() return order def checkout(self): if len(self.beers) == 0: return self.is_open = False db.session.add(self) db.session.commit() def add_beer(self, sku, quantity): found = False for beer in self.beers: if beer.sku == sku: beer.quantity += quantity found = True break if not found: beer = OrderBeer() beer.sku = sku beer.quantity = quantity self.beers.append(beer) db.session.add(self) db.session.commit() def remove_beer(self, sku): OrderBeer.query.filter_by(order_id=self.id, sku=sku).delete() db.session.commit()
class WikiPage(db.Model): __tablename__ = 'wiki_page' id = db.Column(db.Integer, primary_key=True) created = db.Column(db.TIMESTAMP, server_default=text('CURRENT_TIMESTAMP')) versions = db.relationship("WikiPageVersion") def __repr__(self): return '<WikiPage %s>' % self.id def get_current(self): return next( iter([ version for version in self.versions if version.status == WikiPageVersion.STATUS_CURRENT ]), None)
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 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)
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 FoodCategory(db.Model): __tablename__ = 'food_category' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), unique=True, nullable=False) foods = db.relationship('Food', lazy='subquery', backref='food_category') time_created = db.Column(db.DateTime, default=datetime.now())
class User(db.Model): _uid = db.Column('uid', db.Integer, primary_key=True) _password = db.Column(db.String(50)) _name = db.Column(db.String(30)) _email = db.Column(db.String(30)) _phone = db.Column(db.String(30)) _photo = db.Column(db.BLOB) _friends = db.relationship('User', secondary='friendship', primaryjoin=_uid == friendship.c.uid_a, secondaryjoin=_uid == friendship.c.uid_b) _rides = db.relationship('Ride', secondary='user_ride') _notifications = db.relationship('Notification') def __init__(self, uid, passwd, name, email): self._uid = uid self._password = passwd self._name = name self._email = email self._photo = '/assets/img/default-profile-pic.png' self._phone = 'N/A' def __eq__(self, other): if type(other) is not User: return False return self._uid == other.get_uid() def __hash__(self): return self._uid def has_friend(self, user): return user in self._friends def add_friend(self, user): self._friends.append(user) def remove_friend(self, user): self._friends.remove(user) def get_relationship(self, other): self_has_other = self.has_friend(other) other_has_self = other.has_friend(self) if self == other: rel = 'self' elif not self_has_other and not other_has_self: rel = 'none' elif self_has_other and not other_has_self: rel = 'available' elif not self_has_other and other_has_self: rel = 'pending' else: rel = 'friend' return rel def add_notification(self, notification): self._notifications.append(notification) def remove_notification(self, notification): self._notifications.remove(notification) def add_ride(self, ride): self._rides.append(ride) def remove_ride(self, ride): self._rides.remove(ride) def update_rides(self): for r in self._rides: if not r.update(): db.session.delete(r) db.session.commit() def set_name(self, name): self._name = name def set_email(self, email): self._email = email def set_phone(self, phone): self._phone = phone def set_photo(self, photo): self._photo = photo def set_password(self, password): self._password = password def get_uid(self): return self._uid def get_name(self): return self._name def get_email(self): return self._email def get_password(self): return self._password def get_notifications(self): return self._notifications def get_view(self, other): rel = self.get_relationship(other) if rel not in ['self', 'friend']: result = self.get_public_view() else: result = self.get_private_view() result['relationship'] = rel return result def get_public_view(self): return {'name': self._name, 'uid': self._uid, 'photo': self._photo} def get_private_view(self): self.update_rides() view = self.get_public_view() return dict( view, **{ 'email': self._email, 'phone': self._phone, 'rides': [r.get_view() for r in self._rides] })