def list(self, request):
pair_view_set = PairViewSet()
data = []
pairs_names = self._get_bestchange_pair_names()
pairs = Pair.objects.filter(disabled=False,
test_mode=False,
name__in=pairs_names)
for pair in pairs:
if not pair_view_set._get_dynamic_test_mode(pair):
order = Order(pair=pair, amount_base=Decimal('1'))
try:
order.calculate_quote_from_base()
except Price.DoesNotExist:
continue
data.append(self._get_order_return_data(order))
reverse_pair = pair.reverse_pair
if reverse_pair and not pair_view_set._get_dynamic_test_mode(
reverse_pair):
order = Order(pair=reverse_pair, amount_quote=Decimal('1'))
try:
order.calculate_base_from_quote()
except Price.DoesNotExist:
continue
data.append(self._get_order_return_data(order))
return Response(data)
def Salad(request):
item_selections = request.POST
if len(item_selections) !=1:
Total_cost = 0.0
if Order.objects.last() == None:
od = Order(1)
else:
od = Order(Order.objects.last().id+1)
od.save()
for i in item_selections.getlist("salad"):
obj = Menu.objects.all().filter(id=i)
Total_cost += obj[0].Price_small
od.Others.add(obj[0])
od.order_total = Total_cost
od.save()
if Cart.objects.all().filter(user =str(request.user),order_status=False).last() == None:
if Cart.objects.last() == None:
cart = Cart(1,user =str(request.user))
else:
cart = Cart(Cart.objects.last().id + 1,user =str(request.user))
cart.save()
else:
cart = Cart.objects.all().filter(user =str(request.user),order_status=False).first()
cart.stuff.add(od)
cart.Total += Total_cost
cart.save()
return JsonResponse({"output":"Nope"})
else:
return JsonResponse({"output":"Fail"})
def create(self, validated_data):
if (self.context['address_id']):
address = validated_data.pop('address')
order = Order(**validated_data)
order.user = self.context['request'].user
order.address = Address.objects.get(id=self.context['address_id'])
order.save()
else:
address = validated_data.pop('address')
ad = Address.objects.create(**address)
order = Order(**validated_data)
order.user = self.context['request'].user
order.address = ad
order.save()
# order_created(order.id)
# self.context['request'].session['order_id'] = order.id
for cartitem in self.context['cartitems']:
if cartitem.quantity < cartitem.item.quantity:
OrderItem.objects.create(order=order,
item=cartitem.item,
quantity=cartitem.quantity)
else:
raise serializers.ValidationError({'status': 'quantity error'})
order.total = order.get_total_cost()
order.save()
return order
def order_create(request):
cart = Cart(request)
order = Order(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
address = form.cleaned_data['address']
phone_no = form.cleaned_data['phone_no']
city = form.cleaned_data['city']
order = form.save(commit=False)
if cart.coupon:
order.coupon = cart.coupon
order.discount = cart.coupon.discount
order.save()
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
order: Order(request)
#launch assy. tasks
#order_created.delay(order.id)
#set the order in the session
request.session['order_id'] = order.id
#redirect to payment
return redirect(reverse('payment:process'))
else:
form = OrderCreateForm()
return render(request, 'orders/create.html', {'cart': cart, 'form': form})
def _create_order_with_default_values(self, pair):
base_maximal = pair.base.current_maximal_amount_to_sell
base_minimal = pair.base.minimal_amount
quote_maximal = pair.quote.maximal_amount
quote_minimal = pair.quote.minimal_amount
if pair.is_crypto:
amount_quote = \
quote_minimal * \
settings.DEFAULT_CRYPTO_ORDER_DEPOSIT_AMOUNT_MULTIPLIER
if amount_quote >= quote_maximal:
amount_quote = (quote_maximal + quote_minimal) / Decimal('2')
else:
amount_quote = settings.DEFAULT_FIAT_ORDER_DEPOSIT_AMOUNT
if amount_quote < quote_minimal:
amount_quote = \
quote_minimal \
* settings.DEFAULT_FIAT_ORDER_DEPOSIT_AMOUNT_MULTIPLIER
order = Order(pair=pair, amount_quote=amount_quote)
order.calculate_base_from_quote()
if all([
not base_minimal <= order.amount_base <= base_maximal,
base_maximal > base_minimal
]):
if order.amount_base > base_maximal:
# return value between minimal and maximal possible
# (closer to maximal to avoid minimal quote error)
amount_base = \
(base_minimal + Decimal('4') * base_maximal) / Decimal('5')
else:
amount_base = base_minimal
order = Order(pair=pair, amount_base=amount_base)
order.calculate_quote_from_base()
return order
def new_order(request, product_id):
#import pdb; pdb.set_trace()
additional = request.session['additional']
print("Is this an additional order :", additional)
if request.method == 'POST':
print("New Order Request is POST")
if 'order_id' in request.session:
print("Order ID already Exists in Session :",
request.session['order_id'])
setNewId = False
if not additional:
print("Set New ID True")
del request.session['order_id']
print("Order_Id Deleted")
start_order = Order()
start_order.save()
print("New Order ID = ", start_order.id)
print("Adding new Order_Id to session")
request.session['order_id'] = str(start_order.id)
print("Session ID = ", request.session['order_id'])
else:
print("Order ID Does NOT Exist in Session")
print("Set New ID False")
start_order = Order()
start_order.save()
print("New Order ID = ", start_order.id)
request.session['order_id'] = start_order.id
print("Session ID = ", request.session['order_id'])
product = get_object_or_404(Product, id=product_id)
print("Product = ", product.name)
random_ref = ''.join([
random.choice(string.ascii_letters + string.digits) for n in range(32)
])
form = OrderItemCreate(
initial={
'order': request.session['order_id'],
'product': product.id,
'price': product.price,
'quantity': 1,
'name': product.name,
'ref': random_ref
}) # create the form from the POST data
return render(
request, # send user to complete the order details.
'orders/santa/order-detail.html',
{'form': form})
def test_calculator_calc(services: QuerySet):
"""Should calc the order price."""
order = Order()
calc = Calculator()
assert calc.calc(order) is None
service = services.first()
service.price.is_price_fixed = False
order.service = service
assert calc.calc(order) is None
service.price.is_price_fixed = True
service.price.price = Money(1, "USD")
service.duration = 10
now = arrow.utcnow()
order.start_datetime = now.datetime
order.end_datetime = now.shift(minutes=10).datetime
assert calc.calc(order) == service.price.price
order.start_datetime = now
order.end_datetime = now.shift(minutes=30)
assert calc.calc(order) == service.price.price * Decimal(3)
def place_order(request):
if request.method == 'GET':
total_amount = round(
sum([
product.price
for product in Product.objects.filter(cart__user=request.user)
]), 2)
order = Order()
order.amount = total_amount
context = {
'form': OrderForm(instance=order),
}
return render(request, 'orders/order_details.html', context)
else:
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.buyer = request.user
order.order_date = datetime.datetime.now()
order.save()
set_sold_products_unavailable(request.user, order)
update_raised_money(order.amount)
empty_user_cart(request.user)
return redirect('successful donation', order.id)
context = {
'form': form,
}
return render(request, 'orders/order_details.html', context)
def test_notify_order_update(
user: User,
admin: User,
services: "QuerySet[Service]",
mailoutbox: List[EmailMultiAlternatives],
):
"""Should notify about a new review."""
order = Order()
order.service = services.filter(professional__user=admin).first()
order.client = user
order.price = Money(1, "EUR")
notify_order_update(order, is_created=True)
assert len(mailoutbox) == 2
assert admin.email in mailoutbox[0].recipients()
assert user.email in mailoutbox[1].recipients()
assert "new order" in mailoutbox[1].subject
order.created_by = admin
notify_order_update(order, is_created=False)
assert len(mailoutbox) == 3
assert user.email in mailoutbox[2].recipients()
assert "updated" in mailoutbox[2].subject
order.modified_by = user
notify_order_update(order, is_created=False)
assert len(mailoutbox) == 4
assert admin.email in mailoutbox[3].recipients()
def create_order(request, cart, delivery=None):
subtotal = cart.total_price
order = Order()
order.user = request.user
delivery = Delivery.objects.all()[0]
order.delivery = delivery
order.total = subtotal + Decimal(order.delivery.price)
order.save()
for pro in cart:
line = OrderLine()
line.order = order
line.product = pro.item
line.quantity = pro.quantity
if pro.color:
line.color = Color.objects.get(pk=pro.color)
if pro.size:
line.size = Size.objects.get(pk=pro.size)
line.line_price = pro.item.total_price() * pro.quantity
line.save()
request.session['order_pk'] = order.pk
return order
def upload(request):
orders = getOrders()
for order in orders:
orderId = getField(order, 'order_id')
try:
newOrder = Order.objects.get(order_id=orderId)
except:
marketplace = getField(order, 'marketplace')
# Status fields
status = order.getElementsByTagName("order_status").item(0)
marketplaceStatus = getField(status, 'marketplace')
lengowStatus = getField(status, 'lengow')
orderDate = getField(order, 'order_purchase_date')
formatedDate = orderDate if orderDate != '' else None
amount = getField(order, 'order_amount')
currency = getField(order, 'order_currency')
newOrder = Order(None, orderId, marketplace, amount, currency,
marketplaceStatus, lengowStatus, formatedDate)
newOrder.save()
#delete temporary file
os.remove(filename)
messages.success(request, "Orders uploaded successfuly !")
return redirect("/list")
def post(self, request, *args, **kwargs):
client_data = cookie_parser(request.COOKIES.get('client_data'))
order = Order()
order.shipping_address = client_data.get('shipping_address')
order.phone = client_data.get('phone')
order.client_name = client_data.get('client_name')
if request.user.is_authenticated:
order.customer = request.user
order.save()
cart_items = self.get_cart_items(self.request)
total_price = 0
json_data = []
for cart_item in cart_items:
cart_item.order = order
total_price += cart_item.total_price
cart_item.save()
title = "{} {}".format(cart_item.variation.product.name, cart_item.variation.name)
if cart_item.variation.color:
title = "{} {}".format(title, cart_item.variation.color.name)
json_data.append({
'title': title,
'price': float(cart_item.variation.price),
'count': cart_item.count,
'total_price': float(cart_item.total_price)
})
order.products = json_data
order.total_price = Decimal(total_price)
order.order_unique_id = uuid.uuid4()
order.save()
order_detail_url = reverse_lazy('orders:order_detail', args=[order.phone, order.order_unique_id])
data = {'message': _('Order successful placed'), 'status': 'success', 'redirect_url': order_detail_url}
return JsonResponse(data=data, safe=False)
def confirm_order_view(request):
data_basket = []
summa = 0
order = Order(user=request.user, status="new", summa_invoice=0)
order.save()
try:
basket_session = request.session['basket']
except KeyError:
basket_session = {}
index = 0
for priceid in basket_session:
item = Price.objects.get(id=priceid)
OrderItem.objects.create(order=order,
priceitem=item,
cost=item.cost,
count=basket_session[priceid],
provider=item.provider,
nomenclature=item.nomenclature,
brend=item.brend,
articul=item.articul)
summa += basket_session[priceid] * item.cost
order.summa_invoice = round(summa, 2)
order.save()
send_order2email(order.id)
request.session['basket'] = {}
template = loader.get_template('confirm_order.htm')
context = {
'title_html': "Hi",
'user': "******" + request.user.username,
'response': "Ваш заказ №" + str(order.id) + " оформлен",
}
return HttpResponse(template.render(context, request))
def test_import_payeer_invalid_status(self, convert_to_cash, trans_hist):
convert_to_cash.return_value = None
sender = 'zaza'
# TODO: get fixutre
trans_hist.return_value = {
'1': {
'id': '1',
'type': 'transfer',
'status': 'None',
'creditedCurrency': self.EUR.code,
'creditedAmount': str(self.payeer_order_data['amount_quote']),
'to': 'tata',
'shopOrderId': self.payeer_order_data['unique_reference'],
'comment': self.payeer_order_data['unique_reference'],
'from': sender
}
}
order = Order(**self.payeer_order_data)
order.save()
import_payeer_payments = PayeerPaymentChecker()
import_payeer_payments.run()
p = Payment.objects.filter(amount_cash=order.amount_quote,
currency=order.pair.quote,
reference=order.unique_reference)
self.assertEqual(0, len(p))
def test_confirm_order_payment_with_okpay_celery(self, history,
convert_to_cash,
validate):
history.return_value = get_ok_pay_mock()
convert_to_cash.return_value = None
validate.return_value = True
order = Order(**self.okpay_order_data)
order.save()
import_okpay_payments = OkPayPaymentChecker()
import_okpay_payments.run()
p = Payment.objects.filter(amount_cash=order.amount_quote,
currency=order.pair.quote,
reference=order.unique_reference)
self.assertEqual(1, len(p))
pref = PaymentPreference.objects.filter(payment=p[0])
self.assertEqual(1, len(pref))
self.assertEqual(pref[0].identifier, '*****@*****.**')
self.assertEqual(pref[0].secondary_identifier, 'OK487565544')
# apply second time - should not create another payment
import_okpay_payments.run()
p = Payment.objects.filter(amount_cash=order.amount_quote,
currency=order.pair.quote,
reference=order.unique_reference)
self.assertEqual(1, len(p))
order.refresh_from_db()
# check that pref is intact
pref = PaymentPreference.objects.filter(payment=p[0])
self.assertEqual(1, len(pref))
self.assertEqual(pref[0].identifier, '*****@*****.**')
self.assertEqual(pref[0].secondary_identifier, 'OK487565544')
# self.assertIn(order.status, Order.IN_PAID)
# FIXME: CANCEL because fiat needs refactoring
self.assertEqual(order.status, Order.CANCELED)
def order_create(request):
# Getting data
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
content = json.loads(body['order_data'])
# Getting the new sequence
new_sequence = Order.objects.order_by("-id")[0].id
new_sequence += 1
# Creating the object to save
order = Order(id=new_sequence,
date=content['date'],
state='A',
observation=content['observation'],
commentary=content['commentary'],
warehouse_id=content['warehouse']['code'],
branch_id=content['branch']['code'],
travel_id=content['travel']['code'],
applicant_id=content['applicant']['id'],
user_created=content['userCreated'],
date_created=content['dateCreated'])
order.save()
detail_sequence = 0
for d in content['detail']:
detail_sequence += 1
OrderDetail.objects.create(order_id=new_sequence,
sequence=detail_sequence,
quantity=d['quantity'],
detail=d['detail'])
return JSONResponse({'id': new_sequence}, status=status.HTTP_200_OK)
def test_order_clean(mocker: MockFixture):
"""Should run the filler."""
order = Order()
order.validators = []
order.filler = mocker.MagicMock()
order.clean()
order.filler.assert_called_once()
def confrm_checkout(request):
if len(request.session['cart']) != 0:
if request.method == 'POST':
name = request.POST['name']
phone = request.POST['phonenumber']
email = request.POST['email']
address = request.POST['address']
user_id = request.user.id
if name and phone and email and address:
for key,value in request.session['cart'].items():
item = value['title']
quantity = value['quantity']
price = value['price']
total = (float(quantity) * float(price))
order = Order(item=item,quantity=quantity,price=price,total=total,name=name,phone=phone,email=email,address=address,user_id=user_id)
order.save()
cart_clear(request)
messages.success(request,'Order Created SuccessFully')
return redirect('users:dashboard')
else:
messages.info(request,'Filled All The Field')
return redirect('cart:checkout')
else:
messages.warning(request,'SomeThing Went Wrong')
return redirect('cart:checkout')
else:
messages.info(request,"Your cart Is Empty")
return redirect('/')
def model_form_upload(request):
upload_check = False
if request.method == 'POST':
upload_check = False
current_user = request.user
order_list = Order.objects.filter(user=current_user,
is_finished=False).order_by('-id')
if len(order_list) > 0:
order = order_list[0]
else:
order = Order(user=current_user)
order.save()
form = DocumentForm(request.POST, request.FILES)
if form.is_valid:
document = form.save(commit=False)
document.user = current_user
document.order = order
document.save()
# order.is_finished = True
upload_check = True
else:
print(form.errors)
else:
form = DocumentForm()
return render(request, 'relatedpages/upload.html', {
'form': form,
'upload_check': upload_check
})
def createOrder(self, order_details):
order = Order(order_details=[
OrderDetail(product_id=order_detail['product_id'],
product_name=order_detail['product_name'],
price=order_detail['price'],
quantity=order_detail['quantity'],
currency=order_detail['currency'])
for order_detail in order_details
])
self.order_db.add(order)
self.order_db.commit()
order = OrderSchema().dump(order).data
try:
# self.event_dispatcher('order_created', {
# 'order': order
# })
self.products_rpc.handleOrderCreated({'order': order})
except RemoteError as ex:
self.logger.info("orders.createOrder: %s" % ex)
raise OutOfStock(str(ex))
# self.logger.info("createOrder: order: %s" % order)
# Hide real Id from DB
order['hash_id'] = self.hashids.encrypt(order['id'])
return order
def make_order(request):
carts = Cart.objects.filter(c_user=request.user).filter(c_is_select=True)
temp = []
for cart in carts:
if cart.c_goods.g_project_id not in temp:
temp.append(cart.c_goods.g_project.id)
cart_objs = Cart.objects.filter(c_user=request.user).filter(
c_goods__g_project_id=cart.c_goods.g_project_id).filter(
c_is_select=True)
order = Order()
order.o_user = request.user
order.o_merchant = cart.c_goods.g_project.p_merchant
order.o_price = get_total_price_ordering(request.user.id,
cart.c_goods.g_project_id)
order.save()
addressid = request.GET.get('addressid')
address = Address.objects.get(pk=addressid)
address_copy = AddressCopy()
address_copy.a_order = order
address_copy.a_name = address.a_name
address_copy.a_phone = address.a_phone
address_copy.a_address = address.a_address
address_copy.a_code = address.a_code
address_copy.save()
for cart_obj in cart_objs:
orderGoods = OrderGoods()
orderGoods.o_order = order
orderGoods.o_goods_num = cart_obj.c_goods_num
orderGoods.o_goods = cart_obj.c_goods
orderGoods.save()
cart_obj.delete()
data = {'status': 200, 'msg': 'ok', 'order_id': order.id}
return JsonResponse(data=data)
def create_order(data):
order = Order()
order.address = data['Address']
order.delivery = load_delivery(data['Dostavka'])
#normalized_name = normalize.name(data['Name'])
#order.full_name = normalized_name if normalized_name else data["Name"]
#order.first_name = get_full_name_part(normalized_name, FIRST_NAME_PART)
#order.middle_name = get_full_name_part(normalized_name, MIDDLE_NAME_PART)
#order.last_name = get_full_name_part(normalized_name, LAST_NAME_PART)
order.first_name = data['name']
order.middle_name = data['name']
order.last_name = data['name']
order.phone = data['Phone']
order.email = data['Email']
order.comment = data.get('Comment', '')
order.is_payed = is_payed(data['paymentsystem'])
order.payment_system = data['paymentsystem']
order.total = data['payment']['amount']
order.payment_id = data['payment']['orderid']
order.promo_code = data.get('Промокод', '')
order.save()
order.refresh_from_db()
return order
def test_payment_get_paid(self, mock_Request):
Payment = apps.get_model('getpaid', 'Payment')
order = Order(name='Test PLN order', total='123.45', currency='PLN')
order.save()
payment = Payment(pk=99,
order=order,
amount=order.total,
currency=order.currency,
backend='getpaid.backends.payu')
payment.save(force_insert=True)
payment = Payment.objects.get(
pk=99
) # this line is because django bug https://code.djangoproject.com/ticket/5903
processor = getpaid.backends.payu.PaymentProcessor(payment)
processor.get_payment_status(u'99:1342616247.41')
self.assertEqual(payment.status, u'paid')
self.assertNotEqual(payment.paid_on, None)
self.assertNotEqual(payment.amount_paid, Decimal('0'))
url = 'https://secure.payu.com/paygw/UTF/Payment/get/txt'
callargs = mock_Request.call_args_list
self.assertEqual(url, callargs[0][0][0])
if six.PY3:
self.assertIsInstance(callargs[0][0][1], bytes)
self.assertTrue(b'pos_id=123456789' in callargs[0][0][1])
self.assertTrue(
b'session_id=99%3A1342616247.41' in callargs[0][0][1])
else:
self.assertIsInstance(callargs[0][0][1], str)
self.assertTrue('pos_id=123456789' in callargs[0][0][1])
self.assertTrue(
'session_id=99%3A1342616247.41' in callargs[0][0][1])
def handle(self, *args, **options):
logger = logging.getLogger()
steam_handler = logging.StreamHandler()
steam_handler.setLevel(logging.DEBUG)
logger.addHandler(steam_handler)
try:
request = urllib2.urlopen(
"http://test.ecommerce.io/orders-test.xml")
tree = ET.parse(request)
except:
raise CommandError('Xml file is not valid')
orders = tree.find("orders")
for item in orders.getiterator('order'):
if ((item.find('marketplace').text) is not None)\
and(item.find('order_purchase_date').text is not None)\
and(item.find('order_amount').text is not None)\
and(item.find('order_currency').text is not None)\
and(item.find('order_id').text is not None):
marketplace = item.find('marketplace')
order_purchase_date = item.find('order_purchase_date')
order_amount = item.find('order_amount')
order_currency = item.find('order_currency')
order_id = item.find('order_id')
# add and save a new order
new_order = Order(marketplace=marketplace.text,
order_purchase_date=order_purchase_date.text,
order_amount=order_amount.text,
order_currency=order_currency.text,
order_id=order_id.text)
new_order.save()
else:
logger.warning("A required argument is missing"
" for one order, please look at your xml file.")
def request_product(request, item_id, page_num=None):
try:
product = Products.objects.get(id=item_id)
submitted_orders = Order.objects.filter(status=1).filter(
user_id=request.user.id)
requested_prod_ids = [product.item_id for product in submitted_orders]
# owner should not request their products
# avoid multiple requests for same product
# avoid requests on inactive products
if product.user != request.user and item_id not in requested_prod_ids and product.status < 3:
order = Order(user=request.user,
item=Products.objects.get(id=item_id),
owner=product.user)
order.save()
if product.status == 1:
product.status = 2
product.save()
except Products.DoesNotExist:
raise Http404('Products with id %s is not available' % item_id)
previous_url = request.META['HTTP_REFERER']
if not page_num or 'search_term' in previous_url:
return redirect(previous_url)
return redirect('%s?page=%s' % (reverse('products:items:list'), page_num))
def ordering():
if (sb.temp == 1):
resp = sb.handle("show list")
resp, sb.other = resp
resp = "Processing.... \nEnter your phone number:"
elif (sb.temp == 2):
sb.phone = int(s)
resp = "Processing.... \nEnter your address:"
else:
sb.address = s
for product, quantity in sb.other:
p = Product.objects.get(slug=product)
u = User.objects.get(username=request.user.username)
o = Order(item=product,
quantity=quantity,
price=p.price,
total=(int(quantity) * int(p.price)),
name=request.user.username,
phone=sb.phone,
email=u.email,
address=sb.address,
user_id=u.id)
o.save()
resp = "Adding... \nCheck Dashboard"
sb.handle("clear list")
sb.temp = 0
# print(other)
return HttpResponse(resp)
def test_order_auto_filler_set_contacts(user: User):
"""Should set the order contacts."""
user.first_name = "first name"
user.last_name = "last name"
user.phone = "phone"
order = Order()
order.client = user
OrderAutoFiller(order)._set_contacts()
assert order.first_name == user.first_name
assert order.last_name == user.last_name
assert order.phone == user.phone
order.is_another_person = True
order.first_name = None
order.last_name = None
order.phone = None
OrderAutoFiller(order)._set_contacts()
assert order.first_name is None
assert order.last_name is None
assert order.phone is None
order.is_another_person = False
order.first_name = "new first name"
order.last_name = "new last name"
order.phone = "new phone"
OrderAutoFiller(order)._set_contacts()
assert order.first_name == "new first name"
assert order.last_name == "new last name"
assert order.phone == "new phone"
def save(self, user, commit=True):
from django.contrib.contenttypes.models import ContentType
#
booking = super(BookingForm, self).save(commit=False)
booking.booked_by = user
open_order_list = Order.objects.open_order(user=user)
if open_order_list:
order = open_order_list[0]
if commit:
booking.save()
# Add to open order
if not open_order_list:
order = Order(ordered_by=user)
order.save()
order_item = OrderItem(
order=order,
description=booking.price.__unicode__(),
value=(booking.price.value * booking.quantity),
vat=booking.price.vat,
content_type=ContentType.objects.get_for_model(booking),
object_id=booking.id)
order_item.save()
return booking
def handle(self, *args, **options):
# Récupération du fichier xml
response = requests.get(URL)
data = response.content
# Récupération de la racine du fichier XML
xml_root = et.fromstring(data)
# On récupère le noeud parent qui nous interesse : <orders></orders>
orders = xml_root.find("orders")
# On parcours les balises <order></order>
for order_xml in orders.iter('order'):
# Pour chaque order, on initialise une nouvelle commande
# que l'on remplit puis sauvegarde.
new_order = Order()
new_order.id = order_xml.find("order_id").text
new_order.marketplace = order_xml.find("marketplace").text
new_order.idFlux = order_xml.find("idFlux").text
new_order.order_amount = order_xml.find("order_amount").text
if order_xml.find("order_purchase_date").text is not None:
dt = parser.parse(order_xml.find("order_purchase_date").text)
new_order.order_purchase_date = date(dt.year, dt.month, dt.day)
if order_xml.find("order_purchase_heure").text is not None:
dt = parser.parse(order_xml.find("order_purchase_heure").text)
new_order.order_purchase_heure = time(dt.hour, dt.minute,
dt.second)
new_order.save()
def checkout(request, slug):
order = Order.objects.get(slug=slug)
order_items = OrderItem.objects.filter(order=order)
order_total = 0
order_items_total = 0
order.customer = request.user
for item in order_items:
subtotal = item.quantity * item.unity_price
order_total = order_total + subtotal
order_items_total = order_items_total + item.quantity
if order.status == "pending":
order.status = "on_hold"
order.save()
restaurant = order.restaurant
order = Order(restaurant=restaurant)
order.save()
request.session["order_slug"] = order.slug
context = {
'order': order,
'order_items': order_items,
'order_total': order_total,
'order_items_total': order_items_total,
}
return render(request, 'orders/simple_checkout.html', context=context)
