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]
})
