public void SetAsPaid()
{
Status = OrderStatuses.Paid;
}
public HasStatus(OrderStatuses status)
{
_status = status;
}
public OrderStatus GetOrderStatusByValue(OrderStatuses value)
{
return(DbContext.OrderStatuses.FirstOrDefault(g => g.Value == value));
}
public void Save(OrderStatuses orderStatuses)
{
_orderStatusesRepository.Add(orderStatuses);
_unitOfWork.Complete();
}
public OrderResponse(OrderId orderId, OrderStatuses orderStatus, List <OrderItem> orderItems)
{
OrderId = orderId;
OrderStatus = orderStatus;
OrderItems = orderItems;
}
public static OrderStatus GetByOrderStatusEnum(OrderStatuses orderStatus)
{
return(OrderStatuses.SingleOrDefault(s => s.OrderStatusEnum == orderStatus));
}
public Order(int customerID, double weight, double volume, string from, string to, OrderStatuses os)
{
this.orderID = ++ordersCount;
this.customerID = customerID;
this.weight = weight;
this.volume = volume;
this.from = from;
this.to = to;
this.startDate = DateTime.Today.ToString();
this.endDate = null;
switch (os)
{
case OrderStatuses.newOrder:
this.orderStatus = 1;
break;
case OrderStatuses.openOrder:
this.orderStatus = 2;
break;
case OrderStatuses.closeOrder:
this.orderStatus = 3;
break;
case OrderStatuses.cancelOrder:
this.orderStatus = 4;
break;
}
}
public async Task UpdateStausTestPositive(AccountRoles accountRole, OrderStatuses previousOrderStatus, OrderStatuses nextStatus)
{
//Arrange
var owner = EntitiesCreationService.GetOwner();
owner.HashedPassword = "******";
var restaurant = EntitiesCreationService.GetRestaurant();
owner.Restaurants = new List <Restaurant>()
{
restaurant
};
owner = await accountsRepository.AddAsync(owner);
var account = EntitiesCreationService.GetOwner();
account.HashedPassword = "******";
account.Role = accountRole;
var order = EntitiesCreationService.GetOrder();
var orderStatus = EntitiesCreationService.GetOrderStatus();
orderStatus.Status = previousOrderStatus;
order.OrderStatuses = new List <OrderStatus>()
{
orderStatus
};
order.RestaurantId = owner.Restaurants[0].RestaurantId;
account.Orders = new List <Order>()
{
order
};
account = await accountsRepository.AddAsync(account);
try
{
//Act
await orderService.UpdateStaus(account.AccountId, account.Orders[0].EntityId, nextStatus);
//Assert
var statuses = ordersStatusRepository.GetAllStatusesForOrder(account.Orders[0].EntityId);
Assert.Contains(statuses, s => s.Status == nextStatus);
var orders = ordersRepository.GetAllOrdersForRegularUser(account.EntityId);
Assert.Equal(orders[0].LatestOrderStatus, nextStatus);
}
finally
{
//Clear
accountsRepository.Remove(account);
accountsRepository.Remove(owner);
}
}
public async Task <IActionResult> PutOrderStatus(string id, [FromBody] OrderStatusPutRequest req)
{
if (req.Status == null)
{
return(BadRequest(new ApiResponse
{
Success = false,
ErrorCode = ErrorCodes.MISSING_FIELD,
}));
}
var res = await _orderService.GetOrder(id);
if (!res.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
if (res.Data == null)
{
return(NotFound());
}
var order = res.Data;
if (!OrderStatuses.isValidStatusChange(order.Status.CurrentStatus, req.Status, Role))
{
return(BadRequest(new ApiResponse
{
Success = false,
ErrorCode = ErrorCodes.ORDER_INVALID_STATUS_CHANGE,
}));
}
if (!order.UserId.Equals(UserId) && !order.RestaurantOwnerId.Equals(UserId))
{
return(Forbid());
}
var v = await _restaurantService.GetRestaurant(order.RestaurantId);
if (!v.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
if (v.Data == null)
{
return(Forbid());
}
var k = await _restaurantService.IsBlocked(order.UserId, order.RestaurantId);
if (!k.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
if (k.Data)
{
return(Forbid());
}
order.Status.CurrentStatus = req.Status;
order.Status.StatusHistory.Add(new StatusHistoryItem
{
Date = Utils.GetDateEpoch(),
Status = req.Status
});
var result = await _orderService.UpdateOrderStatus(id, order);
if (!result.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
var user = await _userService.Get(res.Data.UserId);
if (!user.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
List <OrderItemDTO> list = new List <OrderItemDTO>();
var f = await _restaurantService.GetAllFood(res.Data.RestaurantId);
if (!f.Success)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
List <Food> foods = f.Data;
foreach (var item in res.Data.Items)
{
OrderItemDTO ord = new OrderItemDTO
{
FoodId = item.FoodId,
Quantity = item.Quantity
};
if (foods != null)
{
var cur = foods.Find(x => x.Id.Equals(item.FoodId));
ord.FoodName = cur.Name;
ord.Price = cur.Price;
}
list.Add(ord);
}
OrderDTO o = new OrderDTO
{
Date = res.Data.Date,
IsRestaurantDeleted = res.Data.IsRestaurantDeleted,
IsUserBlocked = res.Data.IsUserBlocked,
OrderId = res.Data.OrderId,
RestaurantId = res.Data.RestaurantId,
RestaurantOwnerId = res.Data.RestaurantOwnerId,
Status = res.Data.Status,
RestaurantName = v.Data.Name,
TotalPrice = res.Data.TotalPrice,
UserId = res.Data.UserId,
UserName = user.Data.Name,
Items = list
};
return(Ok(new ApiResponse <OrderDTO>
{
Success = true,
Data = o
}));
}
public void Start()
{
Status = OrderStatuses.Processing;
}
public async Task UpdateStausTestNegative(AccountRoles accountRole, OrderStatuses previousOrderStatus, OrderStatuses nextStatus)
{
//Arrange
var owner = EntitiesCreationService.GetOwner();
owner.HashedPassword = "******";
var restaurant = EntitiesCreationService.GetRestaurant();
owner.Restaurants = new List <Restaurant>()
{
restaurant
};
owner = await accountsRepository.AddAsync(owner);
var account = EntitiesCreationService.GetOwner();
account.HashedPassword = "******";
account.Role = accountRole;
var order = EntitiesCreationService.GetOrder();
var orderStatus = EntitiesCreationService.GetOrderStatus();
orderStatus.Status = previousOrderStatus;
order.OrderStatuses = new List <OrderStatus>()
{
orderStatus
};
order.RestaurantId = owner.Restaurants[0].RestaurantId;
account.Orders = new List <Order>()
{
order
};
account = await accountsRepository.AddAsync(account);
try
{
//Act
//Assert
await Assert.ThrowsAnyAsync <Exception>(async() => await orderService.UpdateStaus(account.AccountId, account.Orders[0].EntityId, nextStatus));
}
finally
{
//Clear
accountsRepository.Remove(account);
}
}
internal List <TDto> RetrieveOrdersBySupplierAndStatus <TDto>(object instanceId, OrderStatuses status, IDataConverter <OrderData, TDto> converter)
where TDto : class
{
ArgumentValidator.IsNotNull("instanceId", instanceId);
ArgumentValidator.IsNotNull("status", status);
ArgumentValidator.IsNotNull("converter", converter);
IOrderService service = UnitOfWork.GetService <IOrderService>();
var query = service.SearchBySupplierAndStatus(instanceId, (int)status);
if (query.HasResult)
{
return(query.DataToDtoList(converter).ToList());
}
return(null);
}
public async Task ChangeOrderStatus(Order order, OrderStatuses status)
{
order.Status = status;
context.Orders.Update(order);
await context.SaveChangesAsync();
}
public void Update(OrderStatuses orderStatuses)
{
_orderStatusesRepository.Update(orderStatuses);
_unitOfWork.Complete();
}
public async Task OrderStatusChangedNotify(int regularUserId, int orderId, int ownerId, OrderStatuses orderStatus)
{
var args = new
{
regularUserId,
orderId,
ownerId,
orderStatus
};
await hubContext.Clients.All.SendAsync("onOrderStatusChanged", args);
}
public int CountOrdersByState(OrderStatuses OrderState)
{
return(3);
}
public OrderStatus GetOrderStatusByValue(OrderStatuses value)
{
var orderStatus = orderStatusesRepository.GetOrderStatusByValue(value);
return(orderStatus);
}
public OrderStatus GetOrderStatusByOrderStatusEnum(OrderStatuses orderStatus)
{
return(DatabaseCommandDirectory.Instance.GetAllOrderStatuses().SingleOrDefault(s => s.OrderStatusEnum == orderStatus));
}
public void Start()
{
Status = OrderStatuses.PROCESSING;
}
public InvalidStatusTransitionException(OrderStatuses currentState, OrderStatuses targetState)
: base($"It is not possible to switch from {currentState} status to {targetState} status")
{
}
internal static void NewOrderMatch(string derived_currency, long order_id, int user_id, decimal actual_amount, OrderStatuses order_status) //new order status => DAEMON
{
Queues.daemon_queue.Enqueue(new OrderMatchMsg(derived_currency, order_id, user_id, actual_amount, (int)order_status));
}
public void Close()
{
Status = OrderStatuses.Closed;
}
