public async Task <IActionResult> PutOrderOffer(int id, OrderOffer orderOffer)
        {
            if (id != orderOffer.Id)
            {
                return(BadRequest());
            }

            _context.Entry(orderOffer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!OrderOfferExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemplo n.º 2
0
        public async Task <Unit> Handle(AcceptOrderCommand request, CancellationToken cancellationToken)
        {
            var contractor = await _dbContext.Contractors.FindAsync(request.ContractorId);

            if (contractor == null)
            {
                throw new ContractorDoesNotExistException(request.ContractorId);
            }

            var order = await _dbContext.Orders
                        .FirstOrDefaultAsync(x => x.Id == request.OrderId, cancellationToken);

            if (order == null)
            {
                //throw new BadRequestException($"Distributed order does not exist: {request.OrderId}");
                throw new BadRequestException($"Order does not exist: {request.OrderId}");
            }

            if (await _dbContext.OrderOffers.AnyAsync(x =>
                                                      x.OrderId == request.OrderId && x.ContractorId == request.ContractorId,
                                                      cancellationToken: cancellationToken))
            {
                throw new BadRequestException(
                          $"Contractor: {request.ContractorId} already accepted this order: {request.OrderId}");
            }

            var orderOffer = new OrderOffer
            {
                Comment        = request.Comment,
                ContractorId   = request.ContractorId,
                OrderId        = request.OrderId,
                PredictedPrice = request.PredictedPrice
            };

            await _dbContext.OrderOffers.AddAsync(orderOffer, cancellationToken);

            await _dbContext.SaveChangesAsync(cancellationToken);

            return(Unit.Value);
        }
        public async Task <ActionResult <OrderOffer> > PostOrderOffer([FromBody] OrderOffer orderOffer)
        {
            var order = _context.Order.Find(orderOffer.OrderId);

            orderOffer.Status = (int)Models.Enums.OfferStatus.Pending;  // Pending

            try
            {
                _context.OrderOffer.Add(orderOffer);

                await _context.SaveChangesAsync();

                notificationProvider.CreateNewNotification(orderOffer.UserId, order.UserId, NotificationTemplates.CreateNewOffer, "order-details/" + order.Id);
            }
            catch (Exception e)
            {
                throw;
            }


            return(CreatedAtAction("GetOrderOffer", new { id = orderOffer.Id }, orderOffer));
        }