class ProductType(SurrogatePK, Model):
__tablename__ = 'product_types'
name = Column(db.String(80), nullable=False)
product_category_id = reference_col('product_categories', nullable=False)
product_category = relationship('ProductCategory', backref='product_types')
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name, product_category_id):
self.name = name
self.product_category_id = product_category_id
def __repr__(self):
return '<Product Type Name %r>' % self.name
def serialize(self):
return {
"id": self.id,
"name": self.name,
"product_type": [pt.serialize() for pt in self.get_sub_types()]
}
def get_sub_types(self):
return ProductSubType.query.filter_by(product_type_id=self.id)
class ProductRatings(SurrogatePK, Model):
__tablename__ = 'product_ratings'
product_id = reference_col('products', nullable=False)
product = relationship('Product', backref='product_ratings')
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='product_ratings')
rating = Column(db.Integer, nullable=False)
review = Column(db.String(80), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, product_id, user_id, rating, review):
self.product_id = product_id
self.user_id = user_id
self.rating = rating
self.review = review
def serialize(self):
return {
"id": self.id,
"product": self.product_id,
"user": self.user_id,
"rating": self.rating,
"review": self.review
}
class Payment(SurrogatePK, Model):
__tablename__ = 'payments'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='payments')
order_id = reference_col('orders', nullable=False)
order = relationship('Order', backref='payments')
payment_method = Column(db.Enum('Cheque',
'Cash',
'M-pesa',
'Debit Card',
'Credit Card',
name='payment_method'),
nullable=False,
default='Cash')
amount = Column(db.Numeric(9, 6), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, order_id, payment_method, amount):
self.user_id = user_id
self.order_id = order_id
self.payment_method = payment_method
self.amount = amount
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"order": self.order_id,
"payment_method": self.payment_method,
"amount": self.amount,
"date": self.created_at
}
class Cart(SurrogatePK, Model):
__tablename__ = 'cart'
product_id = reference_col('products', nullable=False)
product = relationship('Product', backref='cart')
user = Column(db.Integer, nullable=False)
quantity = Column(db.Integer, nullable=False)
total = Column(db.Numeric(15, 2), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user, product_id, quantity, total):
self.user = user
self.product_id = product_id
self.quantity = quantity
self.total = total
def __repr__(self):
return '<Cart %r>' % self.user + self.product_id + self.quantity + self.total
def serialize(self):
return {
"id": self.id,
"user": self.user,
"product": self.product.serialize(),
"quantity": self.quantity,
"total": float(self.total),
}
class Earning(SurrogatePK, Model):
__tablename__ = 'earnings'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='earnings')
order_id = reference_col('orders', nullable=False)
order = relationship('Order', backref='earnings')
total = Column(db.Numeric(9, 6), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, order_id, total):
self.user_id = user_id
self.order_id = order_id
self.total = total
# def get_order(self):
# order = Order.query.filter_by(id=self.order_id).first()
# return order
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"order": self.order_id,
"status": self.status,
"date": self.created_at
}
class VehicleType(SurrogatePK, Model):
__tablename__ = 'vehicle_Type'
name = Column(db.String(30), nullable=False)
make = Column(db.String(30), nullable=False)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
def __init__(self, name, make):
self.name = name
self.make = make
def __repr__(self):
return '<Vehicle Type %r>' % self.name + self.make
class County(SurrogatePK, Model):
__tablename__ = 'counties'
name = Column(db.String(80), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name):
self.name = name
def __repr__(self):
return '<County %r>' % self.name
def serialize(self):
return {"id": self.id, "name": self.name}
class TransporterCurrentLocation(SurrogatePK, Model):
__tablename__ = 'transporter_current_location'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='transporter_current_location')
latitude = Column(db.String(80), nullable=True)
longitude = Column(db.String(80), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, latitude, longitude):
self.user_id = user_id
self.latitude = latitude
self.longitude = longitude
def __repr__(self):
return '<Driver %r>' % self.user_id + self.latitude + self.longitude
class Branch(SurrogatePK, Model):
__tablename__ = 'branches'
name = Column(db.String(80), nullable=False)
farmer_id = reference_col('farmers', nullable=True)
farmer = relationship('Farmer', backref='branches')
location = Column(db.String(300), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name, location, farmer):
self.name = name
self.location = location
self.farmer = farmer
def __repr__(self):
return '<Branch %r>' % self.name + self.location + self.farmer
class Document(SurrogatePK, Model):
"""an uploaded document."""
__tablename__ = 'documents'
name = Column(db.String(80), nullable=False)
filename = Column(db.String(256), nullable=False)
user_id = reference_col('users', nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
user = relationship('User', backref='documents')
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
"""Represent instance as a unique string."""
return '<Document({name})>'.format(name=self.name)
class Vehicle(SurrogatePK, Model):
__tablename__ = 'vehicles'
number = Column(db.String(30), unique=True)
type_id = reference_col('vehicle_Type', nullable=False)
type = relationship('VehicleType', backref='vehicles')
colour = Column(db.String(30), unique=True)
expiry_date = Column(db.DateTime, nullable=False)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
def __init__(self, number, type, colour, user, expiry_date):
self.number = number
self.type = type
self.colour = colour
self.user = user
self.expiry_date = expiry_date
def __repr__(self):
return '<Vehicle %r>' % self.licence + self.user + self.vehicle + self.expiry_date
class Transporter(SurrogatePK, Model):
__tablename__ = 'transporters'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='transporters')
vehicle_type = Column(db.String(80), nullable=False)
vehicle_reg_no = Column(db.String(80), nullable=False)
vehicle_color = Column(db.String(80), unique=True, nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, vehicle_type, vehicle_reg_no, vehicle_color):
self.user_id = user_id
self.vehicle_type = vehicle_type
self.vehicle_reg_no = vehicle_reg_no
self.vehicle_color = vehicle_color
def __repr__(self):
return '<Transporter %r>' % self.user + self.vehicle + self.licence + self.location
class Variable(SurrogatePK, Model):
__tablename__ = 'variables'
cost_per_km_normal_time = Column(db.Numeric(15, 2), nullable=False)
cost_per_km_peak_time = Column(db.Numeric(15, 2), nullable=False)
cost_per_km_scheduled = Column(db.Numeric(15, 2), nullable=False)
cost_waiting_time = Column(db.Numeric(15, 2), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, cost_per_km_normal_time, cost_per_km_peak_time,
cost_per_km_scheduled, cost_waiting_time):
self.cost_per_km_normal_time = cost_per_km_normal_time
self.cost_per_km_peak_time = cost_per_km_peak_time
self.cost_per_km_scheduled = cost_per_km_scheduled
self.cost_waiting_time = cost_waiting_time
def __repr__(self):
return '<Variable %r>' % self.cost_per_km_normal_time + self.cost_per_km_peak_time + self.cost_per_km_scheduled + self.cost_waiting_time
class Purchase(SurrogatePK, Model):
__tablename__ = 'purchases'
product_id = reference_col('products', nullable=False)
product = relationship('Product', backref='purchases')
user = Column(db.Integer, nullable=False)
quantity = Column(db.Integer, nullable=False)
total = Column(db.Numeric(15, 2), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user, product_id, quantity, total):
self.user = user
self.product_id = product_id
self.quantity = quantity
self.total = total
def serialize(self):
return {
"id": self.id,
"user": self.get_user().first_name,
"product_name": self.get_product().name,
"product_price": float(self.get_product().price),
"product": self.product.serialize(),
"seller": self.get_seller(),
"quantity": self.quantity,
"total": float(self.total),
"Date": self.created_at,
}
def get_user(self):
from soko.user.models import User
return User.query.get(self.user)
def get_product(self):
return Product.query.get(self.product_id)
def get_seller(self):
from soko.user.models import User
product = Product.query.get(self.product_id)
user = User.query.get(product.user_id)
return user.first_name
class Trip(SurrogatePK, Model):
__tablename__ = 'trips'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='trips')
order_id = reference_col('orders', nullable=False)
order = relationship('Order', backref='trips')
status = Column(db.Enum('Accepted',
'Rejected',
'Canceled',
'Started',
'Finished',
'Pending',
name='trip_status'),
nullable=False,
default='Pending')
lat = Column(db.Numeric(9, 6), nullable=False)
lng = Column(db.Numeric(9, 6), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, order_id, status, lat, lng):
self.user_id = user_id
self.order_id = order_id
self.status = status
self.lat = lat
self.lng = lng
# def get_order(self):
# order = Order.query.filter_by(id=self.order_id).first()
# return order
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"order": self.order_id,
"status": self.status,
"latitude": self.lat,
"longitude": self.lng,
"date": self.created_at
}
class Farmer(SurrogatePK, Model):
__tablename__ = 'farmers'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='farmers')
id_number = Column(db.Integer, nullable=True)
photo = Column(db.String(80), nullable=True)
product_id = reference_col('products', nullable=True)
product = relationship('Product', backref='farmers')
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user, id_number, photo, product):
self.user = user
self.id_number = id_number
self.photo = photo
self.product = product
def __repr__(self):
return '<Farmer %r>' % self.user + self.id_number + self.photo + self.product + self.branch
class Tracom(SurrogatePK, Model):
__tablename__ = 'transporters'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='transporters')
vehicle_id = reference_col('vehicles', nullable=False)
vehicle = relationship('Vehicle', backref='transporters')
photo = Column(db.String(80), nullable=False)
licence = Column(db.String(80), unique=True, nullable=False)
location = Column(db.String(30), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user, vehicle, photo, licence, location):
self.user = user
self.vehicle = vehicle
self.photo = photo
self.licence = licence
self.location = location
def __repr__(self):
return '<Transporter %r>' % self.user + self.vehicle + self.licence + self.location
class ShoppingList(SurrogatePK, Model):
__tablename__ = 'shopping_list'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='shopping_list')
product_id = reference_col('products', nullable=False)
product = relationship('Product', backref='shopping_list')
quantity = Column(db.Integer, nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, product_id, quantity):
self.user_id = user_id
self.product_id = product_id
self.quantity = quantity
def serialize(self):
return {
"user_id": self.user_id,
"product": self.product_id,
"quantity": self.quantity,
}
class ProductCategory(SurrogatePK, Model):
__tablename__ = 'product_categories'
name = Column(db.String(80), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Product Category Type %r>' % self.name
def serialize(self):
return {
"id": self.id,
"name": self.name,
"product_types": [pt.serialize() for pt in self.get_types()]
}
def get_types(self):
return ProductType.query.filter_by(product_category_id=self.id)
class ProductSubType(SurrogatePK, Model):
__tablename__ = 'product_sub_types'
name = Column(db.String(80), nullable=False)
description = Column(db.String(500), nullable=False)
product_category_id = reference_col('product_categories', nullable=False)
product_category = relationship('ProductCategory',
backref='product_sub_sub_types')
product_type_id = reference_col('product_types', nullable=False)
product_type = relationship('ProductType', backref='product_sub_sub_types')
photo = Column(db.String(500), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name, description, product_category_id, product_type_id,
photo):
self.name = name
self.description = description
self.product_category_id = product_category_id
self.product_type_id = product_type_id
self.photo = photo
def __repr__(self):
return '<Product Sub Type Name %r>' % self.name
def serialize(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"product_category": self.product_category_id,
"product_type": self.product_type_id,
"photo": self.photo
}
def get_photo(self):
if os.path.exists("soko/static/uploads/" + self.photo):
return self.photo
return "missing.jpg"
class Delivery(SurrogatePK, Model):
__tablename__ = 'deliveries'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='deliveries')
product_id = reference_col('products', nullable=False)
product = relationship('Product', backref='deliveries')
quantity = Column(db.Integer, nullable=False)
purchase_date = Column(db.DateTime, nullable=False)
transporter = Column(db.Integer, nullable=False)
status = Column(db.Enum('Accepted',
'Delivered',
'Pending',
name='status_delivery'),
nullable=False,
default='Pending')
lat = Column(db.Numeric(9, 6), nullable=False)
lng = Column(db.Numeric(9, 6), nullable=False)
total = Column(db.Numeric(15, 2), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, product_id, quantity, purchase_date,
transporter, status, lat, lng, total):
self.user_id = user_id
self.product_id = product_id
self.quantity = quantity
self.purchase_date = purchase_date
self.transporter = transporter
self.status = status
self.lat = lat
self.lng = lng
self.total = total
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"product": self.product.serialize(),
"quantity": self.quantity,
"purchase_date": self.purchase_date,
"transporter": self.transporter,
"status": self.status,
"lat": float(self.lat),
"lng": float(self.lng),
"total": float(self.total),
"date": self.created_at
}
class FarmerAddress(SurrogatePK, Model):
__tablename__ = 'farmer_address'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='farmer_address')
primary_address = Column(db.String(300), nullable=False)
location = Column(db.String(80), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, primary_address, location):
self.user_id = user_id
self.primary_address = primary_address
self.location = location
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"primary_address": self.primary_address,
"location": self.location,
"Date": self.created_at,
}
class Locations(SurrogatePK, Model):
__tablename__ = 'locations'
user = Column(db.Integer, nullable=False)
latitude = Column(db.String(150), nullable=False)
longitude = Column(db.String(150), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user, latitude, longitude):
self.user = user
self.latitude = latitude
self.longitude = longitude
def __repr__(self):
return '<Location %r>' % self.user + self.latitude + self.longitude
def serialize(self):
return {
"id": self.id,
"user": self.user,
"latitude": self.latitude,
"longitude": self.longitude
}
class Role(SurrogatePK, Model):
"""A role for a user."""
__tablename__ = 'roles'
name = Column(db.String(80), unique=True, nullable=False)
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='roles')
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
"""Represent instance as a unique string."""
return '<Role({name})>'.format(name=self.name)
class Order(SurrogatePK, Model):
__tablename__ = 'orders'
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='orders')
consumer = Column(db.String(120), nullable=True)
order_date = Column(db.DateTime, nullable=False)
status = Column(db.Enum('Accepted',
'Delivered',
'Pending',
name='order_status'),
nullable=False,
default='Pending')
lat = Column(db.Numeric(9, 6), nullable=False)
lng = Column(db.Numeric(9, 6), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, user_id, consumer, order_date, status, lat, lng):
self.user_id = user_id
self.consumer = consumer
self.order_date = order_date
self.status = status
self.lat = lat
self.lng = lng
def serialize(self):
return {
"id": self.id,
"user": self.user_id,
"consumer": self.consumer,
"order_date": self.order_date,
"status": self.status,
"lat": float(self.lat),
"lng": float(self.lng)
}
class Product(SurrogatePK, Model):
__tablename__ = 'products'
name = Column(db.String(80), nullable=False)
product_category_id = reference_col('product_categories', nullable=False)
product_category = relationship('ProductCategory', backref='products')
product_type_id = reference_col('product_types', nullable=False)
product_type = relationship('ProductType', backref='products')
product_sub_type_id = reference_col('product_sub_types', nullable=False)
product_sub_type = relationship('ProductSubType', backref='products')
user_id = reference_col('users', nullable=False)
user = relationship('User', backref='products')
description = Column(db.String(500), nullable=False)
packaging = Column(db.String(80), nullable=False)
price = Column(db.Numeric(15, 2), nullable=False)
quantity = Column(db.Integer, nullable=False)
photo = Column(db.String(500), nullable=False)
lat = Column(db.Numeric(9, 6), nullable=True)
lng = Column(db.Numeric(9, 6), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def __init__(self, name, product_category_id, product_type_id,
product_sub_type_id, description, packaging, price, quantity,
photo, user_id, lat, lng):
self.name = name
self.product_category_id = product_category_id
self.product_type_id = product_type_id
self.product_sub_type_id = product_sub_type_id
self.description = description
self.packaging = packaging
self.price = price
self.quantity = quantity
self.photo = photo
self.user_id = user_id
self.lat = lat
self.lng = lng
def serialize(self):
return {
"id": self.id,
"name": self.name,
"photo": self.photo,
"seller": self.get_user(),
"lat": float(self.lat),
"lng": float(self.lng),
"description": self.description,
"quantity": self.quantity,
"packaging": self.packaging,
"farmer": self.user_id,
"product_type": self.product_type_id,
"product_sub_type": self.product_sub_type_id,
"price": float(self.price)
}
def get_photo(self):
if os.path.exists("soko/static/uploads/" + self.photo):
return self.photo
return "missing.jpg"
def get_user(self):
from soko.user.models import User
user = User.query.filter_by(id=self.user_id).first()
if user.first_name:
return user.first_name
else:
return user.business_name
class Loan(SurrogatePK, Model):
"""an uploaded document."""
__tablename__ = 'loans'
name = Column(db.String(80), nullable=False)
user_id = reference_col('users', nullable=True)
due_on = Column(db.DateTime, nullable=False)
paid_on = Column(db.DateTime, nullable=True)
user = relationship('User', backref='loans')
total = Column(db.Integer, nullable=True)
paid = Column(db.Integer, nullable=True)
status = Column(db.Integer)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
def get_status_name(self):
# TODO: figure out the status
if not self.status:
return "Pending"
elif self.status == 1:
return "Denied"
elif self.status == 2:
return "Unpaid"
elif self.status == 3:
return "Paid"
return "Unknown (" + str(self.status) + ")"
def is_approved(self):
return self.status in [2, 3]
def is_denied(self):
return self.status in [1]
def is_pending(self):
return not self.status
def is_paid(self):
return self.paid >= self.total
def get_remaining(self):
if not self.total:
return 0
if not self.paid:
return self.total
r = self.total - self.paid
if r > 0:
return r
return 0
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
# def __repr__(self):
# """Represent instance as a unique string."""
# return '<Loan({name})>'.format(name=self.name)
def serialize(self):
return {
"id": self.user_id,
"name": self.name,
"due_on": self.due_on,
"paid_on": self.paid_on,
"amount paid": self.paid,
"total": float(self.total),
"status": self.status,
"created_at": self.created_on
}
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
email = Column(db.String(80), unique=True, nullable=False)
password = Column(db.String(128), nullable=True)
password_reset = Column(db.Integer, nullable=True)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
phone_number = Column(db.String(15), nullable=True)
profile_photo = Column(db.String(150), nullable=True)
category = Column(db.String(30), nullable=True)
user_type = Column(db.String(80), nullable=True)#company or individual
business_name = Column(db.String(300), nullable=True)#company or individual
business_branch = Column(db.String(300), nullable=True) # company or individual
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
token = Column(db.String(100), nullable=False)
photo = Column(db.String(300), nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
region = Column(db.String(80), nullable=True)
lat = Column(db.String(80), nullable=True)
lng = Column(db.String(80), nullable=True)
def __init__(self, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, 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)
print ("SET PASSWORD '" + str(password) + "'")
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def cart_count(self):
return Cart.query.filter_by(user=self.id).count()
@property
def full_name(self):
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name, self.surname)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
