class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128))
description = db.Column(db.String(1000))
following_users = db.relationship(
'User',
secondary=association_table2,
primaryjoin=id == association_table2.c.left_id,
secondaryjoin=id == association_table2.c.right_id,
backref='followers')
following_charities = db.relationship('Charity',
secondary=association_table,
backref='followers')
def __init__(self, username=None, description=None, password=None):
if username:
self.username = username
if password:
self.hash_password(password)
if description:
self.description = description
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
class Category(db.Model, HasImage):
category_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
name = db.Column(
db.String(100),
nullable=False,
unique=True
)
image = db.Column(
db.String(100),
nullable=False,
unique=True
)
# products = db.relationship('Product', backref=db.backref('category', lazy=True))
def deleteImage(self):
from karma.admin.views import Image, CATEGORY_URL, PRODUCT_URL
image = Image(None, CATEGORY_URL, self.image)
image.deleteImage()
def storeImage(self, image):
from karma.admin.views import Image, CATEGORY_URL, PRODUCT_URL
image = Image(image, CATEGORY_URL)
self.image = image.create()
class ProductImage(db.Model):
image_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
product_id = db.Column(
db.Integer,
db.ForeignKey('product.product_id'),
nullable=False
)
name = db.Column(
db.String(100)
)
product = db.relationship(
'Product',
backref=db.backref('images', lazy=True),
)
def delete(self):
from karma.admin.views import Image, CATEGORY_URL, PRODUCT_URL
image = Image(None, PRODUCT_URL, self.name)
image.deleteImage()
db.session.delete(self)
class CartItem(db.Model, SavableMixin):
def __init__(self, **kwargs):
super(CartItem, self).__init__(**kwargs)
# self.updateTotal()
# print('cart item created')
cart_item_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
cart_id = db.Column(
db.Integer,
db.ForeignKey('cart.cart_id'),
nullable=False
)
product_id = db.Column(
db.Integer,
db.ForeignKey('product.product_id'),
nullable=False
)
product = db.relationship(
'Product',
uselist=False
)
cart = db.relationship(
'Cart',
backref=db.backref('items', lazy=True)
)
quantity = db.Column(
db.Integer,
nullable=False,
default=1
)
total = db.Column(
db.Float,
nullable=False,
default=0,
)
def calculateTotal(self):
return self.product.price*self.quantity
def updateTotal(self):
self.total = self.calculateTotal()
self.save()
return True
def delete(self):
db.session.delete(self)
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32), index=True)
content = db.Column(db.String(1000), index=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
karma = db.relationship('User',
secondary=karma_posts,
backref='liked_posts')
class OrderItem(db.Model):
order_item_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
order_id = db.Column(
db.Integer,
db.ForeignKey('order.order_id'),
nullable=False
)
order = db.relationship(
'Order',
backref=db.backref('orderitems', lazy=True)
)
product_id = db.Column(
db.Integer,
db.ForeignKey('product.product_id'),
nullable=False,
)
product = db.relationship(
'Product',
uselist=False
)
quantity = db.Column(
db.Integer,
nullable=False,
default=1,
)
total = db.Column(
db.Float,
nullable=False,
default=0.00
)
def calculateTotal(self):
return self.product.price*self.quantity
def updateTotal(self):
self.total = self.calculateTotal()
self.save()
return True
class User(db.Model, UserMixin):
id = db.Column('user_id', db.Integer, primary_key=True,
unique=True, nullable=False, autoincrement=True)
username = db.Column(db.String(50), unique=True, nullable=False)
fullname = db.Column(db.String(50), nullable=False)
_password = db.Column('password', db.String(200), nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
phone = db.Column(db.String(50), nullable=False,)
date_joined = db.Column(
db.DateTime, nullable=False, default=datetime.now
)
is_admin = db.Column(db.Boolean, nullable=False, default=False)
email_is_verified = db.Column(db.Boolean, nullable=False, default=False)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, value):
"""Store the password as a hash for security"""
self._password = generate_password_hash(value)
def check_password(self, value):
return check_password_hash(self._password, value)
def addToCart(self, CartItem):
if not self.cart:
self.createCart()
return self.cart[0].addItem(CartItem)
def createCart(self):
cart = Cart(user_id = self.id)
self.cart.append(cart)
print(self.cart)
# db.session.add(self)
# db.session.commit()
def placeOrder(self, location):
order = Order()
order.setLocation(location)
order.setUpItems()
self.orders.append(order)
self.cart[0].clear()
db.session.add(self)
db.session.commit()
@staticmethod
def count():
return len(User.query.all())
class Location(db.Model):
location_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
order_id = db.Column(
db.Integer,
db.ForeignKey('order.order_id'),
nullable=False
)
latitude = db.Column(
db.Float,
nullable=False,
)
longitude = db.Column(
db.Float,
nullable=False
)
country = db.Column(
db.String(200),
nullable=True
)
address = db.Column(
db.String(200),
nullable=True
)
order = db.relationship(
'Order',
backref=db.backref('location', lazy=True)
)
class Payment(db.Model):
payment_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
type = db.Column(
db.String(30),
nullable=True
)
date_created = db.Column(
db.DateTime,
nullable=False,
default=datetime.now
)
date_updated = db.Column(
db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now,
)
paid = db.Column(
db.Boolean,
nullable=False,
default=False,
)
refrence = db.Column(
db.String(150),
nullable=True,
)
#!/usr/bin/env python
from karma import db
karma_posts = db.Table(
'karma_posts', db.Model.metadata,
db.Column('left_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('right_id',
db.Integer,
db.ForeignKey('post.id'),
primary_key=True))
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32), index=True)
content = db.Column(db.String(1000), index=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
karma = db.relationship('User',
secondary=karma_posts,
backref='liked_posts')
class Charity(db.Model):
__tablename__ = 'charity'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), index=True)
description = db.Column(db.String(1000), index=False)
#!/usr/bin/env python
from karma.api.models.charity import Charity
from flask.ext.login import UserMixin
from karma import db
from passlib.apps import custom_app_context as pwd_context
association_table = db.Table(
'association', db.Model.metadata,
db.Column('left_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('right_id',
db.Integer,
db.ForeignKey('charity.id'),
primary_key=True))
association_table2 = db.Table(
'association2', db.Model.metadata,
db.Column('left_id', db.Integer, db.ForeignKey('user.id')),
db.Column('right_id', db.Integer, db.ForeignKey('user.id')))
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128))
description = db.Column(db.String(1000))
class Product(db.Model):
product_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
title = db.Column(
db.String(100)
)
description = db.Column(
db.String(500),
nullable=True
)
price = db.Column(
db.Float,
nullable=False,
default=0.00
)
times_bought = db.Column(
db.Integer,
nullable=False,
default=0
)
views = db.Column(
db.Integer,
nullable= False,
default = 0
)
in_stock = db.Column(
db.Integer,
nullable=False,
default=3
)
category_id = db.Column(
db.Integer,
db.ForeignKey('category.category_id'),
nullable=False
)
# images = db.relationship('ProductImage', backref=db.backref('product', lazy=True))
category = db.relationship(
'Category', backref=db.backref('product', lazy=True))
def addImages(self, images):
for image in images:
image_name = self.storeImage(image)
img = ProductImage(name=image_name)
self.images.append(img)
def storeImage(self, image):
from karma.admin.views import Image, CATEGORY_URL, PRODUCT_URL
image = Image(image, PRODUCT_URL)
return image.create()
def delete(self,):
self.deleteImages()
db.session.delete(self)
db.session.commit()
def deleteImages(self,):
for image in self.images:
image.delete()
return True
def incrementTimesViewed(self):
self.views+=1
db.session.add(self)
db.session.commit()
def incrementTimesBought(self, quantity = 1):
self.times_bought+=quantity
db.session.add(self)
db.session.commit()
class Cart(db.Model, SavableMixin):
def __init__(self, **kwargs):
super(Cart, self).__init__(**kwargs)
self.updateTotal()
print('cart created')
cart_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.user_id'),
nullable=False,
)
user = db.relationship(
'User',
backref='cart',
uselist=True,
)
total = db.Column(
db.Float,
nullable=False,
default=0.00
)
def itemExists(self, item):
for product in self.items:
if str(product.product_id) == str(item.product_id):
return True
return False
def retrieveItem(self, item):
for product in self.items:
if str(product.product_id) == str(item.product_id):
return product
def addItem(self, item):
if(self.itemExists(item)):
existingItem = self.retrieveItem(item)
existingItem.quantity = int(
existingItem.quantity) + int(item.quantity)
print(
"""
This item already exists
"""
)
else:
self.items.append(item)
self.save()
return True
def calculateTotal(self):
total = 0
for item in self.items:
total += item.total
return total
def updateTotal(self):
self.total = self.calculateTotal()
self.save()
return True
def clear(self):
self.total = 0
for item in self.items:
item.delete()
self.save()
class Order(db.Model):
order_id = db.Column(
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True
)
status = db.Column(
db.String(15),
nullable=False,
default=OrderStatus['PENDING']
)
date_created = db.Column(
db.DateTime,
nullable=False,
default=datetime.now
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.user_id'),
nullable=False
)
user = db.relationship(
'User',
backref=db.backref('orders', lazy=True)
)
total = db.Column(
db.Float,
nullable=False,
default=0.00
)
@staticmethod
def count():
return len(Order.query.all())
@staticmethod
def pendingOrders():
return len(Order.query.filter_by(status=OrderStatus['PENDING']).all())
@staticmethod
def deliveredOrders():
return len(Order.query.filter_by(status=OrderStatus['DELIVERED']).all())
@staticmethod
def transitOrders():
return len(Order.query.filter_by(status=OrderStatus['TRANSIT']).all())
def setLocation(self, location):
self.location.append(location)
def setUpItems(self, ):
for item in current_user.cart[0].items:
newItem = OrderItem(
product_id=item.product_id,
quantity=item.quantity,
total=item.total
)
item.product.incrementTimesBought(item.quantity)
self.orderitems.append(newItem)
self.updateTotal()
def updateTotal(self):
self.total = current_user.cart[0].total