Beispiel #1
0
    protected override void GetCleaningJob()
    {
        base.GetCleaningJob();

        if (Debugger._instance.cleaningJobQueue.Count > 0)
        {
            currCleaningJob    = Debugger._instance.cleaningJobQueue.Dequeue();
            owner.getSetHasJob = true;
            base.RequestPath(owner.transform.position, currCleaningJob.startLocation);
        }
    }
Beispiel #2
0
        private static string OverworkHelper(int CleanerId, CleaningJob job)
        {
            var HoursWeekly = GetCleanerHours(CleanerId, job.Date);

            if (HoursWeekly >= 18)
            {
                using (var db = new PodaciContext())
                {
                    var cleaner = db.Cleaners.FirstOrDefault(x => x.Id == CleanerId);
                    MessageBox.Show($"Warning! {cleaner?.Name} {cleaner?.Surname} has {HoursWeekly} hours a week (on week {job.Week})!", "Possible cleaner over worked!", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return(CleanerId + "," + job.Week);
                }
            }

            return(null);
        }
        //int startDay = -1;
        public CleaningJobRepeatWin(int cleaningJobId)
        {
            InitializeComponent();
            //CleaningJobId = cleaningJobId;



            using (var db = new PodaciContext())
            {
                cleaningJob = db.CleaningJobs.Include(x => x.RepeatJob).FirstOrDefault(x => x.Id == cleaningJobId);
                if (cleaningJob.RepeatJob != null)
                {
                    model = cleaningJob.RepeatJob;
                }
                else
                {
                    model = new RepeatJob();
                }
                model.AllDaysToDays();
                if (model.AllDays == 0)
                {
                    var day = Fun.getDay(cleaningJob.Date);
                    model.days[day] = true;
                }

                //var day = Fun.getDay(cleanJob.Date);
                //var week = Fun.getWeek(cleanJob.Date);
                //startDay = day;
                //model.days[day] = true;

                //var cleanJobs = db.CleaningJobs.Include(x => x.RepeatJob).Where(x => x.Id != cleaningJobId && x.ClientId == cleanJob.ClientId && x.RepeatJobId == model.Id && x.Week == week)?.ToList();
                //if (cleanJobs != null)
                //    foreach (var c in cleanJobs)
                //    {
                //        var d = (((int)c.Date.DayOfWeek == 0) ? 7 : (int)c.Date.DayOfWeek) - 1; ;
                //        model.days[d] = true;
                //    }
            }

            RepeatCombo.ItemsSource = ZP.RepeatDict;
            this.DataContext        = model;
        }
Beispiel #4
0
    private void Start()
    {
        if (_instance == null)
        {
            _instance = this;
        }
        else
        {
            Destroy(this);
        }

        for (int i = 0; i < haulingObjects.Length; i++)
        {
            HaulingJob newHaulingJob = new HaulingJob(haulingObjects[i], new HaulableItem(haulingObjects[i]));
            haulingJobQueue.Enqueue(newHaulingJob);
        }

        for (int j = 0; j < cleaningObjects.Length; j++)
        {
            CleaningJob newCleaningJob = new CleaningJob(cleaningObjects[j], new CleanableItem(cleaningObjects[j]));
            cleaningJobQueue.Enqueue(newCleaningJob);
        }
    }
Beispiel #5
0
        public static void setRepeatingJobs(int RepeatJobId, CleaningJob CleaningJobCopy)
        {
            try
            {
                if (RepeatJobId == 0)
                {
                    return;
                }

                int iterations = 50;

                var date = CleaningJobCopy.Date;


                List <int> ids = new List <int>();
                using (var db = new PodaciContext())
                {
                    var RepeatJob = db.RepeatJobs
                                    .Include(x => x.CleaningJobs).FirstOrDefault(x => x.Id == RepeatJobId);

                    RepeatJob.AllDaysToDays();
                    //var defaultCleanJob = RepeatJob.CleaningJobs.FirstOrDefault();
                    int week = getWeek(date);

                    int year = date.Year;



                    int        maxWeek = getWeek(new DateTime(year, 12, 31));
                    List <int> weeks   = new List <int> {
                        week
                    };

                    for (int i = 0; i < iterations + 1; i++)
                    {
                        weeks.Add((weeks[i] + RepeatJob.RepeatFrequency) % (maxWeek + 1));
                    }
                    List <CleaningJob> toRemove = new List <CleaningJob>();
                    foreach (var cleanJob in RepeatJob.CleaningJobs)
                    {
                        if (cleanJob.Date >= date)
                        {
                            if (!RepeatJob.days[cleanJob.Day] || !weeks.Contains(cleanJob.Week))
                            {
                                toRemove.Add(cleanJob);
                            }
                        }
                    }

                    foreach (var c in toRemove)
                    {
                        if (c.Id != CleaningJobCopy.Id)
                        {
                            db.Remove(c);
                        }
                    }
                    db.SaveChanges();
                    if (RepeatJob.CleaningJobs == null || RepeatJob.CleaningJobs.Count <= 0)
                    {
                        return;
                    }

                    int day = getDay(date);

                    List <DateTime> weekDatetimes = new List <DateTime>();

                    for (int i = 0; i < 7; i++)
                    {
                        if (RepeatJob.days[i])
                        {
                            weekDatetimes.Add(date.AddDays(i - day));
                        }
                    }
                    int datesCount = weekDatetimes.Count;

                    for (int i = 0; i < iterations; i++)
                    {
                        //var watch = System.Diagnostics.Stopwatch.StartNew();

                        for (int j = 0; j < datesCount; j++)
                        {
                            var cleanjob = RepeatJob.CleaningJobs.FirstOrDefault(x => x.Date.Date == weekDatetimes[j].Date);
                            if (cleanjob == null)
                            {
                                var defaultCleanJob = new CleaningJob();
                                defaultCleanJob.TeamId      = CleaningJobCopy.TeamId;
                                defaultCleanJob.TimeEnd     = CleaningJobCopy.TimeEnd;
                                defaultCleanJob.TimeStart   = CleaningJobCopy.TimeStart;
                                defaultCleanJob.Location    = CleaningJobCopy.Location;
                                defaultCleanJob.NoOfHours   = CleaningJobCopy.NoOfHours;
                                defaultCleanJob.ClientId    = CleaningJobCopy.ClientId;
                                defaultCleanJob.CleanerId   = CleaningJobCopy.CleanerId;
                                defaultCleanJob.ServiceId   = CleaningJobCopy.ServiceId;
                                defaultCleanJob.Amount      = CleaningJobCopy.Amount;
                                defaultCleanJob.Date        = weekDatetimes[j];
                                defaultCleanJob.RepeatJob   = null;
                                defaultCleanJob.RepeatJobId = RepeatJobId;
                                defaultCleanJob.JobStatus   = CleaningJobCopy.JobStatus;
                                db.Add(defaultCleanJob);
                                db.SaveChanges();
                                ids.Add(defaultCleanJob.Id);
                            }
                            else
                            {
                                cleanjob.TeamId    = CleaningJobCopy.TeamId;
                                cleanjob.TimeEnd   = CleaningJobCopy.TimeEnd;
                                cleanjob.TimeStart = CleaningJobCopy.TimeStart;
                                cleanjob.Location  = CleaningJobCopy.Location;
                                cleanjob.NoOfHours = CleaningJobCopy.NoOfHours;
                                cleanjob.ClientId  = CleaningJobCopy.ClientId;
                                cleanjob.CleanerId = CleaningJobCopy.CleanerId;
                                cleanjob.ServiceId = CleaningJobCopy.ServiceId;
                                cleanjob.Amount    = CleaningJobCopy.Amount;
                                cleanjob.Date      = weekDatetimes[j];
                                cleanjob.JobStatus = CleaningJobCopy.JobStatus;

                                //watch.Reset();
                                //watch.Start();
                                if (cleanjob.Id != CleaningJobCopy.Id)
                                {
                                    ids.Add(cleanjob.Id);
                                    db.Update(cleanjob);
                                }
                                //watch.Stop();
                                //var elapsedMs2 = watch.ElapsedMilliseconds;
                                //System.Diagnostics.Debug.WriteLine("elapsedMs2= " + elapsedMs2 );
                            }

                            weekDatetimes[j] = weekDatetimes[j].AddDays(7 * RepeatJob.RepeatFrequency);
                        }
                    }
                    db.SaveChanges();
                }
                using (var db = new PodaciContext())
                {
                    var cjTemp = db.CleaningJobs.Include(x => x.ServiceJobs).FirstOrDefault(x => x.Id == CleaningJobCopy.Id);



                    foreach (int id in ids)
                    {
                        var ServiceJobsCopy = new List <ServiceJob>();
                        foreach (var v in cjTemp.ServiceJobs)
                        {
                            ServiceJobsCopy.Add(new ServiceJob {
                                CleaningJobId = v.CleaningJobId, ServiceId = v.ServiceId
                            });
                        }


                        if (ServiceJobsCopy != null)
                        {
                            foreach (var v in ServiceJobsCopy)
                            {
                                v.CleaningJobId = id;
                                v.CleaningJob   = null;
                            }
                        }
                        var cljTemp = db.CleaningJobs.Include(x => x.ServiceJobs).FirstOrDefault(x => x.Id == id).ServiceJobs;


                        checkAndSaveServiceJobs(ServiceJobsCopy, cljTemp, db);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error Repeating jobs: " + ex.Message);
            }
        }
Beispiel #6
0
        public static void workerBusy(CleaningJob job)
        {
            var cleanerTemp = job.Cleaner;

            if (cleanerTemp == null)
            {
                if (job.CleanerId != null && job.CleanerId != 0 && job.CleanerId != -1)
                {
                    using (var db = new PodaciContext())
                        cleanerTemp = db.Cleaners.FirstOrDefault(x => x.Id == job.CleanerId);
                }
            }
            List <Cleaner> cleaners = new List <Cleaner>();

            if (cleanerTemp == null)
            {
                var team = job.Team;

                if (team == null)
                {
                    if (job.TeamId != null && job.TeamId != 0 && job.TeamId != -1)
                    {
                        using (var db = new PodaciContext())
                            team = db.Teams
                                   .Include(x => x.CleanerTeams)
                                   .ThenInclude(y => y.Cleaner)
                                   .FirstOrDefault(x => x.Id == job.TeamId);
                    }
                }
                if (team?.CleanerTeams == null)
                {
                    return;
                }

                foreach (var ct in team.CleanerTeams)
                {
                    if (ct?.Cleaner != null)
                    {
                        cleaners.Add(ct.Cleaner);
                    }
                }
            }
            else
            {
                cleaners.Add(cleanerTemp);
            }


            foreach (var cleaner in cleaners)
            {
                var Days       = new bool[] { cleaner.Monday, cleaner.Tuesday, cleaner.Wednesday, cleaner.Thursday, cleaner.Friday, cleaner.Saturday, cleaner.Sunday };
                var Days2      = new bool[] { cleaner.Monday2, cleaner.Tuesday2, cleaner.Wednesday2, cleaner.Thursday2, cleaner.Friday2, cleaner.Saturday2, cleaner.Sunday2 };
                var DaysStart  = new DateTime[] { cleaner.MondayStart, cleaner.TuesdayStart, cleaner.WednesdayStart, cleaner.ThursdayStart, cleaner.FridayStart, cleaner.SaturdayStart, cleaner.SundayStart };
                var DaysEnd    = new DateTime[] { cleaner.MondayEnd, cleaner.TuesdayEnd, cleaner.WednesdayEnd, cleaner.ThursdayEnd, cleaner.FridayEnd, cleaner.SaturdayEnd, cleaner.SundayEnd };
                var DaysStart2 = new DateTime[] { cleaner.MondayStart2, cleaner.TuesdayStart2, cleaner.WednesdayStart2, cleaner.ThursdayStart2, cleaner.FridayStart2, cleaner.SaturdayStart2, cleaner.SundayStart2 };
                var DaysEnd2   = new DateTime[] { cleaner.MondayEnd2, cleaner.TuesdayEnd2, cleaner.WednesdayEnd2, cleaner.ThursdayEnd2, cleaner.FridayEnd2, cleaner.SaturdayEnd2, cleaner.SundayEnd2 };
                if (!(job.Day > 0))
                {
                    continue;
                }
                if (!Days[job.Day])
                {
                    MessageBox.Show($"Warning! Cleaner {cleaner.Name} {cleaner.Surname} not available {ZP.days[job.Day]}!");
                    continue;
                }

                var zeroTime = new DateTime(2020, 1, 1).TimeOfDay;

                if (job.TimeStart.TimeOfDay == zeroTime && job.TimeStart.TimeOfDay == zeroTime)
                {
                    continue;
                }

                if (DaysStart[job.Day].TimeOfDay == zeroTime && DaysEnd[job.Day].TimeOfDay == zeroTime)
                {
                    continue;
                }

                if (job.TimeStart.TimeOfDay >= DaysStart[job.Day].TimeOfDay && job.TimeStart.TimeOfDay <= DaysEnd[job.Day].TimeOfDay &&
                    job.TimeEnd.TimeOfDay >= DaysStart[job.Day].TimeOfDay && job.TimeEnd.TimeOfDay <= DaysEnd[job.Day].TimeOfDay)
                {
                    continue;
                }

                if (Days2[job.Day])
                {
                    if (job.TimeStart.TimeOfDay >= DaysStart2[job.Day].TimeOfDay && job.TimeStart.TimeOfDay <= DaysEnd2[job.Day].TimeOfDay &&
                        job.TimeEnd.TimeOfDay >= DaysStart2[job.Day].TimeOfDay && job.TimeEnd.TimeOfDay <= DaysEnd2[job.Day].TimeOfDay)
                    {
                        continue;
                    }
                }

                MessageBox.Show($"Warning! Cleaner {cleaner.Name} {cleaner.Surname} not available {ZP.days[job.Day]} between hours of {job.TimeStart.ToString("HH:mm")} - {job.TimeEnd.ToString("HH:mm")}!");
            }
        }