def update_cart(request):
pending = ''
qerror = ''
from django.middleware.csrf import get_token
csrf_token = get_token(request)
reload = 'location.reload(true);'
if request.method == 'POST':
postdata = request.POST.copy()
page_title = postdata['page_title']
if postdata['submit'] == 'Remove':
if pending_checker(request) == 0:
pending = 'You have a pending transaction on this cart'
else:
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
if pending_checker(request) == 0:
pending = 'You have a pending transaction on this cart'
else:
try:
int(postdata['quantity'])
cart.update_cart(request)
except:
if cart.cart_distinct_item_count(request) > 0:
qerror = 'Invalid Quantity Value'
paid = ''
subtotal = cart.cart_subtotal(request)
cart_items = cart.get_cart_items(request)
cart_item_count = cart.cart_distinct_item_count(request)
# Put this in here so that it cuts across all pages and it is related to cart. See function def for comments
if bgprocess(request) == 0:
paid = "(Paid)"
cart_template = "tags/cart_box.html"
cart_html = render_to_string(cart_template, locals())
if len(pending) == 0 and len(qerror) == 0:
cart_items = cart.get_cart_items(request)
cart_subtotal = cart.cart_subtotal(request)
template = "cart/cart_preview.html"
html = render_to_string(template, locals())
print(html)
response = simplejson.dumps({
'success': 'True',
'html': html,
'cart_html': cart_html
})
else:
html = '<p class="errorlist">{{ qerror }}</p>'
response = simplejson.dumps({'success': 'False', 'html': html})
return HttpResponse(response,
content_type='application/javascript; charset=utf-8')
def create_order(request, transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
# return the new order object
return order
def create_order(request, transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance = order)
order = checkout_form.save(commit = False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price
oi.product = ci.product
oi.save()
cart.empty_cart(request)
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
return order
def cart_item_change(request,template_name):
print('cart_item_change')
print(request.POST)
cart.update_cart(request)
print('updated')
cart_items_list = []
cart_items = cart.get_cart_items(request)
# serializers.serialize("json", )
cart_item_count = cart.cart_distinct_item_count(request)
# result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
print(cart_item_count)
for c in cart_items:
# print(c)
item = {}
item.setdefault('image',c.image())
item.setdefault('name',c.name())
item.setdefault('quantity',c.quantity)
price = str(c.price())
item.setdefault('unit_price',price)
total = str(c.total())
item.setdefault('total_price',total)
item.setdefault('id',c.id)
# print(item)
cart_items_list.append(item)
# print(cart_items_list)
# cart_items = serializers.serialize("json", cart_items_list)
# print(cart_items)
result = {'cart_items' : cart_items_list ,'cart_item_count' : cart_item_count}
print(json.dumps(result))
print('++++++++++++++++++++++++++++++')
return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
def get_cart_data(request, context={}):
from cart import cart
# expand : boolean; if true then the cart items will returned in dictionary along with values, else direct browsed objects will be returned
cart_items = cart.get_cart_items(request)
item_ids = []
res = {'cart_items': {}}
for item in cart_items:
item_ids.append(item.product.id)
res['cart_items'].update(get_item_deails(item))
result_quantities = get_products_availability(item_ids)
final_items_list = []
for item in cart_items:
available_qty = result_quantities.get(str(item.product_id),
{'virtual_available': 0})
res['cart_items'][item.id].update({'qty': available_qty})
if canbe_checkedout(res['cart_items'][item.id]):
final_items_list.append(item)
cart_total = cart.get_cart_total(final_items_list)
discount = cart.get_cart_discount(final_items_list, request)
discount_percentage = cart.get_discount_percentage(cart_total, discount)
net_total = round(cart.get_net_total(discount_percentage, cart_total), 2)
cart_item_count = cart.cart_distinct_item_count(final_items_list)
res.update({
'cart_item_count': cart_item_count,
'discount_percentage': discount_percentage,
'discount': discount,
'net_total': net_total,
'cart_total': cart_total,
'checkout_cart_items': final_items_list,
'actual_cart_items': cart_items
})
return res
def show_cart(request, template_name="cart/cart.html"):
currency_symbol = request.session.get('currency_symbol', '$')
currency_rate = request.session.get('currency_rate', 1)
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['mode'] == 'remove':
cart.remove_from_cart(request)
if postdata['mode'] == 'update':
cart.update_cart(request)
print(
'----------------------------------------------------------------------'
)
print(postdata)
# return render_to_response(template_name,locals(),context_instance=RequestContext(request))
cart_items = cart.get_cart_items(request)
for c_item in cart_items:
c_item.price = math.floor(
c_item.price() / decimal.Decimal(currency_rate) * 100) / 100
c_item.total = math.floor(
c_item.total() / decimal.Decimal(currency_rate) * 100) / 100
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
mode = 'cart'
# currency = '€'
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def product_add_to_cart(request, template_name = "catalog/subcategory.html"):
cart.add_to_cart(request)
cart_items = serializers.serialize("json", cart.get_cart_items(request))
cart_item_count = cart.cart_distinct_item_count(request)
result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
print(result)
return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
def _build_xml_shopping_cart(request):
doc = Document()
root = doc.createElement('checkout-shopping-cart')
root.setAttribute('xmlns', 'http://checkout.google.com/schema/2')
doc.appendChild(root)
shopping_cart = doc.createElement('shopping-cart')
root.appendChild(shopping_cart)
items = doc.createElement('items')
shopping_cart.appendChild(items)
cart_items = cart.get_cart_items(request)
for cart_item in cart_items:
item = doc.createElement('item')
items.appendChild(item)
item_name = doc.createElement('item-name')
item_name_text = doc.createTextNode(str(cart_item.name))
item_name.appendChild(item_name_text)
item.appendChild(item_name)
item_description = doc.createElement('item-description')
item_description_text = doc.createTextNode(str(cart_item.name))
item_description.appendChild(item_description_text)
item.appendChild(item_description)
unit_price = doc.createElement('unit-price')
unit_price.setAttribute('currency', 'USD')
unit_price_text = doc.createTextNode(str(cart_item.price))
unit_price.appendChild(unit_price_text)
item.appendChild(unit_price)
quantity = doc.createElement('quantity')
quantity_text = doc.createTextNode(str(cart_item.quantity))
quantity.appendChild(quantity_text)
item.appendChild(quantity)
checkout_flow = doc.createElement('checkout-flow-support')
root.appendChild(checkout_flow)
merchant_flow = doc.createElement('merchant-checkout-flow-support')
checkout_flow.appendChild(merchant_flow)
shipping_methods = doc.createElement('shipping-methods')
merchant_flow.appendChild(shipping_methods)
flat_rate_shipping = doc.createElement('flat-rate-shipping')
flat_rate_shipping.setAttribute('name', 'FedEx Ground')
shipping_methods.appendChild(flat_rate_shipping)
shipping_price = doc.createElement('price')
shipping_price.setAttribute('currency', 'USD')
flat_rate_shipping.appendChild(shipping_price)
shipping_price_text = doc.createTextNode('9.99')
shipping_price.appendChild(shipping_price_text)
return doc.toxml(encoding='utf-8')
def _build_xml_shopping_cart(request):
doc = Document()
root = doc.createElement('checkout-shopping-cart')
root.setAttribute('xmlns', 'http://checkout.google.com/schema/2')
doc.appendChild(root)
shopping_cart = doc.createElement('shopping-cart')
root.appendChild(shopping_cart)
items = doc.createElement('items')
shopping_cart.appendChild(items)
cart_items = cart.get_cart_items(request)
for cart_item in cart_items:
item = doc.createElement('item')
items.appendChild(item)
item_name = doc.createElement('item-name')
item_name_text = doc.createTextNode(str(cart_item.name))
item_name.appendChild(item_name_text)
item.appendChild(item_name)
item_description = doc.createElement('item-description')
item_description_text = doc.createTextNode(str(cart_item.name))
item_description.appendChild(item_description_text)
item.appendChild(item_description)
unit_price = doc.createElement('unit-price')
unit_price.setAttribute('currency','USD')
unit_price_text = doc.createTextNode(str(cart_item.price))
unit_price.appendChild(unit_price_text)
item.appendChild(unit_price)
quantity = doc.createElement('quantity')
quantity_text = doc.createTextNode(str(cart_item.quantity))
quantity.appendChild(quantity_text)
item.appendChild(quantity)
checkout_flow = doc.createElement('checkout-flow-support')
root.appendChild(checkout_flow)
merchant_flow = doc.createElement('merchant-checkout-flow-support')
checkout_flow.appendChild(merchant_flow)
shipping_methods = doc.createElement('shipping-methods')
merchant_flow.appendChild(shipping_methods)
flat_rate_shipping = doc.createElement('flat-rate-shipping')
flat_rate_shipping.setAttribute('name','FedEx Ground')
shipping_methods.appendChild(flat_rate_shipping)
shipping_price = doc.createElement('price')
shipping_price.setAttribute('currency','USD')
flat_rate_shipping.appendChild(shipping_price)
shipping_price_text = doc.createTextNode('9.99')
shipping_price.appendChild(shipping_price_text)
return doc.toxml(encoding='utf-8')
def checkout(request):
if request.method == 'POST':
cart_items = cart_module.get_cart_items(request)
cart_subtotal = cart_module.cart_subtotal(request)
return render(request, 'account/checkout.html', {'cart_items':cart_items,
'cart_id':cart_items[0].cart_id,
'cart_subtotal':cart_subtotal, 'user':request.user} )
else:
return HttpResponseRedirect('/account/')
def cart_box_menu(request):
"""Tag for shopping cart box in menu bar
"""
cart_item_count = cart.cart_distinct_item_count(request)
cart_items = cart.get_cart_items(request)
return {
'cart_item_count': cart_item_count,
'cart_items': cart_items
}
def create_order(request, order_total, transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.status = Order.SUBMITTED
order.user = None
# order.order_total = order_total
order_total.purchased = True
if request.user.is_authenticated():
order.user = request.user
from accounts import profile
user_profile = profile.get_profile(request)
# verificar si campos requeridos estan vacios, si lo estan crear un user_profile para este usuario desde
# aqui, asi no tendria q escribirlo en el form UserProfileForm
if not user_profile.email or not user_profile.shipping_name or user_profile.shipping_city == 0:
profile.set_profile(request)
order.save()
order_total.order = order
order_total.save()
# if the order save succeeded
if order.pk:
# verificar si el usuario tuvo la promo4, para eliminarla
try:
promo4_id = request.session['promo4_id']
del request.session['promo4_id']
promo4 = Promo4.objects.get(id=promo4_id)
promo4.active = False
promo4.save()
except KeyError:
pass
try: # eliminar el codigo de promoion para el usuario
promo_id = request.session['promo3_id']
del request.session['promo3_id']
Promo3.objects.get(id=promo_id).delete()
except KeyError:
pass
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price() # now using @property
oi.product = ci.product
# disminuir del almacen la cant disponible para este prod
ci.product.quantity -= ci.quantity
ci.product.save()
oi.save()
# all set, empty cart
cart.empty_cart(request)
# utils.send_email("Leoshop", "Gracias por preferirnos", user_profile.email)
# return the new order object
return order
def show_cart(request):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
cart_items = cart.get_cart_items(request)
cart_subtotal = cart.cart_subtotal(request)
return render(request, "cart/cart.html", locals())
def show_cart(request, template_name='cart/cart.html'):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
cart_items = cart.get_cart_items(request)
page_title = "Shopping cart"
cart_subtotal = cart.cart_subtotal(request)
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def show_cart(request, template_name="cart/cart.html"):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
return render(request, template_name, locals())
def cart_box(request):
paid = ''
subtotal = cart.cart_subtotal(request)
cart_items = cart.get_cart_items(request)
cart_item_count = cart.cart_distinct_item_count(request)
# Put this in here so that it cuts across all pages and it is related to cart. See function def for comments
if bgprocess(request) == 0:
paid = "(Paid)"
return {
'cart_item_count': cart_item_count,
'paid': paid,
'cart_items': cart_items,
'subtotal': subtotal
}
def show_cart(request, template_name="cart/cart.djhtml"):
if request.method == "POST":
postdata = request.POST.copy()
if postdata["submit"] == "Remove":
cart.remove_from_cart(request)
if postdata["submit"] == "Update":
cart.update_cart(request)
if postdata["submit"] == "Checkout":
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
cart_items = cart.get_cart_items(request)
page_title = "Shopping Cart"
return render(request, template_name, locals())
def show_cart(request, template_name="shop/cart/cart.html"):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
if postdata['submit'] == 'Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
merchant_id = settings.GOOGLE_CHECKOUT_MERCHANT_ID
return render(request, template_name, locals())
def show_cart(request, template_name="cart/cart.html"):
if request.method == 'POST':
post_data = request.POST.copy()
if post_data['submit'] == 'Remove':
cart.remove_from_cart(request)
if post_data['submit'] == 'Update':
cart.update_cart(request)
if post_data['submit'] == 'Checkout':
url = urlresolvers.reverse('show_checkout')
return HttpResponseRedirect(url)
cart_items = cart.get_cart_items(request)
cart_item_count = cart.cart_distinct_item_count(request)
cart_subtotal = cart.cart_subtotal(request)
page_title = 'Shopping Cart'
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def checkout(request, template_name=""):
currency_symbol = request.session.get('currency_symbol','$');
currency_rate = request.session.get('currency_rate',1);
cart_items = cart.get_cart_items(request)
# sql="SELECT products.name, products.price FROM cart_items, products where cart_items.product_id = products.id"
# cart_items=connection.cursor()
# cart_items.execute(sql)
for c_item in cart_items:
print(c_item)
c_item.price = math.floor(c_item.price()/decimal.Decimal(currency_rate)*100)/100
c_item.total = math.floor(c_item.total()/decimal.Decimal(currency_rate)*100)/100
cart_subtotal = cart.cart_subtotal(request)
flat_price = math.floor(3.06/currency_rate*100)/100
total_price = math.floor((cart_subtotal+flat_price)*100)/100
mode = 'checkout'
return render_to_response(template_name,locals(),context_instance=RequestContext(request))
def create_transactions(request):
cart_items = cart.get_cart_items(request)
transactions = []
total = 0
description = ''
for ci in cart_items:
# create order item for each cart item
total = total + (ci.price() * ci.quantity)
description = '|'.join([description, ci.product.name])
transactions.append({
'amount': {
'total': str(total),
"currency": "USD"
},
'description': ci.product.name
})
return transactions
def pay(request):
"""
Do the "create order" thing.
It get the CARD_ID_SESSION_KEY from session to get the items information that been added into cart by user.
Then calling the cart_subtotal() function in cart_module to get the order total price.
The shipping information will also be collected through html form.
If every thing is fine, then create an order, else return error message.
:param request:
:return:
"""
if request.method == 'POST':
if request.session[CART_ID_SESSION_KEY] != '':
cart_items = cart_module.get_cart_items(request)
cart_subtotal = cart_module.cart_subtotal(request)
shipping_zip = request.POST['shipping_zip']
shipping_add = request.POST['shipping_add']
shipping_to = request.POST['shipping_to']
username = request.user.username
cart_id = cart_items[0].cart_id
try:
order = Order.objects.get(cart_id = request.session[CART_ID_SESSION_KEY])
except Order.DoesNotExist:
order = None
if order != None:
order = Order.objects.get(cart_id=request.session[CART_ID_SESSION_KEY])
else:
order = Order()
order.cart_id = cart_id
order.shipping_add = shipping_add
order.shipping_to = shipping_to
order.shipping_zip = shipping_zip
order.username = username
order.total_price = cart_subtotal
order.save()
request.session[CART_ID_SESSION_KEY] = '' # delete session key
return HttpResponseRedirect('/account/order/'+order.order_id+'/')
else:
return render(request, 'account/error.html',{'error':'This order has been created.' })
else:
return HttpResponseRedirect('/account/')
def index(request, template_name="catalog/index.html"):
page_title = 'Online shop'
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Checkout':
cart_items = cart.get_cart_items(request)
for cart_item in cart_items:
p = cart_item.product
p.quantity -= cart_item.quantity
p.save()
cart.remove_from_cart(request, cart_items)
message = f"""
Thank you, for buying something in our shop.
If you wanna , you can continue.
Pleasure work for you.
"""
return render(request, template_name, context=locals())
def create_transactions(request):
cart_items = cart.get_cart_items(request)
transactions = []
total = 0
description = ''
for ci in cart_items:
# create order item for each cart item
total = total + (ci.price()*ci.quantity)
description = '|'.join([description,ci.product.name])
transactions.append({
'amount':{
'total':str(total),
"currency":"USD"
},
'description':ci.product.name
})
return transactions
def show_cart(request, template_name="cart.html"):
""" view function for the page displaying the customer shopping cart, and allows for the updating of quantities
and removal product instances
"""
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
## if postdata['submit'] == 'Checkout':
## checkout_url = checkout.get_checkout_url(request)
## return HttpResponseRedirect(checkout_url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
return render_to_response(template_name, locals())
def create_order(request):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from accounts import profile
profile.fill(request)
# mail the managers
mail_manager_subject = '{0} has been placed!'.format(order)
mail_manager_message = '{0} has been placed by {1}.\n\nClick here: {2}'.format(
order, order.user if order.user else 'anonymous',
request.build_absolute_uri(
reverse('admin:checkout_order_change', args=(order.pk, ))))
mail_managers(mail_manager_subject, mail_manager_message)
# mail the customer
if order.email:
# FIXME: someday make templates for these emails
mail_customer_subject = 'Thank you for placing {0}!'.format(order.name)
mail_customer_message = '{0} was placed by you. Click here for more details: {1}\n\nThank you for your order!\n\n{2}'.format(
order.name, request.build_absolute_uri(order.get_absolute_url()),
settings.SITE_NAME)
send_mail(mail_customer_subject, mail_customer_message,
settings.DEFAULT_FROM_EMAIL, [order.email])
# return the new order object
return order
def show_cart(request, template_name="cart/cart.html"):
request.session.set_test_cookie()
next1 = ''
recent_views = stats.recommended_from_views(request)
if request.method == 'POST':
print(request.session['cart_id'])
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
if pending_checker(request) == 0:
url = reverse('show_checkout', args=['Lipa'])
return HttpResponseRedirect(url)
cart.remove_from_cart(request)
next1 = request.GET.get('next', '')
if len(next1) > 0:
url = reverse('show_checkout', args=[next1])
return HttpResponseRedirect(url)
if postdata['submit'] == 'Update':
if pending_checker(request) == 0:
url = reverse('show_checkout', args=['Lipa'])
return HttpResponseRedirect(url)
try:
int(postdata['quantity'])
cart.update_cart(request)
next1 = request.GET.get('next', '')
if len(next1) > 0:
url = reverse('show_checkout', args=[next1])
return HttpResponseRedirect(url)
except:
if cart.cart_distinct_item_count(request) > 0:
qerror = 'Invalid Quantity Value'
if postdata['submit'] == 'Card Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if postdata['submit'] == 'Mpesa Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if len(next1) > 0:
url = reverse('show_checkout', args=[next1])
return HttpResponseRedirect(url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
return render(request, template_name, locals(), RequestContext(request))
def cart_box(request):
currency_symbol = request.session.get('currency_symbol', '$')
currency_rate = request.session.get('currency_rate', 1)
cart_item_count = cart.cart_distinct_item_count(request)
# return {'cart_item_count' : cart_item_count }
cart_items = cart.get_cart_items(request)
print('++++++++++++++++++++++++')
for c_item in cart_items:
c_item.price = math.floor(
c_item.price() / decimal.Decimal(currency_rate) * 100) / 100
cart_subtotal = cart.cart_subtotal(request)
print(cart_subtotal)
return {
'cart_items': cart_items,
'cart_item_count': cart_item_count,
'cart_subtotal': cart_subtotal,
'currency_symbol': currency_symbol
}
def show_cart(request, template_name="cart/cart.html"):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
# someday consider a modal dialog for this
if postdata['submit'] == 'Remove All':
cart.empty_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
if postdata['submit'] == 'Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if postdata['submit'] == 'Continue Shopping':
return_url = cart.get_return_url(request)
return HttpResponseRedirect(return_url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
return render(request, template_name, locals())
def show_cart(request, template_name="cart/cart.html"):
if request.method == "POST":
postdata = request.POST.copy()
if postdata["submit"] == "Remove":
cart.remove_from_cart(request)
# someday consider a modal dialog for this
if postdata["submit"] == "Remove All":
cart.empty_cart(request)
if postdata["submit"] == "Update":
cart.update_cart(request)
if postdata["submit"] == "Checkout":
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if postdata["submit"] == "Continue Shopping":
return_url = cart.get_return_url(request)
return HttpResponseRedirect(return_url)
cart_items = cart.get_cart_items(request)
page_title = "Shopping Cart"
return render(request, template_name, locals())
def show_cart(request, template_name="cart/cart.djhtml"):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
# someday consider a modal dialog for this
if postdata['submit'] == 'Remove All':
cart.empty_cart(request)
if postdata['submit'] == 'Update':
cart.update_cart(request)
if postdata['submit'] == 'Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if postdata['submit'] == 'Continue Shopping':
return_url = cart.get_return_url(request)
return HttpResponseRedirect(return_url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
return render(request, template_name, locals())
def order_add(request, template_name="/"):
order = Order()
order.date = datetime.datetime.now().strftime("%m/%d/%Y")
order.last_updated = datetime.datetime.now().strftime("%m/%d/%Y")
order.user = request.user
order.ip_address = request.META['REMOTE_ADDR']
print(request.META['REMOTE_ADDR'])
print('-----------------------------')
print(request)
order.transaction_id = 1
order.save()
cart_item_list = cart.get_cart_items(request)
for item in cart_item_list:
order_item = OrderItem()
order_item.product = item.product
order_item.quantity = item.quantity
order_item.price = item.price()
order_item.order = order
order_item.save()
cart.clean(request)
url = urlresolvers.reverse('my_account')
return HttpResponseRedirect(url)
def show_cart(request, template_name="cart/cart.html"):
if request.method == 'POST':
postdata = request.POST.copy()
if postdata['submit'] == 'Remove':
cart.remove_from_cart(request)
if postdata['submit'] == 'Update':
try:
int(postdata['quantity'])
cart.update_cart(request)
except:
if cart.cart_distinct_item_count(request) > 0:
qerror = 'Invalid Quantity Value'
if postdata['submit'] == 'Card Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
if postdata['submit'] == 'Mpesa Checkout':
checkout_url = checkout.get_checkout_url(request)
return HttpResponseRedirect(checkout_url)
cart_items = cart.get_cart_items(request)
page_title = 'Shopping Cart'
cart_subtotal = cart.cart_subtotal(request)
return render(request, template_name, locals(), RequestContext(request))
def create_order(request):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from accounts import profile
profile.fill(request)
# mail the managers
mail_manager_subject = '{0} has been placed!'.format(order)
mail_manager_message = '{0} has been placed by {1}.\n\nClick here: {2}'.format(order, order.user if order.user else 'anonymous', request.build_absolute_uri(reverse('admin:checkout_order_change', args=(order.pk,))))
mail_managers(mail_manager_subject, mail_manager_message)
# mail the customer
if order.email:
# FIXME: someday make templates for these emails
mail_customer_subject = 'Thank you for placing {0}!'.format(order.name)
mail_customer_message = '{0} was placed by you. Click here for more details: {1}\n\nThank you for your order!\n\n{2}'.format(order.name, request.build_absolute_uri(order.get_absolute_url()), settings.SITE_NAME)
send_mail(mail_customer_subject, mail_customer_message, settings.DEFAULT_FROM_EMAIL, [order.email])
# return the new order object
return order
def create_order(request, transaction_id):
""" if the POST to the payment gateway successfully billed the customer,
create a new order containing each CartItem instance, save the order with
the transaction ID from the gateway, and empty the shopping cart
"""
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
# If a User is authenticated, associate the order to their account
if request.user.is_authenticated:
order.user = request.user
order.status = Order.SUBMITTED
order.save()
if order.pk:
""" if the order save succeeded """
cart_items = cart.get_cart_items(request)
for ci in cart_items:
""" create order item for each cart item """
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price # now using @property
oi.product = ci.product
oi.save()
# all set, clear the cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated:
from accounts import profile
profile.set(request)
return order
def create_order(request, transaction_id):
""" if the POST to the payment gateway successfully billed the customer, create a new order
containing each CartItem instance, save the order with the transaction ID from the gateway,
and empty the shopping cart
"""
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
if order.pk:
""" if the order save succeeded """
cart_items = cart.get_cart_items(request)
for ci in cart_items:
""" create order item for each cart item """
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price # now using @property
oi.product = ci.product
oi.save()
# all set, clear the cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from ecomstore.accounts import profile
profile.set(request)
return order
def create_order(request, transaction_id):
postdata = request.POST.copy()
order = Order()
checkout_form = MpesaCheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.billing_name = postdata['shipping_name']
order.billing_address_1 = postdata['shipping_address_1']
order.billing_address_2 = postdata['shipping_address_2']
order.billing_city = postdata['shipping_city']
order.billing_zip = postdata['shipping_zip']
order.billing_country = postdata['shipping_country']
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated:
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price # now using @property
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated:
profile.set(request)
# return the new order object
return order
def cart_items(request):
cart_items_ = cart.get_cart_items(request)
cart_subtotal = cart.cart_subtotal(request)
return {'cart_items_': cart_items_, 'request': request, 'cart_subtotal': cart_subtotal}
def post(self, request, format=None):
params = json.loads(request.body)
step = params.get('step', False)
assert step, "Step value is required"
headers = {'Content-Type': 'text/xml'}
next_step = False
api_key = IrConfigParameters.objects.get_param('nmi_key', 'No key')
note, created = CartNote.objects.get_or_create(
cart_id=_cart_id(request))
note.note = params.get('note', '')
note.shipping_cost = params.get('shipping_cost', 0.00)
note.promotion_code = params.get('promotion_code', "")
note.save()
if step == "step1":
total = params.get('total', 0.00)
redirect_uri = request.build_absolute_uri(
reverse('checkout:make_payment'))
xml_string = '''
<sale>
<api-key>%s</api-key>
<redirect-url>%s</redirect-url>
<amount>%s</amount>
</sale>
''' % (api_key, redirect_uri, total)
result = requests.post('https://secure.nmi.com/api/v2/three-step',
data=xml_string,
headers=headers)
next_step = 'step2'
if not request.user.is_authenticated():
shipping_address = params.get('shipping_address', False)
dob = shipping_address.get('dob', "0000-00-00")
billing_address = params.get('billing_address', False)
odoo_adapter = OdooAdapter()
partner = odoo_adapter.create(
'res.partner', {
'name': shipping_address.get('name', "No Name"),
'website_customer': True,
'classify_finance': 'website',
'acccount_type': 'website',
'type': 'contact',
'email': billing_address.get('email', False),
'phone': billing_address.get('phone', False),
'notify_email': 'none',
'birth_date': dob,
'is_company': False,
})
shipping_partner = odoo_adapter.create(
'res.partner', {
'name': shipping_address.get('name', "No Name"),
'type': 'delivery',
'notify_email': 'none',
'country_id': shipping_address.get('country_id', 0),
'state_id': shipping_address.get('state_id', 0),
'street': shipping_address.get('street', False),
'street2': shipping_address.get('street2', False),
'zip': shipping_address.get('zip', False),
'city': shipping_address.get('city', False),
'website_customer': True,
'notify_email': 'none',
'active': True,
'parent_id': partner,
'is_company': False,
})
billing_partner = odoo_adapter.create(
'res.partner', {
'name': billing_address.get('name', "No Name"),
'type': 'invoice',
'notify_email': 'none',
'country_id': billing_address.get('country_id', 0),
'state_id': billing_address.get('state_id', 0),
'street': billing_address.get('street', False),
'street2': billing_address.get('street2', False),
'zip': billing_address.get('zip', False),
'city': billing_address.get('city', False),
'website_customer': True,
'notify_email': 'none',
'active': True,
'email': billing_address.get('email', False),
'phone': billing_address.get('phone', False),
'parent_id': partner,
'is_company': False,
})
cart_items = get_cart_items(request)
for i in cart_items:
i.partner_id = partner
i.save()
return JsonResponse(data={
'xml_string': result.text,
'next_step': next_step,
},
status=int(result.status_code),
safe=True)
def get(self, request):
country_id = int(request.GET.get('country_id', False))
state_id = int(request.GET.get('state_id', False))
country = Country.objects.get(pk=country_id)
address = {
'country_id': country_id,
'zip': request.GET.get('zip', False),
}
response = {
'error': True,
'msg': 'The Cart is Empty.',
}
dob = request.GET.get('dob', "0000-00-00")
dob_parse = datetime.strptime(dob, "%Y-%m-%d")
if not request.COOKIES.get('ac_custom_verified'):
country = Country.objects.get(pk=country_id)
state = State.objects.get(pk=state_id)
data_verify = {
"key": request.agechecker.get('key', ""),
"data": {
"address": request.GET.get('street', 'No Address'),
"city": request.GET.get('city', 'No City'),
"country": country.code,
"dob_day": dob_parse.day,
"dob_month": dob_parse.month,
"dob_year": dob_parse.year,
"first_name": request.GET.get('name', 'No Name'),
"last_name": "",
"state": state.code, # Accepts only two characters
"zip": request.GET.get('zip', 'No zip')
}
}
headers = {'Content-Type': 'application/json'}
res = requests.post('https://api.agechecker.net/v1/create',
data=json.dumps(data_verify),
headers=headers)
res = res.json()
response.update(
{'agechecker': {
'data': data_verify,
'response': res,
}})
else:
response.update(
{'agechecker': {
'response': {
'status': 'accepted'
},
}})
# {"uuid": "MnZFkxUiOjgC1tZVkzn7XcfX6Tmhs2S6", "status": "photo_id"}
# {u'error': {u'message': u'Invalid data length.', u'code': u'invalid_data_length'}}
# {u'error': {u'message': u'DOB is below the minimum age of 18', u'code': u'user_underage'}}
# {u'status': u'accepted', u'uuid': u'lT2jwXSlIDvGSyc4bbGK38W0TbshkN2C'}
cart = get_cart_items(request)
if cart.exists():
cart_items = map(lambda x: (x.product_id, x.quantity), cart)
cart_total = float(request.GET.get('cart_total', 0))
is_business = is_user_business(request.user)
if request.user.is_authenticated():
Partner.objects.filter(
id=request.user.odoo_user.partner_id.id).update(
birth_date=dob_parse)
if is_business:
type = None
if request.user.is_authenticated():
type = request.user.odoo_user.partner_id.classify_finance
if (cart_total > 500) and (type not in [
"wholesale", 'private_label'
]):
response['error'] = False
response['rate'] = 0.00
response['msg'] = "Free Shipping"
return JsonResponse(data=response, status=200, safe=True)
else:
try:
odoo_adapter = OdooAdapter()
resp = odoo_adapter.execute_method(
'rate.fedex.request',
'calculate_rates_for_address',
params_list=[address, cart_items])
rate = resp.get('rate', False)
if rate:
response['error'] = False
response['rate'] = rate
response['msg'] = ""
else:
response['msg'] = resp.get(
'msg',
"We were unable to get the shipment rates. Please contact JJuice directly!"
)
except Exception:
response[
'msg'] = "We were unable to get the shipment rates. Please contact JJuice directly!"
return JsonResponse(data=response, status=200, safe=True)
else:
if cart_total > 55:
response['error'] = False
response['rate'] = 0.00
response['msg'] = "Free Shipping"
return JsonResponse(data=response, status=200, safe=True)
else:
response['error'] = False
response['rate'] = 2.95
response['msg'] = ""
return JsonResponse(data=response, status=200, safe=True)
else:
return HttpResponseNotFound('Sorry! Cart is Empty')
def _build_xml_shopping_cart(request):
doc = Document()
if request.POST:
postdata = request.POST.copy()
card_num = postdata.get('credit_card_number', '')
exp_month = postdata.get('credit_card_expire_month', '')
exp_year = postdata.get('credit_card_expire_year', '')
exp_date = exp_year + '-' + exp_month
cvv = postdata.get('credit_card_cvv', '')
emailaddr = postdata.get('email', '')
# billing info
bname = postdata.get('billing_name', '')
fullname = bname.split(' ')
fname = fullname[0]
if len(fullname) > 1:
lname = fullname[len(fullname) - 1]
bcity = postdata.get('shipping_city', '')
bstate = postdata.get('shipping_state', '')
bzip = postdata.get('shipping_zip', '')
bcountry = postdata.get('shipping_country', '')
baddress1 = postdata.get('billing_address_1', '')
baddress2 = postdata.get('billing_address_2', '')
baddress = str(baddress1) + ' ' + str(baddress2)
# shipping info
sname = postdata.get('shipping_name', '')
sfullname = sname.split(' ')
sfname = sfullname[0]
if len(sfullname) > 1:
slname = sfullname[len(sfullname) - 1]
scity = postdata.get('billing_city', '')
sstate = postdata.get('billing_state', '')
szip = postdata.get('billing_zip', '')
scountry = postdata.get('billing_country', '')
saddress1 = postdata.get('billing_address_1', '')
saddress2 = postdata.get('billing_address_2', '')
saddress = str(saddress1) + ' ' + str(saddress2)
root = doc.createElement('createTransactionRequest')
root.setAttribute('xmlns', 'AnetApi/xml/v1/schema/AnetApiSchema.xsd')
doc.appendChild(root)
merchantauthentication = doc.createElement('merchantAuthentication')
root.appendChild(merchantauthentication)
name = doc.createElement('name')
name_text = doc.createTextNode(str(settings.AUTHNET_LOGIN))
name.appendChild(name_text)
merchantauthentication.appendChild(name)
transactionkey = doc.createElement('transactionKey')
transactionkey_text = doc.createTextNode(str(settings.AUTHNET_KEY))
transactionkey.appendChild(transactionkey_text)
merchantauthentication.appendChild(transactionkey)
transactionrequest = doc.createElement('transactionRequest')
root.appendChild(transactionrequest)
transactiontype = doc.createElement('transactionType')
transactiontype_text = doc.createTextNode(str(settings.AUTHNET_TTYPE))
transactiontype.appendChild(transactiontype_text)
transactionrequest.appendChild(transactiontype)
amount = doc.createElement('amount')
amount_text = doc.createTextNode(str(cart.cart_subtotal(request) / USD))
amount.appendChild(amount_text)
transactionrequest.appendChild(amount)
payment = doc.createElement('payment')
transactionrequest.appendChild(payment)
creditcard = doc.createElement('creditCard')
payment.appendChild(creditcard)
cardnumber = doc.createElement('cardNumber')
cardnumber_text = doc.createTextNode(str(card_num))
cardnumber.appendChild(cardnumber_text)
creditcard.appendChild(cardnumber)
expirationdate = doc.createElement('expirationDate')
expirationdate_text = doc.createTextNode(str(exp_date))
expirationdate.appendChild(expirationdate_text)
creditcard.appendChild(expirationdate)
cardcode = doc.createElement('cardCode')
cardcode_text = doc.createTextNode(cvv)
cardcode.appendChild(cardcode_text)
creditcard.appendChild(cardcode)
order = doc.createElement('order')
transactionrequest.appendChild(order)
invoicenumber = doc.createElement('invoiceNumber')
invoicenumber_text = doc.createTextNode(str(InvNo))
invoicenumber.appendChild(invoicenumber_text)
order.appendChild(invoicenumber)
description = doc.createElement('description')
description_text = doc.createTextNode('Modern Musician Invoice')
description.appendChild(description_text)
order.appendChild(description)
lineitems = doc.createElement('lineItems')
transactionrequest.appendChild(lineitems)
cart_items = cart.get_cart_items(request)
for cart_item in cart_items:
lineitem = doc.createElement('lineItem')
lineitems.appendChild(lineitem)
itemid = doc.createElement('itemId')
itemid_text = doc.createTextNode(str(cart_item.product.id))
itemid.appendChild(itemid_text)
lineitem.appendChild(itemid)
name = doc.createElement('name')
name_text = doc.createTextNode(str(cart_item.name))
name.appendChild(name_text)
lineitem.appendChild(name)
description = doc.createElement('description')
description_text = doc.createTextNode(str(cart_item.description))
description.appendChild(description_text)
lineitem.appendChild(description)
quantity = doc.createElement('quantity')
quantity_text = doc.createTextNode(str(cart_item.quantity))
quantity.appendChild(quantity_text)
lineitem.appendChild(quantity)
price = doc.createElement('unitPrice')
price_text = doc.createTextNode(str(cart_item.price / USD))
price.appendChild(price_text)
lineitem.appendChild(price)
customer = doc.createElement('customer')
transactionrequest.appendChild(customer)
id = doc.createElement('id')
id_text = doc.createTextNode(str(request.user.id))
id.appendChild(id_text)
customer.appendChild(id)
email = doc.createElement('email')
email_text = doc.createTextNode(str(emailaddr))
email.appendChild(email_text)
customer.appendChild(email)
billto = doc.createElement('billTo')
transactionrequest.appendChild(billto)
firstname = doc.createElement('firstName')
firstname_text = doc.createTextNode(str(fname))
firstname.appendChild(firstname_text)
billto.appendChild(firstname)
lastname = doc.createElement('lastName')
lastnmae_text = doc.createTextNode(str(lname))
lastname.appendChild(lastnmae_text)
billto.appendChild(lastname)
address = doc.createElement('address')
address_text = doc.createTextNode(baddress)
address.appendChild(address_text)
billto.appendChild(address)
city = doc.createElement('city')
city_text = doc.createTextNode(str(bcity))
city.appendChild(city_text)
billto.appendChild(city)
state = doc.createElement('state')
state_text = doc.createTextNode(str(bstate))
state.appendChild(state_text)
billto.appendChild(state)
zip = doc.createElement('zip')
zip_text = doc.createTextNode(str(bzip))
zip.appendChild(zip_text)
billto.appendChild(zip)
country = doc.createElement('country')
country_text = doc.createTextNode(str(bcountry))
country.appendChild(country_text)
billto.appendChild(country)
shipto = doc.createElement('shipTo')
transactionrequest.appendChild(shipto)
firstname = doc.createElement('firstName')
firstname_text = doc.createTextNode(str(sfname))
firstname.appendChild(firstname_text)
shipto.appendChild(firstname)
lastname = doc.createElement('lastName')
lastnmae_text = doc.createTextNode(str(slname))
lastname.appendChild(lastnmae_text)
shipto.appendChild(lastname)
address = doc.createElement('address')
address_text = doc.createTextNode(saddress)
address.appendChild(address_text)
shipto.appendChild(address)
city = doc.createElement('city')
city_text = doc.createTextNode(str(scity))
city.appendChild(city_text)
shipto.appendChild(city)
state = doc.createElement('state')
state_text = doc.createTextNode(str(sstate))
state.appendChild(state_text)
shipto.appendChild(state)
zip = doc.createElement('zip')
zip_text = doc.createTextNode(str(szip))
zip.appendChild(zip_text)
shipto.appendChild(zip)
country = doc.createElement('country')
country_text = doc.createTextNode(str(scountry))
country.appendChild(country_text)
shipto.appendChild(country)
return doc.toxml(encoding='utf-8')
def getOrder(request, type):
categories = Category.objects.filter(is_active=True)
brands = Brand.objects.filter(is_active=True)
if request.method == 'POST':
postdata = request.POST.copy()
try:
address = postdata.get('address')
except:
address = ' '
name = postdata.get('namefield')
phone = postdata.get('phone')
delivery = postdata.get('delivery')
payment = postdata.get('payment')
# post form sends a string value
if delivery == 'True':
delivery = True
else:
delivery = False
if payment == 'True':
payment = True
else:
payment = False
p = 0
if int(type) == 0:
total = cart.cart_subtotal(request)
else:
p = Product.objects.get(id=type)
p.quantity -= 1
p.save()
total = p.price
newOrder = Order(name=name, phone=phone, address=address, total=total, is_card_payment=payment,
is_delivery=delivery)
newOrder.save()
if int(type) == 0:
oCart = cart.get_cart_items(request)
for ci in oCart:
oi = OrderItem(product=ci.product, order=newOrder, quantity=ci.quantity)
oi.save()
ci.product.quantity -= ci.quantity
ci.product.save()
cart.empty_cart(request)
else:
oi = OrderItem(product=p, order=newOrder, quantity=1)
oi.save()
context = {
'id': newOrder.id,
'opened': newOrder.opened_at,
'success': True,
'cart_distinct': 0,
'categories': categories,
'brands': brands,
}
else:
cart_distinct = cart.cart_distinct_item_count(request)
context = {
'success': False,
'cart_distinct': cart_distinct,
'categories': categories,
'brands': brands,
}
return HttpResponse(render_to_response('checkout-success.html', context, context_instance=RequestContext(request)))
def edit_model(request,model,id,template_name=""):
page=request.GET.get('page')
if request.method == 'POST':
print(request.POST)
print('edit')
if model == 'category':
category = get_object_or_404(Category, id=id)
postdata = request.POST.copy()
category.name = postdata.get('name')
category.slug = slug(category.name)
category.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
category.description = postdata.get('description')
is_active = postdata.get('is_active')
if is_active == "True":
category.is_active = True
else:
category.is_active = False
category.save()
print('edit category')
elif model == 'subcategory':
subcategory = get_object_or_404(SubCategory, id=id)
subcategory.name = request.POST.get('name')
subcategory.description = request.POST.get('description')
subcategory.slug = slug(subcategory.name)
is_active = request.POST.get('is_active')
subcategory.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
if is_active=="True":
subcategory.is_active = True
else:
subcategory.is_active = False
subcategory.categories.clear()
selected_c = json.loads(request.POST.get('selected_categories'))
for s_c in selected_c:
c = get_object_or_404(Category, slug=s_c)
subcategory.categories.add(c)
subcategory.save()
print('edit subcategory')
elif model == 'product':
p = get_object_or_404(Product, id=id)
postdata = request.POST.copy()
p.name = postdata.get('name')
product_name = postdata.get('name')
p.brand = postdata.get('brand')
p.sku = postdata.get('sku')
p.price = postdata.get('price')
p.old_price = postdata.get('old_price')
p.quantity = postdata.get('quantity')
p.description = postdata.get('description')
user = get_object_or_404(MyUser, username=postdata.get('user'))
p.user = user
p.slug = slug(p.name)
is_active = request.POST.get('is_active')
if is_active=="True":
p.is_active = True
else:
p.is_active = False
p.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
if request.FILES:
print('image_exist')
## delete image ###
os.remove(MEDIA_ROOT+'images/products/thumbnails/'+p.image)
os.remove(MEDIA_ROOT+'images/products/main/'+p.image)
###################
p_main_file=request.FILES['img']
file_extention = os.path.splitext(str(request.FILES['img']))[1]
# print(file_extention)
# file_name = str(request.FILES['img']).split('.')
# file_extention = file_name[len(file_name)-1]
image_name = str(user)+'_'+p.name+file_extention
p_thumbnail_file=request.FILES['img']
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'wb+') as destination:
if p_thumbnail_file.multiple_chunks():
for chunk in p_thumbnail_file.chunks():
destination.write(chunk)
else:
destination.write(p_thumbnail_file.read())
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'rb+') as destination:
image_file = destination.read()
with open(MEDIA_ROOT+'images/products/main/'+image_name, 'wb+') as destination:
destination.write(image_file)
p.image=image_name
else:
print('image_empty')
# p.save()
p.subcategories.clear()
selected_subc = json.loads(request.POST.get('selected_subcategories'))
for p_subc in selected_subc:
subc = get_object_or_404(SubCategory, slug=p_subc)
p.subcategories.add(subc)
p.save()
print('edit product')
elif model == 'myuser':
user = get_object_or_404(MyUser, id=id)
postdata = request.POST.copy()
# print(postdata)
user.username = postdata.get('name')
user.first_name = postdata.get('first_name')
user.last_name = postdata.get('last_name')
user.date_of_birth = postdata.get('date_of_birth')
user.address = postdata.get('address')
user.telephone = postdata.get('telephone')
# user.password = make_password(postdata.get('password'))
is_active = postdata.get('is_active')
if is_active=="True":
user.is_active = True
else:
user.is_active = False
is_staff = postdata.get('is_staff')
if is_staff=="True":
user.is_staff = True
else:
user.is_staff = False
is_superuser = postdata.get('is_superuser')
if is_superuser=="True":
user.is_superuser = True
else:
user.is_superuser = False
user.user_permissions.clear()
selected_permissions= json.loads(request.POST.get('selected_permissions'))
for s_p in selected_permissions:
perm = get_object_or_404(Permission, codename=s_p)
user.user_permissions.add(perm)
user.save()
print('edit myuser')
elif model == 'order':
order = get_object_or_404(Order, id=id)
postdata = request.POST.copy()
myuser = get_object_or_404(MyUser, username=postdata.get('user'))
order.address = myuser.address
order.phone = myuser.telephone
order_status = get_object_or_404(OrderStatus, id= postdata.get('status'))
order.status = order_status
order.ip_address = postdata.get('ip_address')
order.user = myuser
order.transaction_id = postdata.get('transaction_id')
order.last_updated = datetime.datetime.now().strftime("%m/%d/%Y")
order.save()
print(order.id);
item = OrderItem.objects.filter(order=order)
for i in item:
i.delete()
cart_items = cart.get_cart_items(request)
for c in cart_items:
orderitem = OrderItem()
orderitem.product = c.product
orderitem.price = c.price()
orderitem.quantity = c.quantity
orderitem.order = order
orderitem.save()
print('edit order')
elif model == 'orderitem':
orderitem = get_object_or_404(OrderItem, id=id)
postdata = request.POST.copy()
product = get_object_or_404(Product, slug=postdata.get('product'))
orderitem.product = product
orderitem.price = product.price
orderitem.quantity = postdata.get('quantity')
order = get_object_or_404(Order, id=postdata.get('order'))
orderitem.order = order
orderitem.save()
print('edit orderitem')
url = urlresolvers.reverse('model',kwargs = {'model':model})+'?page='+page
return HttpResponseRedirect(url)
# return show_model(request,model,page,'')
else:
app_list = permission_app(request)
# print('_________________edit_permission_________________')
if check_permission(request,'edit',model):
if model == 'category':
category = get_object_or_404(Category, id=id)
elif model == 'subcategory':
category = Category.objects.all()
subcategory = get_object_or_404(SubCategory, id=id)
print('subcategory')
categories = []
for cate in subcategory.categories.all():
categories.append(slug(cate.name))
categories = json.dumps(categories)
# print(categories)
elif model == 'product':
user_list = MyUser.objects.all()
subcategory = SubCategory.objects.all()
product = get_object_or_404(Product, id=id)
subcategories = []
for subc in product.subcategories.all():
subcategories.append(slug(subc.name))
subcategories = json.dumps(subcategories)
print('product')
# print(subcategories)
elif model == 'myuser':
print('myuser')
myuser = get_object_or_404(MyUser, id=id)
user_permissions = myuser.get_all_permissions()
all_permissions = Permission.objects.all()
# for a in all_permissions:
# print (a.codename)
selected_permissions = []
for s_p in user_permissions:
s_p_list = s_p.split('.')
selected_permissions.append(s_p_list[1])
selected_permissions = json.dumps(selected_permissions)
# print(selected_permissions)
# print('--------permission------------')
# print(all_permissions)
elif model == 'order':
user_list = MyUser.objects.all()
order = get_object_or_404(Order, id=id)
product = Product.objects.all()
order_status = OrderStatus.objects.all()
orderitem = OrderItem.objects.filter(order = order)
print(orderitem)
cart.clean(request)
for o_i in orderitem:
cart.add_orderitem_to_cart(o_i,request)
cart_items = cart.get_cart_items(request)
cart_items_list = []
for c in cart_items:
# print(c)
item = {}
item.setdefault('image',c.image())
item.setdefault('name',c.name())
item.setdefault('quantity',c.quantity)
price = str(c.price())
item.setdefault('price',price)
total = str(c.total())
item.setdefault('total',total)
item.setdefault('id',c.id)
# print(item)
cart_items_list.append(item)
# print(order.status)
# print(order.ORDER_STATUSES[0][1])
print('order')
elif model == 'orderitem':
product = Product.objects.all()
order_list = Order.objects.all()
orderitem = get_object_or_404(OrderItem, id=id)
cart.clean(request)
for o in orderitem:
cart.add_orderitem_to_cart(o)
cart_items = CartItem
print('orderitem')
# subcategories = SubCategory.objects.all()
template_name = 'myadmin/edit/'+model+'.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
else:
template_name = 'myadmin/err.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
def add_model(request,model,template_name=""):
# show_model(request,model,template_name)
# print();
result = "";
if request.method == 'POST':
print('add')
if request.POST.get('mode')=='add_cart_item':
cart.add_to_cart(request)
cart_items_list = []
cart_items = cart.get_cart_items(request)
# serializers.serialize("json", )
cart_item_count = cart.cart_distinct_item_count(request)
# result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
# print(cart_item_count)
for c in cart_items:
# print(c)
item = {}
item.setdefault('image',c.image())
item.setdefault('name',c.name())
item.setdefault('quantity',c.quantity)
price = str(c.price())
item.setdefault('unit_price',price)
total = str(c.total())
item.setdefault('total_price',total)
item.setdefault('id',c.id)
# print(item)
cart_items_list.append(item)
# print(cart_items_list)
# cart_items = serializers.serialize("json", cart_items_list)
# print(cart_items)
result = {'cart_items' : cart_items_list ,'cart_item_count' : cart_item_count}
# print(json.dumps(result))
print('++++++++++++++++++++++++++++++')
return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
else:
if model == 'people':
name = request.POST.get('name')
islug = slug(name)
category = Category()
category.name = name
category.description = request.POST.get('description')
is_active = request.POST.get('is_active')
if is_active=="on":
category.is_active = True
else:
category.is_active = False
category.slug = islug
category.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
category.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
category.save()
result = "saved"
print('add people')
elif model == 'subcategory':
subcategory = SubCategory()
subcategory.name = request.POST.get('name')
subcategory.description = request.POST.get('description')
subcategory.slug = slug(subcategory.name)
is_active = request.POST.get('is_active')
subcategory.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
subcategory.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
if is_active=="on":
subcategory.is_active = True
else:
subcategory.is_active = False
subcategory.save()
selected_c = json.loads(request.POST.get('selected_categories'))
for s_c in selected_c:
c = get_object_or_404(Category, slug=s_c)
subcategory.categories.add(c)
subcategory.save()
print('add subcategory')
elif model == 'product':
p = Product()
postdata = request.POST.copy()
p.name = postdata.get('name','a')
product_name = postdata.get('name','a')
p.brand = postdata.get('brand')
p.sku = postdata.get('sku')
p.price = postdata.get('price')
p.old_price = postdata.get('old_price')
p.quantity = postdata.get('quantity')
p.description = postdata.get('description')
# print(postdata.get('user'))
user = get_object_or_404(MyUser, username=postdata.get('user'))
p.user = user
p.slug = slug(p.name)
is_active = request.POST.get('is_active')
if is_active=="on":
p.is_active = True
else:
p.is_active = False
p.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
p.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
if request.FILES:
print('image_exist')
p_main_file=request.FILES['img']
file_extention = os.path.splitext(str(request.FILES['img']))[1]
# print(file_extention)
# file_name = str(request.FILES['img']).split('.')
# file_extention = file_name[len(file_name)-1]
image_name = str(user)+'_'+p.name+file_extention
p_thumbnail_file=request.FILES['img']
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'wb+') as destination:
if p_thumbnail_file.multiple_chunks():
for chunk in p_thumbnail_file.chunks():
destination.write(chunk)
else:
destination.write(p_thumbnail_file.read())
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'rb+') as destination:
image_file = destination.read()
with open(MEDIA_ROOT+'images/products/main/'+image_name, 'wb+') as destination:
destination.write(image_file)
p.image=image_name
else:
print('image_empty')
p.image='default'
p.save()
selected_subc = json.loads(request.POST.get('selected_subcategories'))
for p_subc in selected_subc:
subc = get_object_or_404(SubCategory, slug=p_subc)
p.subcategories.add(subc)
p.save()
print('add product')
elif model == 'myuser':
user = MyUser()
postdata = request.POST.copy()
user.username = postdata.get('name')
user.first_name = postdata.get('first_name')
user.last_name = postdata.get('last_name')
##########change date format###########YYYY-MM-DD
# date_of_birth = postdata.get('date_of_birth')
# date_list = date_of_birth.split('/')
# join_str = '-'
# user.date_of_birth = join_str.join(date_list)
user.date_of_birth = postdata.get('date_of_birth')
########################################
user.address = postdata.get('address','a')
user.telephone = postdata.get('telephone')
user.password = make_password(postdata.get('password'))
user.is_active = True
user.is_staff = True
user.save()
print('add myuser')
elif model == 'order':
order = Order()
postdata = request.POST.copy()
myuser = get_object_or_404(MyUser, username=postdata.get('user'))
print(postdata)
order.address = myuser.address
order.phone = myuser.telephone
order_status = get_object_or_404(OrderStatus, id=postdata.get('status'))
print(order_status.name)
order.status = order_status
order.ip_address = postdata.get('ip_address')
# user = get_object_or_404(MyUser, username=postdata.get('user'))
order.user = myuser
order.transaction_id = postdata.get('transaction_id')
order.last_updated = datetime.datetime.now().strftime("%m/%d/%Y")
order.save()
print(order.id);
cart_items = cart.get_cart_items(request)
for c in cart_items:
orderitem = OrderItem()
orderitem.product = c.product
orderitem.price = c.price()
orderitem.quantity = c.quantity
orderitem.order = order
orderitem.save()
print('add order')
elif model == 'orderitem':
orderitem = OrderItem()
postdata = request.POST.copy()
product = get_object_or_404(Product, slug=postdata.get('product'))
orderitem.product = product
orderitem.price = product.price
orderitem.quantity = postdata.get('quantity')
order = get_object_or_404(Order, id=postdata.get('order'))
orderitem.order = order
orderitem.save()
print('add orderitem')
# return show_model(request,model,'')
url = urlresolvers.reverse('model',kwargs = {'model':model})
return HttpResponseRedirect(url)
else:
app_list = permission_app(request)
# print('_________________addpermission_________________')
if check_permission(request,'add',model):
if model == 'people':
print('category')
elif model == 'subcategory':
category = Category.objects.all()
print('subcategory')
elif model == 'product':
user_list = MyUser.objects.all()
subcategory = SubCategory.objects.all()
print('product')
print(subcategory)
elif model == 'myuser':
print('myuser')
elif model == 'order':
cart.clean(request)
user_list = MyUser.objects.all()
product = Product.objects.all()
order_status = OrderStatus.objects.all()
# print(request.GET)
# print('-------------------------------')
# cart.add_to_cart(request)
# cart_items = serializers.serialize("json", cart.get_cart_items(request))
# cart_item_count = cart.cart_distinct_item_count(request)
# result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
# print(result)
# print('++++++++++++++++++++++++++++++=')
# return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
print('order')
elif model == 'orderitem':
product = Product.objects.all()
order_list = Order.objects.all()
print('orderitem')
# subcategories = SubCategory.objects.all()
template_name = 'myadmin/add/'+model+'.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
else:
template_name = 'myadmin/err.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
