def purchase():
form = PurchaseForm()
oracle_connection_string = 'oracle+cx_oracle://{username}:{password}@{host}:{port}/{sid}'
engine = create_engine(oracle_connection_string.format(
username="******",
password="******",
sid="XE",
host="localhost",
port="1521",
database="XE",
), echo=True)
with engine.connect() as conn:
global event_name
event_name = re.search(r"[a-zA-z0-9]+", event_name).group(0)
price = conn.execute(
"SELECT PRICE FROM EVENTS WHERE EVENT_NAME = '" + event_name + "'").fetchone()
form.price.label = "price: " + str(price[0])
tickets_left = conn.execute(
"SELECT QUANTITY_TIC FROM EVENTS WHERE EVENT_NAME = '" + event_name + "'").fetchone()
form.tickets_left.label = "tickets left: " + str(tickets_left[0])
global event_time
event_time = conn.execute(
"SELECT EVENT_TIME FROM EVENTS WHERE EVENT_NAME = '" + event_name + "'").fetchone()
form.event_time.label = "event time: " + str(event_time[0])
if form.is_submitted():
try:
int_tickets_left = tickets_left[0] - 1
with engine.connect() as conn:
global client_phone
conn.execute(
"INSERT INTO GUESTS(client_phone, event_name, event_time) VALUES('" + str(
client_phone) + "', '" + str(
event_name) + "', " + "TO_DATE('" + str(event_time[0]) + "', 'YYYY-MM-DD HH24:MI:SS'))")
conn.execute("UPDATE events SET quantity_tic = " + str(int_tickets_left) + " WHERE event_name = '" + event_name + "'")
global candidate
global chats
chats.append(candidate)
return redirect(url_for('success'))
except Exception:
return redirect(url_for("select_event"))
return render_template('purchase.html', form=form)
def purchase_add(request):
if request.method == 'POST':
form = PurchaseForm(request.POST)
p_sn = generate_sn(prefix = 'PR')
if form.is_valid():
p = form.save(commit=False)
p.sn = p_sn
p.save()
serializer = JSONSimpleSerializer()
return HttpResponse(serializer.serialize([p,], use_natural_foreign_keys=True))
else:
form = PurchaseForm()
return render_to_response('modal/main_form.html',{'action':'Add', 'module':module, 'form': form},context_instance=RequestContext(request))
def purchase(request, product_id):
if request.method == 'POST':
form = PurchaseForm(request.POST)
if form.is_valid():
url = "https://careers.undercovertourist.com/assignment/1/products/" + product_id + "/purchase"
data = {
"customer_email": form.cleaned_data['customer_email'],
"customer_name": form.cleaned_data['customer_name'],
"customer_phone": form.cleaned_data['customer_phone'],
"quantity": form.cleaned_data['quantity']
}
fail_context = {
'quantity': form.cleaned_data['quantity'],
'inventory': get_quantity(product_id)
}
if form.cleaned_data['quantity'] > get_quantity(product_id):
return render(request, 'undercovertourist_app/Fail.html',
fail_context)
result = requests.post(url, data=data, headers=headers)
print result.json()
product = get_productdetails(product_id)
customerpurchase = Customer_purchasedata(
customer_email=form.cleaned_data['customer_email'],
customer_name=form.cleaned_data['customer_name'],
customer_phone=form.cleaned_data['customer_phone'],
product_name=product['name'],
product_price=product['price'],
quantity=form.cleaned_data['quantity'],
confirmation_code=result.json()['confirmation_code'],
product_id=product_id)
customerpurchase.save()
success_result = result.json()
print success_result['confirmation_code']
print success_result['product']['name']
success_context = {
'confirmation_code': success_result['confirmation_code'],
'product': success_result['product']['name']
}
return render(request, 'undercovertourist_app/success.html',
success_context)
else:
form = PurchaseForm(initial={'item_id': product_id})
return render(request, 'undercovertourist_app/purchase.html',
{'form': form})
def purchase_update(request):
if request.method == 'POST':
postdata = request.POST.copy()
try:
p = PurchaseOrder.objects.get(sn=postdata.pop('sn')[0])
except PurchaseOrder.DoesNotExist:
raise Http404(module + ' not found')
form = PurchaseForm(postdata, instance=p)
print form.errors
if form.is_valid():
p_saved = form.save()
serializer = JSONSimpleSerializer()
return HttpResponse(serializer.serialize([p_saved,],use_natural_foreign_keys=True))
else:
return HttpResponse('Invalid request.')
def product(request, product_id):
prod = get_object_or_404(Product, pk=product_id)
if request.method == 'POST':
form = PurchaseForm(request.POST)
if form.is_valid():
Purchase.objects.create(cart=Cart.get(request),
product=prod,
quantity=form.cleaned_data['quantity'])
messages.success(request, _('Your purchase was successfully added to the Cart'))
else:
form = PurchaseForm(initial={'quantity': 1})
return render(request, 'shopping_cart/product.html',
{
'product': prod,
'form': form
})
def order_submit():
purchase_form = PurchaseForm()
#TODO: save cc form
if purchase_form.submit.data == True:
return redirect('https://www.paypal.com/cgi-bin/webscr')
content = render_template('order.html', purchase_form=purchase_form)
return content
def edit(request, id):
sales = get_object_or_404(Purchase, pk=id)
PurchaseItemFormSet = inlineformset_factory(
Purchase,
PurchaseItem,
formset=MinimumRequiredFormSet,
form=PurchaseItemForm
)
if request.method == "POST":
form = PurchaseForm(request.POST, instance=sales)
formset = PurchaseItemFormSet(
request.POST,
instance=sales,
minimum_forms=1,
minimum_forms_message="At least 1 purchase item is required."
)
if form.is_valid() and formset.is_valid():
purchase = form.save()
items = formset.save()
for item in items:
item.purchase = purchase
item.save()
messages.success(request, 'Record has been saved successfully.')
return HttpResponseRedirect(".")
else:
messages.error(request, 'Failed to save record. Please correct the errors below.', extra_tags='danger')
else:
form = PurchaseForm(instance=sales)
formset = PurchaseItemFormSet(
instance=sales,
minimum_forms=1
)
context = {
'page_header': "Edit Purchase ID: %s" % id,
'page_title': "Edit Purchase ID: %s" % id,
'form': form,
'formset': formset
}
return render(
request,
'purchase/edit.html',
context
)
def return_product_details(product_id):
"""This isnt actually purchasing a product. This is just notifying
the website owner that a customer wants to purchase a product or has
questions about a product."""
form = PurchaseForm()
if form.validate_on_submit():
request = Request.form_to_model(form)
email = []
email.append(request.email)
result = ''
try:
send_email(request.message)
except:
print(
'GOOGLE ACCOUNT SETTINGS FOR LESS SECURE APP SHOULD BE ENABLED'
)
print('GOOGLE ACCOUNT SETTINGS THE DEVICE SHOULD VERIFIED FOR USE')
result = send_confirmation(email)
print(result)
if result == 535:
print(
'GOOGLE ACCOUNT SETTINGS FOR LESS SECURE APP SHOULD BE ENABLED'
)
print('GOOGLE ACCOUNT SETTINGS THE DEVICE SHOULD VERIFIED FOR USE')
elif result == False:
flash('Error. Invalid email address.', 'danger')
return redirect(f'/products/{product_id}')
#request = Request(email=form.email.data, message=message, firstname=firstname, lastname=lastname, product=product_id)
db.session.add(request)
db.session.commit()
return redirect(f'/request/{product_id}')
product = Product.query.get(product_id)
#need to convert an image for html to display
product.prepare_to_show()
product.available = 'Available'
form.product_id.data = product.id
return render_template('product.html', product=product, form=form)
def add(request):
PurchaseItemFormSet = inlineformset_factory(
Purchase,
PurchaseItem,
formset=MinimumRequiredFormSet,
form=PurchaseItemForm
)
if request.method == "POST":
form = PurchaseForm(request.POST)
formset = PurchaseItemFormSet(
request.POST,
minimum_forms=1,
minimum_forms_message="At least 1 purchase item is required."
)
if form.is_valid() and formset.is_valid():
purchase = form.save()
items = formset.save(commit=False)
for item in items:
item.purchase = purchase
item.save()
messages.success(request, 'Record has been saved successfully.')
return HttpResponseRedirect(".")
else:
messages.error(request, 'Failed to save record. Please correct the errors below.', extra_tags='danger')
else:
form = PurchaseForm()
formset = PurchaseItemFormSet(
minimum_forms=1
)
context = {
'page_header': "Add New Purchase",
'page_title': "Add New Purchase",
'form': form,
'formset': formset
}
return render(
request,
'purchase/add.html',
context
)
def wine_purchase_edit(id=None):
form = PurchaseForm()
if form.validate_on_submit():
g.purchase = Purchase.query.filter_by(id = id).first()
g.purchase.store = form.store.data
g.purchase.price = form.price.data
g.purchase.drank = form.drank.data
db.session.add(g.purchase)
db.session.commit()
flash('Purchase edited', 'success')
return redirect(url_for('wine', id=g.purchase.wine_id))
purchase = Purchase.query.filter_by(id = id).first()
form.store.data = purchase.store
form.price.data = purchase.price
form.drank.data = purchase.drank
return render_template('wine_form.html',
title = "Edit wine",
page = 'wine_edit',
action = 'edit',
form = form,
user = g.user)
def wine_purchase(id):
form = PurchaseForm()
if form.validate_on_submit():
g.purchase = Purchase()
g.wine = Wine.query.filter_by(id = id).first()
g.purchase.wine_id = g.wine.id
g.purchase.price = form.price.data
g.purchase.store = form.store.data
g.purchase.drank = form.drank.data
db.session.add(g.purchase)
db.session.commit()
flash('Purchase for '+g.wine.name+' added','success')
return redirect(url_for('wine',id=id))
if not id:
flash('Need a wine id', 'warning')
return redirect(url_for('index'))
wine = Wine.query.get(id)
return render_template('wine_purchase.html',
title = "New Purchase",
form = form,
page = 'wine_purchase',
wine = wine,
user = g.user)
def add_edit_item(request, model_name, add_edit, edit_id):
"""Add/Edit page for the inventory"""
if add_edit == "add":
edit_id = None
if _checkModel(model_name):
directory = "asset_inventory/add_edit_Pages/"
# Adding or Editing a Job
if model_name == "Job":
templateFile = directory + "Job.html"
post_data = request.POST or None
try:
Job_Instance = Job.objects.get(pk=edit_id)
except Job.DoesNotExist:
Job_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Job", "add", "new"]))
Job_Form = JobForm(post_data, instance=Job_Instance)
if Job_Form.is_valid():
Job_Occurance = Job_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Job"]))
return render_to_response(templateFile, {"form": Job_Form}, context_instance=RequestContext(request))
# Adding or Editing a Location
elif model_name == "Location":
templateFile = directory + "Location.html"
post_data = request.POST or None
try:
Location_Instance = Location.objects.get(pk=edit_id)
except Location.DoesNotExist:
Location_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(
reverse("asset_inventory_add_edit_item", args=["Location", "add", "new"])
)
Location_Form = LocationForm(post_data, instance=Location_Instance)
if Location_Form.is_valid():
Location_Occurance = Location_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Location"]))
return render_to_response(templateFile, {"form": Location_Form}, context_instance=RequestContext(request))
# Adding or Editing a Person
elif model_name == "Person":
templateFile = directory + "Person.html"
post_data = request.POST or None
try:
Person_Instance = Person.objects.get(pk=edit_id)
except Person.DoesNotExist:
Person_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Person", "add", "new"]))
Person_Form = PersonForm(post_data, instance=Person_Instance)
if Person_Form.is_valid():
Person_Occurance = Person_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Person"]))
return render_to_response(templateFile, {"form": Person_Form}, context_instance=RequestContext(request))
# Adding or Editing a Purchase
elif model_name == "Purchase":
templateFile = directory + "Purchase.html"
post_data = request.POST or None
try:
Purchase_Instance = Purchase.objects.get(pk=edit_id)
except Purchase.DoesNotExist:
Purchase_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(
reverse("asset_inventory_add_edit_item", args=["Purchase", "add", "new"])
)
Purchase_Form = PurchaseForm(post_data, instance=Purchase_Instance)
if Purchase_Form.is_valid():
Purchase_Occurance = Purchase_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Purchase"]))
return render_to_response(templateFile, {"form": Purchase_Form}, context_instance=RequestContext(request))
# Adding or Editing a Status
elif model_name == "Status":
templateFile = directory + "Status.html"
post_data = request.POST or None
try:
Status_Instance = Status.objects.get(pk=edit_id)
except Status.DoesNotExist:
Status_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Status", "add", "new"]))
Status_Form = StatusForm(post_data, instance=Status_Instance)
if Status_Form.is_valid():
Status_Occurance = Status_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Status"]))
return render_to_response(templateFile, {"form": Status_Form}, context_instance=RequestContext(request))
# Adding or Editing a Esign
elif model_name == "Esign":
templateFile = directory + "Esign.html"
post_data = request.POST or None
try:
Esign_Instance = Esign.objects.get(pk=edit_id)
except Esign.DoesNotExist:
Esign_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Esign", "add", "new"]))
Esign_Form = EsignForm(post_data, instance=Esign_Instance)
if Esign_Form.is_valid():
Esign_Occurance = Esign_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Esign"]))
return render_to_response(templateFile, {"form": Esign_Form}, context_instance=RequestContext(request))
# Adding or Editing a Device
elif model_name == "Device":
templateFile = directory + "Device.html"
post_data = request.POST or None
try:
Device_Instance = Device.objects.get(pk=edit_id)
except Device.DoesNotExist:
Device_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Device", "add", "new"]))
Device_Form = DeviceForm(post_data, instance=Device_Instance)
if Device_Form.is_valid():
Device_Occurance = Device_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Device"]))
return render_to_response(templateFile, {"form": Device_Form}, context_instance=RequestContext(request))
# This is a catch all response, if some unforseen error manages
# to occur with the calling of add/edit pages
else:
render_to_response(reverse("homepage"))
def order():
purchase_form = PurchaseForm()
content = render_template('order.html', purchase_form=purchase_form)
return content
if purchase_form.submit.data == True:
return redirect('https://www.paypal.com/cgi-bin/webscr')
content = render_template('order.html', purchase_form=purchase_form)
return content
@app.route('/payment')
@app.route('/payment')
def payment():
<<<<<<< Updated upstream
content = index()
content += " payment page"
=======
#content = index()
#content += " payment page"
purchase_form = PurchaseForm()
content = render_template('payment.html', purchase_form=purchase_form)
<<<<<<< Updated upstream
<<<<<<< Updated upstream
<<<<<<< Updated upstream
>>>>>>> Stashed changes
=======
>>>>>>> Stashed changes
=======
>>>>>>> Stashed changes
=======
>>>>>>> Stashed changes
return content
@app.route('/payment/<method>', defaults={'method': 'paypal'})
