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 async Task <IHttpActionResult> WorkWeekCommit([FromBody] WorkDaysUpdateDto wwUpDto)
{
if (wwUpDto == null)
{
return(BadRequest());
}
WorkingWeek week = _weekmenuService.FindById(wwUpDto.MenuId).WorkingWeek;
for (int i = 0; i < wwUpDto.WorkDays.Length; i++)
{
WorkingDay workday = week.WorkingDays.ElementAt(i);
workday.IsWorking = wwUpDto.WorkDays[i];
_db.Entry(workday).State = EntityState.Modified;
}
MenuForWeek menu = _weekmenuService.FindById(wwUpDto.MenuId);
menu.WorkingDaysAreSelected = true;
_db.Entry(menu).State = EntityState.Modified;
week.CanBeChanged = false;
await _db.SaveChangesAsync();
return(Ok(true));
}
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 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
})
public async Task <IHttpActionResult> DeleteMenuForWeek(int menuid)
{
MenuForWeek mfw = _weekmenuService.FindById(menuid);
if (mfw == null)
{
return(NotFound());
}
_db.MenuForWeeks.Remove(mfw);
await _db.SaveChangesAsync();
return(StatusCode(HttpStatusCode.NoContent));
}
public static MenuForWeek GetMenuById(this IRepositoryAsync <MenuForWeek> repository, int menuid)
{
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.ID == menuid);
return(mfw);
}
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 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 async Task <IHttpActionResult> UpdateMenuForDay([FromBody] MenuForDayDto menuforday)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int dishtypeid = _mfdDishPriceService.UpdateMenuForDay(menuforday);
MenuForWeek mfw = _unitOfWork.RepositoryAsync <MenuForWeek>().GetWeekMenuMfdContains(menuforday.Id);
mfw.SummaryPrice = mfw.MenuForDay.Sum(mw => mw.TotalPrice);
_unitOfWork.GetContext().SaveChanges();
_unitOfWork.GetContext().UpdateBalanceByDayMenuDishTypeId(menuforday.Id, dishtypeid);
return(StatusCode(HttpStatusCode.OK));
}
public async Task <IHttpActionResult> SetMenuAsCanMadeOrder([FromBody] MenuCanBeOrderedMessageDto messageDto)
{
if (messageDto == null)
{
return(BadRequest());
}
MenuForWeek menu = _weekmenuService.FindById(messageDto.WeekMenuId);
menu.OrderCanBeCreated = true;
_db.Entry(menu).State = EntityState.Modified;
await _db.SaveChangesAsync();
ApplicationUserManager userManager = new ApplicationUserManager(new UserStore <User>(_unitOfWork.GetContext()));
List <User> users = userManager.Users.ToList();
MessageService.SendEmailAsync(users, MessageTopic.MenuCreated, messageDto.DateTime);
return(Ok(true));
}
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 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
});
}
