Esempio n. 1
0
def create(request):
    body = json.loads(request.body.decode('utf-8'))
    print(body)
    order = Order(
        **{
            'trader_ip': body['ip'],
            'order_id': body['order_id'],
            'product_code': body['code'],
            's_b': body['s_b'],
            'price': body['price'],
            'type': body['type'],
            'status': 'created',
            'amount': body['amount'],
            'remain': body['amount']
        })
    # first: save to db
    order.save()

    # second: judge the type of the order
    if order.type == 'market':
        execute_market_order(order)
    elif order.type == 'limit':
        execute_limit_order(order)
    elif order.type == 'stop':
        execute_stop_order(order)
    elif order.type == 'cancel':
        execute_cancel_order(order)

    # third: return OK
    return HttpResponse(status=200)
Esempio n. 2
0
    def post(self, request):
        serializer = self.serializer(data=request.data)

        if not serializer.is_valid():
            raise BadRequest(serializer.errors)

        quantity = serializer.validated_data.get('quantity')

        with transaction.atomic():
            try:
                order = Order(
                    customer_id=serializer.validated_data.get('customer_id'))
                order.save()

                order_detail = OrderDetail(
                    quantity=quantity,
                    product_id=serializer.validated_data.get('product_id'),
                    order_id=order.id)
                order_detail.save()

                invoice = Invoice(order_id=order.id,
                                  amount=(quantity *
                                          order_detail.product.price))

                invoice.save()
            except Exception as ex:
                raise BadRequest(ex)

        return Response(data={
            "status": "SUCCESS",
            "invoice_number": invoice.id
        })
def create(request):
    body = json.loads(request.body.decode('utf-8'))
    print(body)
    order = Order(**{
        'trader_ip': body['ip'],
        'order_id': body['order_id'],
        'product_code': body['code'],
        's_b': body['s_b'],
        'price': body['price'],
        'type': body['type'],
        'status': 'created',
        'amount': body['amount'],
        'remain': body['amount']
    })
    # first: save to db
    order.save()

    # second: judge the type of the order
    if order.type == 'market':
        execute_market_order(order)
    elif order.type == 'limit':
        execute_limit_order(order)
    elif order.type == 'stop':
        execute_stop_order(order)
    elif order.type == 'cancel':
        execute_cancel_order(order)

    # third: return OK
    return HttpResponse(status=200)
Esempio n. 4
0
 def create(self, validated_data):
     order_data = copy.deepcopy(validated_data)
     del order_data['items']
     item_list_data = validated_data['items']
     order = Order(**order_data)
     order.save()
     for item_data in item_list_data:
         order_item = OrderItem(**item_data)
         order_item.order = order
         order_item.save()
     return order
Esempio n. 5
0
def post_order(request):
    key = request.GET.get('key')
    menus = request.GET.get('menus')
    prices = request.GET.get('prices')
    counts = request.GET.get('counts')
    order = Order(key=key, menus=menus, prices=prices, counts=counts)
    order.save()
    t = Timer(random.uniform(10.0, 20.0), change_status_order, [order])
    t.start()
    return HttpResponse(serializers.serialize('json', [
        order,
    ]),
                        content_type='application/json')
Esempio n. 6
0
 def post(self, request):
     restaurant = Restaurant.objects.get(pk=request.data['restaurantId'])
     ordered_extras = []
     order = Order(user=request.user, restaurant=restaurant,
                   order_cost=request.data['orderCost'], delivery_address=request.data['deliveryAddress'])
     order.save()
     for dish in request.data['orderedItems']:
         ordered_dish = Dish.objects.get(pk=dish['dishId'])
         ordered_dish_instance = OrderedDish(dish=ordered_dish, order=order)
         ordered_dish_instance.save()
         ordered_extras.extend(list(map(lambda x, d=ordered_dish_instance: OrderedExtra(
             extra=Extra.objects.get(pk=x), dish=d), dish['orderedExtras'])))
     OrderedExtra.objects.bulk_create(ordered_extras)
     serializer = OrderSerializer(order)
     return Response(serializer.data)
Esempio n. 7
0
    def create(self, validated_data):
        data = validated_data.get('data')
        if not data:
            raise ValidationError({'validation_error': 'empty request'})

        orders = [Order(**item) for item in data]
        return Order.objects.bulk_create(orders)
