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)
