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