public static SetAsPrevDto GetSetAsPrevDtoById(this IRepositoryAsync<WeekOrderMenu> repository, int weekordid)
{
WeekOrderMenu curOrderMenu = repository.FindOrderMenuById(weekordid);
WeekYearDto curwyDto = new WeekYearDto
{
Week = curOrderMenu.MenuForWeek.WorkingWeek.WeekNumber,
Year = curOrderMenu.MenuForWeek.WorkingWeek.Year.YearNumber
};
WeekYearDto preWeekYearDto = YearWeekHelp.GetPrevWeekYear(curwyDto);
WeekOrderMenu prevWeekOrder = repository.Query()
.Include(om => om.User)
.Include(om => om.MenuForWeek.WorkingWeek.Year)
.Select().FirstOrDefault(om =>
string.Equals(om.User.Id, curOrderMenu.User.Id) &&
om.MenuForWeek.WorkingWeek.WeekNumber == preWeekYearDto.Week &&
om.MenuForWeek.WorkingWeek.Year.YearNumber == preWeekYearDto.Year);
if (prevWeekOrder != null)
return new SetAsPrevDto
{
PrevWeekOrdId = prevWeekOrder.Id,
DayNames = repository.Context.GetDayNames(preWeekYearDto,true).Result,
Prevquants = repository.Context.FactDishQuantByWeekOrderId(prevWeekOrder.Id).Result
};
return null;
}
public static int GetCountByWeekYear(this IRepositoryAsync<WeekOrderMenu> repository, WeekYearDto wyDto)
{
return repository.Query()
.Include(om => om.MenuForWeek.WorkingWeek.Year).Select().Count(
om =>
om.MenuForWeek.WorkingWeek.WeekNumber == wyDto.Week &&
om.MenuForWeek.WorkingWeek.Year.YearNumber == wyDto.Year);
}
public static WeekMenuDto MapWeekMenuDto(this IRepositoryAsync<MenuForWeek> repository, WeekYearDto wyDto)
{
MenuForWeek wmenu = repository.GetWeekMenuByWeekYear(wyDto);
if (wmenu == null && YearWeekHelp.IsCurrentWeekYearDto(wyDto))
{
repository.Context.CreateNewWeekMenu(wyDto);
wmenu = repository.GetWeekMenuByWeekYear(wyDto);
}
;
if (wmenu == null)
{
return null;
}
WeekMenuDto dtoModel = new WeekMenuDto
{
Id = wmenu.ID,
SummaryPrice = wmenu.SummaryPrice,
MfdModels =
wmenu.MenuForDay
.Select(mfd => new MenuForDayDto
{
Id = mfd.ID,
TotalPrice = mfd.TotalPrice,
Dishes =
mfd.DishPriceMfdRelations.Select(dp => dp.Dish).OrderBy(d => d.DishType.Id).Select(d =>
{
var mfdDishPriceRelations =
mfd.DishPriceMfdRelations.FirstOrDefault(dp => dp.DishId == d.DishID);
if (mfdDishPriceRelations != null)
return new DTO.SuperUser.Dishes.DishModelDto
{
DishId = d.DishID,
Title = d.Title,
ProductImage = d.ProductImage,
Price =
mfdDishPriceRelations
.DishPrice.Price,
Category = mfdDishPriceRelations.Dish.DishType.Category,
Description = mfdDishPriceRelations.Dish.Description
};
return null;
}).ToList(),
OrderCanBeChanged = mfd.OrderCanBeChanged,
OrderWasBooking =
repository.GetRepositoryAsync<WeekOrderMenu>().GetUsersMadeOrder(mfd.ID).Any(),
DayMenuCanBeChanged = mfd.DayMenuCanBeChanged
})
.ToList(),
OrderCanBeCreated = wmenu.OrderCanBeCreated,
WorkWeekDays = wmenu.WorkingWeek.WorkingDays.Select(wd => wd.IsWorking).ToArray(),
WorkingDaysAreSelected = wmenu.WorkingDaysAreSelected,
DayNames = repository.Context.GetDayNames(wyDto).Result,
WeekYear = wyDto
};
return dtoModel;
}
/// <summary>
/// Цены на на каждое блюдо в меню на рабочую неделю
/// </summary>
/// <param name="context"></param>
/// <param name="wyDto">Объект, содержащий номера недели и года для запроса</param>
/// <param name="witoutnowork"></param>
/// <returns></returns>
public static async Task<string[]> GetDayNames(this ApplicationDbContext context, WeekYearDto wyDto, bool witoutnowork=false)
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
var withoutNoworking = new SqlParameter("@Wonw", witoutnowork);
var res = context.Database.SqlQuery<string>("Select DayName From GetDayNames(@Week, @Year,@Wonw)",
weekParameter, yearParameter, withoutNoworking)
.ToArrayAsync().Result;
return res;
}
public void CreateWeekMenuTestApi()
{
WeekMenuController weekMenuApi = new WeekMenuController(_unitOfWork);
WeekYearDto wyDto = new WeekYearDto
{
Week = 22,
Year = 2016
};
// weekMenuApi.GetWeekMenu(wyDto).Result;
Assert.IsNotNull(wyDto);
}
public static string GetWeekTitle(IRepositoryAsync<MenuForWeek> menuRepositoryAsync, WeekYearDto dto)
{
WorkingWeek workWeek = menuRepositoryAsync
.WorkWeekByWeekYear(dto);
int mindayId = workWeek.WorkingDays.Where(wd => wd.IsWorking).Min(wd => wd.DayOfWeek.Id);
int maxdayId = workWeek.WorkingDays.Where(wd => wd.IsWorking).Max(wd => wd.DayOfWeek.Id);
DateTime firstday = DateOfWeekIso8601(dto.Year, dto.Week, mindayId);
DateTime lastday = DateOfWeekIso8601(dto.Year, dto.Week, maxdayId);
List<Core.Domains.DayOfWeek> days = menuRepositoryAsync.Context.Days.ToList();
CultureInfo myCi = new CultureInfo("uk-UA");
return string.Format("Неделя_{0}-{1}-{2}", dto.Week, firstday.Date.ToString("ddd_dd_MM_yy", myCi), lastday.Date.ToString("ddd_dd_MM_yy",myCi));
}
public void GetNextWeekMenu()
{
WeekMenuController weekMenuApi = new WeekMenuController(_unitOfWork);
WeekYearDto wyDto = new WeekYearDto
{
Week = 17,
Year = 2016
};
WeekMenuDto dto = weekMenuApi.GetWeekMenu(wyDto).Result;
Assert.IsNotNull(dto);
}
public void TestGetUserWeekOrder()
{
WeekYearDto wyDto = new WeekYearDto
{
Week = 19,
Year = 2016
};
User user = _userManager.FindByName("employee");
//WeekOrderMenu ordmenu = _weekOrderMenuService.FindByUserIdWeekYear(user.Id, wyDto);
WeekPaiment weekPaiment = _weekPaimentService.GetByUseridWeekYear(user.Id, wyDto);
EmployeeWeekOrderDto model = EmployeeWeekOrderDto.MapDto(_unitOfWork.GetContext(), weekPaiment, wyDto);
Assert.IsNotNull(model);
}
public void TestDeleteWeekOrder()
{
User user = _userManager.FindByName("employee");
WeekYearDto wyDto = new WeekYearDto
{
Week = 19,
Year = 2016
};
WeekOrderMenu weekOrderMenu = _weekOrderMenuService.FindByUserIdWeekYear(user.Id, wyDto);
_weekOrderMenuService.Delete(weekOrderMenu);
weekOrderMenu = _weekOrderMenuService.FindByUserIdWeekYear(user.Id, wyDto);
Assert.IsNull(weekOrderMenu);
}
public static MenuForWeek GetWeekMenuByWeekYear(this IRepositoryAsync<MenuForWeek> repository, WeekYearDto wyDto)
{
MenuForWeek mfw =
repository.Query()
.Include(wm => wm.MenuForDay.Select(dm => dm.DishPriceMfdRelations.Select(dp => dp.Dish.DishType)))
.Include(wm => wm.MenuForDay.Select(dm => dm.DishPriceMfdRelations.Select(dp => dp.DishPrice)))
.Include(wm => wm.MenuForDay.Select(dm => dm.DishPriceMfdRelations.Select(dp => dp.Dish.DishDetail)))
.Include(wm => wm.Orders)
.Include(wm => wm.WorkingWeek.Year)
.Include(wm => wm.WorkingWeek.WorkingDays.Select(d => d.DayOfWeek))
.Select()
.FirstOrDefault(
wm => wm.WorkingWeek.WeekNumber == wyDto.Week && wm.WorkingWeek.Year.YearNumber == wyDto.Year);
return mfw;
}
public static List<WeekPaiment> WeekPaiments(this IRepositoryAsync<WeekPaiment> repository, WeekYearDto wyDto)
{
return repository.Query()
.Include(wp => wp.WeekOrderMenu.User)
.Include(wp => wp.WeekOrderMenu.MenuForWeek.WorkingWeek.Year)
.Include(wp => wp.WeekOrderMenu.MenuForWeek.WorkingWeek.WorkingDays.Select(wd => wd.DayOfWeek))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.Dish.DishType)))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.DishPrice)))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.Dish.DishDetail)))
.Select().Where(
wp =>
wp.WeekOrderMenu.MenuForWeek.WorkingWeek.WeekNumber == wyDto.Week &&
wp.WeekOrderMenu.MenuForWeek.WorkingWeek.Year.YearNumber == wyDto.Year)
.OrderBy(wp=>wp.WeekOrderMenu.User.UserName)
.ToList();
}
public static WeekPaiment WeekPaimentByUseridWeekYear(this IRepositoryAsync<WeekPaiment> repository, string userid, WeekYearDto wyDto)
{
return repository.Query()
.Include(wp => wp.WeekOrderMenu.User)
.Include(wp => wp.WeekOrderMenu.MenuForWeek.WorkingWeek.Year)
.Include(wp => wp.WeekOrderMenu.MenuForWeek.WorkingWeek.WorkingDays.Select(wd => wd.DayOfWeek))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.Dish.DishType)))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.DishPrice)))
.Include(wpai => wpai.WeekOrderMenu.MenuForWeek.MenuForDay.Select(mfd => mfd.DishPriceMfdRelations.Select(dpr => dpr.Dish.DishDetail)))
.Select()
.FirstOrDefault(
wp =>
string.Equals(wp.WeekOrderMenu.User.Id, userid) &&
wp.WeekOrderMenu.MenuForWeek.WorkingWeek.WeekNumber == wyDto.Week &&
wp.WeekOrderMenu.MenuForWeek.WorkingWeek.Year.YearNumber == wyDto.Year);
}
public static List<PlannedWeekOrderMenu> OrdersMenuByWeekYear(this IRepositoryAsync<PlannedWeekOrderMenu> repository,
WeekYearDto wyDto)
{
List<PlannedWeekOrderMenu> pagedOrders = repository.Query()
.Include(om => om.User)
.Include(om => om.MenuForWeek.WorkingWeek.Year)
.Include(wm => wm.MenuForWeek.WorkingWeek.WorkingDays.Select(d => d.DayOfWeek))
.Include(om => om.PlannedDayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.Dish.DishType)))
.Include(om => om.PlannedDayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.Dish.DishDetail)))
.Include(om => om.PlannedDayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.DishPrice)))
.Select().Where(
om =>
om.MenuForWeek.WorkingWeek.WeekNumber == wyDto.Week &&
om.MenuForWeek.WorkingWeek.Year.YearNumber == wyDto.Year)
.OrderBy(wp => wp.User.LastName)
.ToList();
return pagedOrders;
}
public void GetMenuExcellTestApi()
{
string _path = AppDomain.CurrentDomain.BaseDirectory.Replace(@"UnitTestProject1\bin\Debug", "") +
@"ACSDining.Web\ExcelFiles\Menu.xls";
//GetExcelController excelApi = new GetExcelController(_unitOfWork);
GetExcelService excelService = new GetExcelService(_unitOfWork.RepositoryAsync<WeekOrderMenu>());
WeekYearDto wyDto = new WeekYearDto
{
Week = 22,
Year = 2016
};
ForMenuExcelDto feDto = new ForMenuExcelDto
{
WeekYear = wyDto,
MenuTitle = "test string"
};
string result = excelService.GetMenuExcel(feDto);
Assert.IsNotNull(result);
Process.Start(_path);
}
public void GetExcellPaimentsTestApi()
{
//string _path = AppDomain.CurrentDomain.BaseDirectory.Replace(@"UnitTestProject1\bin\Debug", "") +
// @"ACSDining.Web\ExcelFiles\Paiments.xls";
//GetExcelController excelApi = new GetExcelController(_unitOfWork);
GetExcelService excelService = new GetExcelService(_unitOfWork.RepositoryAsync<WeekOrderMenu>());
WeekYearDto wyDto = new WeekYearDto
{
Week = 23,
Year = 2016
};
ForExcelDataDto feDto = new ForExcelDataDto
{
WeekYear = wyDto,
DataString = "test string"
};
string result = excelService.GetExcelFileFromPaimentsModel(feDto);
Assert.IsNotNull(result);
Process.Start(result);
}
public static WeekYearDto GetNextWeekYear(WeekYearDto wyDto)
{
WeekYearDto result = new WeekYearDto();
if (wyDto.Week >= 52)
{
DateTime lastDay = new DateTime(wyDto.Year, 12, 31);
if (lastDay.DayOfWeek < DayOfWeek.Thursday || wyDto.Week == 53)
{
result.Week = 1;
result.Year = wyDto.Year + 1;
}
}
else
{
result.Week = wyDto.Week + 1;
result.Year = wyDto.Year;
}
return result;
}
public void GetWeekTitleTestApi()
{
WeekYearDto wyDto = new WeekYearDto
{
Week = 26,
Year = 2016
};
string rezult = YearWeekHelp.GetWeekTitle(_unitOfWork.RepositoryAsync<MenuForWeek>(), wyDto);
Assert.IsNotNull(rezult);
}
public static WorkingWeek WorkWeekByWeekYear(this IRepositoryAsync<MenuForWeek> repository, WeekYearDto wyDto)
{
return repository.GetRepositoryAsync<WorkingWeek>().Query()
.Include(ww => ww.WorkingDays.Select(wd => wd.DayOfWeek))
.Include(ww => ww.Year)
.Select()
.FirstOrDefault(ww => ww.WeekNumber == wyDto.Week && ww.Year.YearNumber == wyDto.Year);
}
/// <summary>
/// Получает список сущностей, содержащих id недельных заказов по каждому пользователю и их полные имена
/// </summary>
/// <param name="context"></param>
/// <param name="wyDto">Объект, содержащий номера недели и года для запроса</param>
/// <returns></returns>
public static async Task<List<WeekUserOrder>> GetWeekOrdersByWeekYear(this ApplicationDbContext context,
WeekYearDto wyDto)
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
return context.Database.SqlQuery<WeekUserOrder>("Select * From WeekOrdersByWeekYear(@Week,@Year)",
weekParameter, yearParameter)
.ToListAsync().Result;
}
public static WeekYearDto GetPrevWeekYear(WeekYearDto wyDto)
{
WeekYearDto result = new WeekYearDto();
if (wyDto.Week == 1)
{
result.Week = YearWeekCount(wyDto.Year);
result.Year = wyDto.Year - 1;
}
else
{
result.Week = wyDto.Week - 1;
result.Year = wyDto.Year;
}
return result;
}
public void TestWeekMenuDelete()
{
WeekMenuController weekMenuApi = new WeekMenuController(_unitOfWork);
WeekYearDto wyDto = new WeekYearDto
{
Week = 18,
Year = 2016
};
MenuForWeek weekmenu = _menuForWeekService.GetWeekMenuByWeekYear(wyDto);
if (weekmenu == null)
{
WeekMenuDto dto = weekMenuApi.GetWeekMenu(wyDto).Result;
weekmenu = _menuForWeekService.GetWeekMenuByWeekYear(wyDto);
}
var res = weekMenuApi.DeleteMenuForWeek(weekmenu.ID).Result;
weekmenu = _menuForWeekService.GetWeekMenuByWeekYear(wyDto);
Assert.IsNull(weekmenu);
}
/// <summary>
/// Получает суммарные фактические количества по каждому заказанному блюду на неделе всеми пользователями
/// </summary>
/// <param name="context"></param>
/// <param name="wyDto">Объект, содержащий номера недели и года для запроса</param>
/// <returns></returns>
public static async Task<double[]> GetFactSumWeekUserCounts(this ApplicationDbContext context, WeekYearDto wyDto)
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
var res= context.Database.SqlQuery<double>("Select SumByDishes From GetFactSumWeekUserCounts(@Week,@Year)",
weekParameter, yearParameter)
.ToArrayAsync().Result;
return res;
}
public void WeekOrderPaged()
{
WeekYearDto wyDto = new WeekYearDto
{
Week = 17,
Year = 2016
};
int totCount;
List<WeekOrderMenu> pagedOrders =
_weekOrderMenuRepository.OrdersMenuByWeekYear(wyDto);
int page = 1;
int pageSize = 7;
List<WeekOrderMenu> needOrders =
pagedOrders.OrderBy(po => po.User.LastName).Skip(pageSize*(page - 1)).Take(pageSize).ToList();
Assert.IsNotNull(needOrders);
}
public void NewMenuProcTest()
{
WeekYearDto wyDto = new WeekYearDto
{
Week = 21,
Year = 2016
};
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
_unitOfWork.GetContext()
.Database.ExecuteSqlCommand("exec CreateNewWeekMenu @Week,@Year",
weekParameter, yearParameter);
;
var res = _weekMenuRepository.Query().Include(wm => wm.WorkingWeek.Year).Select()
.SingleOrDefault(
wm => wm.WorkingWeek.WeekNumber == wyDto.Week && wm.WorkingWeek.Year.YearNumber == wyDto.Year);
Assert.IsNotNull(res);
}
public static bool IsCurrentWeekYearDto(WeekYearDto wyDto)
{
WeekYearDto curwyDto = GetCurrentWeekYearDto();
return curwyDto.Week == wyDto.Week && curwyDto.Year == wyDto.Year;
}
public static void PrevOrdersMenuById(this IRepositoryAsync<WeekOrderMenu> repository, int weekordid)
{
WeekOrderMenu curOrderMenu = repository.FindOrderMenuById(weekordid);
WeekYearDto curwyDto = new WeekYearDto
{
Week = curOrderMenu.MenuForWeek.WorkingWeek.WeekNumber,
Year = curOrderMenu.MenuForWeek.WorkingWeek.Year.YearNumber
};
WeekYearDto preWeekYearDto = YearWeekHelp.GetPrevWeekYear(curwyDto);
WeekOrderMenu prevWeekOrder = repository.Query()
.Include(om => om.User)
.Include(om => om.MenuForWeek.WorkingWeek.Year)
.Include(wm => wm.MenuForWeek.WorkingWeek.WorkingDays.Select(d => d.DayOfWeek))
.Include(om => om.DayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.Dish.DishType)))
.Include(om => om.DayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.Dish.DishDetail)))
.Include(om => om.DayOrderMenus.Select(dm => dm.MenuForDay.DishPriceMfdRelations.Select(dp => dp.DishPrice)))
.Select().FirstOrDefault(om =>
string.Equals(om.User.Id,curOrderMenu.User.Id) &&
om.MenuForWeek.WorkingWeek.WeekNumber == preWeekYearDto.Week &&
om.MenuForWeek.WorkingWeek.Year.YearNumber == preWeekYearDto.Year);
if (prevWeekOrder == null) return ;
List<DayOrderMenu> curDayOrderMenus = repository.DayOrdsByWeekOrdId(weekordid);
List<DayOrderMenu> prevDayOrderMenus = repository.DayOrdsByWeekOrdId(prevWeekOrder.Id);
curDayOrderMenus.ForEach(curdayord =>
{
if (curdayord.MenuForDay.WorkingDay.IsWorking && curdayord.MenuForDay.OrderCanBeChanged)
{
DayOrderMenu prevDayOrd =
prevDayOrderMenus.FirstOrDefault(dord => dord.MenuForDay.WorkingDay.DayOfWeek.Id == curdayord.MenuForDay.WorkingDay.DayOfWeek.Id);
List<DishQuantityRelations> curdrels =
repository.GetRepositoryAsync<DishQuantityRelations>().GetRelationsListByDayOrdId(curdayord.Id);
List<DishQuantityRelations> prevdrels =
repository.GetRepositoryAsync<DishQuantityRelations>().GetRelationsListByDayOrdId(prevDayOrd.Id);
for (int i = 0; i < curdrels.Count; i++)
{
DishQuantityRelations rel = curdrels[i];
rel.DishQuantityId = prevdrels.Count == 0
? repository.GetRepositoryAsync<MfdDishPriceRelations>().GetDishPrice(0.00).Id
: prevdrels[i].DishQuantityId;
repository.Context.Entry(rel).State=EntityState.Modified;
}
}
});
}
/// <summary>
/// Суммы по планируемым оплатам на заказанное количество каждого блюда в меню на неделю
/// </summary>
/// <param name="context"></param>
/// <param name="wyDto">Объект, содержащий номера недели и года для запроса</param>
/// <returns></returns>
public static async Task<double[]> SumWeekPaimentsByDishes(this ApplicationDbContext context, WeekYearDto wyDto)
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
return context.Database.SqlQuery<double>("SELECT SumByDishes FROM SumWeekPaimentsByDishes(@Week,@Year)",
weekParameter, yearParameter)
.ToArrayAsync().Result;
}
/// <summary>
/// Создаёт новое меню на неделю и заполняет его пустыми блюдами
/// </summary>
/// <param name="context"></param>
/// <param name="wyDto">Объект, содержащий номера недели и года для запроса</param>
/// <returns></returns>
public static void CreateNewWeekMenu(this ApplicationDbContext context, WeekYearDto wyDto)
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
context.Database.ExecuteSqlCommand("exec CreateNewWeekMenu @Week,@Year",
weekParameter, yearParameter);
}
public void GetOrders()
{
OrdersController ord = new OrdersController(_unitOfWork);
WeekYearDto wyDto = new WeekYearDto
{
Week = 17,
Year = 2016
};
WeekOrderDto uwoDtos = ord.GetFactMenuOrders(wyDto).Result;
Assert.IsNotNull(uwoDtos);
}
public static bool WeekIsCurrentOrNext(WeekYearDto wyDto)
{
WeekYearDto nextWeekYearDto = GetNextWeekYear(GetCurrentWeekYearDto());
return (wyDto.Week == CurrentWeek() && wyDto.Year == DateTime.Now.Year) ||
(wyDto.Week == nextWeekYearDto.Week && wyDto.Year == nextWeekYearDto.Year);
}
