def post(self, request, *args):
if not request.user.first_name or not request.user.last_name:
content = {
"warning":
"to make an order user has to register a recipient first"
}
return HttpResponse(json.dumps(content),
status=status.HTTP_304_NOT_MODIFIED)
recipient = Recipient.objects.filter(
name=request.user.first_name,
surname=request.user.last_name).first()
if not recipient:
content = {
"warning":
"the recipient doesn't found. try to set up a new one"
}
return HttpResponse(json.dumps(content),
status=status.HTTP_304_NOT_MODIFIED)
serializer_class = OrderSerializer(
data={
'delivery_address': request.data['delivery_address'],
'product_set': request.data['product_set'],
'user': request.user.pk,
'recipient': recipient.pk
})
if not serializer_class.is_valid():
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer_class.save()
return Response(serializer_class.data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def put(self, request, order_id):
order = self.get_object(order_id)
serializer = OrderSerializer(instance=order, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.errors})
def post(self, request, pk):
order = get_object_or_404(Order, pk=pk)
serializer = OrderSerializer(order, data=request.data)
if not serializer.is_valid():
return Response({'serializer': serializer, 'order': order})
serializer.save()
return redirect('order')
def post(self, request, format=None):
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
date = serializer.validated_data.get("date")
order_items = serializer.validated_data.get("items")
for i in order_items:
item = Item.objects.get(pk=i.get("id"))
if ItemHistory.objects.filter(date=date, item=item).exists():
item_sold = ItemHistory.objects.get(date=date, item=item)
item_sold.amount = F('amount') + i.get("amount")
item_sold.save()
else:
item_sold = ItemHistory.objects.create(date=date, item=item, amount=i.get("amount"))
if Composition.objects.filter(item=item).exists():
item_components = list()
queryset = Composition.objects.filter(item=item)
for entry in queryset:
item_components.append((entry.component, entry.amount),)
for component in item_components:
if ComponentHistory.objects.filter(date=date, component=component[0]).exists():
component_spent = ComponentHistory.objects.get(date=date, component=component[0])
component_spent.amount = F('amount') + (component[1] * i.get("amount"))
component_spent.save()
else:
component_spent = ComponentHistory.objects.create(date=date, component=component[0], amount=(component[1]*i.get("amount")))
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def partial_update(self, request, pk=None):
order = Order.objects.all().get(id=pk)
seller_id = order.seller_id
user_id = order.user_id
car_id = order.car_id
car = Car.objects.all().get(id=car_id)
buyer = User.objects.all().get(id=user_id)
buyer.balance = buyer.balance - car.price
buyer_serializer = UserSerializer(buyer,
data=model_to_dict(buyer),
partial=True)
buyer_serializer.is_valid(raise_exception=True)
buyer_serializer.save()
seller = User.objects.all().get(id=seller_id)
seller.balance = seller.balance + car.price
seller_serializer = UserSerializer(seller,
data=model_to_dict(seller),
partial=True)
seller_serializer.is_valid(raise_exception=True)
seller_serializer.save()
order.status = 1
serializer = OrderSerializer(order,
data=model_to_dict(order),
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def create(self, request):
slr = OrderSerializer(data=request.data, context={'request': request})
if slr.is_valid():
slr.save()
return Response(slr.data)
else:
return Response(slr.errors, status=400)
def orders(request):
try:
orders = Order.objects.all()
except Order.DoesNotExist as e:
return Response({'error': str(e)})
if request.method == 'GET':
serializer = OrderSerializer(orders, many=True)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = OrderSerializer(instance=orders, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.errors})
elif request.method == 'POST':
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
elif request.method == 'DELETE':
orders.delete()
return Response({'deleted': True})
def put(self, request, ord_uuid):
order = self.get_object(ord_uuid)
serializer = OrderSerializer(order, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk=None):
order = self.getOrder(pk)
serializer = OrderSerializer(instance=order, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(self.serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, pk):
order = self.get_object(pk)
if request.user.account_type == 2:
data_to_edit = {'status': request.data["status"], 'delivery': request.data["delivery"]}
serializer = OrderSerializer(
order, data=data_to_edit, partial=True)
else:
serializer = OrderSerializer(
order, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, company_id, pk):
try:
request.data["company"] = company_id
order = Order.objects.get(company_id=company_id, pk=pk)
serializer = OrderSerializer(order,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except ObjectDoesNotExist as a:
return JsonResponse(
{"detail": "An error occurred on the server" + str(a)},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def orders_list(request):
permission_classes = (IsAuthenticated)
if request.method == 'GET':
orders = Order.objects.all()
serializer = OrderSerializer(orders, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
elif request.method == 'DELETE':
orders = Order.objects.all()
orders.delete()
def orders_by_user(request, user_id):
try:
user = User.objects.get(id=user_id)
except User.DoesNotExist as e:
return Response({'error': str(e)})
if request.method == 'GET':
orders = user.orders.get_users_orders(user_id)
serializer = OrderSerializer(orders, many=True)
return Response(serializer.data)
elif request.method == 'POST':
request_body = json.loads(request.body)
serializer = OrderSerializer(data=request_body)
if(serializer.is_valid()):
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs):
serializer = OrderSerializer(data=request.data)
# order_tg = 'hell'
if serializer.is_valid():
question = serializer.save()
tgapi(question)
serializer = OrderSerializer(question)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
order = request.data
order["create_date"] = date.today()
car_id = order["car"]
user_id = order["user"]
seller_id = order["seller"]
if user_id is None or car_id is None:
return Response(status=status.HTTP_400_BAD_REQUEST)
# update car
car = Car.objects.all().get(id=car_id)
if car is None:
return Response(status=status.HTTP_404_NOT_FOUND)
if car.status == 1:
return Response(status=status.HTTP_404_NOT_FOUND)
# update user
user = User.objects.all().get(id=user_id)
if user is None:
return Response(status=status.HTTP_404_NOT_FOUND)
if user.balance < car.price:
return Response(status=status.HTTP_406_NOT_ACCEPTABLE)
car.status = 1
serializer_car = CarSerializer(car, data={}, partial=True)
serializer_car.is_valid(raise_exception=True)
serializer_car.save()
# user.balance = user.balance - car.price
# serializer_user = UserSerializer(user, data={}, partial=True)
# serializer_user.is_valid(raise_exception=True)
# serializer_user.save()
serializer = OrderSerializer(data=order)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(status=status.HTTP_201_CREATED)
def post(self, request, format=None):
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
date = serializer.validated_data.get("date")
order_items = serializer.validated_data.get("items")
for i in order_items:
item = Item.objects.get(pk=i.get("id"))
if ItemHistory.objects.filter(date=date, item=item).exists():
item_sold = ItemHistory.objects.get(date=date, item=item)
item_sold.amount = F('amount') + i.get("amount")
item_sold.save()
else:
item_sold = ItemHistory.objects.create(
date=date, item=item, amount=i.get("amount"))
if Composition.objects.filter(item=item).exists():
item_components = list()
queryset = Composition.objects.filter(item=item)
for entry in queryset:
item_components.append(
(entry.component, entry.amount), )
for component in item_components:
if ComponentHistory.objects.filter(
date=date, component=component[0]).exists():
component_spent = ComponentHistory.objects.get(
date=date, component=component[0])
component_spent.amount = F('amount') + (
component[1] * i.get("amount"))
component_spent.save()
else:
component_spent = ComponentHistory.objects.create(
date=date,
component=component[0],
amount=(component[1] * i.get("amount")))
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
if isinstance(request.data, list):
# request having multiple object
serializer = OrderSerializer(data=request.data, many=True)
# get the current hour when the request has been hit
now = datetime.datetime.now()
current_hour = int(now.hour)
current_min = int(now.minute)
# current_hour = 6
# current_min = 2
if (0 <= current_hour <
6) or 13 < current_hour < 16 or current_hour == 24 or (
current_hour == 13
and current_min > 0) or (current_hour == 23
and current_min > 0):
return Response(
{
"Time":
"wrong order timing, please order between 6-9,9-13,16-19,19-23"
},
status=status.HTTP_400_BAD_REQUEST)
if serializer.is_valid():
slot_weight = self.check_per_slot_100kg(request.data)
if slot_weight:
vehicle_limit_pending_per_day = (
self.check_vehicle_per_day_limit_exceeded())[0]
if vehicle_limit_pending_per_day:
# List of [truck, bike, scooter]
vehicle_limit_pending_list_per_day = (
self.check_vehicle_per_day_limit_exceeded())[1]
weight = request.data
weight = sorted(weight,
key=lambda we: we['order_weight'],
reverse=True)
current_slot_list = self.slot_list(
current_hour, current_min)
if current_slot_list == [6, 9]:
# order_assignment(self, weight, truckAvailable, bikeAvailable, scooterAvailable):
# return truck, scooter, bike
if weight[0]['order_weight'] > 50:
return Response(
{
"order_weight":
"Since Truck is not available maximum weight that can be handle by scooter i.e 50 and request is exceeding that"
},
status=status.HTTP_400_BAD_REQUEST)
truck, scooter, bike = self.order_assignment(
request.data, False, True, True)
elif current_slot_list == [9, 13]:
truck, scooter, bike = self.order_assignment(
request.data, True, True, True)
elif current_slot_list == [16, 19]:
truck, scooter, bike = self.order_assignment(
request.data, True, True, True)
elif current_slot_list == [19, 24]:
truck, scooter, bike = self.order_assignment(
request.data, True, False, False)
bike_delivery_partners = DeliveryPartner.objects.filter(
is_available=True,
vehicle_type="Bike").values('delivery_partner_id')
bike_delivery_partners_list = []
if bike_delivery_partners:
for i in bike_delivery_partners:
bike_delivery_partners_list.append(
i['delivery_partner_id'])
scooter_delivery_partners = DeliveryPartner.objects.filter(
is_available=True, vehicle_type="Scooter").values(
'delivery_partner_id')
scooter_delivery_partners_list = []
if scooter_delivery_partners:
for i in scooter_delivery_partners:
scooter_delivery_partners_list.append(
i['delivery_partner_id'])
truck_delivery_partners = DeliveryPartner.objects.filter(
is_available=True,
vehicle_type="Truck").values('delivery_partner_id')
truck_delivery_partners_list = []
if truck_delivery_partners:
for i in truck_delivery_partners:
truck_delivery_partners_list.append(
i['delivery_partner_id'])
assign_data = []
if truck != [] or truck != [[]]:
if not truck_delivery_partners:
return Response(
{
"delivery partner":
"Delivery boy is not available for Truck today"
},
status=status.HTTP_400_BAD_REQUEST)
for truck_list_iterator in truck:
current_truck_dic = {'vehicle_type': "Truck"}
if not truck_delivery_partners_list:
return Response(
{
"delivery partner":
"Delivery boy is not available for Truck today"
},
status=status.HTTP_400_BAD_REQUEST)
else:
current_truck_dic[
"delivery_partner_id"] = truck_delivery_partners_list[
0]
truck_delivery_partners_list.pop(0)
current_truck_dic[
'list_order_ids_assigned'] = truck_list_iterator
assign_data.append(current_truck_dic)
if scooter != [] or scooter != [[]]:
if not scooter_delivery_partners:
return Response(
{
"delivery partner":
"Delivery boy is not available for Truck today"
},
status=status.HTTP_400_BAD_REQUEST)
for scooter_list_iterator in scooter:
current_scooter_dic = {}
current_scooter_dic['vehicle_type'] = "Scooter"
if not scooter_delivery_partners_list:
return Response(
{
"delivery partner":
"Delivery boy is not available for Scooter today"
},
status=status.HTTP_400_BAD_REQUEST)
else:
current_scooter_dic[
"delivery_partner_id"] = scooter_delivery_partners_list[
0]
scooter_delivery_partners_list.pop(0)
current_scooter_dic[
'list_order_ids_assigned'] = scooter_list_iterator
assign_data.append(current_scooter_dic)
if bike != [] or bike != [[]]:
if not bike_delivery_partners:
return Response(
{
"delivery partner":
"Delivery boy is not available for Bike today"
},
status=status.HTTP_400_BAD_REQUEST)
for bike_list_iterator in bike:
current_bike_dic = {}
current_bike_dic['vehicle_type'] = "Bike"
if not bike_delivery_partners_list:
return Response(
{
"delivery partner":
"Delivery boy is not available for Bike today"
},
status=status.HTTP_400_BAD_REQUEST)
else:
current_bike_dic[
"delivery_partner_id"] = bike_delivery_partners_list[
0]
bike_delivery_partners_list.pop(0)
current_bike_dic[
'list_order_ids_assigned'] = bike_list_iterator
assign_data.append(current_bike_dic)
print("assigned data", assign_data)
# example
# assign_data = [
# {
# "vehicle_type":"Scooter",
# "delivery_partner_id":15,
# "list_order_ids_assigned": [11],
# }
# ]
assign_serializer = AssignedOrderSerializer(
data=assign_data, many=True)
if assign_serializer.is_valid():
serializer.save()
assign_serializer.save()
return Response(assign_data,
status=status.HTTP_201_CREATED)
else:
return Response(
{
"vehicle_limit":
"vehicle limit exceeded for today"
},
status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
return Response(
{"slot_weight": "weight exceeded for this slot"},
status=status.HTTP_400_BAD_REQUEST)
else:
# if orderid already exist
return Response(
{
"order":
"Request is expecting a list of object. For example - [{order_id: 1, order_weight:30}]"
},
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_400_BAD_REQUEST)
def orderUpdate(request, id):
order = Order.objects.get(id=id)
serializer = OrderSerializer(instance=order, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
def post(self, request):
serializer = OrderSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
