def detail(request, app_key):
user = request.user
app = get_object_or_404(App, key=app_key)
if request.method == 'GET':
try:
user_app = UserApp.objects.get(user=user, app__key=app_key)
except UserApp.DoesNotExist:
pass
plans = AppPlan.objects.filter(app=app, available=True)
context = {}
context['app'] = app
context['plans'] = plans
return render(request, 'market/{}.html'.format(app_key), context)
else:
plan_id = request.POST.get('plan')
amount = int(request.POST.get('amount'))
plan = AppPlan.objects.get(id=int(plan_id))
price = plan.price
days = plan.period * amount
order = Order(price=price,
amount=amount,
period=plan.period,
user=user,
app=app,
plan=plan)
order.save()
return redirect("market_order", id=order.id)
def post(self, request, format=None):
o = Order()
#o.consumer = request.user.userprofile
o.save()
for item in request.data.get('products'):
product = Product.objects.get(pk = item['product'])
op = OrderProduct()
op.product = product
op.order = o
op.phone = request.data.get('phone')
op.ammount = item['ammount']
op.save()
noty = Notification()
noty.product = product
#noty.consumer = request.user.userprofile
noty.phone = request.data.get('phone')
noty.provider = product.user
noty.ammount = item['ammount']
noty.save()
async_to_sync(channel_layer.group_send)("notifications", {"type": "send_notify"})
return Response(OrderSerializer(o).data)
def post(self, request):
o = Order()
o.consumer = request.user.userprofile
o.save()
for item in request.data.get('products'):
product = Product.objects.get(pk=item['product'])
OrderProduct.objects.create(product=product,
order=o,
amount=item['amount'])
return Response(OrderSerializer(o).data)
def test_order_finish_twice(self):
plan = self.plan1
app = self.app
price = plan.price
amount = 2
order = Order(price=price, amount=amount, period=plan.period, user=self.user, app=app, plan=plan)
order.save()
self.assertTrue(order.state == 0)
now = timezone.now()
order.finish()
userapp = UserApp.objects.get(user=self.user, app=app)
self.assertTrue(userapp.plan == plan)
self.assertTrue((userapp.expired_time - now).days == 60)
self.assertTrue(order.state == 1)
self.assertTrue(OrderLock.objects.get(order=order))
self.assertTrue(UserApp.objects.is_active(self.user, app.key))
#: finish order again
order.finish()
userapp = UserApp.objects.get(user=self.user, app=app)
self.assertTrue(userapp.plan == plan)
self.assertTrue((userapp.expired_time - now).days == 60)
self.assertTrue(order.state == 1)
self.assertTrue(OrderLock.objects.get(order=order))
def test_can_get_userpage_values(self):
"""
Test that get_userpage_values retrieves a dictionary with
the votes, purchases, coin_history, and SuggestionAdminPages
for that user
"""
new_user = User(username="******", email="*****@*****.**", password="******")
new_user.save()
suggestion_1 = Suggestion(is_feature=True, user=new_user, title="Userpage suggestion 1",
details="Any old details", delay_submission=False)
suggestion_1.save()
suggestion_2 = Suggestion(is_feature=True, user=new_user, title="Userpage suggestion 2",
details="Any old details")
suggestion_2.save()
suggestion_admin_1 = SuggestionAdminPage(suggestion=suggestion_1)
suggestion_admin_1.save()
suggestion_admin_2 = SuggestionAdminPage(suggestion=suggestion_2)
suggestion_admin_2.save()
for i in range(5):
random_suggestion = choice(Suggestion.objects.all())
upvote = Upvote(suggestion=random_suggestion, user=new_user)
upvote.save()
random_coin_transaction = choice(range(1, 10))
coin_history_entry = UserCoinHistory(user=new_user, coins_change=1, transaction=random_coin_transaction)
coin_history_entry.save()
order = Order(user=new_user)
order.save()
random_store_item = choice(StoreItem.objects.all())
order_item = OrderItem(order=order, item=random_store_item, quantity=1, total_purchase_price=1)
order_item.save()
userpage_values = get_userpage_values(new_user)
self.assertEqual(len(userpage_values["coin_history"]), 5)
random_purchase = choice(userpage_values["purchases"])
self.assertTrue(isinstance(random_purchase, Order))
random_coin_history = choice(userpage_values["coin_history"])
self.assertTrue(isinstance(random_coin_history, UserCoinHistory))
random_vote = choice(userpage_values["votes"])
self.assertTrue(isinstance(random_vote, Upvote))
random_suggestion_admin = choice(userpage_values["suggestions"])
self.assertTrue(isinstance(random_suggestion_admin, SuggestionAdminPage))
async def on_order(self, order):
print(f"on_order: {order}")
if order["type"] in ["received", "match", "done", "change"]:
return
try:
_price = Decimal(order["price"])
_amount = Decimal(order["size"])
self.orm_cache.append(
Order(
exchange=exchange,
symbol=symbol,
sequence=order["sequence"],
order_id=order["orderId"],
side=OrderSideEnum.SELL.name
if order["side"] == "sell" else OrderSideEnum.BUY.name,
time=ts_to_dt(int(order["time"]) / 10**9),
price=_price,
amount=_amount,
value=_price * _amount,
))
except Exception as e:
logger.error(e)
finally:
if len(self.orm_cache) >= 50:
Order.objects.bulk_create(self.orm_cache,
ignore_conflicts=True)
self.orm_cache = []
def shopping_cart(request):
if request.method != "GET":
return JsonResponse(data={"message": "Wrong method"}, status=400)
# is_active is a field for user model and is_authenticated is a function for user model.
if request.user.is_authenticated and request.user.is_active:
order = Order.initiate(request.user.customer)
return JsonResponse(order.to_dict(), status=200)
else:
return JsonResponse(data={"message": "You are not logged in."}, status=403)
def checkout(request):
order = Order()
i = 0
total_qty = 0
total_price = 0.0
while request.POST.get('productId_' + str(i), None) is not None:
product_id = request.POST.get('productId_' + str(i))
qty = int(request.POST.get('qty_' + str(i)))
total_qty = total_qty + qty
product = Product.objects.get(pk=product_id)
total_price = total_price + product.price_sale
product.qty -= qty
product.save()
# Handle database
# 1- Decrease product count (qty) - read from database [[product = Product.objects.get(pk=product_id)]]
# 2- Add Entry (row) or (save) in order-item table and order (Create order )
i += 1
order.total_qty = total_qty
order.total_price = total_price
order.save()
del request.session[CART_KEY]
return home(request)
def test_creating_order_requires_a_user_value_only(self):
"""
Test to check that creating an Order object only requires
a value for user. delivery_address is optional. date_time should
be set to current datetime
"""
new_user = User.objects.create(username="******", email="*****@*****.**", password="******")
only_user_order = Order(user=new_user)
only_user_order.save()
retrieved_order = Order.objects.get(user=new_user)
self.assertEqual(retrieved_order.date_time.date(), datetime.date.today())
with self.assertRaises(IntegrityError):
order_without_user = Order()
order_without_user.save()
def buy(request, product_code):
amount = 0
if request.method == 'POST':
buy_form = OrderRowForm(request.POST or None)
if buy_form.is_valid():
amount = buy_form.cleaned_data.get('amount')
customer = list(Customer.objects.filter(user=request.user))[0]
product_obj = Product.objects.get(code=product_code)
order_product = Order(customer=customer, status=1)
order_product.add_product(product_obj, amount=amount)
order_product.submit()
order_product.send()
return redirect('product')
else:
product_obj = Product.objects.get(pk=product_code)
return render(request, 'buy.html', {'product_obj': product_obj})
def add_items(request):
if request.method != "POST":
return JsonResponse(data={"message": "Wrong method"}, status=400)
try:
if request.user.is_authenticated and request.user.is_active:
data = json.loads(request.body.decode('utf-8'))
try:
if not isinstance(data, list):
raise Exception()
except:
return JsonResponse(data={"message": "Can't read message body"}, status=400)
order = Order.initiate(request.user.customer)
errors = []
for item in data:
if 'code' in item and 'amount' not in item:
errors.append({'code': item['code'],
'message': "Item has no 'amount' property."
})
continue
if 'code' not in item:
errors.append({'code': "???",
'message': "Item has no 'code' property."
})
continue
try:
if Product.objects.filter(code=item['code']).exists():
order.add_product(Product.objects.get(code=item['code']), item['amount'])
else:
raise Exception("Product not found.")
except Exception as e:
errors.append({'code': item['code'],
'message': str(e)
})
if errors:
return JsonResponse(order.to_dict(errors), status=400)
else:
return JsonResponse(order.to_dict(), status=200)
else:
return JsonResponse(data={"message": "You are not logged in."}, status=403)
except Exception as e:
return JsonResponse(data=str(e), status=400)
def post(self, request):
order = Order()
total_price = 0.0
total_qty = 0
while request.data.get('product_id'):
product = request.data.get('product_id')
qty = request.data.get('qty')
product_id = Product.objects.get(pk=product)
total_price = total_price + product_id.sale_price
total_qty = total_qty + qty
product_id.qty -= qty
product.save()
order.total_qty = total_qty
order.total_price = total_price
order.save()
return Response(status=status.HTTP_201_CREATED)
def submit(request):
if request.method != "POST":
return JsonResponse(data={"message": "Wrong method"}, status=400)
try:
if len(json.loads(request.body.decode('utf-8'))):
raise Exception("")
except:
return JsonResponse({"message": "Can't read request body."}, status=400)
try:
if request.user.is_active and request.user.is_authenticated:
data = json.loads(request.body.decode('utf-8'))
if not isinstance(data, dict):
return JsonResponse({'message': 'Not able to read your request body.'}, status=404)
order = Order.initiate(request.user.customer)
try:
order.submit()
except Exception as e:
return JsonResponse({"message": str(e)}, status=400)
return JsonResponse(order.toDict(), status=200)
else:
return JsonResponse(data={"message": "You are not logged in."}, status=403)
except Exception as e:
return JsonResponse(data=str(e), status=400)
def order(request):
template = 'orders.html'
if request.method == 'POST':
cart = request.session.get('cart')
cart = json.dumps(cart)
user = request.user
new_order = Order(cart=cart, user=user)
new_order.make_pretty_cart()
new_order.save()
request.session['cart'].clear()
request.session.modified = True
context = {
'orders': '',
'result': 'Ваш заказ успешно создан',
'just_ordered': True,
}
context.update(auth_check(request))
return render(request, template, context)
else:
user = request.user
orders = Order.objects.filter(user=user).all()
context = {'orders': orders}
context.update(auth_check(request))
return render(request, template, context)
def setUpTestData(cls):
user_1 = User(username="******")
user_1.save()
user_2 = User(username="******", email="*****@*****.**")
user_2.save()
user_3 = User(username="******", password="******", email="*****@*****.**")
user_3.save()
suggestion_1 = Suggestion(is_feature=True, user=user_1, title="Test Suggestion 1", details="Any old details",
delay_submission=False)
suggestion_1.save()
suggestion_2 = Suggestion(is_feature=True, user=user_2, title="Test Suggestion 2", details="Any old details",
delay_submission=True)
suggestion_2.save()
suggestion_3 = Suggestion.objects.create(is_feature=True, user=user_2, title="Test Suggestion 3",
details="Any old details", delay_submission=False)
suggestion_3.save()
user_1_usercoins = UserCoins(user=user_1, coins=100)
user_1_usercoins.save()
user_2_usercoins = UserCoins(user=user_2, coins=500)
user_2_usercoins.save()
user_3_usercoins = UserCoins(user=user_3, coins=0)
user_3_usercoins.save()
coins_purchase_1 = CoinsPurchase(name="coins purchase 1", coins_price=200)
coins_purchase_1.save()
coins_purchase_2 = CoinsPurchase(name="coins purchase 2", coins_price=500)
coins_purchase_2.save()
suggestion_coins_purchase = CoinsPurchase(name="Suggestion", coins_price=500)
suggestion_coins_purchase.save()
upvote_coins_purchase = CoinsPurchase(name="Upvote", coins_price=100)
upvote_coins_purchase.save()
promote_feature_purchase = CoinsPurchase(name="Feature Suggestion Promotion", coins_price=600)
promote_feature_purchase.save()
coins_store_item_500 = StoreItem(name="500 coins", price=0, delivery_required=False, is_coins=True,
coins_amount=500)
coins_store_item_500.save()
coins_store_item_200 = StoreItem(name="200 coins", price=2, delivery_required=False, is_coins=True,
coins_amount=200)
coins_store_item_200.save()
coins_store_item_1000 = StoreItem(name="1000 coins", price=10, delivery_required=False, is_coins=True,
coins_amount=1000)
coins_store_item_1000.save()
non_coins_store_item = StoreItem(name="not coins", price=5, delivery_required=True, is_coins=False)
non_coins_store_item.save()
order_1 = Order(user=user_1)
order_1.save()
order_2 = Order(user=user_2)
order_2.save()
order_3 = Order(user=user_3)
order_3.save()
