public async Task CheckOut_ModelState_Invalid_Returns_View_With_Models()
{
const string expOrderName = "Test order";
var cartServiceStub = Mock
.Of <ICartService>();
var orderServiceStub = Mock
.Of <IOrderService>();
var controller = new CartController(cartServiceStub, orderServiceStub);
controller.ModelState.AddModelError("error", "InvalidError");
var orderModel = new OrderWebModel
{
Name = expOrderName,
};
var result = await controller.CheckOut(orderModel);
Assert
.IsInstanceOfType(result, typeof(ViewResult));
var viewResult = (ViewResult)result;
Assert
.IsInstanceOfType(viewResult.Model, typeof(CartOrderWebModel));
var cartModel = (CartOrderWebModel)viewResult.Model;
Assert
.AreEqual(expOrderName, cartModel.Order.Name);
}
public ActionResult AddToOrder(int gameId)
{
var order = (OrderWebModel)Session["Order"];
if (order == null)
{
order = new OrderWebModel();
Session["Order"] = order;
}
var orderDetail = order.OrderDetails.FirstOrDefault(o => o.Id == gameId);
if (orderDetail != null)
{
orderDetail.Quantity++;
}
else
{
orderDetail = new OrderDetailsWebModel()
{
Game = Mapper.Map <GameWebModel>(_gameService.GetById(gameId)),
Quantity = 1
};
order.OrderDetails.Add(orderDetail);
}
return(RedirectToAction("Index", "Busket"));
}
//
// GET: /Busket/
public ActionResult Index()
{
var order = (OrderWebModel)Session["Order"];
if (order == null)
{
order = new OrderWebModel();
Session["Order"] = order;
}
return(View(order));
}
public HttpResponseMessage OrderOperation(OrderWebModel model, string type)
{
try
{
IOrderWebService service = new OrderWebService();
OrderWebModel data = service.OrderOperation(model, type);
return(Request.CreateResponse(HttpStatusCode.OK, data));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public HttpResponseMessage SaveWebOrder(OrderWebModel model)
{
try
{
IOrderWebService service = new OrderWebService();
string OrderNo = service.SaveWebOrder(model);
return(Request.CreateResponse(HttpStatusCode.OK, OrderNo));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <Order> CreateOrder(string userName, CartWebModel cart, OrderWebModel orderModel)
{
var model = new CreateOrderDTO
{
Order = orderModel,
Items = cart.ToDTO(),
};
var response = await PostAsync($"{Address}/{userName}", model).ConfigureAwait(false);
var order = await response.EnsureSuccessStatusCode().Content.ReadFromJsonAsync <OrderDTO>().ConfigureAwait(false);
return(order.FromDTO());
}
public async Task <IActionResult> CheckOut(OrderWebModel model)
{
if (!ModelState.IsValid)
{
return(View(nameof(Index),
new CartOrderWebModel {
Cart = _CartService.GetWebModel(), Order = model
}));
}
var order = await _OrderService.CreateOrder(User.Identity !.Name, _CartService.GetWebModel(), model);
_CartService.Clear();
return(RedirectToAction(nameof(OrderConfirmed), new { order.Id }));
}
public async Task <Order> CreateOrder(string userName, CartWebModel cart, OrderWebModel model)
{
var user = await _UserManager.FindByNameAsync(userName);
if (user is null)
{
_Logger.LogError($"Пользователь {userName} отсустсвует в базе данных");
throw new InvalidOperationException($"Пользователь {userName} отсутствует в базе данных");
}
_Logger.LogInformation($"Начало формирования заказа для {userName}");
await using var transaction = await _Context.Database.BeginTransactionAsync();
var order = new Order
{
User = user,
Name = model.Name,
Phone = model.Phone,
Address = model.Address
};
var ids = cart.Items
.Select(i => i.Product.Id).ToArray();
var cartProducts = await _Context.Products
.Where(p => ids.Contains(p.Id)).ToArrayAsync();
order.Items = cart.Items.Join(cartProducts, i => i.Product.Id, p => p.Id, (i, p) => new OrderItem
{
Order = order,
Product = p,
Price = p.Price,
Quantity = i.Quantity
}).ToArray();
_Logger.LogInformation($"Заказ для {userName} успешно сформирован");
await _Context.Orders.AddAsync(order);
await _Context.SaveChangesAsync();
await transaction.CommitAsync();
_Logger.LogInformation($"Заказ для {userName} успешно добавлен в базу данных");
return(order);
}
public static Order ToModel(this OrderWebModel model)
{
return(new Order
{
Id = new Guid(model.Id),
FirstName = model.FirstName,
LastName = model.LastName,
Comment = model.Comment,
Street = model.Street,
StreetNumber = model.StreetNumber,
FlatNumber = model.FlatNumber,
PhoneNumber = model.PhoneNumber,
Email = model.Email,
PostalCode = model.PostalCode,
Country = model.Country,
});
}
public void AddOrder([FromBody] OrderWebModel order)
{
try
{
_queueClient.Publish(new FinalizeOrder()
{
Order = order.ToModel(),
Dishes = order.Dishes,
});
}
catch
{
throw new HttpResponseException
{
Value = "CONNECTION_ERROR"
};
}
}
