def test_is_frozen_if_paid_internally(self): order = Order(**self.data) order.is_paid = True order.save() payment_method = PaymentMethod(name='Internal Test', is_internal=True) payment_method.save() pref = PaymentPreference(payment_method=payment_method, user=order.user, identifier='InternalTestIdentifier') pref.save() payment = Payment(payment_preference=pref, amount_cash=order.amount_cash, order=order, user=order.user, currency=order.currency) payment.save() order = Order.objects.last() # it's paid self.assertTrue(order.is_paid) # therefore it's frozen self.assertTrue(order.payment_status_frozen) # even though deadline is in the future self.assertTrue(order.payment_deadline >= timezone.now())
def get_order(request): if request.method == 'POST': try: reqdict = to_reqdict(request) table_id = reqdict.get('table_id') menu_ids = reqdict.get('menu_id') quantity = reqdict.get('quantity') taste = reqdict.get('quantity') staff_id = None table = Table.objects.get(id=table_id) item = OrderedMenu(menu_id=menu_ids) item.quantity = quantity item.taste = taste item.save() order = Orders() order.table = table order.name = f"{order.table.name.lower()}_{datetime.datetime.now().isoformat()}" order.save() order.menu.add(item) messages.success(request, f'Order has been placed for {table.name}') except Exception as e: messages.error(request, 'Failed to add Menu') import traceback e = traceback.format_exc() print(e) return redirect(reverse('home'))
def generateOrder(request): total = 0 for item in request.items.all(): partial = _price(item) total += partial.get('price', 0) order = Order(request=request, price=total, status=Order.PENDING) order.save()
def test_type_cannot_be_empty(self): """Test the typ cannot be empty and must be set""" order = Order(order_by=self.company, order_of=self.company_2, price=5, amount=10000) with self.assertRaises(IntegrityError): order.save()
def test_is_expired_after_payment_deadline(self): order = Order(**self.data) order.payment_window = 60 # expires after 1h order.save() order = Order.objects.last() order.created_on = timezone.now() - timedelta(minutes=120) # 2h ago self.assertTrue(order.expired)
def order(db, store, merchant, item): order = Order(address="This is the test address", merchant=merchant, store=store, order_subtotal=123.23, taxes=452.24, order_total=234.12) order.save() item_list = [item.id] order.items.add(*item_list) return order
def setUp(self): super(UpdateWithdrawAddressTestCase, self).setUp() PaymentMethod.objects.all().delete() method_data = { 'bin': 426101, 'fee': 0.0, 'is_slow': 0, 'name': 'Alpha Bank Visa' } payment_method = PaymentMethod(**method_data) payment_method.save() pref_data = { 'user': self.user, 'identifier': str(payment_method.bin), 'comment': 'Just testing' } pref = PaymentPreference(**pref_data) pref.save() pref.currency.add(self.USD) pref.save() """Creates an order""" data = { 'amount_cash': Decimal(30674.85), 'amount_btc': Decimal(1.00), 'currency': self.USD, 'user': self.user, 'admin_comment': 'test Order', 'unique_reference': '12345', 'payment_preference': pref } order = Order(**data) # TODO: patch and uncomment # order.full_clean() # ensure is initially correct order.save() self.order = order pk = self.order.pk self.url = reverse('core.update_withdraw_address', kwargs={'pk': pk}) self.addr_data = { 'type': 'W', 'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j', 'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j', } self.addr = Address(**self.addr_data) self.addr.user = self.user self.addr.save() # The 'other' address for the Transaction user = User.objects.create_user(username='******') addr2 = Address(**self.addr_data) addr2.user = user addr2.save()
def generate_orders(request, times): for i in range(0, times): o = Order() o.user = get_random_instance(User) o.bill_address = get_random_instance(Address, choice='B') o.ship_address = get_random_instance(Address, choice='S') o.payment = get_random_instance(Payment, relation='Order') o.save() return HttpResponse(f'{times} Orders generated !')
def test_payment_deadline_calculation(self): created_on = timezone.now() payment_window = 60 order = Order(**self.data) order.payment_window = payment_window expected = created_on + timedelta(minutes=payment_window) order.save() # ignore ms self.assertTrue( abs(expected - order.payment_deadline) < timedelta(seconds=1))
def post(self, request): company = request.data.get("companyId") address = request.data.get("addressId") payment_method = request.data.get("paymentMethod") retry_in_local_request = request.data.get("retryInLocal") total = request.data.get("total") items = request.data.get("items") if payment_method is None \ or total is None or items is None: return Response({'message': 'Some Atribute is not Found'}, status=400) client = Client.objects.get(user=self.request.user) company = Company.objects.get(pk=company) if not company.available_now: return Response({'state': "Cancelado", 'responseCode': 400}) order = Order() order.id_company = company order.state = State.objects.get(pk=1) order.retry_in_local = retry_in_local_request if not retry_in_local_request: order.address = AddressSaved.objects.get(pk=address) order.client = client order.payment_method = PaymentMethod.objects.get( description=payment_method) order.total = int(total) order.save() for item in items: detail_order = DetailOrder() detail_order.order = order detail_order.product = Products.objects.get(pk=item.get('id')) detail_order.quantity = item.get('quantity') detail_order.save() response = { 'dateCreated': formats.date_format(timezone.localtime(order.date), "d/m/Y H:i"), 'orderId': order.pk, 'state': order.state.description, 'responseCode': 200 } title = "Hay un nuevo pedido Pendiente" text = "{} esta esperando a que lo confirmes".format( client.user.first_name) send_notification_to_seller(order, text, title) return Response(response)
def test_not_frozen_if_paid(self): order = Order(**self.data) order.is_paid = True order.save() order = Order.objects.last() # it's paid self.assertTrue(order.is_paid) # therefore it's frozen self.assertFalse(order.payment_status_frozen) # even though deadline is in the future self.assertTrue(order.payment_deadline >= timezone.now())
def test_is_frozen_if_expired(self): order = Order(**self.data) order.payment_window = 60 # expires after 1h order.save() order = Order.objects.last() order.created_on = timezone.now() - timedelta(minutes=120) # 2h ago # deadline is in the past self.assertTrue(timezone.now() > order.payment_deadline) # so it's frozen self.assertTrue(order.payment_status_frozen) # even though it's not paid self.assertFalse(order.is_paid)
def test_is_not_frozen_if_is_not_paid_neither_expired(self): payment_window = 60 order = Order(**self.data) order.payment_window = payment_window order.save() order = Order.objects.last() # it's not paid self.assertFalse(order.is_paid) # also it's not expired self.assertFalse(order.expired) # so it's not frozen self.assertFalse(order.payment_status_frozen)
def test_is_not_expired_if_paid(self): order = Order(**self.data) order.payment_window = 60 # expires after 1h order.is_paid = True order.save() order = Order.objects.last() order.created_on = timezone.now() - timedelta(minutes=120) # 2h ago # deadline is in the past self.assertTrue(timezone.now() > order.payment_deadline) # but already paid self.assertTrue(order.is_paid) # so it's not expired self.assertFalse(order.expired)
def remove_orders(request, table_id, menu_id): if request.method == 'POST': try: reqdict = to_reqdict(request) table_id = reqdict.get('table_id') menu_ids = reqdict.get('menu_ids'), staff_id = None table = Table.objects.get(id=table_id) items = OrderedMenu.objects.filter(id__in=menu_ids) order = Orders() order.table = table order.menu.add(items) order.save() messages.success(request, f'Order has been placed for {table.name}') except Exception as e: messages.error(request, 'Failed to add Menu') print(e) return redirect(reverse('home'))
def basket(request): if Order.objects.filter(user=request.user, status__base_status__id=1): order_ = Order.objects.get(user=request.user, status__base_status__id=1) else: status = Status(base_status=BaseStatus.objects.get(id=1), datetime=datetime.now()) status.save() order_ = Order(user=request.user) order_.save() order_.status.add(status) order_.save() addresses = Address.objects.filter(Q(user=request.user) | Q(user__id=1)) return render( request, "basket.html", { "order": order_, "addresses": addresses, "payment_methods": PaymentMethod.objects.all(), "categories": Category.objects.all(), "advertisements": Advertising.objects.all() })
def basket_add(request, product_id): product_ = Product.objects.get(id=product_id) if Order.objects.filter(user=request.user, status__base_status__id=1): order_ = Order.objects.get(user=request.user, status__base_status__id=1) else: status = Status(base_status=BaseStatus.objects.get(id=1), datetime=datetime.now()) status.save() order_ = Order(user=request.user) order_.save() order_.status.add(status) order_.save() ordered_products = order_.products.all() if product_ in [ ordered_product.product for ordered_product in ordered_products ]: for order_prod in ordered_products: if order_prod.product == product_: order_prod.count += 1 order_prod.save() break else: ordered_product = OrderedProduct(product=product_, count=1) ordered_product.save() order_.products.add(ordered_product) order_.save() return HttpResponseRedirect(request.GET.get("path"))
def create_order(cls, user): cls.setUpClass() payment_method = PaymentMethod.objects.first() if payment_method is None: method_data = { 'bin': 426101, 'fee': 0.0, 'is_slow': 0, 'name': 'Alpha Bank Visa' } payment_method = PaymentMethod(**method_data) payment_method.save() pref_data = { 'user': user, 'currency': cls.USD, 'identifier': str(payment_method.bin), 'comment': 'Just testing' } pref = PaymentPreference(**pref_data) pref.save() """Creates an order""" data = { 'amount_cash': Decimal(30674.85), 'amount_btc': Decimal(1.00), 'currency': cls.USD, 'user': user, 'admin_comment': 'test Order', 'unique_reference': '12345', 'withdraw_address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j', 'payment_preference': pref } order = Order(**data) order.full_clean() # ensure is initially correct order.save() return order
def setUp(self): user, created = User.objects.get_create(username='******') code = Code(user=user) code.save() # in real life middleware checks that # referee and referrer are not the same person self.referral = Referral(code=code, referee=user) self.referral.save() for i in range(10): rand_coin = self.amount_coin_base * \ randint(1, self.amount_coin_multiplier) order = Order(user=user, amount_coin=rand_coin) order.save() self.orders.append(order) for i in range(self.test_subjects): order = self.orders[i] order.is_complete = True order.save() self.turnover += order.amount_btc self.revenue = self.turnover / 100 *\ self.referral.program.percent_first_degree
def create(self, validated_data): order = Order(address=validated_data['address'], created_by=validated_data['created_by']) order.save() return order
def post(self, request): data = request.data link = Link.objects.filter(code=data['code']).first() if not link: raise exceptions.APIException('Invalid code!') try: order = Order() # creo ordine # DATI PRESI DAL LINK (il carrello) order.code = link.code order.user_id = link.user.id order.ambassador_email = link.user.email # =========================== # DATI PRESI DALLA RICHIESTA POST (dal front-end) order.first_name = data['first_name'] order.last_name = data['last_name'] order.email = data['email'] order.address = data['address'] order.country = data['country'] order.city = data['city'] order.zip = data['zip'] # salvo su db ma nella trnsazione order.save() # preparo lista di items dell'ordine CON I DATI - lista di oggetti json line_items = [] for item in data['products']: product = Product.objects.filter(pk=item['product_id']).first() quantity = decimal.Decimal(item['quantity']) order_item = OrderItem() # creo item order_item.order = order order_item.product_title = product.title order_item.price = product.price order_item.quantity = quantity order_item.ambassador_revenue = decimal.Decimal(.1) * product.price * quantity order_item.admin_revenue = decimal.Decimal(.9) * product.price * quantity order_item.save() # SALVO l'item dell'ordine line_items.append({ 'name': product.title, 'description': product.description, 'images': [ product.image ], 'amount': int(100 * product.price), #in centesimi di dollaro (per stripe) 'currency': 'usd', 'quantity': quantity }) stripe.verify_ssl_certs = False stripe.api_key = "sk_test_B9N7bDJ1lEt8ey2GZ72qCCor" source = stripe.checkout.Session.create( success_url='http://localhost:5000/success?source={CHECKOUT_SESSION_ID}', #URL DEL FRONTEND cancel_url='http://localhost:5000/error', payment_method_types=['card'], line_items=line_items ) order.transaction_id = source['id'] #id della transazione di stripe order.save() return Response(source) except Exception: transaction.rollback() return Response({ 'message': "Error occurred" })
class OrderSetAsPaidTestCase(UserBaseTestCase, OrderBaseTestCase): def setUp(self): super(OrderSetAsPaidTestCase, self).setUp() currency = self.RUB self.data = { 'amount_cash': Decimal(30674.85), 'amount_btc': Decimal(1.00), 'currency': currency, 'user': self.user, 'admin_comment': 'test Order', 'unique_reference': '12345' } self.order = Order(**self.data) self.order.save() self.url = reverse('core.payment_confirmation', kwargs={'pk': self.order.pk}) def test_cannot_set_as_paid_if_has_no_withdraw_address(self): response = self.client.post(self.url, {'paid': 'true'}) self.assertEqual(403, response.status_code) self.assertEquals( response.content, b'An order can not be set as paid without a withdraw address') def test_can_set_as_paid_if_has_withdraw_address(self): # Creates an withdraw address fro this user address = Address(user=self.user, type='W', address='17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j') address.save() # Creates an Transaction for the Order, using the user Address transaction = Transaction(order=self.order, address_to=address, address_from=address) transaction.save() # Set Order as Paid response = self.client.post(self.url, {'paid': 'true'}) expected = {"frozen": None, "paid": True, "status": "OK"} self.assertJSONEqual( json.dumps(expected), str(response.content, encoding='utf8'), ) def test_can_set_as_paid_if_has_withdraw_address_internal(self): # Creates an withdraw address fro this user address = Address(user=self.user, type='W', address='17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j') address.save() payment_method = PaymentMethod(name='Internal Test', is_internal=True) payment_method.save() pref = PaymentPreference(payment_method=payment_method, user=self.order.user, identifier='InternalTestIdentifier') pref.save() payment = Payment(payment_preference=pref, amount_cash=self.order.amount_cash, order=self.order, currency=self.RUB, user=self.order.user) payment.save() # Creates an Transaction for the Order, using the user Address transaction = Transaction(order=self.order, address_to=address, address_from=address) transaction.save() # Set Order as Paid response = self.client.post(self.url, {'paid': 'true'}) expected = {"frozen": True, "paid": True, "status": "OK"} self.assertJSONEqual( json.dumps(expected), str(response.content, encoding='utf8'), )
amount_of_places=4, color=fake.color_name(), engineer=engineer, park=park, car_plate=2) p = random_date(d1, d2) z = p + timedelta(hours=randint(1, 9)) order = Order( customer=customer, car=car, time_begin=p, time_end=z, location_begin=str(randint(0, 1000)) + ' ' + str(randint(0, 1000)), location_end=str(randint(0, 1000)) + ' ' + str(randint(0, 1000)), location_car=str(randint(0, 1000)) + ' ' + str(randint(0, 1000))) order.save() payment = Payment(order=order, time_of_payment=z, price=randint(25, 500)) payment.save() for i in range(0, 110): try: operator = Operator.objects.get(info=Employee.objects.get( username='******')) except Operator.DoesNotExist: employee = Employee(username=fake.user_name(), first_name=fake.first_name(), last_name=fake.last_name(), email=fake.free_email(), phone_number=fake.phone_number()) employee.save() operator = Operator(info=employee, park=park, car=None)
def add_to_order(request, *args, **kwargs): if request.method == "GET": return render(request, "restaurant/order.php") if request.method == "POST": order = Order() cart = FoodCart.objects.filter(session_key=request.session.session_key, checked_out=False) total = 0 for item in cart: total += item.get_total restaurant = item.restaurant total += restaurant.delivery_charge order.total_price = total order.paid = False first_name = request.POST.get("first_name", "") middle_name = request.POST.get("middle_name", "") last_name = request.POST.get("last_name", "") email = request.POST.get("email", "") contact_number = request.POST.get("contact", "") address_line1 = request.POST.get("address1", "") address_line2 = request.POST.get("address2", "") city = request.POST.get("city", "") state = request.POST.get("state", "") zip = request.POST.get("zip", "") order.first_name = first_name order.last_name = last_name order.middle_name = middle_name order.email = email order.contact_number = contact_number order.address_line1 = address_line1 order.address_line2 = address_line2 order.city = city order.state = state order.zip_code = zip if 'comment' in request.POST: message = request.POST.get('comment', '') order.note = message order.payment = 1 last_order = Order.objects.last() if last_order: order_id = last_order.id order_id = order_id + 1 else: order_id = 1 id_string = randomString() + str(order_id) if Order.objects.filter(id_string=id_string).exists(): id_string = randomString() + str(order_id) order.id_string = id_string else: order.id_string = id_string order.status = 1 order._runsignal = False order._approved = False order._prepared = False order.save() for item in cart: order.cart.add(item) item.checked_out = True item.save() order._runsignal = False order._approved = False order._prepared = False order.save() return HttpResponseRedirect('/')
def get(self, request): if request.is_ajax(): action = request.GET.get('action') if action == "confirm_order": order_id = int(request.GET.get('order_id')) orders = Order.objects.filter(order_id=order_id) for order in orders: order.is_confirmed = True order.save() #On vide la panier cart_clear(request) return JsonResponse({}, status=200) elif action == 'new_order': last_name = request.GET.get('last_name') first_name = request.GET.get('first_name') adresse = request.GET.get('adresse') phone_number = request.GET.get('phone_number') new_id_order = IdOrder(user=request.user) new_id_order.save() list_selected_products = get_selected_articles( request, new_id_order.id) for selected_product in list_selected_products: new_order = Order( last_name=last_name, first_name=first_name, adresse=adresse, phone_number=phone_number, user=request.user, selected_product=selected_product, order_id=new_id_order.id, price=float(selected_product.price) * float(selected_product.quantity), ) new_order.save() return JsonResponse({'order_id': str(new_id_order.id)}, status=200) elif action == 'change_order': last_name = request.GET.get('last_name') first_name = request.GET.get('first_name') adresse = request.GET.get('adresse') phone_number = request.GET.get('phone_number') order_id = request.GET.get('order_id') list_selected_products = SelectedProduct.objects.filter( order_id=order_id) list_order = Order.objects.filter(order_id=order_id) for order in list_order: order.last_name = last_name order.first_name = first_name order.phone_number = phone_number order.adresse = adresse order.save() return JsonResponse({'order_id': order_id}, status=200) return render(request, 'order/order.html')
def insert_order(request): cart = Cart(request) if request.method == "POST": total_price = request.POST["total_price"] user = request.user # -------------billing info------------------- first_name = request.POST['first_name'] last_name = request.POST['last_name'] address = request.POST['address'] city = request.POST['city'] state = request.POST['state'] zip_code = request.POST['zip_code'] phone = request.POST['phone'] # -------------billing info------------------ # print(request.POST) # print(request.session['cart']) # checkcart = request.session['cart'] # if checkcart == {}: # return redirect() if (total_price == '0'): messages.warning(request, "Sorry! Your cart is empty..!") elif address == '' or city == '' or state == '' or phone == '': messages.warning(request, "Please fill-up the billing info properly!") else: order = Order(total_price=total_price, customer=user) # print(order.id) billing = BillingInfo(first_name=first_name, last_name=last_name, address=address, city=city, state=state, zip_code=zip_code, phone=phone, order=order, customer=user) order.save() billing.save() cart.clear() for item in cart: product = item['product'] quantity = item['quantity'] price = item['total_price'] order_details = OrderDetail(quantity=quantity, price=price, product=product, order=order) order_details.save() # find product by id # print(item) Product.objects.filter(id=item['id']).update( quantity=F('quantity') - item['quantity']) # update product qauntity old_qyt - cartqyt messages.success(request, "Your order has been placed successfully..!") return redirect(checkout)
def form_valid(self, form): """ Logic for valid form. """ context = self.get_context_data(form=form) context.update({ 'seats': form.cleaned_data['seats'], 'name': form.cleaned_data['name'], 'phone': form.cleaned_data['phone'], 'email': form.cleaned_data['email'], 'comment': form.cleaned_data['comment'] }) action = self.request.GET.get('action') if action == 'preview': self.template_name = "core/event_order_preview.html" return self.render_to_response(context) elif action == 'confirm': # Now we can create an order client, created = Client.objects.get_or_create( name=form.cleaned_data['name'], phone=form.cleaned_data['phone'], email=form.cleaned_data['email'], event=context['event'] ) client.save() order = Order( client=client, status=ORDER_STATUS_CHOICES[0][0], comment=form.cleaned_data['comment'], event=context['event'] ) order.save() for seat in form.cleaned_data['seats']: # Check for seat status if seat.status == SEAT_STATUS_CHOICES[0][0]: seat.order = order seat.save() else: order.delete() self.template_name = 'core/event_order.html' return self.render_to_response(context) # Send email to managers that order has been created. # We put it into try clause logger = logging.getLogger('orders') handler = logging.FileHandler('var/orders.log') formatter = logging.Formatter( '%(asctime)s %(levelname)s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) try: subject = u'Новый заказ - № %s: %s заказал %s билетов.' % \ (order.id, order.client, len(order.seats.all())) message = render_to_string('core/email/new_order.txt', {'order': order}) recipients = [u.email for u in User.objects.filter(is_staff=True) if u.profile.event == context['event']] send_mail(subject, message, '*****@*****.**', recipients, fail_silently=False) # Log about success logger.info(subject) except Exception, e: # Log error and order ID logger.error('Error during managers send mail: %s : %s' % \ (e, subject)) self.template_name = "core/event_order_success.html" return self.render_to_response(context)
def post(self, request): data = request.data link = Link.objects.filter(code=data['code']).first() if not link: raise exceptions.APIException('Invalid code!') try: order = Order() order.code = link.code order.user_id = link.user.id order.ambassador_email = link.user.email order.first_name = data['first_name'] order.last_name = data['last_name'] order.email = data['email'] order.address = data['address'] order.country = data['country'] order.city = data['city'] order.zip = data['zip'] order.save() line_items = [] for item in data['products']: product = Product.objects.filter(pk=item['product_id']).first() quantity = decimal.Decimal(item['quantity']) order_item = OrderItem() order_item.order = order order_item.product_title = product.title order_item.price = product.price order_item.quantity = quantity order_item.ambassador_revenue = decimal.Decimal(.1) * product.price * quantity order_item.admin_revenue = decimal.Decimal(.9) * product.price * quantity order_item.save() line_items.append({ 'name': product.title, 'description': product.description, 'images': [ product.image ], 'amount': int(100 * product.price), 'currency': 'usd', 'quantity': quantity }) stripe.api_key = 'sk_test_51H0wSsFHUJ5mamKOVQx6M8kihCIxpBk6DzOhrf4RrpEgqh2bfpI7vbsVu2j5BT0KditccHBnepG33QudcrtBUHfv00Bbw1XXjL' source = stripe.checkout.Session.create( success_url='http://localhost:5000/success?source={CHECKOUT_SESSION_ID}', cancel_url='http://localhost:5000/error', payment_method_types=['card'], line_items=line_items ) order.transaction_id = source['id'] order.save() return Response(source) except Exception: transaction.rollback() return Response({ 'message': "Error occurred" })
def handle(self, *args, **options): restaurant = Horecama(name='108', address='Улица Универститетская блабла', type='R', description='Блабла') restaurant.save() restaurant = Horecama(name='Pyatorochka', address='Улица Универститетская блабла', type='M', description='Блабла') restaurant.save() restaurant = Horecama(name='Bechetle', address='Улица Универститетская блабла', type='M', description='Блабла') restaurant.save() g1 = Goods(name="Ananas", description="", price="20", horecama=restaurant) g1.save() g2 = Goods(name="Pivas", description="", price="20", horecama=restaurant) g2.save() g3 = Goods(name="Vodka", description="", price="200", horecama=restaurant) g3.save() order = Order(user_name='Vladimir Kekovich', user_phone='88005553535', address='Улица универская блабла', price=200) order.save() mtm = GoodsQuantityOrder(quantity=10, order=order, goods=g1) mtm.save() mtm = GoodsQuantityOrder(quantity=10, order=order, goods=g2) mtm.save() mtm = GoodsQuantityOrder(quantity=10, order=order, goods=g3) mtm.save() feedback = HorecamaFeedback(user_name='Vladimir Kekovich', horecama=restaurant, rating=4, order=order) feedback.save() feedback = HorecamaFeedback(user_name='Ivan Kekovich', horecama=restaurant, rating=5) feedback.save() feedback = HorecamaFeedback(user_name='Sashok Kekovich', horecama=restaurant, rating=1) feedback.save() return restaurant.name
class PaymentReleaseTestCase(UserBaseTestCase, OrderBaseTestCase): def setUp(self): super(PaymentReleaseTestCase, self).setUp() self.method_data = {"is_internal": 1, 'name': 'Robokassa'} amount_cash = Decimal(30000.00) self.payment_method = PaymentMethod(name='ROBO') self.payment_method.save() self.addr_data = { 'type': 'W', 'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j', 'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j', } self.addr = Address(**self.addr_data) self.addr.user = self.user self.addr.save() pref_data = { 'user': self.user, 'comment': 'Just testing', 'payment_method': self.payment_method } pref = PaymentPreference(**pref_data) pref.save('internal') self.data = { 'amount_cash': amount_cash, 'amount_btc': Decimal(1.00), 'currency': self.RUB, 'user': self.user, 'admin_comment': 'test Order', 'unique_reference': '12345', 'payment_preference': pref, 'is_paid': True } self.order = Order(**self.data) self.order.save() self.pay_data = { 'amount_cash': self.order.amount_cash, 'currency': self.RUB, 'user': self.user, 'payment_preference': pref, } self.payment = Payment(**self.pay_data) self.payment.save() tx_id_ = '76aa6bdc27e0bb718806c93db66525436' \ 'fa621766b52bad831942dee8b618678' self.transaction = Transaction(tx_id=tx_id_, order=self.order, address_to=self.addr) self.transaction.save() def test_bad_release_payment(self): for o in Order.objects.filter(is_paid=True, is_released=False): p = Payment.objects.filter(user=o.user, amount_cash=o.amount_cash, payment_preference=o.payment_preference, is_complete=False, currency=o.currency).first() if p is not None: tx_id_ = release_payment(o.withdraw_address, o.amount_btc) self.assertEqual(tx_id_, None) def test_orders_with_approved_payments(self): for o in Order.objects.filter(is_paid=True, is_released=False): p = Payment.objects.filter(user=o.user, amount_cash=o.amount_cash, payment_preference=o.payment_preference, is_complete=False, currency=o.currency).first() if p is not None: o.is_released = True o.save() p.is_complete = True p.save() self.assertTrue(o.is_released) self.assertTrue(p.is_complete) def checker_transactions(self): if check_transaction(self.transaction.tx_id): self.transaction.is_completed = True self.transaction.save() self.assertTrue(self.transaction.is_completed)
class OrderPriceGenerationTest(OrderBaseTestCase, UserBaseTestCase): @classmethod def setUpClass(cls): super(OrderPriceGenerationTest, cls).setUpClass() def test_auto_set_amount_cash_buy_btc_with_usd(self): # When the client slees we buy and vice versa # TODO: consider different naming conventions amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_SELL_USD * amount_btc self.order = Order(order_type=Order.BUY, amount_btc=amount_btc, currency=self.USD, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected) @skip("causes failures, needs to be migrated") def test_auto_set_amount_cash_buy_btc_with_eur(self): # When the client slees we buy and vice versa # TODO: consider different naming conventions amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_SELL_RUB / \ OrderBaseTestCase.RATE_EUR * amount_btc self.order = Order(order_type=Order.BUY, amount_btc=amount_btc, currency=self.EUR, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected) def test_auto_set_amount_cash_buy_btc_with_rub(self): amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_SELL_RUB * amount_btc self.order = Order(order_type=Order.BUY, amount_btc=amount_btc, currency=self.RUB, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected) def test_auto_set_amount_cash_sell_btc_for_usd(self): amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_BUY_USD * amount_btc self.order = Order(order_type=Order.SELL, amount_btc=amount_btc, currency=self.USD, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected) @skip("causes failures, needs to be migrated") def test_auto_set_amount_cash_sell_btc_for_eur(self): amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_BUY_RUB / \ OrderBaseTestCase.RATE_EUR * amount_btc self.order = Order(order_type=Order.SELL, amount_btc=amount_btc, currency=self.EUR, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected) def test_auto_set_amount_cash_sell_btc_for_rub(self): amount_btc = 2.5 expected = OrderBaseTestCase.PRICE_BUY_RUB * amount_btc self.order = Order(order_type=Order.SELL, amount_btc=amount_btc, currency=self.RUB, user=self.user) self.order.save() self.assertEqual(self.order.amount_cash, expected)