public async Task <IActionResult> UpdateOrderStatus(int id, [FromBody] OrderStatusDTO orderStatusDto)
{
var order = await _context.Order.FindAsync(id);
if (order != null)
{
order.OrderStatus = orderStatusDto.OrderStatus;
_context.Entry(order).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
return(NotFound());
}
public async Task <IActionResult> PutOrderStatus([FromRoute] int id, [FromBody] OrderStatusDTO orderStatus)
{
orderStatus.CustomerOrder = null;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderStatus.Id)
{
return(BadRequest());
}
_context.Entry(Mapper.Map <OrderStatus>(orderStatus)).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderStatusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public HttpResponseMessage OrderStatus(OrderStatusDTO data)
{
var ordData = new OrderData(data.ItemId);
ordData.OrderStatus = data.Status.ToString("D3");
ordData.Save();
return(Request.CreateResponse(HttpStatusCode.OK, NBrightRepository.Instance.GetOrders(PortalSettings.PortalId).FirstOrDefault(o => o.ItemId == data.ItemId)));
}
public Guid AddOrderStatus(OrderStatusDTO orderStatus)
{
OrderStatus dataModel = new OrderStatus();
orderStatus.CopyTo(dataModel);
_context.OrderStatuses.Add(dataModel);
_context.SaveChanges();
return(dataModel.Id);
}
public void UpdateOrderStatus(OrderStatusDTO orderStatus)
{
OrderStatus dataModel = new OrderStatus();
orderStatus.CopyTo(dataModel);
_context.Entry(dataModel).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
return;
}
public OrderStatusDTO UpdateOrderStatus(OrderStatusDTO status)
{
using (var e = new EntityTC())
{
e.OrderStatus.AddOrUpdate(_mapper.Map <OrderStatus>(status));
e.SaveChanges();
var o = e.OrderStatus.Single(p => p.StatusID == status.StatusID);
return(_mapper.Map <OrderStatusDTO>(o));
}
}
public OrderStatusDTO CreateOrderStatus(OrderStatusDTO status)
{
using (var e = new EntityTC())
{
OrderStatus o = _mapper.Map <OrderStatus>(status);
e.OrderStatus.Add(o);
e.SaveChanges();
return(_mapper.Map <OrderStatusDTO>(o));
}
}
public int UpdateOrderStatus(OrderStatusDTO order)
{
using (var context = new PizzeriaMasterpieceEntities())
{
var currentOrder = context.Orders.Find(order.OrderId);
currentOrder.OrderStatusId = order.OrderStatusId;
context.SaveChanges();
return(currentOrder.OrderId);
}
}
public ActionResult CancelOrder(int orderId, int orderStatusId)
{
var serviceReference = new OrderServiceReference.OrderServiceClient();
OrderStatusDTO os = new OrderStatusDTO()
{
OrderId = orderId,
OrderStatusId = 3
};
var response = serviceReference.UpdateOrderStatus(os);
return(Json(response));
}
public void DeleteOrderStatus(OrderStatusDTO orderStatus)
{
if (orderStatus != null)
{
var stat = _context.OrderStatuses.FirstOrDefault(x => x.Id == orderStatus.Id);
if (stat == null)
{
return;
}
_context.OrderStatuses.Remove(stat);
_context.SaveChanges();
}
return;
}
public OperationDetails ChangeOrderStatus(int orderId, OrderStatusDTO orderStatusDTO)
{
var order = _db.OrderRepository.FindById(orderId);
if (order == null)
{
return(new OperationDetails(false, "Operation was failed", "order is null"));
}
order.OrderStatus = (OrderStatus)(int)orderStatusDTO;
_db.OrderRepository.Update(order);
_db.Save();
return(new OperationDetails(true, "Operation was successfully completed", ""));
}
public async Task <IActionResult> PostOrderStatus([FromBody] OrderStatusDTO orderStatus)
{
orderStatus.CustomerOrder = null;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var os = Mapper.Map <OrderStatus>(orderStatus);
_context.OrderStatus.Add(os);
await _context.SaveChangesAsync();
orderStatus.Id = os.Id;
return(CreatedAtAction("GetOrderStatus", new { id = os.Id }, orderStatus));
}
public void GetOrderStatusesResponseTest()
{
var message = new GetOrderStatusesResponse();
Assert.AreEqual(message.Kind, MessageKind.GetOrderStatusesResponse);
var item = new OrderKindDTO();
item.OrderKindID = Guid.NewGuid();
item.Title = "Title";
var orderStatus = new OrderStatusDTO();
orderStatus.OrderStatusID = Guid.NewGuid();
orderStatus.Title = "Title";
orderStatus.StatusKindID = 1;
message.OrderKinds.Add(item);
message.OrderStatuses.Add(orderStatus);
var serializer = new ProtocolSerializer(ProtocolVersion.Version10);
var data = serializer.Serialize(message);
Assert.IsNotNull(data);
var savedMessage = serializer.DeserializeGetOrderStatusesResponse(data);
Assert.IsNotNull(savedMessage);
Assert.AreEqual(serializer.GetMessageInfoOrNull(data).Kind, MessageKind.GetOrderStatusesResponse);
Assert.AreEqual(savedMessage.OrderKinds.Count, 1);
Assert.AreEqual(savedMessage.OrderStatuses.Count, 1);
var savedOrderStatus = savedMessage.OrderStatuses[0];
var savedOrderKind = savedMessage.OrderKinds[0];
Assert.AreEqual(orderStatus.StatusKindID, savedOrderStatus.StatusKindID);
Assert.AreEqual(orderStatus.Title, savedOrderStatus.Title);
Assert.AreEqual(orderStatus.OrderStatusID, savedOrderStatus.OrderStatusID);
Assert.AreEqual(savedOrderKind.OrderKindID, item.OrderKindID);
Assert.AreEqual(savedOrderKind.Title, item.Title);
}
public ResponseDTO UpdateOrderStatus(OrderStatusDTO order)
{
try
{
var orderRepository = new OrderRepository();
var supplyRepository = new SupplyRepository();
var productSupplyRepository = new ProductSupplyRepository();
if (order.OrderStatusId == 3)
{
orderRepository.UpdateOrderStatus(order);
return(new ResponseDTO()
{
Status = 1,
Message = "Pedido Rechazado"
});
}
else
{
var currentoOrder = orderRepository.GetOrder(order.OrderId);
if (currentoOrder.OrderStatusId != 1)
{
return(new ResponseDTO()
{
Status = 1,
Message = "El Pedido ya fue atendido"
});
}
// var currentSupplies = supplyRepository.GetSupplies();
var serviceReference = new SupplyServiceReference.SupplyServieClient();
var currentSupplies = serviceReference.ListAllSupplyInformation();
var usedSupplies = new List <SupplyDTO>();
foreach (var odetail in currentoOrder.OrderDetails)
{
var supplies = productSupplyRepository.GetSuppliesByProduct(odetail.ProductId);
foreach (var supply in supplies)
{
var csupply = usedSupplies.FirstOrDefault(p => p.SupplyId == supply.SupplyId);
if (csupply != null)
{
csupply.Quantity = csupply.Quantity + supply.Quantity * odetail.Quantity;
}
else
{
var newcsupply = new SupplyDTO();
newcsupply.SupplyId = supply.SupplyId;
newcsupply.Quantity = supply.Quantity * odetail.Quantity;
usedSupplies.Add(newcsupply);
}
}
}
foreach (var item in usedSupplies)
{
var csupply = currentSupplies.FirstOrDefault(p => p.SupplyId == item.SupplyId);
if (item.Quantity > csupply.Quantity)
{
order.OrderStatusId = 3;
orderRepository.UpdateOrderStatus(order);
return(new ResponseDTO()
{
Status = 1,
Message = "Pedido Rechazado Automaticamente por falta de Stock"
});
}
}
foreach (var item in usedSupplies)
{
var csupply = currentSupplies.FirstOrDefault(p => p.SupplyId == item.SupplyId);
csupply.Quantity = csupply.Quantity - item.Quantity;
//supplyRepository.UpdateSupply(csupply);
serviceReference.UpdateSupplyInformation(csupply);
}
orderRepository.UpdateOrderStatus(order);
return(new ResponseDTO()
{
Status = 1,
Message = "Pedido Aprobado"
});
}
}
catch (Exception ex)
{
return(new ResponseDTO()
{
Status = 0,
Message = "A ocurrido un error"
});
}
}
public List <OrderStatusDTO> GetVendorOrderStatus(Guid vendorId, int menuType)
{
var orderedItemsQ = eCanteenEntities.OrderItem.Join(eCanteenEntities.MenuFoodItem, oi => oi.FoodItemId, mfi => mfi.FoodItemId, (oi, mfi) => new
{
OrderId = oi.OrderId,
FoodItemId = oi.FoodItemId,
Quantity = oi.Quantity,
MenuType = mfi.Type
}).
Join(eCanteenEntities.FoodItem, omfi => omfi.FoodItemId, fi => fi.Id, (omfi, fi) => new
{
OrderId = omfi.OrderId,
FoodItemId = omfi.FoodItemId,
Quantity = omfi.Quantity,
MenuType = omfi.MenuType,
FoodItemName = fi.Name
}).Join(eCanteenEntities.Order, X => X.OrderId, o => o.Id, (X, o) => new
{
OrderId = X.OrderId,
OrderTokenNo = o.TokenNo,
FoodItemId = X.FoodItemId,
Quantity = X.Quantity,
VendorId = o.VenderId,
CustomerId = o.CustomerId,
MenuType = X.MenuType,
OrderStatus = o.Status,
Accepted = o.Accepted,
OrderAmount = o.Total,
FoodItemName = X.FoodItemName,
PaymentStatus = o.PaymentStatus
}).Join(eCanteenEntities.Customer, od => od.CustomerId, c => c.Id, (od, c) => new {
OrderId = od.OrderId,
OrderTokenNo = od.OrderTokenNo,
FoodItemId = od.FoodItemId,
Quantity = od.Quantity,
VendorId = od.VendorId,
CustomerId = od.CustomerId,
MenuType = od.MenuType,
OrderStatus = od.OrderStatus,
Accepted = od.Accepted,
OrderAmount = od.OrderAmount,
FoodItemName = od.FoodItemName,
CustomerName = c.Name,
CustomerEmail = c.Email,
CustomerContact = c.Contact,
PaymentStatus = od.PaymentStatus
})
.Where(b => b.VendorId.Equals(vendorId) && b.MenuType.Equals(menuType) && b.PaymentStatus.Equals(1)).GroupBy(g => g.OrderId);
var orderedItems = orderedItemsQ.ToList();
var orderStatusList = new List <OrderStatusDTO>();
foreach (var vo in orderedItems)
{
var orderStatusItem = new OrderStatusDTO();
var firstRow = vo.ToList().FirstOrDefault();
orderStatusItem.Customer = new Customer {
Id = firstRow.CustomerId, Name = firstRow.CustomerName, Email = firstRow.CustomerEmail, Contact = firstRow.CustomerContact
};
orderStatusItem.Order = new Order {
Id = firstRow.OrderId, TokenNo = firstRow.OrderTokenNo, Status = firstRow.OrderStatus, Accepted = firstRow.Accepted, Total = firstRow.OrderAmount, VenderId = firstRow.VendorId
};
orderStatusItem.OrderedItems = new List <FoodItem>();
foreach (var foodItem in vo.ToList())
{
orderStatusItem.OrderedItems.Add(new FoodItem {
Id = foodItem.FoodItemId, Name = foodItem.FoodItemName, Type = foodItem.MenuType, Quantity = foodItem.Quantity
});
}
orderStatusList.Add(orderStatusItem);
}
return(orderStatusList);
}
public static void CopyTo(this OrderStatusDTO dto, OrderStatus dataModel)
{
dataModel.Id = dto.Id;
dataModel.StatusValue = dto.StatusValue;
}
public async Task CreateAsync(OrderStatusDTO orderStatus)
{
await _repo.CreateAsync(_mapper.Map <OrderStatus>(orderStatus));
}
async Task <OrderStatusDTO> IService <OrderStatusDTO, int> .Update(OrderStatusDTO entity)
{
OrderStatus orderStatus = await _orderStatusRepository.Update(_mapper.Map <OrderStatusDTO, OrderStatus>(entity));
return(_mapper.Map <OrderStatus, OrderStatusDTO>(orderStatus));
}