Esempio n. 8
0
def route_order_create(buyer_id, seller_id, line_items):
    order = Order(buyer_id=buyer_id, seller_id=seller_id, line_items=[])
    total = 0
    for li in line_items:
        product = Product.query.filter(Product.id == li['product_id']).first()
        total += li['quantity'] * product.price
        item = LineItem(product=product,
                        order=order,
                        quantity=li['quantity'],
                        unit_price=li['quantity'] * product.price)
        order.line_items.append(item)
    order.total = total
    db.session.add(order)
    db.session.commit()
    db.session.refresh(order)
    return order
Esempio n. 9
0
def payment_result(params):
    calculated_signature = get_signature(params)
    existing_signature = params["signature"]
    # allow testing only if enabled globally
    testing = params["testing"] == "1" and __testing_mode
    if testing or existing_signature == calculated_signature:
        try:
            form = ModulTxnForm(params)
            if form.errors:
                logging.error(
                    f"Modulbank Txn couldn't be validated: {form.errors.as_data()}"
                )
                return 500
            else:
                # save txn (should it be one txn with set_paid?)
                txn: ModulTxn = form.save()

                # then pay an order
                order = Order.set_paid_by(txn)

                # if everything was fine - send application
                send_application(order)
                return 200
        except Exception as e:
            logging.error(e, exc_info=True)
            return 500
    else:
        logging.warning(
            f"Incorrect signature value: Expected {calculated_signature} but got {existing_signature}"
        )
        return 401
Esempio n. 10
0
 def post(self, request, pk='r'):
     rest_id = request.session['id']
     customer_lat = request.data['lat']
     customer_long = request.data['long']
     order_price = request.data['price']
     driver_id = find_driver(rest_id)
     order_obj = Order(
         restaurant_id=rest_id,
         driver_id=driver_id,
         customer_lat=customer_lat,
         customer_long=customer_long,
         order_price=order_price,
         status='S1',
     )
     order_obj.save()
     return Response(None, status=200)
Esempio n. 11
0
def get_order_history(request):
    user = request.auth.user
    customer = Customer.objects.get(id=user.id)
    if customer.basket_free:
        basket_list = BasketListModel.objects.filter(
            user=customer).order_by('basket_group_id')
        orders = []
        for basket_group in basket_list:
            basket_products = Basket.objects.filter(
                basket_group_id=basket_group.basket_group_id, user=customer)
            total_price = 0
            products = []
            for basket in basket_products:
                products.append(basket.product)
                total_price += basket.product.price * basket.quantity
            order = Order(products=products,
                          basket_group=basket_group,
                          total_price=total_price)
            orders.append(order)
        serializer = OrderSerializer(orders, many=True)
        return Response(serializer.data)
    else:
        basket_list = BasketListModel.objects.filter(
            user=customer).order_by('basket_group_id')
        basket_group_it = basket_list[len(basket_list) - 2].basket_group_id
        basket_group = basket_list[len(basket_list) - 2]
        orders = []
        for it in range(1, basket_group_it + 1):
            basket_products = Basket.objects.filter(basket_group_id=it,
                                                    user=customer)
            total_price = 0
            products = []
            for basket in basket_products:
                products.append(basket.product)
                total_price += basket.product.price * basket.quantity

            order = Order(products=products,
                          basket_group=basket_group,
                          total_price=total_price)
            orders.append(order)
        serializer = OrderSerializer(orders, many=True)
        return Response(serializer.data)
Esempio n. 12
0
def add_order():
    email = request.json["mail"]
    order_items = request.json["items"]
    user_id = request.json["user"]

    new_order = Order(email, datetime.datetime.now())

    if user_id:
        new_order.user = user_id

    db.session.add(new_order)
    db.session.commit()

    for item in order_items:
        instance = OrderItem(item["id"], new_order.id, item["quantity"])
        db.session.add(instance)

    db.session.commit()

    return order_schema.dump(new_order)
