public static int CheckForNextExecution()
        {
            using (var db = new TrainingEntities())
            {
                var lastMinTaskRun = db.MinMaxAvgThreads.Where(x => x.Minimum.HasValue && x.Minimum > 0).Select(x => x.LastExecution).OrderByDescending(x => x).FirstOrDefault(); //make sure that does a Top 1
                var lastMaxTaskRun = db.MinMaxAvgThreads.Where(x => x.Maximum.HasValue && x.Maximum > 0).Select(x => x.LastExecution).OrderByDescending(x => x).FirstOrDefault(); //Test to see if Take (1 just gets one)
                var lastAvgTaskRun = db.MinMaxAvgThreads.Where(x => x.Average.HasValue && x.Average > 0).Select(x => x.LastExecution).OrderByDescending(x => x).FirstOrDefault();

                //var nextMinTaskRun = db.TaskLists.Where(x => x.Id.Equals(1)).Select(x => x.Schedule.Ticks).LastOrDefault();
                //var nextMaxTaskRun = db.TaskLists.Where(x => x.Id.Equals(2)).Select(x => x.Schedule.Ticks).LastOrDefault();
                //var nextAvgTaskRun = db.TaskLists.Where(x => x.Id.Equals(3)).Select(x => x.Schedule.Ticks).LastOrDefault();

                if (lastMinTaskRun.CompareTo(lastMaxTaskRun) <= 0 && lastMinTaskRun.CompareTo(lastAvgTaskRun) < 0)
                {
                    return 1;
                }

                else if (lastMaxTaskRun.CompareTo(lastMinTaskRun) <= 0 && lastMaxTaskRun.CompareTo(lastAvgTaskRun) < 0)
                {
                    return 2;
                }

                else
                {
                    return 3;
                }
            }
        }
Beispiel #2
0
        public void SaveTaskList(Threads model)
        {
            using (var db = new TrainingEntities())
            {
                int taskId;
                var checkTaskExists = db.TaskLists.Where(t => t.TaskName.ToLower().Equals(model.Task.ToLower())).FirstOrDefault();

                if (checkTaskExists != null)
                {
                    taskId = checkTaskExists.Id;
                    db.SaveChanges();
                }

                else
                {
                    var taskList = new TaskList
                    {
                        TaskName = model.Task,
                        NextExecution = model.NextExecution
                    };
                    db.TaskLists.Add(taskList);
                    db.SaveChanges();
                }

            }
        }
Beispiel #3
0
        public void SaveData(Threads model)
        {
            using (var db = new TrainingEntities())
            {
                var checkTaskExists = db.TaskLists.Where(t => t.TaskName.ToLower().Equals(model.Task.ToLower())).FirstOrDefault();

                var s = new MinMaxAvgThread
                {
                    TaskId = checkTaskExists.Id,
                    LastExecution = model.LastExecution,
                    Minimum = model.Min,
                    Maximum = model.Max,
                    Average = model.Average

                };

                db.MinMaxAvgThreads.Add(s);

                try
                {
                    db.SaveChanges();
                }

                catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
                {
                    Exception raise = dbEx;
                    foreach (var validationErrors in dbEx.EntityValidationErrors)
                    {
                        foreach (var validationError in validationErrors.ValidationErrors)
                        {
                            string message = string.Format("{0}:{1}",
                                validationErrors.Entry.Entity.ToString(),
                                validationError.ErrorMessage);
                            raise = new InvalidOperationException(message, raise);
                        }
                    }
                    throw raise;
                }
            }
        }