def _read_orders(self, path: str): with open(path + "orders.txt", "r") as file: orders = list() next(file) for line in file: data = line.split(",") company_name = data[0].strip() depot_of_name = data[1].strip() amount = int(data[2]) price = int(data[3]) typ = data[4].strip().capitalize() assert any([typ == Order.type_buy(), typ == Order.type_sell()]) order_of = Company.objects.get(name=company_name) order_by = Company.objects.get(name=depot_of_name) orders.append( Order(order_of=order_of, order_by=order_by, amount=amount, price=price, typ=typ)) if self.setup_path == path: Order.objects.bulk_create(orders) return orders
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 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 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_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 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_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)
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_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 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 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)
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 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 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 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 b_test_multiple_buy_orders(self): amount = 10000 sell_order_two = Order.objects.create(order_by_id=5, order_of_id=2, price=2, amount=amount, typ=Order.type_sell()) orders = [] for i in range(amount): orders.append( Order(order_by_id=6, order_of_id=2, price=2, amount=1, typ=Order.type_buy())) Order.objects.bulk_create(orders) print("Order start") from django.db import connection, reset_queries from django.conf import settings settings.DEBUG = True reset_queries() start = time.time() OrderTask().run() end = time.time() print(end - start) print(len(connection.queries)) # print(connection.queries) settings.DEBUG = False reset_queries()
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 bulk_update(self, batch=False): # ToDo: Benchmarktest, I do not know if that approach scales # maybe work with batch size, if 500 values in a dict, insert it and clear it # Either clear & insert the lists if we check for batch size # or clear & insert the lists if we force it # Normally a batch run happens during the order check after every order # so the data does not get to full # A force insert happens when all orders have been matched # and we want to insert the rest if not batch or len(self.depot_positions_create) > self.BATCH: l = list() for key in self.depot_positions_create: v = self.depot_positions_create[key] l.append( DepotPosition(depot_of_id=key[0], company_id=key[1], amount=v)) DepotPosition.objects.bulk_create(l) self.depot_positions_create = dict() if not batch or len(self.depot_positions_update) > self.BATCH: for key in self.depot_positions_update: v = self.depot_positions_update[key] DepotPosition.objects.filter( depot_of_id=key[0], company_id=key[1]).update(amount=F("amount") + v) self.depot_positions_update = dict() # activity if not batch or len(self.activity_update) > self.BATCH: list_ = [v for k, v in self.activity_update.items()] Activity.objects.filter(id__in=list_).update( updated=timezone.now()) self.activity_update = dict() # update cash of companies if not batch or len(self.companies_cash_update) > self.BATCH: l = list() for k, v in self.companies_cash_update.items(): obj = Company(id=k, cash=F("cash") + v) l.append(obj) # Company.objects.filter(id=k).update(cash=F("cash")+v) Company.objects.bulk_update(l, ["cash"]) self.companies_cash_update = dict() # delete Orders if not batch or len(self.order_ids_delete) > self.BATCH: Order.objects.filter(id__in=self.order_ids_delete).delete() self.order_ids_delete = list() if not batch or len(self.order_update) > self.BATCH: l = list() for k in self.order_update: obj = Order(id=k, amount=self.order_update[k]) l.append(obj) Order.objects.bulk_update(l, fields=["amount"]) # delete Positions if not batch: DepotPosition.objects.filter(amount=0).delete() # create trades and statement of acounts # For performance reason we use bulk_creates to save queries. # There is just a slight problem regarding the trades and the statement of accounts: # We want to save the trade id of the related trade in the statement of account. # So we create the trades first, then retrieve their ids and set them in the statement # of account objects before inserting them in the database. # # As we are using postgresql as our database it supports the setting of the id # field of objects during bulk_create. Postgresql the greatest database of all time!!! if not batch or len(self.trades) > self.BATCH or len( self.statements) > self.BATCH: Trade.objects.bulk_create(self.trades) i = 0 for trade in self.trades: # For every trade there are 2 statement of accounts: # One for the buyer & one for the seller. self.statements[i].trade = trade self.statements[i + 1].trade = trade fst_statement = self.statements[i] snd_statement = self.statements[i + 1] if fst_statement.value != snd_statement.value or fst_statement.amount != snd_statement.amount: raise ValueError( f"Statement did not match: {fst_statement} {snd_statement}" ) if trade.get_value() != fst_statement.value: raise ValueError( f"Trade {trade} does not match statement: {fst_statement}" ) if trade.get_value() != snd_statement.value: raise ValueError( f"Trade {trade} does not match statement: {snd_statement}" ) i += 2 for statement in self.statements: assert statement.trade is not None StatementOfAccount.objects.bulk_create(self.statements) self.statements = list() self.trades = list() if not batch or len(self.notifications) > self.BATCH: Notification.objects.bulk_create(self.notifications) # for obj in self.notifications: # e = Event(user_id=obj.user_id, typ="Order", msg=obj.subject) # store_event(e) self.notifications = list()
def get_data_provider(self, x): return lambda:\ ((lambda data: Order(**data), i) for i in range(x))
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 create(self, validated_data): order = Order(address=validated_data['address'], created_by=validated_data['created_by']) order.save() return order
try: car = Car.objects.get(car_id=random.randint(0, 99)) except Car.DoesNotExist: car = Car(car_id=i, model="BMW i3", 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(),
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('/')