Esempio n. 13
0
def add_product(request, customer_id):
  # get current cart from cache if current cart does not exist, make a new one
  jsonObj = json.loads(request.body)
  product_id = jsonObj['product_id']
  quantity = jsonObj['quantity']
  product = Product.objects.filter(id=product_id)[0]
  if quantity > product.inventory:
    data = { "error": "not enough inventory"}
  else:
    orderList = Order.objects.filter(customer_id=customer_id, status=0)
    if orderList:
      cart = orderList[0]
    else:
      current_customer = Customer.objects.filter(id=customer_id)[0]
      cart = Order(status=0, customer_id=current_customer)
    # check request object for item
    cart.total_cost = cart.total_cost + (product.unit_cost * quantity)
    cart.save()
    order_detail = OrderDetail(order_id=cart, product_id=product, quantity=quantity)
    order_detail.save()
    data = serializers.serialize("json", [order_detail,])
  return JsonResponse(data, safe=False)
Esempio n. 14
0
    def order(self, request, pk=None):
        """Permet de créer une commande.

         Il faut envoyer un dictionaire dont la valeur "billets" correspondt à un tableau contenat les billest
        """

        clean_old_orders.delay()

        # On récupère l'évenement en s'assurant au passage que l'utilisateur a le droit  d'y accéder
        event = Event.for_user(request.user).get(id=pk)
        # On récupère le client lié à l'user
        client = request.user.client

        # On récupère la commande en cours si il en existe une, sinon on la crée
        order = client.orders.filter(event=event, status__lt=Order.STATUS_PAYMENT,
                                     created_at__gt=timezone.now() - timedelta(minutes=20)).first() or \
                Order(event=event, client=client, status=Order.STATUS_SELECT_PRODUCT)
        order.save()

        if request.method == 'GET':
            return Response(OrderSerializer(order).data)

        # On place le status en sélection de produit
        order.status = order.STATUS_SELECT_PRODUCT
        order.save()

        order.billets.all().delete()

        # Si il y a un champ billets dans les données renvoyées
        if "billets" in request.data:
            # Pour chaque billet dans l'array de billets
            for billet in request.data['billets']:
                # Si le billet est update
                if "id" not in billet:
                    billet_data = BilletSerializer(data=billet,
                                                   context={"order": order.id})
                    if billet_data.is_valid():
                        billet_data.validated_data['order'] = order
                        billet = billet_data.create(billet_data.validated_data)
                        billet.save()

        ok = order.is_valid()
        # Si la commande ne répond pas aux règles
        if not ok:
            order.destroy_all()
            return Response("NIQUE TA MERE ESSAYE PAS DE GRUGER", status=400)

        order.status = order.STATUS_SELECT_PARTICIPANT
        order.save()

        return Response(OrderSerializer(order).data)
Esempio n. 15
0
    def create(self, client, order):
        if not client:
            name = None

            if self.data.source == 'facebook':
                facebook_user = FacebookService.get_user_info(
                    self.data.sender_id)
                if facebook_user['first_name'] and facebook_user['last_name']:
                    name = facebook_user['first_name'] + " " + facebook_user[
                        'last_name']

            client = Client(token=self.data.sender_id,
                            source=self.data.source,
                            name=name)
            client.save()

        if order:
            # TODO ask to client if he wants to clear items
            pass
        else:
            order = Order(client=client)
            order.save()

        return None
Esempio n. 16
0
def post():
    order_data = request.json
    result = OrderDao().load(order_data)
    if result.errors:
        return result.errors, 400

    order = Order.create(customer_name=result.data['customer_name'], customer_email=result.data['customer_email'])

    comment_list = []
    for comment in result.data['comments']:
        comment_list.append(Comment(text=comment, order_id=order.id))

    Comment.bulk_create(comment_list)

    return order_data, 200
Esempio n. 17
0
def make_purchase(order_id: str):

    order, order_items = Order.get_with_items(order_id)

    @dataclass(init=True)
    class ModulReceiptItem:
        name: str
        quantity: int
        price: int
        sno: str = "usn_income"
        payment_object: str = "service"
        payment_method: str = "advance"
        vat: str = "none"

    def to_receipt_item(oi: OrderItem):
        return ModulReceiptItem(str(oi), oi.quantity, oi.price)

    def randomStr(size: int):
        ''.join(random.choice(string.ascii_letters) for x in range(size))

    receipt_items = map(lambda oi: dataclasses.asdict(to_receipt_item(oi)),
                        order_items)

    txn_params = {
        "salt": randomStr(32),
        "merchant": settings.PAYMENT_MERCHANT_ID,
        "receipt_contact": '*****@*****.**',
        "testing": 1 if __testing_mode else 0,
        "order_id": order.id,
        "receipt_items": json.dumps(list(receipt_items)),
        "amount": order.amount,
        "client_phone": order.phone,
        "client_email": order.email,
        "callback_url": "{}/api/payment_result".format(__host),
        "description": "Заказ №{}".format(order.id),
        "unix_timestamp": int(time()),
        "success_url":
        "{}/success-page?pg_order_id={}".format(__host, order.id)
    }

    # make signature afterwards
    signature = get_signature(txn_params)
    txn_params["signature"] = signature

    resp = requests.post(__api_url, data=txn_params, allow_redirects=False)
    return resp
