def purchase(request):
if "pokemon" in request.GET:
pokemon = Pokemon.objects.get(pk=float(request.GET["pokemon"]))
if "currently_purchasing" in request.session:
purchase = Purchase.objects.get(pk=request.session["currently_purchasing"])
purchase.pokemons.add(pokemon)
messages.success(request, "Pokemon añadido correctamente.")
return render(request, "index.html", {"pokemons": [pokemon for pokemon in Pokemon.objects.all()]})
else:
purchase = Purchase(user=request.user)
purchase.save()
request.session["currently_purchasing"] = purchase.id
purchase.pokemons.add(pokemon)
messages.success(request, "Pokemon añadido correctamente.")
return render(request, "index.html", {"pokemons": [pokemon for pokemon in Pokemon.objects.all()]})
elif "clean" not in request.GET:
if "currently_purchasing" in request.session:
purchase = Purchase.objects.get(pk=request.session["currently_purchasing"])
return render(request, "purchase.html", { "purchase_pokemons": purchase.pokemons.all() })
else:
return render(request, "purchase.html")
if "clean" in request.GET:
if "currently_purchasing" in request.session:
purchase = Purchase.objects.get(pk=request.session["currently_purchasing"])
purchase.delete()
del request.session["currently_purchasing"]
messages.success(request, "Pedido borrado correctamente.")
return render(request, "index.html", {"pokemons": [pokemon for pokemon in Pokemon.objects.all()]})
def test_save(self):
stuff = FoodStuff(name = 'some stuff')
stuff.save()
provider = FoodProvider(name='some provider')
provider.save()
purchase = Purchase(
provider = provider,
stuff = stuff,
cost = 100,
unit_count = 10,
unit_size = 1,
)
purchase.save()
self.assertEqual(3, purchase.transactions.count())
self.assertEqual(10, stuff.material_account.balance())
self.assertEqual(100, stuff.monetary_account.balance())
self.assertEqual(-10, provider.material_account.balance())
main_cashbox = get_main_cashbox()
self.assertEqual(-100, main_cashbox.account.balance())
def setUp(self):
self.stuff = FoodStuff(name='some stuff 3')
self.stuff.save()
recipe = Recipe(name='some recipe 3')
recipe.save()
ingredient = RecipeIngredient(
stuff = self.stuff,
recipe = recipe,
count = 1.5
)
ingredient.save()
self.product = Product(
name = 'some product 3',
recipe = recipe,
markup = 1.5
)
self.product.save()
provider = FoodProvider(name='some provider')
provider.save()
purchase = Purchase(
provider = provider,
stuff = self.stuff,
cost = 200,
unit_count = 10,
unit_size = 1,
)
purchase.save()
self.offer = SaleOffer(product=self.product)
self.offer.save()
def checkout(request):
cart = []
if request.POST:
cj = request.POST.get("cart")
else:
cj = request.GET.get("cart")
# Open cash drawer
fail = False
for f in json.loads(cj):
try:
product = Product.objects.get(pk=f['id'])
if f['num'] > product.stocked:
fail = True
cart.append({
'product': product,
'amount': f['num'],
'price': f['num'] * product.price,
})
except Product.DoesNotExist:
continue
if request.POST:
purchase = Purchase()
purchase.salesperson = request.user
purchase.total = sum([i['product'].price * i['amount'] for i in cart])
purchase.save()
for i in cart:
i['product'].stocked -= i['amount']
i['product'].save()
ProductPurchase.objects.create(
purchase=purchase,
product=i['product'],
amount=i['amount'])
template = loader.get_template('cashdesk/bon.txt')
context = RequestContext(
request,
{
'purchase': purchase,
'productpurchases': ProductPurchase.objects.filter(
purchase=purchase),
}
)
bon = template.render(context)
printer.print_and_cut(
request.session['printer'],
bon, True)
return HttpResponseRedirect("/")
ctx = {
'cart': cart,
'fail': fail,
'cartjson': request.GET.get("cart"),
'total': sum([i['product'].price * i['amount'] for i in cart]),
}
return render(request, 'cashdesk/checkout.html', ctx)
def test_create(self):
provider = FoodProvider(name='some provider')
provider.save()
purchase = Purchase(
provider = provider,
stuff = self.stuff,
cost = 200,
unit_count = 10,
unit_size = 1,
)
purchase.save()
check = Calculation.create(self.offer, self.ingredient)
self.assertEqual(1.5, check.material_count)
self.assertTrue(check.feasible)
self.assertEqual(30, check.monetary_count)
def save(self, commit=True):
item = super(customerForm, self).save(commit=False)
item.set_password(self.cleaned_data["password"])
account = Account(name=self.cleaned_data["name"], access=self.cleaned_data["access"],
args2=self.cleaned_data["args2"], num_threads=self.cleaned_data["num_threads"])
purchase = Purchase(startDate=self.cleaned_data["startDate"], endDate=self.cleaned_data["endDate"],
initial=self.cleaned_data["initial"], available=self.cleaned_data["initial"])
if commit:
item.save()
self.save_m2m()
account.customer = item
account.save()
purchase.account = account
purchase.save()
return item
def purchase_item(request, item_id):
if request.method == 'POST':
item = get_object_or_404(Item, id=item_id)
form = PurchaseForm(request.POST)
if form.is_valid():
bidder = form.cleaned_data['bidder']
unit_price = item.unit_price if item.fixed_price else form.cleaned_data['unit_price']
quantity = form.cleaned_data['quantity']
if bidder and item and (quantity <= item.quantity_remaining() or item.quantity_remaining() == -1):
p = Purchase(bidder=bidder, item=item, quantity=quantity, unit_price=unit_price)
p.save()
messages.info(request, "%s successfully purchased %s" % (bidder.name, item.name))
return redirect(item)
else:
messages.error(request, "Invalid Form %s" % form.errors)
messages.error(request, "Unable to complete purchase.")
return redirect(item) #TODO go back to form with errors
return redirect('/')
def pay_for_a_plan_success(request,pending_purchase,context,user_existing_coupons,selected_plan):
# add the purchase to the database
new_purchase = Purchase()
new_purchase.user = pending_purchase.user
new_purchase.data_transfer_plan = pending_purchase.data_transfer_plan
if user_existing_coupons:
new_purchase.amount_paid = selected_plan.discounted_price
else:
new_purchase.amount_paid = selected_plan.original_price
new_purchase.remaining_allowance_frequency = pending_purchase.data_transfer_plan.freq
new_purchase.save()
# save follow_up number using hash
follow_up_number = generate_md5_hash(str(new_purchase.id))
new_purchase.follow_up_number = follow_up_number
new_purchase.save()
context['follow_up_number'] = follow_up_number
# if necessary, remove user's best coupon
if user_existing_coupons:
best_coupon = utility_functions.get_best_coupon(user_existing_coupons)
best_coupon.delete()
# send an email
plaintext = loader.get_template('payment/pay_for_a_plan_complete_email.txt')
htmly = loader.get_template('payment/pay_for_a_plan_complete_email.html')
subject = loader.get_template('payment/pay_for_a_plan_complete_email_subject.html')
subject_content = subject.render(context).replace('\n',' ')
text_content = plaintext.render(context)
html_content = htmly.render(context)
from_email = '*****@*****.**'
recipient_list = [new_purchase.user.email]
msg = EmailMultiAlternatives(subject_content, text_content, from_email, recipient_list)
msg.attach_alternative(html_content, "text/html")
msg.send()
# return response to the user.
return render(request,'payment/successful_payment.html',context)
def test_gets(self):
stuff = FoodStuff(name='foobar 2')
stuff.save()
self.assertEqual(0, stuff.get_material_count())
self.assertEqual(0, stuff.get_unit_cost())
self.assertFalse(stuff.is_feasible())
provider = FoodProvider(name='some provider')
provider.save()
purchase = Purchase(
provider = provider,
stuff = stuff,
cost = 200,
unit_count = 10,
unit_size = 1,
)
purchase.save()
self.assertEqual(10, stuff.get_material_count())
self.assertEqual(20, stuff.get_unit_cost())
self.assertTrue(stuff.is_feasible())
def viewSingleOrderOpportunity(request, pk):
"""Displays the contents of a single OrderOpportunity"""
if request.method == "GET":
try:
order = Order.objects.filter(order_opportunity=pk).get(user=request.user)
order_opportunity = OrderOpportunity.objects.get(pk=pk)
purchases = Purchase.objects.filter(order__user=request.user).filter(order__order_opportunity=pk)
PurchaseFormSet = formset_factory(PurchaseForm, extra=0)
formset_initial_data = [{'qty': i.qty,
'product_pk': i.pk,
'price': i.product_for_sale.price,
#'price': i.qty * i.product_for_sale.price,
'name': i.product_for_sale.name} for i in purchases]
formset = PurchaseFormSet(initial=formset_initial_data)
total = reduce(lambda x, y: x+y, [p.qty * p.product_for_sale.price for p in purchases], 0)
total = total + order_opportunity.fuel_surcharge
return render_to_response('ReadOnlyOrder.html',
{'order_opportunity': order_opportunity,
'formset': formset,
'total': total},
context_instance=RequestContext(request))
except Order.DoesNotExist:
order_opportunity = OrderOpportunity.objects.get(pk=pk)
products_for_sale = ProductForSale.objects.filter(order_opportunity=pk)
PurchaseFormSet = formset_factory(PurchaseForm, extra=0)
formset_initial_data = [{'product_pk': i.pk,
'price': i.price,
'name': i.name} for i in products_for_sale]
formset = PurchaseFormSet(initial=formset_initial_data)
agreement = PurchaseAgreementForm()
return render_to_response('PlaceOrder.html',
{'order_opportunity': order_opportunity,
'agreement': agreement,
'formset': formset},
context_instance=RequestContext(request))
elif request.method == "POST":
PurchaseFormSet = formset_factory(PurchaseForm)
formset = PurchaseFormSet(request.POST)
agreement = PurchaseAgreementForm(request.POST)
order_opportunity = OrderOpportunity.objects.get(pk=pk)
if formset.is_valid() and agreement.is_valid():
order_opportunity = OrderOpportunity.objects.get(pk=pk)
order = Order(order_opportunity=order_opportunity, user=request.user)
order.save()
num_purchases = 0
for form in formset.forms:
if int(form['qty'].data) == 0: continue
product_for_sale = ProductForSale.objects.get(pk=form['product_pk'].data)
purchase = Purchase(qty=form['qty'].data,
product_for_sale=product_for_sale,
order=order)
purchase.save()
num_purchases = num_purchases + 1
if num_purchases == 0:
order.delete()
else:
return render_to_response('PlaceOrder.html',
{'order_opportunity': order_opportunity,
'agreement': agreement,
'formset': formset},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse('single-order-opportunity', args=[pk]))
def create_purchase(user,
receipt,
signature=None,
max_reactivations=0,
save=False,
apportable=True):
"""Add purchase to database. max_reactivations is the number
of times a duplicated purchase can be added to the database
(useful for restore purchases across devices). Receipt should
be text and not parsed json. Signature is
required for Android purchases but not used for iOS.
Returns None if the purchase has already been activated for user,
or max_reactivations reached or not verified. Max_reactivations
should be used for managed/nonconsumable purchases only.
"""
if apportable and user.platform == 'Android':
# apportable format
parsed = json.loads(receipt)
signature = parsed['SKPaymentTransactionReceiptSignature']
receipt = parsed['SKPaymentTransactionReceiptSignedData']
logging.debug('Signature: %s' % signature)
logging.debug('Receipt: %s' % receipt)
if user.platform == 'Android':
data = verify_android_purchase(receipt,
signature,
app.config['GOOGLE_PLAY_PUBLIC_KEY'],
debug=app.config['DEBUG'])
order_id = data['orderId']
elif user.platform == 'iOS':
data = verify_ios_purchase(receipt, app.config['USE_IOS_SANDBOX'])
order_id = data['original_transaction_id']
if Purchase.select().where((Purchase.order_id == order_id)
& (Purchase.user == user)).count() > 0:
return None
if Purchase.select().where(
Purchase.order_id == order_id).count() > max_reactivations:
raise abort(400, 'You\'ve restored your purchase more than the max ' + \
'amount of times. Please contact us to request more.')
if user.platform == 'iOS':
purchase = Purchase(
order_id=order_id,
product_id=data['product_id'],
created=datetime.fromtimestamp(
int(data['original_purchase_date_ms']) / 1000.0),
purchase_token=data['transaction_id'],
user=user,
)
elif user.platform == 'Android':
purchase = Purchase(
order_id=order_id,
product_id=data['productId'],
created=datetime.fromtimestamp(data['purchaseTime'] / 1000.0),
purchase_token=data['purchaseToken'],
user=user,
)
if save:
purchase.save()
return purchase
