public static MenuForDayDto GetMenuForDayDto(this IRepositoryAsync <MfdDishPriceRelations> repository,
MenuForDay mfd)
{
List <MfdDishPriceRelations> mfdrels = repository.Queryable().Where(mp => mp.MenuForDayId == mfd.ID).ToList();
List <Dish> dishes =
repository.GetRepositoryAsync <Dish>()
.Queryable().Include("DishType").Include("DishDetail")
.Where(d => mfdrels.Select(md => md.DishId).Contains(d.DishID)).OrderBy(d => d.DishType.Id)
.ToList();
List <DishModelDto> dishmodels = dishes.Select(d => repository.GetDishModelDto(d, mfd.ID)).ToList();
return(new MenuForDayDto
{
Id = mfd.ID,
TotalPrice = mfd.TotalPrice,
Dishes = dishmodels,
OrderCanBeChanged = mfd.OrderCanBeChanged,
OrderWasBooking = repository.GetRepositoryAsync <WeekOrderMenu>().GetUsersMadeOrder(mfd.ID).Any()
});
}
// The callback, no inside the method used above.
// This will run every hour.
private static void TimerElapsed(object o, System.Timers.ElapsedEventArgs e)
{
Logger.Trace("DateTime: {0}, e.SignalTime.Hour= {1}", DateTime.Now, e.SignalTime /*e.SignalTime.Hour*/);
if (e.SignalTime.Hour < 9)
{
return;
}
int daynum = (int)e.SignalTime.DayOfWeek;
IUnitOfWorkAsync unitofwork = DependencyResolver.Current.GetService <IUnitOfWorkAsync>();
WorkingWeek currWorkingWeek =
unitofwork.RepositoryAsync <MenuForWeek>().WorkWeekByWeekYear(YearWeekHelp.GetCurrentWeekYearDto());
using (ApplicationDbContext db = new ApplicationDbContext())
{
MenuForDay menuForDay =
db.MenuForDays.Include("WorkingDay.DayOfWeek").ToList()
.Where(mfd => currWorkingWeek.WorkingDays.Select(wd => wd.Id).Contains(mfd.WorkingDay.Id))
.FirstOrDefault(d => d.WorkingDay.DayOfWeek.Id == daynum);
if (menuForDay != null && (menuForDay.DayMenuCanBeChanged || menuForDay.OrderCanBeChanged))
{
db.DayFactToPlan();
Logger.Trace("DayFactToPlan was executed !!!");
string _dirpath = HostingEnvironment.MapPath("~/ExcelFiles/");
string[] filePaths = Directory.GetFiles(_dirpath, "*.xls");
foreach (var filename in filePaths)
{
if (File.Exists(filename))
{
File.Delete(filename);
Logger.Trace("File {0} was deleted!", filename);
}
}
}
}
//TimerFired.Set();
}
public static int UpdateMfdDishes(this IRepositoryAsync <MfdDishPriceRelations> repository,
MenuForDayDto menuforday)
{
MenuForDay menuFd =
repository.GetRepositoryAsync <MenuForDay>()
.Query()
.Include(mfd => mfd.DishPriceMfdRelations.Select(dp => dp.DishPrice))
.Include(mfd => mfd.DishPriceMfdRelations.Select(dp => dp.Dish))
.Include(mfd => mfd.DishPriceMfdRelations.Select(dp => dp.Dish.DishType))
.Include(mfd => mfd.DayOrderMenus.Select(dp => dp.MenuForDay))
.Include(mfd => mfd.DayOrderMenus.Select(dp => dp.MenuForDay.WorkingDay.DayOfWeek))
.Include(mfd => mfd.DayOrderMenus.Select(dp => dp.WeekOrderMenu.DayOrderMenus))
.Include(mfd => mfd.WorkingDay.WorkingWeek.Year)
.Include(mfd => mfd.DayOrderMenus.Select(dord => dord.WeekOrderMenu.MenuForWeek))
.Select()
.FirstOrDefault(mfd => mfd.ID == menuforday.Id);
if (menuFd != null)
{
int changedishid = menuforday.Dishes.Select(d => d.DishId)
.FirstOrDefault(id => !menuFd.DishPriceMfdRelations.Select(dp => dp.DishId).Contains(id));
if (changedishid == 0)
{
for (int i = 0; i < menuFd.DishPriceMfdRelations.Count; i++)
{
if (menuFd.DishPriceMfdRelations.ElementAt(i).DishPrice != repository.GetDishPrice(menuforday.Dishes.ElementAt(i).Price))
{
changedishid = menuFd.DishPriceMfdRelations.ElementAt(i).DishId;
}
}
}
menuFd.DishPriceMfdRelations = repository.MfdByMenuForDayDto(menuforday);
Dish dish =
repository.GetRepositoryAsync <Dish>()
.Query()
.Include(d => d.DishType)
.Include(d => d.CurrentPrice)
.Select()
.FirstOrDefault(d => d.DishID == changedishid);
MfdDishPriceRelations rel =
menuFd.DishPriceMfdRelations.FirstOrDefault(
mfd => dish != null && string.Equals(mfd.Dish.DishType.Category, dish.DishType.Category));
if (rel != null && dish != null)
{
rel.DishId = changedishid;
var firstOrDefault = menuforday.Dishes.FirstOrDefault(d => d.DishId == changedishid);
if (firstOrDefault != null)
{
dish.CurrentPrice = repository.GetDishPrice(firstOrDefault.Price);
}
rel.DishPrice = dish.CurrentPrice;
repository.Context.Entry(rel).State = EntityState.Modified;
repository.Context.Entry(dish).State = EntityState.Modified;
menuFd.TotalPrice = menuforday.TotalPrice;
repository.Context.Entry(menuFd).State = EntityState.Modified;
return(dish.DishType.Id);
}
}
return(0);
}
public static void CreateMenuForWeek(ApplicationDbContext context, DishHelp[] dishArray)
{
string[] categories = context.DishTypes.OrderBy(t => t.Id).Select(dt => dt.Category).ToArray();
Dish[] darray = context.Dishes.Where(d => d.Title != null).ToArray();
DishPrice[] dishPrices = context.DishPrices.ToArray();
Func <string, IEnumerable <DishHelp>, int> countDish = (str, list) =>
{
int coun = list.Count(el => string.Equals(el.DishType.Category, str));
return(coun);
};
Dictionary <string, int> catCount = categories.ToDictionary(cat => cat, count => countDish(count, dishArray));
Func <List <Dish> > getDishes = () =>
{
return
(catCount.Select(
pair =>
darray.Where(d => string.Equals(d.DishType.Category, pair.Key))
.ElementAt(Rand.Next(pair.Value))).ToList());
};
Func <double, DishPrice> getDishPrice = (price) =>
{
return(dishPrices.FirstOrDefault(d => Math.Abs(price - d.Price) < 0.001));
};
Year year = context.Years.FirstOrDefault(y => y.YearNumber == DateTime.Now.Year);
Year correct_year = context.Years.FirstOrDefault(y => y.YearNumber == DateTime.Now.Year - 1);
int correct_week = 0;
List <MenuForWeek> weekmenus = new List <MenuForWeek>();
List <MfdDishPriceRelations> mfdDishPriceRelationses = new List <MfdDishPriceRelations>();
for (int week = 0; week < 5; week++)
{
var weekLessZero = YearWeekHelp.CurrentWeek() - week <= 0;
if (weekLessZero)
{
year = correct_year;
correct_week = YearWeekHelp.YearWeekCount(DateTime.Now.Year - 1);
}
List <MenuForDay> mfdays = new List <MenuForDay>();
WorkingWeek workweek =
context.WorkingWeeks.Include("Year").ToList().FirstOrDefault(
w => year != null && (w.WeekNumber == YearWeekHelp.CurrentWeek() - week + correct_week &&
w.Year.YearNumber == year.YearNumber));
//bool ordCanCreated = true; //
for (int i = 1; i <= 7; i++)
{
List <Dish> dishes = getDishes();
dishes.OrderBy(d => d.DishType.Id);
WorkingDay workday =
context.WorkingDays.Include("WorkingWeek").ToList().FirstOrDefault(
wd => workweek != null && (wd.WorkingWeek.ID == workweek.ID && wd.DayOfWeek.Id == i));
if (workday != null /* && workday.IsWorking*/)
{
MenuForDay dayMenu = new MenuForDay
{
//Dishes = dishes,
WorkingDay = workday,
//TotalPrice = dishes.Select(d => d.Price).Sum(),
DayMenuCanBeChanged =
week == 0 /*&& ((int) DateTime.Now.DayOfWeek) >= i - 1 && DateTime.Now.Hour < 9*/,
OrderCanBeChanged = week == 0 //&& ((int)DateTime.Now.DayOfWeek) >= i - 1 && DateTime.Now.Hour < 9
};
mfdDishPriceRelationses.AddRange(dishes.Select(d => new MfdDishPriceRelations
{
Dish = d,
MenuForDay = dayMenu,
DishPrice = d.CurrentPrice
}));
dayMenu.TotalPrice =
mfdDishPriceRelationses.Where(mdr => mdr.MenuForDay == dayMenu)
.Sum(mdr => mdr.Dish.CurrentPrice.Price);
mfdays.Add(dayMenu);
}
}
weekmenus.Add(new MenuForWeek
{
MenuForDay = mfdays,
WorkingWeek = workweek,
SummaryPrice = mfdays.Where(mfd => mfd.WorkingDay.IsWorking).Select(d => d.TotalPrice).Sum(),
OrderCanBeCreated = true,
SUCanChangeOrder = week == 0,
WorkingDaysAreSelected = true
});
}
context.MenuForWeeks.AddRange(weekmenus);
context.MfdDishPriceRelations.AddRange(mfdDishPriceRelationses);
context.SaveChanges();
}