Esempio n. 18
0
 def get_queryset(self):
     base = Billet.objects.filter(
         order__event__organizer__membership__user=self.request.user) | Billet.objects.filter(
         order__event__membership__user=self.request.user)
     if 'status' in self.request.GET:
         status = self.request.GET.get('status', '')
         base = base.filter(order__in=Order.accountable_orders(), canceled=False)
         if status == 'accountable':
             pass
         elif status == 'validated':
             base = base.filter(order__in=Order.objects.filter(status=Order.STATUS_VALIDATED))
     if 'event' in self.request.GET:
         event = self.request.GET.get('event', '')
         event = self.allowed_events().get(id=event)
         base = base.filter(order__event=event)
     if 'products' in self.request.GET:
         products = self.products_for_order()
         base = base.filter(product__in=products)
     return base
Esempio n. 19
0
def newOrder():
    
    values = request.json

    neworder = Order(OrderTypeID= values["OrderTypeID"], 
    OrderDate= values["OrderDate"], 
    State= values["State"], 
    PayState= values["PayState"], 
    TotalQuantity= values["TotalQuantity"],
    EstimatedTime= 20,
    Notes= values["Notes"],
    SubTotal= values["SubTotal"],
    Discount= values["Discount"],
    Tax= values["Tax"],
    Total= values["Total"],
    ClientName= values["ClientName"])

    db.session.add(neworder)
    db.session.commit()

    cart = values["Cart"]
    print(cart)

    for i in cart: 
        neworderdetail = OrderDetail(OrderID=  neworder.OrderID, 
        ProductID= i["ProductID"], 
        Quantity= i["Quantity"],
        SubTotal= i["SubTotal"],
        Discount=i["Discount"],
        Tax= i["Tax"],
        Total= i["Total"])
        db.session.add(neworderdetail)
        db.session.commit()

    response_body = {
        "status": "OK",
        "NewOrderID": neworder.OrderID
    }
    status_code = 200 
        
    return jsonify(response_body),200
Esempio n. 20
0
 def get_queryset(self):
     base = Answer.objects.filter(question__in=Question.objects.filter(
         Q(option__event__organizer__membership__user=self.request.user) |
         Q(product__event__organizer__membership__user=self.request.user) |
         Q(option__event__membership__user=self.request.user) |
         Q(product__event__membership__user=self.request.user)))
     if 'question' in self.request.GET:
         question = self.request.GET.get('question', '')
         base = base.filter(question=question)
     if 'status' in self.request.GET:
         status = self.request.GET.get('status', '')
         if status == 'accountable':
             base = base.filter(order__in=Order.accountable_orders())
         elif status == 'validated':
             base = base.filter(order__status=Order.STATUS_VALIDATED)
         elif status == 'any':
             base = base
     else:
         if self.action == 'list':
             base = base.filter(order__status=Order.STATUS_VALIDATED)
     return base
Esempio n. 21
0
 def get_queryset(self):
     base = Order.objects.filter(
         event__organizer__membership__user=self.request.user) | Order.objects.filter(
         event__membership__user=self.request.user)
     if 'status' in self.request.GET:
         status = self.request.GET.get('status', '')
         if status == 'accountable':
             base = base.filter(id__in=Order.accountable_orders())
         elif status == 'validated':
             base = base.filter(status=Order.STATUS_VALIDATED)
         elif status == 'any':
             base = base
     else:
         if self.action == 'list':
             base = base.filter(status=Order.STATUS_VALIDATED)
     if 'search' in self.request.GET:
         search = self.request.GET.get('search', '').split(' ')
         for word in search:
             base = base.filter(Q(client__first_name__icontains=word) |
                                Q(client__last_name__icontains=word) |
                                Q(client__email__icontains=word) |
                                Q(transaction__mercanet__transactionReference=word))
     base = base.order_by('created_at').reverse()
     return base
