def getJanuaryOrders(self):
orders = []
try:
# Setup connection to the DB
db_config = read_db_config()
conn = MySQLConnection(**db_config)
cursor = conn.cursor()
# Calls the stored procedure
cursor.callproc('getJanuaryOrders')
udao = UserDao()
cadao = CustomerAddressDao()
pdao = PaymentInfoDao()
# This loop iterates through the resultsets
for result in cursor.stored_results():
# This loop iterates through the rows in each resultset
for x in result.fetchall():
order = RetailOrder()
order.order_id = x[0]
order.date_ordered = x[1]
order.total_price = x[2]
order.discount = x[3]
order.customer = x[4]
orders.append(order)
# Close the connection to the DB
cursor.close()
conn.close()
except Error as error:
print(error)
except Exception as e:
print(e)
return orders
class CustomerCardView(TemplateView):
template_name = 'Store/customer/ccard.html'
udao = UserDao()
pdao = PaymentInfoDao()
cadao = CustomerAddressDao()
rdao = RetailOrderDao()
@never_cache
def get(self,request,card_id):
user_id = request.session['user_id']
username = request.session['username']
card = self.pdao.get_byid(card_id)
orders = self.rdao.getOrdersByCardID(card_id)
intitial_data = {
'street': card.billing_address.street,
'city': card.billing_address.city,
'state_code': card.billing_address.state_code,
'zip_code': card.billing_address.zip_code
}
eaddress = AddAddressForm2(intitial_data)
context = {
'card': card,
'eaddress': eaddress,
'orders': orders
}
context['username'] = username
context['user_id'] = user_id
return render(request, self.template_name, context)
@never_cache
def post(self,request,card_id):
user_id = request.session['user_id']
username = request.session['username']
card = self.pdao.get_byid(card_id)
context={}
eaddress = AddAddressForm2(request.POST)
if 'update-address' in request.POST:
if eaddress.is_valid():
a = CustomerAddress()
a.address_id = card.billing_address.address_id
a.customer_id = user_id
a.street = eaddress.cleaned_data['street']
a.city = eaddress.cleaned_data['city']
a.state_code = eaddress.cleaned_data['state_code']
a.zip_code = eaddress.cleaned_data['zip_code']
a.address_type = 'Billing'
self.cadao.update(a)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse(('customercard'),kwargs={'card_id':card_id}))
else:
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse(('customercard'),kwargs={'card_id':card_id}))
def get_byid(self, order_id):
try:
# Setup connection to the DB
db_config = read_db_config()
conn = MySQLConnection(**db_config)
cursor = conn.cursor()
order = None
args = [order_id]
cadao = CustomerAddressDao()
pdao = PaymentInfoDao()
# Calls the stored procedure
cursor.callproc('getRetailOrderByOrderID', args)
# This loop iterates through the resultsets
for result in cursor.stored_results():
# This loop iterates through the rows in each resultset
for x in result.fetchall():
order = RetailOrder()
order.order_id = x[0]
order.date_ordered = x[1]
order.discount = x[2]
order.total_price = x[3]
order.status = x[4]
u = User()
u.id = x[5]
u.first_name = x[6]
u.last_name = x[7]
order.customer = u
p = PaymentInfo()
p.card_id = x[8]
p.last_four = x[9]
p.card_issuer = x[10]
order.card = p
a = CustomerAddress()
a.address_id = x[11]
a.street = x[12]
a.city = x[13]
a.state_code = x[14]
a.zip_code = x[15]
order.shipping_address = a
# Close the connection to the DB
cursor.close()
conn.close()
except Error as error:
print(error)
except Exception as e:
print(e)
return order
def getOrdersByShippingAddressID(self, addresss_id):
orders = []
try:
# Setup connection to the DB
db_config = read_db_config()
conn = MySQLConnection(**db_config)
cursor = conn.cursor()
args = [addresss_id]
# Calls the stored procedure
cursor.callproc('getOrdersByShippingAddressID', args)
udao = UserDao()
cadao = CustomerAddressDao()
pdao = PaymentInfoDao()
# This loop iterates through the resultsets
for result in cursor.stored_results():
# This loop iterates through the rows in each resultset
for x in result.fetchall():
order = RetailOrder()
order.order_id = x[0]
order.date_ordered = x[1]
order.total_price = x[2]
order.discount = x[3]
order.customer = udao.get_byid(x[4])
order.shipping_address = cadao.get_byid(x[5])
order.card = pdao.get_byid(x[6])
order.status = x[7]
orders.append(order)
# Close the connection to the DB
cursor.close()
conn.close()
except Error as error:
print(error)
except Exception as e:
print(e)
return orders
class CustomerAddressIndexView(TemplateView):
template_name = 'Store/customer/caddressindex.html'
cusadd = CustomerAddress()
cadao = CustomerAddressDao()
@never_cache
def get(self,request):
user_id = request.session['user_id']
username = request.session['username']
caddress = self.cadao.get_all_addresses_by_customer_id(user_id)
aaddress = AddAddressForm()
eaddress = EditAddressForm()
context = {
'caddress': caddress,
'aaddress': aaddress,
'eaddress': eaddress
}
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return render(request, self.template_name,context)
@never_cache
def post(self,request):
user_id = request.session['user_id']
username = request.session['username']
daddress = DeleteAddressForm(request.POST)
aaddress = AddAddressForm(request.POST)
context = {}
if 'add-address' in request.POST:
if aaddress.is_valid():
a = CustomerAddress()
a.customer_id = user_id
a.street = aaddress.cleaned_data['street']
a.city = aaddress.cleaned_data['city']
a.state_code = aaddress.cleaned_data['state_code']
a.zip_code = aaddress.cleaned_data['zip_code']
a.address_type = aaddress.cleaned_data['address_type']
self.cadao.create(a)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse('customeraccount'))
else:
return redirect(reverse('caddpayindex'))
class CustomerOrderView(TemplateView):
template_name = 'Store/customer/corder.html'
odao = RetailOrderDao()
pdao = PaymentInfoDao()
bodao = BookOrderDao()
adao = CustomerAddressDao()
bdao = Book()
@never_cache
def get(self, request, order_id):
order = self.odao.get_byid(order_id)
bookorder = self.bodao.get_byid(order_id)
billing = self.pdao.get_byid(order.card.card_id)
context = {
'order': order,
'bookorder':bookorder,
'billing': billing
}
if order.discount > 0.0:
original_price = round((order.total_price / Decimal(1 - order.discount)), 2)
context['original_price'] = original_price
context['discount'] = round((Decimal(order.discount) * 100), 2)
context['money_saved'] = original_price - order.total_price
context['user_id'] = request.session['user_id']
context['username'] = request.session['username']
return render(request, self.template_name, context)
@never_cache
def post(self,request, order_id):
context = {}
if 'cancel-order' in request.POST:
self.odao.update(order_id)
context['user_id'] = request.session['user_id']
context['username'] = request.session['username']
return redirect(reverse('customeraccount'))
else:
context['user_id'] = request.session['user_id']
context['username'] = request.session['username']
return redirect(reverse('customeraccount'))
class CustomerAddCardView(TemplateView):
template_name = 'Store/customer/addcard.html'
user = User()
udao = UserDao()
customer = CustomerInfo()
cdao = CustomerInfoDAO()
cusadd = CustomerAddress()
cadao = CustomerAddressDao()
payment = PaymentInfo()
pdao = PaymentInfoDao()
@never_cache
def get(self,request):
context={}
user_id = request.session['user_id']
username = request.session['username']
user = self.udao.get_byid(user_id)
customer = self.cdao.get_byid(user_id)
cusadd =CustomerAddress()
cusadd.customer_id = user_id
caddress = self.cadao.get_all_addresses_by_customer_id(user_id)
bill_addresses = self.cadao.get_by_customer_and_type(user_id, "Billing")
bill_address_choices = []
for address in bill_addresses:
address_val = (str(address.address_id), str(address.street) + " " + str(address.city) + ", "
+ str(address.state_code) + " " + str(address.zip_code))
bill_address_choices.append(address_val)
num_bill_address = len(bill_address_choices)
aaddress = AddAddressForm2()
addcard = AddPaymentInfoForm(bill_address_choices=bill_address_choices)
context['addcard'] = addcard
context['aaddress'] = aaddress
context['user_id'] = request.session['user_id']
context['username'] = request.session['username']
context['num_bill_address'] = num_bill_address
return render(request, self.template_name,context)
@never_cache
def post(self,request):
context={}
user_id = request.session['user_id']
username = request.session['username']
bill_addresses = self.cadao.get_by_customer_and_type(user_id, "Billing")
bill_address_choices = []
for address in bill_addresses:
address_val = (str(address.address_id), str(address.street) + " " + str(address.city) + ", "
+ str(address.state_code) + " " + str(address.zip_code))
bill_address_choices.append(address_val)
addcard = AddPaymentInfoForm(request.POST,bill_address_choices=bill_address_choices)
aaddress = AddAddressForm2(request.POST)
if 'add-card' in request.POST:
if addcard.is_valid():
p = PaymentInfo()
p.customer_id = user_id
p.card_number = addcard.cleaned_data['card_number']
p.cvc = addcard.cleaned_data['cvc']
p.expir_date = addcard.cleaned_data['expir_date']
p.card_issuer = addcard.cleaned_data['card_issuer']
p.billing_address.address_id = addcard.cleaned_data['billing_addresses']
self.pdao.create(p)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse('customeraccount'))
elif 'add-address' in request.POST:
if aaddress.is_valid():
a = CustomerAddress()
a.customer_id = user_id
a.street = aaddress.cleaned_data['street']
a.city = aaddress.cleaned_data['city']
a.state_code = aaddress.cleaned_data['state_code']
a.zip_code = aaddress.cleaned_data['zip_code']
a.address_type = 'Billing'
self.cadao.create(a)
context['user_id'] = request.session['user_id']
context['username'] = request.session['username']
return redirect(reverse('customeraddcard'))
else:
return redirect(reverse('customeraccount'))
class CAddressAccountView(TemplateView):
udao = UserDao()
user = User()
cadao = CustomerAddressDao()
customer = CustomerAddress()
padao = PaymentInfoDao()
rdao = RetailOrderDao()
template_name = 'Store/customer/caddressaccount.html'
@never_cache
def get(self,request,address_id):
user_id = request.session['user_id']
username = request.session['username']
address = self.cadao.get_byid(address_id)
payment = self.padao.get_by_address_id(address_id,user_id)
orders = self.rdao.getOrdersByCardID(address_id)
initial_data = {
'street': address.street,
'city': address.city,
'state_code': address.state_code,
'zip_code': address.zip_code,
'address_type': address.address_type
}
eaddress = EditAddressForm(initial_data)
daddress = DeleteAddressForm()
apayment = AddPaymentInfoForm2()
context = {
'address':address,
'eaddress': eaddress,
'payment': payment,
'apayment': apayment,
'daddress': daddress,
'orders': orders
}
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return render(request,self.template_name,context)
@never_cache
def post(self,request,address_id):
user_id = request.session['user_id']
username = request.session['username']
eaddress = EditAddressForm(request.POST)
apayment = AddPaymentInfoForm2(request.POST)
daddress = DeleteAddressForm(request.POST)
address = self.cadao.get_byid(address_id)
user_id = address.customer_id
context = {}
if 'edit-address' in request.POST:
if eaddress.is_valid():
a = CustomerAddress()
a.address_id = address_id
a.customer_id = user_id
a.street = eaddress.cleaned_data['street']
a.city = eaddress.cleaned_data['city']
a.state_code = eaddress.cleaned_data['state_code']
a.zip_code = eaddress.cleaned_data['zip_code']
a.address_type = eaddress.cleaned_data['address_type']
self.cadao.update(a)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse(('customeraddress'), kwargs={'address_id': address_id}))
elif 'add-card' in request.POST:
if apayment.is_valid():
p = PaymentInfo()
p.card_number = apayment.cleaned_data['card_number']
p.cvc = apayment.cleaned_data['cvc']
p.expir_date = apayment.cleaned_data['expir_date']
p.card_issuer = apayment.cleaned_data['card_issuer']
p.customer_id = user_id
p.billing_address.address_id = address_id
self.padao.create(p)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse(('customeraddress'), kwargs={'address_id': address_id}))
elif 'delete-address' in request.POST:
if daddress.is_valid():
a = CustomerAddress()
a.address_id = daddress.cleaned_data['address_id']
a.customer_id = user_id
self.cadao.delete(a)
context['user_id'] = request.session['user_id'],
context['username'] = request.session['username']
return redirect(reverse('customeraccount'))
else:
return redirect(reverse(('customeraddress'), kwargs={'address_id': address_id}))
class CheckOutView(TemplateView):
template_name = 'Store/customer/checkout.html'
retail_order_dao = RetailOrderDao()
payment_dao = PaymentInfoDao()
customer_address_dao = CustomerAddressDao()
cart_dao = CartDao()
@never_cache
def get(self, request):
if 'user_id' in request.session:
if 'payment_choice' in request.session:
# Get data from db to show order summary
payment_choice = self.payment_dao.get_byid(
request.session['payment_choice'])
shipping_choice = self.customer_address_dao.get_byid(
request.session['shipping_choice'])
cart_items = self.cart_dao.get_all(request.session['user_id'])
username = request.session['username']
cart_total = 0
for item in cart_items:
cart_total += (item.total_item_price)
context = {
'payment_choice': payment_choice,
'shipping_choice': shipping_choice,
'cart_items': cart_items,
'cart_total': cart_total,
'user_id': request.session['user_id'],
'username': username
}
if cart_total >= 75:
context['discount_price'] = round(
(cart_total * Decimal(0.9)), 2)
request.session['discount'] = 0.1
else:
request.session['discount'] = 0.0
else:
return redirect(reverse('ship_pay'))
else:
return redirect(reverse('login'))
return render(request, self.template_name, context)
def post(self, request):
retail_order = RetailOrder()
context = {}
if 'place-order' in request.POST:
try:
# Get data from form
retail_order.customer.customer_id = request.session['user_id']
retail_order.shipping_address.address_id = request.POST[
'shipping_choice']
retail_order.card.card_id = request.POST['payment_choice']
retail_order.discount = request.session['discount']
# Submit order information to server
order_id = self.retail_order_dao.create(retail_order)
context['notification'] = "Order made!"
except:
print("Error occured")
context['notification'] = "Error!"
return redirect(reverse('invoice', kwargs={'order_id': order_id}))
class ShipPayView(TemplateView):
template_name = 'Store/customer/shippay.html'
payment_dao = PaymentInfoDao()
customer_address_dao = CustomerAddressDao()
@never_cache
def get(self, request):
context = {}
if 'user_id' in request.session:
user_id = request.session['user_id']
username = request.session['username']
cards = self.payment_dao.get_by_customer_id(user_id)
ship_addresses = self.customer_address_dao.get_by_customer_and_type(
user_id, "Shipping")
# This code organizes the credit card info and shipping info so that the Django form can handle it
# The choice field in the forms class takes a list of tuples for choices
card_choices = []
for card in cards:
card_val = (str(card.card_id), str(card.card_issuer) +
" card ending in " + str(card.last_four))
card_choices.append(card_val)
shipping_choices = []
for address in ship_addresses:
address_val = (str(address.address_id),
str(address.street) + " " + str(address.city) +
", " + str(address.state_code) + " " +
str(address.zip_code))
shipping_choices.append(address_val)
if not card_choices:
context['notification'] = "Fill out your card information!"
elif not shipping_choices:
context['notification'] = "Fill out your shipping information!"
else:
shippay_form = ShipPayForm(card_choices=card_choices,
shipping_choices=shipping_choices)
context['shippay_form'] = shippay_form
context['cards'] = cards
context['user_id'] = user_id
context['username'] = username
else:
return redirect(reverse('login'))
return render(request, self.template_name, context)
def post(self, request):
# Gets form data
context = {}
user_id = request.session['user_id']
username = request.session['username']
cards = self.payment_dao.get_by_customer_id(user_id)
ship_addresses = self.customer_address_dao.get_by_customer_and_type(
user_id, "Shipping")
# This code organizes the credit card info and shipping info so that the Django form can handle it
# The choice field in the forms class takes a list of tuples for choices
card_choices = []
for card in cards:
card_val = (str(card.card_id), str(card.card_issuer) +
" card ending in " + str(card.last_four))
card_choices.append(card_val)
shipping_choices = []
for address in ship_addresses:
address_val = (str(address.address_id), str(address.street) + " " +
str(address.city) + ", " + str(address.state_code) +
" " + str(address.zip_code))
shipping_choices.append(address_val)
shippay_form = ShipPayForm(request.POST,
card_choices=card_choices,
shipping_choices=shipping_choices)
# Validate POST data
if 'review-order' in request.POST:
if shippay_form.is_valid():
# Get choice of payment and shipping address
payment_choice_id = shippay_form.cleaned_data['credit_cards']
shipping_choice_id = shippay_form.cleaned_data[
'shipping_addresses']
request.session['payment_choice'] = payment_choice_id
request.session['shipping_choice'] = shipping_choice_id
context['username'] = request.session['username']
return redirect(reverse('checkout'))