def create(self, request, *args, **kwargs): if "items" in request.data: buffer = get_lines_items(request.data["items"]) request.data["items"] = [] else: return Response({"error": "empty orders"}) _o = OrderSerializer(data=request.data) if _o.is_valid(): order = _o.save() order.items.add(*buffer) if not self.make_payment(order): order.delete() return Response({ "success": False, "message": "Not enough Balance" }) goods = [] for item in order.items.all(): if item.product.require_manual_activation: print(f"ORDER {order.id} STATUS Require manual activation") order.status = 1 _o = OrderSerializer(order) headers = self.get_success_headers(_o.data) return Response(_o.data, status=status.HTTP_201_CREATED, headers=headers) gds = Good.objects.filter( product=item.product, status="UNUSED").all()[:item.quantity] if not gds: if gds.count() == 0: print("product not in stock") else: print("there is not enough goods") order.status = 0 order.save() _o = OrderSerializer(order) headers = self.get_success_headers(_o.data) return Response(_o.data, status=status.HTTP_201_CREATED, headers=headers) for good in gds: good.status = "SENT" good.save() goods.append(good.id) order.goods.set(goods) order.status = 2 order.save() _o = OrderSerializer(order) headers = self.get_success_headers(_o.data) return Response(_o.data, status=status.HTTP_201_CREATED, headers=headers) return Response(_o.errors)
def post(self, request, format=None): serializer = OrderSerializer(data=request) 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)
def ChangeStatus(request, orderID, format=None): if request.method == 'PATCH': try: master = orderMaster.objects.get(id=orderID) except product.DoesNotExist: raise Response(status=404) print(master) print(request.data) # master.status = x # master.save() # return JsonResponse( # { # 'success':True # } # ) serializer = OrderSerializer(master, data=request.data, partial=True) if serializer.is_valid(): data = {} #print(serializer.status ) b = serializer.save() # b = serializer.update(master, request.data) print(b) data['success'] = True #data['data'] = b return Response(data) return Response(status=400)
def post(self, request, format=None): pk = request.data['id'] order = self.get_order(pk) 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 post(request): """Create new order for an account""" try: account_name = request.query_params.get('account') account = _get_account_(account_name) except AccountNotFound as err: return Response( data={'error': str(err)}, status=status.HTTP_404_NOT_FOUND, ) client = bitmex( test=BITMEX_TEST_MODE, api_key=account.api_key, api_secret=account.api_secret, ) try: # FIXME: it always raises error: # "Account has insufficient Available Balance" result, _ = client.Order.Order_new( symbol=request.data['symbol'], orderQty=request.data['volume'], side=request.data['side'], ordType='Market', ).result() except HTTPUnauthorized as err: return Response( data={'error': str(err)}, status=status.HTTP_401_UNAUTHORIZED, ) except HTTPNotFound as err: return Response( data={'error': str(err)}, status=status.HTTP_404_NOT_FOUND, ) except HTTPBadRequest as err: return Response( data={'error': str(err)}, status=status.HTTP_400_BAD_REQUEST, ) except KeyError as err: return Response( data={'error': f'Missed mandatory field {err}'}, status=status.HTTP_400_BAD_REQUEST, ) serializer = OrderSerializer( data={ **request.data, 'order_id': result.get('orderID'), 'price': result.get('price'), 'account': account.id, } ) 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)
def create(self, request): serializer = OrderSerializer(data=request.data, context={'request': request}) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = OrderSerializer(data=request.data, context={'request': request}) serializer.is_valid(raise_exception=True) order = serializer.save() return Response({ 'msg': '提交成功', 'order_id': order.id }, status=status.HTTP_200_OK)
def update(self, request, pk): order = get_object_or_404(Order, id=pk) if order.status == 'created': serializer = OrderSerializer(order, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) else: message = 'Вы не можете редактировать заказ в обработке/доставленный заказ/отмененный заказ' return Response({"data": f"{message}"}, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): order_id = request.query_params.get('order_id') if order_id: queryset = Order.objects.get(pk=order_id) serializer = OrderSerializer(queryset) else: queryset = Order.objects.all().prefetch_related('items') serializer = OrderSerializer(queryset, many=True) return Response(serializer.data)
def post(self, request, *args, **kwargs): try: data = JSONParser().parse(request) print(data, type(data)) data['customer'] = request.user.id serializer = OrderSerializer(data=data) if serializer.is_valid(): serializer.save() else: return Response({'status': 'error', 'message': serializer.errors}, status=400) return Response({'status': 'success', 'data': serializer.data}, status=200) except Exception as e: return Response({'status': 'error', 'errors': str(e)}, status=400)
def list(self, request): id_token = request.query_params.get('id_token') uid = get_uid(id_token) if uid != None: try: user = User.objects.get(username=uid) qset = Order.objects.filter(user=user) serializer = OrderSerializer(qset, many=True) return Response(serializer.data) except: serializer = OrderSerializer({}, many=True) return Response(serializer.data) serializer = OrderSerializer(self.queryset, many=True) return Response(serializer.data)
def order_list(request, format=None): """ List all orders, or create a new order. """ if request.method == 'GET': orders = Order.objects.all() serializer = OrderSerializer(orders, many=True) return Response(serializer.data) elif request.method == 'POST': order = Order() order.save() serializer = OrderSerializer(order) return Response(serializer.data)
class OrderCreateView(mixins.CreateModelMixin, GenericViewSet): queryset = Order.objects.none() serializer_class = OrderSerializer permission_classes = [HasStoreProfile] @swagger_auto_schema(request_body=no_body, operation_id='placeOrder', responses={200: OrderSerializer(many=True)}) def create(self, request, *args, **kwargs): """Places orders for all products currently in the cart.""" me = self.request.user.profile with transaction.atomic(): if not me.cart.count(): raise NotFound('No items in cart.') products_by_seller = defaultdict(list) for item in me.cart.all(): # type: CartItem prod = item.product products_by_seller[prod.seller].append( dict(product=prod, quantity=item.quantity, unit=prod.unit, subtotal=prod.unit_price * item.quantity)) orders = [] for seller, products in products_by_seller.items(): order = Order.objects.create(buyer=me, seller=seller) for prod in products: OrderItem.objects.create(order=order, **prod) orders.append(order) me.cart.all().delete() serializer = self.get_serializer(many=True, instance=orders) return Response(serializer.data, status=201)
class ApplicationSerializer(serializers.ModelSerializer): entries = ApplicationEntrySerializer(many=True) contract = ContractSerializer(source='get_contract', read_only=True) account = AccountSerializer(source='get_account', read_only=True) order = OrderSerializer(source='get_order', read_only=True) client = serializers.PrimaryKeyRelatedField(queryset=Client.objects.all(), allow_null=True) class Meta: model = Application fields = 'id', 'date', 'type', 'client', 'entries', 'contract', 'account', 'order' # , 'protocols', def create(self, validated_data): entries = validated_data.pop('entries') if validated_data['client'] is None: validated_data['client'] = Client.objects.create( short_name='<без названия>') application = Application.objects.create(**validated_data) for entry in entries: ApplicationEntry.objects.create(application=application, **entry) return application def update(self, instance: Application, validated_data): ApplicationEntry.objects.filter(application=instance).delete() entries = validated_data.pop('entries') for attr, value in validated_data.items(): setattr(instance, attr, value) for entry in entries: ApplicationEntry.objects.create(application=instance, **entry) instance.save() return instance
def get(self, request, *args, **kwargs): user = request.user query = Order.objects.filter(user=user) serializer = OrderSerializer(query, many=True, context=self.get_renderer_context()) return Response(serializer.data)
def post(self, request): # TODO: check deference between tests and browser request if '_content' in request.data: requested_data = json.loads(request.data['_content']) else: requested_data = json.loads(request.data) self.check_request_format(requested_data) requested_order = requested_data['order'] order_id = requested_order['id'] # TODO: validate currency code corresponds to the international standard currency = requested_order.get('currency') items = requested_order['items'] try: # checks if we already have the order in the system order = Order.objects.get(id=order_id) except Order.DoesNotExist: order = Order.objects.create(id=order_id, currency=currency) for item in items: product = self.check_product_info(item) ProductQuantity.objects.create(order=order, product=product, quantity=item['quantity']) serialize_fields = ('id', 'items', 'currency', 'total_price', 'total_vat', 'customer') serializer = OrderSerializer(order, fields=serialize_fields) return Response(serializer.data)
def orders(request, id, *args, **kwargs): try: # must be Json array having 'n' strings raw_fields = request.GET.get(EXTRA_PARAMS['FIELDS'], None) fields = process_fields_query(raw_fields) except JSONDecodeError: return Response({"errors": { "fields": ['Value must be valid JSON.'] }}, status=status.HTTP_400_BAD_REQUEST) order = None try: if request.user.is_staff: order = Order.objects.get(Q(id=id), ~Q(status='saved')) else: order = request.user.orders.get(id=id) except ObjectDoesNotExist: return Response({'errors': { 'order': ['Does not exist.'] }}, status=status.HTTP_400_BAD_REQUEST) return Response( OrderSerializer(order, fields=fields).data, status=status.HTTP_200_OK, )
class UserSerializer(serializers.ModelSerializer): orders = OrderSerializer(many=True) class Meta: model = User fields = ('username', 'first_name', 'deposit', 'orders' ) # put Chinese name in first_name
def list(self, request): """Lists all orders the user has. Arguments: request: the request data sent by the user, it is used for Pagination Returns: HTTP 403 if user is not authenticated HTTP 200 Response with all orders in JSON. """ queryset = None if hasattr(request.user, 'profile'): queryset = request.user.profile.orders.all() # this is a regular user if hasattr(request.user, 'driver_profile'): queryset = request.user.driver_profile.served_orders.all() # this is a driver if hasattr(request.user, 'shop_profile'): queryset = request.user.shop_profile.served_orders.all() # this is a shop paginator = LimitOffsetPagination() paginator.default_limit = 15 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = OrderSerializer(paginated_queryset, many=True) return Response(data={'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'orders': serializer.data})
class UserSerializer(serializers.ModelSerializer): user_card = CardSerialiser(many=True) user_order = OrderSerializer(many=True) class Meta: model = user fields = ['email', 'nickname', 'user_card', 'follows']
def my_orders(request, format=None): query = request.query_params.get('status') if query: orders = request.user.orders.filter(status=query) else: orders = request.user.orders serializer = OrderSerializer(orders, many=True) return Response(serializer.data)
def post(self, request, format=None): pk_list = request.data['ids'] if pk_list: orders = Orders.objects.filter(pk__in=pk_list) else: orders = Orders.objects.all() serializer = OrderSerializer(orders, many=True) return Response(serializer.data)
def retrieve(self, request, pk): try: order = Order.objects.prefetch_related( 'cart__cart_items__item').get(id=pk) except Order.DoesNotExist: raise Http404 serializer = OrderSerializer(order) return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request, order_id=None): if self.request.user.optiz: queryset = Order.objects.all() else: queryset = self.queryset.filter( order_company=self.request.user.user_company) serializer = OrderSerializer(queryset, many=True) return Response(serializer.data)
def get(self, req, pk): # Get Property Data property_info = self.get_property(pk) property_json = PopulatedPropertySerializer(property_info) # Get Order (if found) order = get_active_order(req.user.id, pk ) # Send JSON data to client with or without order details if necessary if len(order) != 0: order_json = OrderSerializer(order[0]) order_json.data['value_change'] = value_change(previous=order_json.data['value_at_time'], current=property_json.data['current_valuation']) return Response({'property':property_json.data, 'order': order_json.data} , status=status.HTTP_200_OK ) return Response({'property':property_json.data, 'order': None} , status=status.HTTP_200_OK )
def OrderList(request): if request.method == 'GET': try: order = orderMaster.objects.all() except product.DoesNotExist: raise Response(status=404) serializer = OrderSerializer(order, many=True) return Response(serializer.data)
def post(self, request, *args, **kwargs): cartList = Cart.objects.filter(user_id=self.request.user.id) n = random.randint(0,123445) # shuffle list # convert list to string now = datetime.datetime.now() finalStr = '' user = User.objects.get(id=self.request.user.id) mrp = 'mrp1' try: mrp = user.profile.state.dbp except Exception as e: pass order, created = Order.objects.get_or_create(orderId = n, total = 0, user = user,addedon = datetime.datetime.now()) totalPrice = 0 if cartList.exists(): for cart in cartList: finalStr = 'EC/'+str(now.year)+'/OR'+str(cart.product.category.id)+str(n) cart_product = cart.product.mrp1 if mrp=='dbp1': cart_product = cart.product.dbp1 cart_quantity = cart.quantity totalPrice = totalPrice+int(cart_product)*int(cart_quantity) OrderDetail.objects.create(order_number=finalStr, order = order, product_id = cart.product_id, quantity = cart.quantity, user = user,addedon = datetime.datetime.now()) cart.delete() order.total = totalPrice order.save() oreder_data = OrderSerializer(order) queryset = OrderDetail.objects.filter(order_id=order.id).distinct().values('order_number') csv_arr = [] for csvorder in queryset: orderMain = OrderDetail.objects.filter(order_number=csvorder['order_number']) data = OrderDetailSerializer(orderMain,many=True) for order in data.data: arr = {} arr['Ecatalogue_orderno'] = csvorder['order_number'] arr['Ecatalogue_orderDate'] = order['addedon'] arr['Customer_Code'] = order['user'] arr['Shipping_point'] = "" arr['line_no'] = 1 arr['Item_Code'] = "'"+str(order['product']['item_code']) arr['Item_Variant'] = order['product']['variant'] arr['Quantity'] = order['quantity'] arr['Remarks'] = "" arr['Company_Code'] = user.profile.company_code csv_arr.append(arr) csvfilename = str(csvorder['order_number']) csvfilename = 'EC-00-'+str(n)+'-OR.csv' filename = settings.MEDIA_ROOT+'/order_csv/'+csvfilename csv_url = settings.ROOT_URL+'/api/media/order_csv/'+csvfilename try: write_to_csv(csv_arr,filename) sendemail(oreder_data.data,csv_url) except Exception as e: pass return Response('created')
class CustomerSerializer(serializers.ModelSerializer): carts = ShoppingCartSerializer(read_only=True, many=True) orders = OrderSerializer(read_only=True, many=True) class Meta: model = models.User fields = ('id', 'username', 'password', 'email', 'is_staff', 'first_name', 'last_name', 'date_joined', 'last_login', 'carts', 'orders') extra_kwargs = {'password': {'write_only': True}}
def assigned_orders(request, format=None): query = request.query_params.get('status') if query: orders = request.user.picks.filter(status=query) else: orders = request.user.picks.exclude( status=Order.STATUS_CANCELLED).exclude( status=Order.STATUS_COMPLETED) serializer = OrderSerializer(orders, many=True) return Response(serializer.data)
def get(self, request, pk, format=None): queryset = self.request.user.enterprise.order.filter(id=pk) #pk = self.kwargs.get('pk') #orderitems=Order.objects.filter(id=pk) serializer = OrderSerializer(queryset, many=True) return Response(serializer.data)
def post(self, request, format=None): 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)