public ActionResult GetListForAjax(string userName, string userPwd)
{
OrderUserInfo orderUserInfo = OrderUserService.Get(userName, userPwd);
if (orderUserInfo.Id == 0)
{
return(Json(new { login = false, orders = new List <OrderInfo>() }));
}
var orders = OrderService.List(new OrderSearchSetting()
{
PageIndex = 0,
PageSize = 1000,
ShowDeleted = false,
OrderUserId = orderUserInfo.Id
}).Select((m, index) => new {
OrderNumber = m.OrderNumber,
ProductName = m.ProductName,
Amount = m.Amount,
DeliveryDate = m.DeliveryDate.ToString("yyyy-MM-dd"),
Status = EnumHelper.GetEnumDescription(m.Status),
Remark = m.Remark,
Index = index
});
return(Json(new { login = true, orders = orders }));
}
//
// GET: /OrderUser/
public ActionResult Edit()
{
int id = Controleng.Common.CECRequest.GetQueryInt("id", 0);
var model = OrderUserService.Get(id);
return(View(model));
}
public ActionResult List()
{
int pageIndex = Controleng.Common.CECRequest.GetQueryInt("page", 0);
int pageSize = 10;
var list = OrderUserService.List(pageIndex, pageSize);
return(View(list));
}
public async void CreateOrderAsync_Positive_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "CreateOrderAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
context.AddRange(_users);
await context.SaveChangesAsync();
User userWithApartments = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithApartments.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new OrderUserService(context, _mapper);
var user = context.Users.AsNoTracking().FirstOrDefault();;
var apartment = context.Apartments.AsNoTracking().FirstOrDefault();;
IEnumerable <DateTime> dateTimes = new List <DateTime>()
{
DateTime.Now.Date
};
AddOrder order = new AddOrder()
{
ApartmentId = apartment.Id.ToString(),
Dates = dateTimes
};
var resultPositive = await service.CreateOrderAsync(order, user.Id.ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Apartment.Title.Should().BeEquivalentTo(apartment.Title);
resultPositive.Data.Order.Dates.FirstOrDefault().Should().BeSameDateAs(dateTimes.First());
context.BusyDates.FirstOrDefault().Date.Should().BeSameDateAs(dateTimes.First());
}
}
public ActionResult Edit(OrderInfo model, FormCollection fc)
{
bool error = false;
if (OrderService.IsExistsOrderNumber(model.Id, model.OrderNumber))
{
error = true;
ModelState.AddModelError("ExistsOrderNumber", "此订单号已存在，请选择其他订单号！");
}
if (!error && ModelState.IsValid)
{
model.OrderCompanyName = OrderUserService.Get(model.OrderUserId).CompanyName;
OrderService.Update(model);
ModelState.AddModelError("Success", "保存成功！");
}
return(View(model));
}
public ActionResult Edit(OrderUserInfo model)
{
bool error = false;
if (OrderUserService.ExistsUserName(model.Id, model.UserName))
{
ModelState.AddModelError("UserNameExists", "用户名存在");
error = true;
}
if (OrderUserService.ExistsCompanyName(model.Id, model.CompanyName))
{
ModelState.AddModelError("CompanyNameExists", "公司名已存在");
}
if (!error && ModelState.IsValid)
{
OrderUserService.Update(model);
ModelState.AddModelError("Success", "保存成功！");
}
return(View());
}
public async void DeleteOrderByIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "DeleteOrderByIdAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
Country country = new Country()
{
Name = "Litva"
};
context.Add(country);
context.AddRange(_users);
await context.SaveChangesAsync();
User userWithOrders = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithOrders.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
Apartment apartmentWithOrders = context.Apartments.AsNoTracking().FirstOrDefault();
Order order = new Order()
{
ApartmentId = apartmentWithOrders.Id,
CustomerId = userWithOrders.Id,
};
List <BusyDate> busyDates = new List <BusyDate>();
BusyDate date = new BusyDate()
{
ApartmentId = apartmentWithOrders.Id,
Date = DateTime.Now.Date
};
busyDates.Add(date);
order.Dates = _mapper.Map <HashSet <BusyDate> >(busyDates);
context.AddRange(order);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var orderInBase = await context.Orders.AsNoTracking().FirstOrDefaultAsync();
var service = new OrderUserService(context, _mapper);
var resultPositive = await service.DeleteOrderByIdAsync(orderInBase.Id.ToString(), orderInBase.CustomerId.ToString());
var resultNegative = await service.DeleteOrderByIdAsync(new Guid().ToString(), new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Message.Should().BeNull();
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Message.Should().Contain("not found");
}
}
public async void UpdateOrderAsync_Positive_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "UpdateOrderAsync_PositiveAndNegative_TestAsync")
.Options;
using (var context = new ApartmentContext(options))
{
Country country = new Country()
{
Name = "Litva"
};
context.Add(country);
context.AddRange(_users);
await context.SaveChangesAsync();
User userWithOrders = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithOrders.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
Apartment apartmentWithOrders = context.Apartments.AsNoTracking().FirstOrDefault();
Order order = new Order()
{
ApartmentId = apartmentWithOrders.Id,
CustomerId = userWithOrders.Id,
};
List <BusyDate> busyDates = new List <BusyDate>();
BusyDate date = new BusyDate()
{
ApartmentId = apartmentWithOrders.Id,
Date = DateTime.Now.Date
};
busyDates.Add(date);
order.Dates = _mapper.Map <HashSet <BusyDate> >(busyDates);
context.AddRange(order);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new OrderUserService(context, _mapper);
var orderInBase = await context.Orders.AsNoTracking().FirstOrDefaultAsync();
var orderForUpdate = _mapper.Map <OrderDTO>(orderInBase);
DateTime newDate = new DateTime(DateTime.Now.Year + 1, DateTime.Now.Month, DateTime.Now.Day);
IEnumerable <DateTime> dates = new List <DateTime>()
{
newDate
};
orderForUpdate.Dates = dates;
var resultPositive = await service.UpdateOrderAsync(orderForUpdate);
resultPositive.IsSuccess.Should().BeTrue();
//resultPositive.Data.Order.Dates.FirstOrDefault().Should().BeSameDateAs(newDate);
}
}
public async void GetAllOrdersByApartmentIdAsync_PositiveAndNegative_TestAsync()
{
var options = new DbContextOptionsBuilder <ApartmentContext>()
.UseInMemoryDatabase(databaseName: "GetAllOrdersByApartmentIdAsync_PositiveAndNegative_TestAsync")
.Options;
Apartment apartmentWithOrders;
using (var context = new ApartmentContext(options))
{
Country country = new Country()
{
Name = "Litva"
};
context.Add(country);
context.AddRange(_users);
await context.SaveChangesAsync();
User userWithOrders = context.Users.AsNoTracking().FirstOrDefault();
foreach (var item in _addresses)
{
item.CountryId = context.Countries.FirstOrDefault().Id;
}
for (int i = 0; i < 2; i++)
{
_apartments[i].OwnerId = userWithOrders.Id;
_apartments[i].Address = _addresses[i];
}
context.AddRange(_apartments);
await context.SaveChangesAsync();
apartmentWithOrders = context.Apartments.AsNoTracking().FirstOrDefault();
Order order = new Order()
{
ApartmentId = apartmentWithOrders.Id,
CustomerId = userWithOrders.Id,
};
List <BusyDate> busyDates = new List <BusyDate>();
BusyDate date = new BusyDate()
{
ApartmentId = apartmentWithOrders.Id,
Date = DateTime.Now.Date
};
busyDates.Add(date);
order.Dates = _mapper.Map <HashSet <BusyDate> >(busyDates);
context.AddRange(order);
await context.SaveChangesAsync();
}
using (var context = new ApartmentContext(options))
{
var service = new OrderUserService(context, _mapper);
var ordersInBase = await context.Orders.AsNoTracking().ToListAsync();
var apartmentWithoutOrders = await context.Users.Where(_ => _.Id != apartmentWithOrders.Id).FirstOrDefaultAsync();
var resultPositive = await service.GetAllOrdersByApartmentIdAsync(new Common.PagedRequest <string>(apartmentWithOrders.Id.ToString()));
var resultNegative = await service.GetAllOrdersByApartmentIdAsync(new Common.PagedRequest <string>(apartmentWithoutOrders.Id.ToString()));
foreach (var item in ordersInBase)
{
resultPositive.Data.Data.FirstOrDefault()
.ApartmentId
.Should().BeEquivalentTo(item.ApartmentId.ToString());
}
resultNegative.Data.Data.Should().BeEmpty();
}
}
