public static WeekOrderDto GetMapDto(IUnitOfWorkAsync unitOfWork, WeekYearDto wyDto, bool needfact = true)
{
ApplicationDbContext context = unitOfWork.GetContext();
MenuForWeek menuForWeek = unitOfWork.RepositoryAsync <MenuForWeek>().GetWeekMenuByWeekYear(wyDto);
if (menuForWeek == null)
{
return(null);
}
List <WeekOrderMenu> weekOrderMenus = unitOfWork.RepositoryAsync <WeekOrderMenu>()
.OrdersMenuByWeekYear(wyDto).Where(word => word.User.IsExisting).OrderBy(wo => wo.User.LastName).ToList();
return(new WeekOrderDto
{
WeekYearDto = wyDto,
SuCanChangeOrder = menuForWeek.SUCanChangeOrder,
UserWeekOrders =
weekOrderMenus.Select(woDto => UserWeekOrderDto.MapDto(context, woDto)).ToList(),
DayNames = context.GetDayNames(wyDto, true).Result,
WeekDishPrices = context.GetWeekDishPrices(wyDto).Result,
SummaryDishQuantities = context.GetFactSumWeekUserCounts(wyDto).Result,
AllDayNames = context.GetDayNames(wyDto).Result
});
}
public static EmployeeWeekOrderDto MapDto(ApplicationDbContext context, WeekPaiment weekPaiment,
WeekYearDto wyDto)
{
double defaultDebt;
double.TryParse(WebConfigurationManager.AppSettings["defaultCreditValue"], out defaultDebt);
return(new EmployeeWeekOrderDto
{
WeekOrderId = weekPaiment.WeekOrderMenu.Id,
DayOrders =
weekPaiment.WeekOrderMenu.DayOrderMenus.Where(dom => dom.MenuForDay.WorkingDay.IsWorking)
.Select(OrderDayMenuDto.MapDto)
.ToList(),
WeekOrderDishes = context.FactDishQuantByWeekOrderId(weekPaiment.WeekOrderMenu.Id).Result,
WeekIsPaid = weekPaiment.WeekIsPaid,
Balance = weekPaiment.WeekOrderMenu.User.Balance,
WeekYear = wyDto,
PrevWeekBalance = weekPaiment.PreviousWeekBalance,
WeekPaiment = weekPaiment.Paiment,
AllowDebt = defaultDebt,
CheckDebt = weekPaiment.WeekOrderMenu.User.CheckDebt,
DayNames = context.GetDayNames(wyDto).Result
});
}
public async Task <IHttpActionResult> IsNextWeek([FromBody] WeekYearDto wyDto)
{
WeekYearDto curWeekYearDto = YearWeekHelp.GetCurrentWeekYearDto();
WeekYearDto nextWeekYearDto = YearWeekHelp.GetNextWeekYear(curWeekYearDto);
return(Ok(wyDto.Week == nextWeekYearDto.Week && wyDto.Year == nextWeekYearDto.Year));
}
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));
}
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 async Task <WeekYearDto> Create()
{
WeekYearDto nextDto = YearWeekHelp.GetNextWeekYear(YearWeekHelp.GetCurrentWeekYearDto());
_db.CreateNewWeekMenu(nextDto);
return(await Task.FromResult(nextDto));
}
/// <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 async Task <IHttpActionResult> CanCreateOrderOnNextWeek()
{
WeekYearDto curWeekYearDto = YearWeekHelp.GetCurrentWeekYearDto();
WeekYearDto nextWeekYearDto = YearWeekHelp.GetNextWeekYear(curWeekYearDto);
MenuForWeek nextWeekMenu = _weekMenuService.GetWeekMenuByWeekYear(nextWeekYearDto);
return(Ok(nextWeekMenu != null && nextWeekMenu.OrderCanBeCreated));
}
public Task <bool> IsNexWeekMenuExist()
{
WeekYearDto curWeekYear = YearWeekHelp.GetCurrentWeekYearDto();
WeekYearDto nextWeekYearDto = YearWeekHelp.GetNextWeekYear(curWeekYear);
MenuForWeek nextWeek =
_weekmenuService.GetWeekMenuByWeekYear(nextWeekYearDto);
return(Task.FromResult(nextWeek != null));
}
public static WorkWeekDto MapWorkWeekDto(WorkingWeek workweek)
{
return(new WorkWeekDto
{
WorkWeekId = workweek.ID,
WeekYear = WeekYearDto.MapDto(workweek),
WorkDays = workweek.WorkingDays.Select(WorkDayDto.MapDto).ToList(),
CanBeChanged = YearWeekHelp.WeekDaysCanBeChanged(workweek)
});
}
/// <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 async Task <WeekPaimentDto> GetWeekPaiments([FromBody] WeekYearDto wyDto)
{
if (wyDto == null)
{
wyDto = YearWeekHelp.GetCurrentWeekYearDto();
}
WeekPaimentDto dto = WeekPaimentDto.GetMapDto(_unitOfWork.RepositoryAsync <WeekPaiment>(), wyDto);
return(await Task.FromResult(dto));
}
public void GetWeekTitleTestApi()
{
WeekYearDto wyDto = new WeekYearDto
{
Week = 26,
Year = 2016
};
string rezult = YearWeekHelp.GetWeekTitle(_unitOfWork.RepositoryAsync <MenuForWeek>(), wyDto);
Assert.IsNotNull(rezult);
}
public async Task <PlanWeekOrderDto> GetPlanMenuOrders([FromBody] WeekYearDto wyDto)
{
if (wyDto == null)
{
wyDto = YearWeekHelp.GetCurrentWeekYearDto();
}
PlanWeekOrderDto weekOrderDto = PlanWeekOrderDto.GetMapDto(_unitOfWork, wyDto);
return(await Task.FromResult(weekOrderDto));
}
public async Task <IHttpActionResult> NextWeekOrderExists()
{
WeekYearDto curWeekYearDto = YearWeekHelp.GetCurrentWeekYearDto();
WeekYearDto nextWeekYearDto = YearWeekHelp.GetNextWeekYear(curWeekYearDto);
string userid = RequestContext.Principal.Identity.GetUserId();
WeekOrderMenu wom = _orderMenuService.FindByUserIdWeekYear(userid, nextWeekYearDto);
return(Ok(wom != null));
}
public static bool WeekDaysCanBeChanged(WorkingWeek workweek)
{
WeekYearDto curDto = new WeekYearDto
{
Week = CurrentWeek(),
Year = DateTime.Now.Year
};
WeekYearDto nextDto = GetNextWeekYear(curDto);
return((workweek.WeekNumber == curDto.Week && workweek.Year.YearNumber == curDto.Year) ||
(workweek.WeekNumber == nextDto.Week && workweek.Year.YearNumber == nextDto.Year));
}
public void CreateWeekMenuTestApi()
{
WeekMenuController weekMenuApi = new WeekMenuController(_unitOfWork);
WeekYearDto wyDto = new WeekYearDto
{
Week = 22,
Year = 2016
};
// weekMenuApi.GetWeekMenu(wyDto).Result;
Assert.IsNotNull(wyDto);
}
public async Task <WeekMenuDto> GetWeekMenu([FromBody] WeekYearDto wyDto)
{
if (wyDto == null)
{
wyDto = YearWeekHelp.GetCurrentWeekYearDto();
}
WeekMenuDto
resultdto = await Task.FromResult(_weekmenuService.GetWeekMenuDto(wyDto));
return(resultdto);
}
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 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 WeekOrderMenu FindByUserIdWeekYear(string userid, WeekYearDto wyDto)
{
return(_repository.Query()
.Include(om => om.MenuForWeek.WorkingWeek.Year)
.Include(om => om.User)
.Include(om => om.DayOrderMenus.Select(dom => dom.MenuForDay.WorkingDay.DayOfWeek))
.Select()
.FirstOrDefault(
om =>
string.Equals(om.User.Id, userid) &&
om.MenuForWeek.WorkingWeek.WeekNumber == wyDto.Week &&
om.MenuForWeek.WorkingWeek.Year.YearNumber == 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;
}
}
});
}
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 void StoredFuncTest()
{
WeekYearDto wyDto = YearWeekHelp.GetCurrentWeekYearDto();
//var res = _unitOfWork.GetContext().GetWeekUserOrderDishQuantyties(wyDto).ToList();
{
var weekParameter = new SqlParameter("@Week", wyDto.Week);
var yearParameter = new SqlParameter("@Year", wyDto.Year);
var res = _unitOfWork.GetContext().GetDayNames(wyDto).Result;
//.Database.SqlQuery(typeof(WeekUserOrder), "Select * From WeekOrdersByWeekYear(@Week,@Year)",
// weekParameter, yearParameter)
// .ToListAsync()
// .Result; ;
Assert.IsNotNull(res);
}
}
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 static WeekMenuDto GetWeekMenuDto(this IRepositoryAsync <MfdDishPriceRelations> repository,
MenuForWeek mfw)
{
WeekYearDto wyDto = WeekYearDto.MapDto(mfw.WorkingWeek);
return(new WeekMenuDto
{
Id = mfw.ID,
SummaryPrice = mfw.SummaryPrice,
MfdModels = mfw.MenuForDay.Select(repository.GetMenuForDayDto).ToList(),
OrderCanBeCreated = mfw.OrderCanBeCreated,
WorkWeekDays = mfw.WorkingWeek.WorkingDays.Select(wd => wd.IsWorking).ToArray(),
WorkingDaysAreSelected = mfw.WorkingDaysAreSelected,
DayNames = repository.Context.GetDayNames(wyDto).Result,
WeekYear = wyDto
});
}
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 static WeekPaimentDto GetMapDto(IRepositoryAsync<WeekPaiment> repository , WeekYearDto wyDto)
{
ApplicationDbContext context = repository.Context;
MenuForWeek menuForWeek = repository.GetRepositoryAsync<MenuForWeek>().GetWeekMenuByWeekYear(wyDto);
if (menuForWeek == null) return null;
List<WeekPaiment> weekPaiments = repository.WeekPaiments(wyDto).Where(word=>word.WeekOrderMenu.User.IsExisting).OrderBy(wo => wo.WeekOrderMenu.User.LastName).ToList();
return new WeekPaimentDto
{
WeekYearDto = wyDto,
UserWeekPaiments = weekPaiments.Select(updto => UserWeekPaimentDto.MapDto(context, updto)).ToList(),
SummaryDishPaiments = context.SumWeekPaimentsByDishes(wyDto).Result,
DayNames = context.GetDayNames(wyDto,true).Result,
WeekDishPrices = context.GetWeekDishPrices(wyDto).Result,
SuCanChangeOrder = menuForWeek.SUCanChangeOrder,
AllDayNames = context.GetDayNames(wyDto).Result
};
}
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 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);
}
public static WeekOrderDto GetMapDto(IUnitOfWorkAsync unitOfWork, WeekYearDto wyDto, bool needfact = true)
{
ApplicationDbContext context = unitOfWork.GetContext();
MenuForWeek menuForWeek = unitOfWork.RepositoryAsync<MenuForWeek>().GetWeekMenuByWeekYear(wyDto);
if (menuForWeek == null) return null;
List<WeekOrderMenu> weekOrderMenus = unitOfWork.RepositoryAsync<WeekOrderMenu>()
.OrdersMenuByWeekYear(wyDto).Where(word=>word.User.IsExisting).OrderBy(wo=>wo.User.LastName).ToList();
return new WeekOrderDto
{
WeekYearDto = wyDto,
SuCanChangeOrder = menuForWeek.SUCanChangeOrder,
UserWeekOrders =
weekOrderMenus.Select(woDto => UserWeekOrderDto.MapDto(context, woDto)).ToList(),
DayNames = context.GetDayNames(wyDto, true).Result,
WeekDishPrices = context.GetWeekDishPrices(wyDto).Result,
SummaryDishQuantities = context.GetFactSumWeekUserCounts(wyDto).Result,
AllDayNames = context.GetDayNames(wyDto).Result
};
}
public static EmployeeWeekOrderDto MapDto(ApplicationDbContext context, WeekPaiment weekPaiment,
WeekYearDto wyDto)
{
double defaultDebt;
double.TryParse(WebConfigurationManager.AppSettings["defaultCreditValue"], out defaultDebt);
return new EmployeeWeekOrderDto
{
WeekOrderId = weekPaiment.WeekOrderMenu.Id,
DayOrders =
weekPaiment.WeekOrderMenu.DayOrderMenus.Where(dom => dom.MenuForDay.WorkingDay.IsWorking)
.Select(OrderDayMenuDto.MapDto)
.ToList(),
WeekOrderDishes = context.FactDishQuantByWeekOrderId(weekPaiment.WeekOrderMenu.Id).Result,
WeekIsPaid = weekPaiment.WeekIsPaid,
Balance = weekPaiment.WeekOrderMenu.User.Balance,
WeekYear = wyDto,
PrevWeekBalance = weekPaiment.PreviousWeekBalance,
WeekPaiment = weekPaiment.Paiment,
AllowDebt = defaultDebt,
CheckDebt = weekPaiment.WeekOrderMenu.User.CheckDebt,
DayNames = context.GetDayNames(wyDto).Result
};
}