Esempio n. 22
0
def insert_user_order(request):
    if request.method == 'POST':
        try:
            token = request.headers.get('token')
            token = Token.objects.filter(token=token)
            if token.exists():
                user = token[0].user
                info = loads(request.body.decode('utf-8'))
                time = info['datetime']
                if not RestaurantInfo.objects.first().open:
                    return my_response(
                        False, 'The restaurant is closed, Please try later',
                        {})
                if not check_allow_record_order(time):
                    return my_response(
                        False,
                        'Maximum order is recorded for the restaurant time period, Please try again in a few minutes',
                        {})
                total_price = info['totalPrice']
                description = info['description']
                address = info['addressId']
                del_time = info['deliveryTime']
                order_type = info['orderType']
                ser_charge = info['serviceCharge']
                delivery_cost = info['deliveryCost']
                pay_type = info['paymentType']
                tr_id = random.randint(100000, 100000000)
                order = Order(
                    user=user,
                    track_id=str(tr_id),
                    datetime=time,
                    total_price=total_price,
                    description=description,
                    address_id=address,
                    delivery_time=del_time,
                    order_type=order_type,
                    service_charge=ser_charge,
                    delivery_cost=delivery_cost,
                    payment_type=pay_type,
                )
                order.save()

                foods = info['foods']
                for f in foods:
                    of = OrderFood(food_size_id=f['foodSizeId'],
                                   order=order,
                                   number=f['number'])
                    of.save()

                    ts = f['types']
                    for t in ts:
                        OrderType(order_food=of, food_type_id=t).save()
                    food_options = f['foodOptions']
                    for op_size_id in food_options:
                        OrderOption(order_food=of,
                                    option_size_id=op_size_id).save()
                options = info['options']
                for o in options:
                    of = OrderFood(food_size_id=o['optionSizeId'],
                                   order=order,
                                   number=o['number'])
                    of.save()

                notif_to_admin(orderId=order.order_id,
                               title='order',
                               message='you have a order with trackId: ' +
                               str(order.track_id))
                return my_response(True, 'success', order.to_json())
            else:
                return my_response(False, 'invalid token', {})
        except Exception as e:
            return my_response(
                False, 'error in insert order, check body send, ' + str(e), {})
    else:
        return my_response(False, 'invalid method', {})
Esempio n. 23
0
def clean_old_orders():
    deleted, _ = Order.objects.exclude(
        id__in=Order.accountable_orders()).delete()
    return deleted
Esempio n. 24
0
def get_AllOrders():      
    return jsonify(Order.getAllOrders()), 200
Esempio n. 25
0
def create_order(request):
    user_id = request.query_params.get("user_id")
    if user_id == None:
        user_id = uuid.uuid4()

    response = requests.get(
        "http://basket-web:8004/basket/createOrder/?user_id=%d" %
        int(user_id)).json()
    # response = requests.get("http://127.0.0.1:8002/basket/createOrder/?user_id=%d" % int(user_id)).json()
    queryBefore = Order.objects.all().count()
    order = Order()
    order.user_id = user_id
    order.total_amount = 0
    order.save()
    queryset = Order.objects.filter(user_id=user_id).order_by('-order_id')

    order_serializer = OrderSerializer(queryset, many=True)

    prices = 0.0

    for i in range(len(response)):
        order_item = OrderItem()
        order_item.order_id = Order.objects.filter(
            order_id=order_serializer.data[0]['order_id']).first()
        order_item.catalog_item_id = response[i]['catalog_item_id']

        order_item.quantity = response[i]["quantity"]
        order_item.price = requests.get(
            "http://catalog-web:8002/product/basket/?prod_id=%d" %
            order_item.catalog_item_id).json()[0]['price']
        #  order_item.price = requests.get("http://127.0.0.1:8003/product/basket/?prod_id=%d" % order_item.catalog_item_id).json()[0]['price']
        print(order_item.price)
        prices += (order_item.price * order_item.quantity)
        order_item.save()

    order = Order.objects.filter(order_id=order_serializer.data[0]['order_id'])
    order.update(total_amount=prices)

    print(order.first().total_amount)
    order.first().save()

    queryAfter = Order.objects.all().count()

    if (queryAfter == queryBefore + 1):
        return Response({'success': True}, status=200)
    else:
        return Response({'success': False}, status=200)