def create_user():
for Model in (Role, User, UserRoles, Item, Customer, Cart, CartItem):
Model.drop_table(fail_silently=True)
Model.create_table(fail_silently=True)
user_datastore.create_user(
email='*****@*****.**',
password='******'
)
item1 = Item(name='notebook', stock=300, price=500)
item1.save()
item2 = Item(name='TV', stock=250, price=200)
item2.save()
item3 = Item(name='flash', stock=950, price=10)
item3.save()
item4 = Item(name='smartphone', stock=455, price=150)
item4.save()
item5 = Item(name='camera', stock=50, price=550)
item5.save()
customer = Customer(name='John', birthday=date(1990, 1, 15))
customer.save()
cart1 = Cart(customer=customer.id)
cart1.save()
cartitem = CartItem(cart=cart1, item=item1, quantity=3)
cartitem.save()
customer = Customer(name='Olivier', birthday=date(1995, 2, 22))
customer.save()
cart2 = Cart(customer=customer.id)
cart2.save()
cartitem = CartItem(cart=cart2, item=item5, quantity=45)
cartitem.save()
def cart_view():
if request.method == 'POST':
cart = Cart()
# check for malformed post
try:
products_data = json.loads(request.data, parse_int=int)
except JSONDecodeError:
return redirect(url_for('product_list'))
# so we wont create actual empty Cart in db for every cart/ request when cart is empty
if products_data.get('id') == '' and not products_data['products']:
return url_for('cart_view', cart_id='0')
products = Product.query.filter(
Product.id.in_([*products_data['products']])).all()
prod_dict = {int(product.id): product for product in products}
for product_id, quantity in products_data['products'].items():
cart.cart_products.append(
CartProduct(prod_dict[int(product_id)], quantity=quantity))
db.session.add(cart)
db.session.commit()
return url_for('cart_view', cart_id=cart.id)
elif request.method == 'GET':
if not request.args.get('cart_id'):
return redirect(url_for('product_list'))
cart = Cart()
cart_id = request.args.get('cart_id')
if cart_id != '0':
cart = Cart.query.get_or_404(cart_id)
return render_template('cart.html', cart=cart)
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(Cart(id=1, user_id=1, product_id=1, quantity=100))
self.db.session.add(Cart(id=2, user_id=2, product_id=2, quantity=200))
self.db.session.commit()
self.app = tested_app.test_client()
def add_to_cart(user, product_id, params):
if not params:
params = {}
amount = params.get("amount", 1)
cart_item = Cart.query.filter_by(user_id=user["id"], product_id=product_id)
if not cart_item.count():
if amount == 0:
return api.error_400("There is no product by that ID.")
cart_item = Cart(product_id, user["id"], amount)
db.session.add(cart_item)
else:
cart_item = cart_item.one()
if amount > 0:
cart_item.amount = amount
else:
db.session.delete(cart_item)
try:
db.session.commit()
except sqlalchemy.exc.IntegrityError:
return api.error_400("There is no product by that ID.")
return api.success()
def add_cart():
try:
request_data = request.get_json()
u_id = request_data["u_id"]
g_id = request_data["goods_id"]
except:
return jsonify({
'status': 400,
'msg': '请求参数错误'
})
try:
cart = db.session.query(Cart).filter(Cart.u_id == u_id, Cart.goods_id == g_id)
if cart.count() == 0:
g_num = 1
is_select = False
new_cart = Cart(u_id=u_id, goods_id=g_id, c_goods_num=g_num, c_is_selected=is_select)
db.session.add(new_cart)
db.session.commit()
else:
current_cart = cart.first()
current_cart.c_goods_num += 1
db.session.commit()
return jsonify({
'status': 200,
'msg': '添加购物车成功'
})
except:
return jsonify({
'status': 300,
'msg': "添加购物车失败"
})
def add_to_cart(jwt):
body = request.get_json()
try:
validate_required_fields_in_new_cart(body)
cart = Cart(
customer_id=body.get('customer_id', None),
product_id=body.get('product_id', None),
amount=body.get('amount', None),
product_price=body.get('product_price', None),
)
cart.insert()
return jsonify({
'success': True,
'created': cart.id,
})
except ValueError:
logging.exception("message")
db.session.rollback()
abort(422)
finally:
db.session.close()
def start(bot, update, user_data):
uid = update.message.from_user.id
bot.sendChatAction(uid, action=typing)
# btrack(update.message, event_name="start-test-inline")
# if the user is admin
if uid == owner_id:
text = texts.welcome_admin
keyboard = main_kbd_admin
next_state = "MAIN_MENU_A"
# if the user is an ordinary user (is not admin)
else:
# if user is not saved in user_data dict
if 'user' not in user_data: # useless if statement? now we don't save user in the dict
# and the user is not saved in DB
if session.query(User.tuid).filter_by(tuid=uid).scalar() is None:
# we should save the user in user_data dict
from_user = update.message.from_user
user = User(tuid=uid, first_name=from_user.first_name, last_name=from_user.last_name)
# also save the user in DB
session.add(user)
session.commit()
# create an empty cart for the user
user_data["cart"] = Cart()
user_data["prev_delivery_addr"] = []
# welcome, pathetic user
text = texts.welcome_user
# if user is saved in user_data dict we have nothing to do but to welcome him again
else:
text = texts.welcome_again_user
keyboard = main_kbd_user
next_state = "MAIN_MENU_U"
return ans(text=text, keyboard=keyboard, next_state=next_state)(bot, update)
def addcart():
data = request.form
product = Product.query.filter_by(id=int(data['product_id'])).first()
product_price = int(data['quantity']) * product.price
cart = Cart(user_id=current_user.id,
product_id=int(data['product_id']),
quantity=int(data['quantity']),
price=product_price)
if cart.quantity < 0:
return {}
product = Cart.query.filter_by(product_id=cart.product_id,
user_id=current_user.id).first()
if product:
product.quantity += cart.quantity
product.price += product_price
db.session.commit()
return {}
if cart.quantity != 0:
db.session.add(cart)
db.session.commit()
return {}
def create(qty, product_id, username, cart_number) -> dict:
""" Create Cart """
result: dict = {}
try:
data_stock = Stock.query.filter_by(product_id=product_id).first()
if (data_stock is not None and data_stock.stock > 0):
if ((data_stock.stock - qty) >= 0):
data = Cart(qty, product_id, username, 'Stock Available',
cart_number)
data.save()
result = {
'product_id': data.product_id,
'qty': data.qty,
'username': data.username,
'date_created': str(data.date_created),
}
else:
result = {'message': 'Stock is not Enough'}
else:
result = {'message': 'Stock Unavailable'}
except IntegrityError:
Cart.rollback()
raise ResourceExists('file_name already exists')
return result
def register(bot, update, args):
# Function to register new customer and define Cart # for further shopping
# In addition, it finds already registered Customer and return their Cart #
try:
name = args[0]
birthday = args[1]
if Customer.select().where(
Customer.name == name) and Customer.select().where(
Customer.birthday == birthday):
cart_id = Customer.get(Customer.name == name,
Customer.birthday == birthday).id
bot.send_message(
chat_id=update.message.chat_id,
text='Dear, {}! You are already registered in our shop =) '
'Glad to see you again! '
'Please use Your Cart #: {} for all purchases.'
'\nIf you need help, please use /guidance'.format(
name, cart_id))
else:
customer = Customer(name=name, birthday=birthday)
customer.save()
cart = Cart(customer=customer.id)
cart.save()
bot.send_message(
chat_id=update.message.chat_id,
text='Congratulations, {}! You are registered and '
'can continue shopping :) '
'Please use Your Cart #: {} for all purchases.'
'\nIf you need help, please use /guidance'.format(
name, cart.id))
except IndexError:
bot.send_message(chat_id=update.message.chat_id,
text='Please use proper format: '
'Your name Your birthday (YEAR-MM-DD). ')
def cart(book_name):
global user_name
book_id = Book.get_id_by_username(book_name)
author = Book.get_author_by_username(book_name)
price = Book.get_price_by_username(book_name)
genre = Book.get_genre_by_username(book_name)
edition = Book.get_edition_by_username(book_name)
Session = sessionmaker(bind=engine)
session = Session()
customer_id = Customer.get_id_by_username(user_name)
temp = 0
cart = session.query(Cart).filter(Cart.customer_id == customer_id).all()
for book in cart:
print(book.book_id)
if book.book_id == book_id:
temp += 1
if temp > 0:
flash('This book is already in your cart!!')
return redirect(url_for('search'))
cart = Cart(customer_id=customer_id, book_id=book_id, book_name=book_name, author=author,
price=price, genre=genre, book_edition=edition)
session.add(cart)
session.commit()
res = session.query(Cart).filter(Cart.customer_id == customer_id).all()
session.flush()
session.close()
return render_template('shopping_cart.html', res=res, user_logged=user_logged, user_name=user_name)
def index(page=1):
if request.method == 'GET':
goods = Goods.query.filter().paginate(page, config.POSTS_PER_PAGE,
False)
return render_template('index.html', goods=goods)
elif request.method == 'POST':
user_account = session.get('user_account')
if user_account:
user = Users.query.filter(Users.account == user_account).first()
user_id = user.id
good_id = request.form.get('good_id')
check_exist = Cart.query.filter(Cart.user_id == user_id).filter(
Cart.goods_id == good_id).first()
if check_exist:
check_exist.goods_num = check_exist.goods_num + 1
db.session.commit()
else:
new_cart = Cart(user_id=user_id, goods_id=good_id, goods_num=1)
db.session.add(new_cart)
db.session.commit()
goods = Goods.query.filter().paginate(page, config.POSTS_PER_PAGE,
False)
return render_template('index.html',
goods=goods,
status=1,
color='success',
alert='Add to cart successfully!')
else:
return redirect(url_for('login'))
goods = Goods.query.filter().paginate(page, config.POSTS_PER_PAGE, False)
return render_template('index.html', goods=goods)
def buyProductView(request):
user = request.user
if user.profile.corporate is False:
category = request.GET.get('category', '')
products = Product.objects.filter(p_type=category)
context_dict = {'products': products}
# user is adding a product to cart
if request.GET.get('add', ''):
django_id = request.GET.get('add', '')
if not Cart.objects.filter(
user=user,
product=Product.objects.filter(id=django_id)).exists():
cart = Cart(user=user,
product=Product.objects.get(id=django_id),
quantity=1)
cart.save()
full_cart = Cart.objects.filter(user=user).distinct()
categories = Product.objects.order_by().values_list(
'p_type').distinct()
categories_string = [x[0] for x in categories]
context_dict['full_cart'] = full_cart
context_dict['categories_string'] = categories_string
return render(request, 'users/shop/buy.html', context_dict)
else:
return redirect('/')
def addCart():
#返回参数结构
responseData = {"status": 0, "message": '', "result": {}}
goodsId = request.form.get("goodsId")
goodsPrice = request.form.get("goodsPrice")
goodsNumber = request.form.get("goodsNumber")
goodsStyle = request.form.get("goodsStyle")
goodsSize = request.form.get("goodsSize")
userId = '1111'
if not (goodsId and goodsPrice and goodsNumber and goodsStyle
and goodsSize):
responseData["status"] = 1
responseData["message"] = "缺少必要的业务参数!"
else:
goods = Cart(goodsId=goodsId,
goodsPrice=goodsPrice,
goodsNumber=goodsNumber,
goodsStyle=goodsStyle,
goodsSize=goodsSize,
userId=userId)
db.session.add(goods)
db.session.commit()
responseData["status"] = 0
responseData["message"] = "加入购物车成功!"
# 返回数据
return jsonify(responseData)
def order_confirm(bot, update, user_data):
uid = update.message.from_user.id
answer = update.message.text
keyboard = main_kbd_user
next_state = "MAIN_MENU_U"
# delivery:
if "delivery_addr" in user_data:
dtime = correct_time(answer)
if not dtime:
text = texts.wrong_time_format
keyboard = None
next_state = None
else:
user_data["delivery_time"] = dtime
addr = user_data["delivery_addr"]
ddate = user_data["delivery_date"]
# dtime = user_data["delivery_time"]
cart = user_data["cart"]
order_json = cart.json_repr()
new_order = Order(addr=addr,
ddate=ddate,
dtime=dtime,
order=order_json)
user = session.query(User).filter_by(tuid=uid).scalar()
user.uorders.append(new_order)
session.commit()
# TODO: save delivery_addr and suggest it next time
user_data["prev_delivery_addr"].append(addr)
user_data["cart"] = Cart()
del user_data["delivery_addr"]
del user_data["delivery_date"]
del user_data["delivery_time"]
text = texts.delivery_confirmation % (addr, ddate, dtime,
cart.total)
# pickup:
else:
pickup_point = answer
cart = user_data["cart"]
order_json = cart.json_repr()
new_order = Order(pickup=pickup_point, order=order_json)
user = session.query(User).filter_by(tuid=uid).scalar()
user.uorders.append(new_order)
session.commit()
text = texts.pickup_confirmation % (answer, cart.total)
user_data["cart"] = Cart()
return ans(text=text, keyboard=keyboard, next_state=next_state)(bot,
update)
def view_cart(request):
cart = request.session.get("cart", None)
if not cart:
cart = Cart()
request.session["cart"] = cart
return render_to_response("view_cart.html",
locals(),
context_instance=RequestContext(request))
def test_update_cart(self):
user = self._create_user_in_database()
cart = Cart(self.request)
cart.new(self.request)
cart.add(product=user, quantity=3, unit_price=100)
cart.update(product=user, quantity=2, unit_price=200)
self.assertEquals(cart.summary(), 400)
self.assertEquals(cart.count(), 2)
def add2Cart(request, cuisineID):
# FIXME: 如果餐厅在“打烊”状态，应该无法添加到购物车,返回错误
cart = request.session.get('cart', None)
if cart is None:
cart = Cart()
res = {'size': cart.add(int(cuisineID))}
request.session['cart'] = cart
return HttpResponse(json.dumps(res))
def test_cart(products):
print('Received products are {0}'.format(products))
try:
products = products.split(',')
products = [eval(product) for product in products]
except Exception as e:
print('Unable to decode products, please try again')
my_cart = Cart(products=products)
Cart.calculate_total(my_cart, offers)
def addToCart():
user = User.query.get(request.data['id'])
data = request.json
newProductInCart = Cart(user_id=user.id,
product_id=data['product_id'],
product_details_id=data['product_details_id'],
quantity=data['quantity'])
db.session.add(newProductInCart)
db.session.commit()
return jsonify({'message': 'item has been added to the cart'})
def _create_cart_in_database(self, creation_date=datetime.datetime.now(),
checked_out=False):
"""
Helper function so I don't repeat myself
"""
cart = Cart()
cart.creation_date = creation_date
cart.checked_out = False
cart.save()
return cart
def add_to_cart(request, id):
product = Product.objects.get(id=id)
cart = request.session.get("cart", None)
if not cart:
cart = Cart()
request.session["cart"] = cart
cart.add_product(product)
request.session["cart"] = cart
# return view_cart(request)
return HttpResponseRedirect("/depotapp/cart/view/")
def on_post(self, req, resp, userId):
try:
cart = Cart(userId=userId)
carts = Cart.objects(userId=userId)
if len(carts) == 0:
cartResp = cart.save()
ResponseUtil.makeBody(resp, cartResp.to_json())
else:
ResponseUtil.makeBody(resp, carts[0].to_json())
except Exception as e:
ResponseUtil.error(e, resp)
def list_item_of_user(id_user):
cart = Cart.query.filter(Cart.id_user == id_user).all()
if (cart != []):
id_cart = cart[0].id
else:
newcart = Cart(id_user=id_user)
db.session.add(newcart)
db.session.commit()
id_cart = Cart.query.filter(Cart.id_user == id_user).first().id
list_item = CartItem.query.filter(CartItem.id_cart == id_cart).all()
return id_cart, list_item
def insertcart(request):
x = request.GET["pid"]
qt = request.GET["qt"]
user = User.objects.get(id=request.session.get("_auth_user_id"))
un = str(user.username)
pr = Product.objects.get(pid=x)
a = int(str(x))
b = int(str(qt))
c = un
d = float(pr.pcost)
e = int(str(qt)) * float(pr.pcost)
ct = Cart(username=c, pid=a, units=b, unitprice=d, tuprice=e)
ct.save()
return render(request, 'insertcart.html')
def list_item_of_user_name_book(id_user):
cart = Cart.query.filter(Cart.id_user == id_user).all()
if (cart != []):
id_cart = cart[0].id
else:
newcart = Cart(id_user=id_user)
db.session.add(newcart)
db.session.commit()
id_cart = Cart.query.filter(Cart.id_user == id_user).first().id
list_item = CartItem.query.filter(CartItem.id_cart == id_cart).join(
Book, Book.id == CartItem.idBook).add_column(Book.name).all()
return id_cart, list_item
def order_confirm(bot, update, user_data):
answer = update.message.text
# delivery:
if "delivery_addr" in user_data:
user_data["delivery_time"] = answer
addr = user_data["delivery_addr"]
ddate = user_data["delivery_date"]
dtime = user_data["delivery_time"]
cart = user_data["cart"]
order_json = cart.json_repr()
new_order = Order(addr=addr,
ddate=ddate,
dtime=dtime,
order=order_json)
user = user_data['user']
user.uorders.append(new_order)
session.commit()
# TODO: save delivery_addr and suggest it next time
user_data["prev_delivery_addr"].append(addr)
user_data["cart"] = Cart()
del user_data["delivery_addr"]
del user_data["delivery_date"]
del user_data["delivery_time"]
text = texts.delivery_confirmation % (addr, ddate, dtime, cart.total)
# pickup:
else:
pickup_point = answer
cart = user_data["cart"]
order_json = cart.json_repr()
new_order = Order(pickup=pickup_point, order=order_json)
user = user_data['user']
user.uorders.append(new_order)
session.commit()
text = texts.pickup_confirmation % (answer, cart.total)
user_data["cart"] = Cart()
ans(text=text, keyboard=main_kbd_user)(bot, update)
return "MAIN_MENU_U"
def insert_into_cart(user_id, product_id, quantity):
stock = db_session.query(Product).filter_by(id=product_id).first()
available_stock = stock.count
if available_stock > int(quantity):
pro = db_session.query(Cart).filter_by(user_id=user_id,
product_id=product_id).first()
if pro != None:
return "result"
else:
item = Cart(user_id=user_id, product_id=product_id, count=quantity)
db_session.add(item)
db_session.commit()
return True
else:
return False
def insert_into_cart(product_id, quantity, user_id):
available_stock = session.query(Item).filter_by(id=product_id).first()
available_quantity = available_stock.quantity
if available_quantity < int(quantity):
return False
else:
avail = session.query(Cart).filter_by(user_id=user_id,
item_id=product_id).first()
if avail != None:
return "No"
else:
product = Cart(user_id=user_id,
item_id=product_id,
desired_quantity=quantity)
session.add(product)
session.commit()
return True
def add(request, good_id, count):
buyers = request.user #获得当前用户
#buy_goods=Goods.objects.get(id=int(good_id))#购买的商品
buy_count = int(count)
goods_cart = Cart.objects.filter(user=buyers, goods_id=int(good_id))
if len(goods_cart) >= 1: #如果商品存在
buy_cart = goods_cart[0]
buy_cart.count = buy_cart.count + buy_count
else:
buy_cart = Cart()
buy_cart.user = buyers
buy_cart.goods_id = good_id
buy_cart.count = buy_count
buy_cart.save()
if request.is_ajax():
count = Cart.objects.filter(user=buyers)
return JsonResponse({'count': count})
else:
return redirect('/cart/')