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('/')
