public async Task <IActionResult> UpdateOrderStatus([FromBody] OrderResource orderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = mapper.Map <OrderResource, Order>(orderResource);
repository.UpdateOrderStatus(item);
await unitOfWork.CompleteAsync();
if (item == null)
{
return(NotFound());
}
mapper.Map <OrderResource, Order>(orderResource, item);
await unitOfWork.CompleteAsync();
item = await repository.GetOrderByIdUser(item.UserID);
var result = mapper.Map <Order, OrderResource>(item);
return(Ok(result));
}
/// <summary>
///
/// </summary>
/// <param name="Body"></param>
/// <returns>OrderResource</returns>
public async Task <OrderResource> SaveOrderAsync(OrderResource Body)
{
var path = "/orders";
path = path.Replace("{format}", "json");
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, String>();
var fileParams = new Dictionary <String, String>();
String postBody = null;
postBody = apiClient.Serialize(Body); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { "client_id", "access_token" };
// make the HTTP request
IRestResponse response = (IRestResponse)await apiClient.CallApiAsync(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling SaveOrder: " + response.Content, response.Content);
}
return((OrderResource)apiClient.Deserialize(response.Content, typeof(OrderResource)));
}
public IActionResult AddOrder(OrderResource orderResource)
{
try {
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
else
{
Order order = mapper.Map <OrderResource, Order>(orderResource);
var orders = this._OrderRepo.AddOrder(order);
if (orders != null)
{
return(Ok(new ApiResponse <Order> {
Status = true, Entry = orders
}));
}
return(BadRequest(new ApiResponse <Order> {
Status = false, Entry = null, ErrorCode = ErrorMessageCode.CreateError
}));
}
}
catch (Exception ex) {
_Logger.LogError(ex.Message);
return(BadRequest(new ApiResponse <Order> {
Status = false, Entry = null, ErrorCode = ErrorMessageCode.CreateError
}));
}
}
public async Task CreateInvoiceBulkAsync()
{
using (var controllerStore = new InvoicingController(AuthenticationProvider))
{
List <OrderResource> orders = new List <OrderResource>();
int i = 0;
while (i < 10)
{
i++;
// order para criar no invoicing
List <ItemLine> items = new List <ItemLine>()
{
new ItemLine("Cad-0001", "Cadeira Branca 0001", 2, 10)
};
Client shipping = new Client("INDIF", "Miguel Dias", "Rua dos Bombeiros", "Leiria", "4509-003");
// order para criar no invoicing
OrderResource order = new OrderResource("ENC.2021." + i, shipping, items);
orders.Add(order);
}
var result = await controllerStore.PostBulkInvoiceAsync(orders);
Assert.IsTrue(result.Count() == 10);
}
}
public async Task CreateInvoiceAsync()
{
using (var controllerStore = new InvoicingController(AuthenticationProvider))
{
// order para criar no invoicing
List <ItemLine> items = new List <ItemLine>()
{
new ItemLine("Cad-0001", "Cadeira Branca 0001", 2, 10)
};
Client shipping = new Client("INDIF", "Miguel Dias", "Rua dos Bombeiros", "Leiria", "4509-003");
// order para criar no invoicing
OrderResource order = new OrderResource("ENC.2021.1", shipping, items);
var result = await controllerStore.PostInvoiceAsync(order);
if (string.IsNullOrEmpty(result.Value))
{
throw new Exception((result.Result as ObjectResult).Value.ToString());
}
MiddlewareResponse r = JsonSerializer.Deserialize <MiddlewareResponse>(result.Value);
Debug.WriteLine(string.Concat("ProcessId: ", r.id));
Debug.WriteLine(string.Concat("State: ", r.state));
Assert.IsTrue(!string.IsNullOrEmpty(result.Value));
}
}
public IHttpActionResult DeleteOrder(long id)
{
Order order = db.Orders.Find(id);
if (order == null)
{
return(NotFound());
}
var orderResource = new OrderResource
{
CustomerID = order.CustomerID,
GTotal = order.GTotal,
OrderID = order.OrderID,
OrderNo = order.OrderNo,
PMethod = order.PMethod,
Customer = new CustomerResource {
CustomerID = order.Customer.CustomerID, Name = order.Customer.Name
},
OrderItems = order.OrderItems.Select(j => new OrderItemResource {
ItemID = j.ItemID, Quantity = j.Quantity
})
};
var Items = db.OrderItems.Where(i => i.OrderID == order.OrderID).ToList <OrderItem>();
foreach (var i in Items)
{
db.OrderItems.Remove(i);
}
db.Orders.Remove(order);
db.SaveChanges();
return(Ok(orderResource));
}
private Order GetTestOrder()
{
var orderResource = new OrderResource(Context.ApiContext);
var orders = orderResource.GetOrders(0, 1);
return(orders.Items.FirstOrDefault()); // might return null
}
public IHttpActionResult GetOrder(long id)
{
Order order = db.Orders.Find(id);
if (order == null)
{
return(NotFound());
}
var orderResource = new OrderResource
{
CustomerID = order.CustomerID,
GTotal = order.GTotal,
OrderID = order.OrderID,
OrderNo = order.OrderNo,
PMethod = order.PMethod,
Customer = new CustomerResource {
CustomerID = order.Customer.CustomerID, Name = order.Customer.Name
},
OrderItems = order.OrderItems.Select(j => new OrderItemResource {
ItemID = j.ItemID, Quantity = j.Quantity
})
};
return(Ok(orderResource));
}
public async Task <OrderResource> AddAsync(OrderResource resource)
{
Order entity = ToEntity(resource);
_db.Orders.Add(entity);
await _db.SaveChangesAsync();
return(ToResource(entity));
}
public async Task <OrderResource> ReplaceAsync(int id, OrderResource resource)
{
Order entity = await FindAsync(id);
Mapper.Map(resource, entity);
await _db.SaveChangesAsync();
return(ToResource(entity));
}
private Order GetOrderById(MozuContext mozuContext, string id)
{
if (!_orders.ContainsKey(id))
{
OrderResource resource = new OrderResource(mozuContext.GetApiContext());
Order o = resource.GetOrder(id);
_orders[id] = o;
}
return(_orders[id]);
}
public async Task <ActionResult <OrderResource> > CreateOrder(OrderResource orderResource)
{
var order = orderConverter.ConvertToModel(orderResource);
var savedOrder = await orderService.CreateOrder(order);
var savedOrderResource = orderConverter.ConvertToResource(savedOrder);
return(Ok(savedOrderResource));
}
public void Initialize()
{
RestbucksResources.BaseAddress = "http://restbucks.net";
_repository = new InMemoryOrderRepository();
var mapper = new OrderRepresentationMapper(new ItemRepresentationMapper());
_sut = new OrderResource(
new CreateOrderActivity(_repository, mapper),
new ReadOrderActivity(_repository, mapper),
new RemoveOrderActivity(_repository, mapper));
}
public async Task <OrderResource> GetProductsOfAnOrder(Guid id)
{
List <ProductDetails> listProductDetails;
listProductDetails = await azureDocDBHelper.GetOrderProductsDetails(id);
OrderResource orderResource = new OrderResource();
orderResource.OrderProducts = listProductDetails;
return(orderResource);
}
public async Task <ActionResult <string> > PostInvoiceAsync([FromBody] OrderResource product)
{
try
{
return(new ActionResult <string>(await InvoicesManager.CreateInvoiceMiddlewareAsync(this.AuthenticationProvider, product)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private async void btnGetOrderByGuid_Click(object sender, EventArgs e)
{
var orderGuid = txtOrderGuid.Text;
var orderResource = new OrderResource(_apiContext);
var order = await orderResource.GetOrderAsync(orderGuid);
if (order != null && order.Items.Count > 0)
{
dataGridViewOrders.DataSource = order.Items;
}
}
public async Task <OrderResource> GetOrders()
{
List <Order> listOrderDetails;
listOrderDetails = await azureDocDBHelper.GetOrders();
OrderResource orderResource = new OrderResource();
orderResource.Orders = listOrderDetails;
return(orderResource);
}
public async Task <IHttpActionResult> PostOrder(OrderResource resoure)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
OrderResource result = await _ordersService.AddAsync(resoure);
return(CreatedAtRoute("DefaultApi", new { id = result.Id }, result));
}
public Order ConvertToModel(OrderResource orderResource)
{
return(new Order
{
CreatedById = orderResource.CreatedById,
CreatedByUsername = orderResource.CreatedByUsername,
LastModifiedById = orderResource.LastModifiedById,
OrderItems = orderResource.OrderItems.Select(i => orderItemConverter.ConvertToModel(i)).ToList(),
TotalPrice = orderResource.TotalPrice
});
}
protected override async Task <bool> GetDataAsync()
{
var resource = new OrderResource(Context);
_results = await resource.GetOrdersAsync(startIndex : StartIndex, pageSize : PageSize, sortBy : SortBy, filter : Filter, q : Q, qLimit : QLimit, responseFields : ResponseFields);
TotalCount = _results.TotalCount;
PageCount = _results.PageCount;
PageSize = _results.PageSize;
return(_results.Items != null && _results.Items.Count > 0);
}
public async Task OpenedAsync(IApiContext apiContext, Event eventPayLoad)
{
var orderId = eventPayLoad.EntityId;
var orderResource = new OrderResource(apiContext);
var order = await orderResource.GetOrderAsync(orderId);
foreach (var orderItem in order.Items)
{
var productCode = orderItem.Product.Properties;
}
}
public Order ParseOrder(OrderResource order)
{
return(new Order
{
TotalPrice = order.TotalPrice,
Address = order.Address,
OrderTime = order.OrderTime,
//OrderId = order.OrderId,
CustomerId = order.CustomerId,
LocationId = order.LocationId,
LineItem = ParseOrderProductResource(order.LineItem),
});
}
public IActionResult AddOrder(OrderResource order)
{
try
{
_orderService.AddOrder(_mapper.ParseOrder(order));
_orderService.SaveChanges();
return(CreatedAtAction("addOrder", order));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IHttpActionResult> PutOrder(int id, OrderResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
resource.Id = id;
await _ordersService.ReplaceAsync(id, resource);
return(StatusCode(HttpStatusCode.NoContent));
}
public IActionResult Insert([FromBody] OrderResource orderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = _mapper.Map <OrderResource, Order>(orderResource);
order.CreateTimeStamp = DateTime.UtcNow;
_unitOfWork.Orders.Add(order);
_unitOfWork.Complete();
return(Created(new Uri(Request.GetDisplayUrl() + "/" + order.Id), Mapper.Map <Order, OrderResource>(order)));
}
public async Task <int> FindOrderId(OrderResource orderResource)
{
Order order = mapper.Map <Order>(orderResource);
IEnumerable <Order> orders = await unitOfWork.OrderRepository.GetAllWithProducts();
int Id = -1;
foreach (var i in orders)
{
if (i == order)
{
Id = i.Id;
}
}
return(Id);
}
private void CreateOrder(OrderModel orderModel)
{
// Create Order History from the model
var orderResource = new OrderResource(Context.ApiContext);
// get a sample existing order... this is just for debug/testing purposes
var testOrder = GetTestOrder();
// TODO handle exceptions from here and log them. There could be products which no longer exist or invalid colors
// Create order History
ReportProgress(string.Format("Starting order import for {4} items. The first variation is \"{0}\" of Product Code \"{1}\" with color of \"{2}\" and size of \"{3}\".", orderModel.Order.Items[0].Product.VariationProductCode, orderModel.Order.Items[0].Product.ProductCode, orderModel.Order.Items[0].Product.Options[0].StringValue, orderModel.Order.Items[0].Product.Options[1].StringValue, orderModel.Order.Items.Count()));
orderModel.Order = orderResource.CreateOrder(orderModel.Order);
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] OrderResource orderResource)
{
if (orderResource == null)
{
orderResource = new OrderResource();
}
var order = _mapper.Map <OrderResource, Order>(orderResource);
var result = await _orderService.UpdateAsync(id, order);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async virtual Task <IActionResult> SetOrderAsync(ResourceOrderModel <TResource> resourceOrderModel)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var orderResourceEvent = new OrderResource <TResource>(resourceOrderModel);
var context = await _mediator.Send(orderResourceEvent);
if (context != null)
{
resourceOrderModel = context;
}
if (resourceOrderModel.Errors.Any())
{
foreach (var error in resourceOrderModel.Errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (!ModelState.IsValid)
{
return(PartialView("_Order", resourceOrderModel));
}
var update = await _repository.SetOrderAsync(resourceOrderModel);
if (update <= 0)
{
return(BadRequest());
}
_logger.LogResourceOrdered(ResourceType);
var resourceOrderedEvent = new ResourceOrdered <TResource>();
await _mediator.Publish(resourceOrderedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
return(Ok());
}
public async Task <IActionResult> CreateOrder([FromBody] OrderResource orderResource)
{
// if (!ModelState.IsValid)
// {
// return BadRequest(ModelState);
// }
var order = mapper.Map <OrderResource, Order>(orderResource);
var dateAndTime = DateTime.Now;
order.OrderDate = dateAndTime.Date;
context.Orders.Add(order);
await context.SaveChangesAsync();
var result = mapper.Map <Order, OrderResource>(order);
return(Ok(result));
}
/// <summary>
///
/// </summary>
/// <param name="Body"></param>
/// <returns>OrderResource</returns>
public async Task<OrderResource> SaveOrderAsync (OrderResource Body) {
var path = "/orders";
path = path.Replace("{format}", "json");
var queryParams = new Dictionary<String, String>();
var headerParams = new Dictionary<String, String>();
var formParams = new Dictionary<String, String>();
var fileParams = new Dictionary<String, String>();
String postBody = null;
postBody = apiClient.Serialize(Body); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { "client_id", "access_token" };
// make the HTTP request
IRestResponse response = (IRestResponse) await apiClient.CallApiAsync(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400) {
throw new ApiException ((int)response.StatusCode, "Error calling SaveOrder: " + response.Content, response.Content);
}
return (OrderResource) apiClient.Deserialize(response.Content, typeof(OrderResource));
}
