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)
