Beispiel #1
0
        private List <TurnoWork> getTurnos(ScheduledTask task, List <TurnoWork> currentTurnos, DateTime startDate)
        {
            var machine                = task.MachineId;
            var duration               = task.HourDuration;
            List <TurnoWork> turnos    = new List <TurnoWork>();
            DateTime         startTime = GetNextValidStartDate(startDate, task);

            while (duration > 0)
            {
                var       realTurns           = currentTurnos.Concat(turnos).ToList();
                TurnoWork avaibleFuncionarios = GetShift(startTime, task, realTurns);
                while (avaibleFuncionarios == null)
                {
                    startTime           = startTime.AddMinutes(60);
                    avaibleFuncionarios = GetShift(startTime, task, realTurns);
                    if (avaibleFuncionarios != null)
                    {
                    }
                }
                duration -= avaibleFuncionarios.end.Subtract(avaibleFuncionarios.start).TotalHours;
                startTime = avaibleFuncionarios.start;
                turnos.Add(avaibleFuncionarios);
            }
            return(turnos);
        }
Beispiel #2
0
        private void calendar1_ItemSelected(object sender, System.Windows.Forms.Calendar.CalendarItemEventArgs e)
        {
            TurnoWork task = (TurnoWork)e.Item.Tag;

            if (task == null)
            {
                return;
            }
            LoadTaskData(task);
        }
Beispiel #3
0
        private void LoadTaskData(TurnoWork task)
        {
            Schedule best = genetik?.Best;

            if (best == null)
            {
                return;
            }

            this.propertyGrid1.SelectedObject = new TurnoVisualizer(task, best.GetEvents(), Tasks);
        }
Beispiel #4
0
        // devolve os funcionar que podem trabalhar a começar nestas horas e a duraçao do turno
        private TurnoWork GetShift(DateTime startTime, ScheduledTask task, List <TurnoWork> currentTurnos)
        {
            List <TurnoFuncionario> turnosDecentes = new List <TurnoFuncionario>();

            this.turnos = this.turnos == null?context.TurnosFuncionario.ToList() : this.turnos;

            var dia      = ToDiaDaSemana(startTime);
            var filtered = turnos.Where(x => x.DiaDaSemana.ToLower() == dia.ToLower());

            foreach (var tu in filtered)
            {
                turnosDecentes.AddRange(ConvertTurnos(tu, startTime));
            }
            if (turnosDecentes.Count == 0)
            {
                return(null);
            }
            // validar se o turno e valido para se escolhido
            Func <TurnoFuncionario, bool> validarHoras = (TurnoFuncionario turno) =>
            {
                if (turno.Start.Hour <= startTime.Hour && turno.End.Hour >= startTime.Hour)
                {
                    if (startTime.DayOfWeek == turno.Start.DayOfWeek)
                    {
                        return(true);
                    }
                }
                return(false);
            };

            Func <TurnoFuncionario, bool> validarOverlap = (TurnoFuncionario turno) =>
            {
                var ActualStart = new DateTime(startTime.Year, startTime.Month, startTime.Day, turno.Start.Hour, turno.Start.Minute, turno.Start.Second);
                var ActualEnd   = new DateTime(startTime.Year, startTime.Month, startTime.Day, turno.End.Hour, turno.End.Minute, turno.End.Second);;

                if (currentTurnos.Any(x => ((x.frente.Any(func => func.Nome == turno.Funcionario.Nome) ||
                                             x.tras.Any(func => func.Nome == turno.Funcionario.Nome)) &&
                                            x.start >= ActualStart && x.end <= ActualEnd)) ||
                    currentTurnos.Any(x => x.start >= ActualStart && x.end <= ActualEnd && x.Task == task))
                {
                    return(false);
                }
                return(true);
            };
            List <TurnoFuncionario> frentes = new List <TurnoFuncionario>();
            List <TurnoFuncionario> trass   = new List <TurnoFuncionario>();
            var requiredF = task.GeneticProcess.Machine.MinPessFrente;
            var requiredT = task.GeneticProcess.Machine.MaxPessFrente;

            while (frentes.Count != requiredF)
            {
                var frente = turnosDecentes.FirstOrDefault(x => x.Funcionario.Frente.HasValue && x.Funcionario.Frente.Value && frentes.All(frt => x.Funcionario.Nome != frt.Funcionario.Nome) && trass.All(frt => x.Funcionario.Nome != frt.Funcionario.Nome) && validarHoras(x) && validarOverlap(x));
                if (frente == null)
                {
                    return(null);
                }
                frentes.Add(frente);
            }
            while (trass.Count != requiredT)
            {
                var tras = turnosDecentes.FirstOrDefault(x => x.Funcionario.Tras.HasValue && x.Funcionario.Tras.Value && frentes.All(frt => x.Funcionario.Nome != frt.Funcionario.Nome) && trass.All(frt => x.Funcionario.Nome != frt.Funcionario.Nome) && validarHoras(x) && validarOverlap(x));
                if (tras == null)
                {
                    return(null);
                }
                trass.Add(tras);
            }
            var tWork = new TurnoWork();
            var start = new DateTime(startTime.Year, startTime.Month, startTime.Day, frentes[0].Start.Hour, frentes[0].Start.Minute, frentes[0].Start.Second);
            var end   = new DateTime(startTime.Year, startTime.Month, startTime.Day, frentes[0].End.Hour, frentes[0].End.Minute, frentes[0].End.Second);

            tWork.frente = frentes.Select(x => x.Funcionario).ToList();
            tWork.tras   = trass.Select(x => x.Funcionario).ToList();
            tWork.start  = start;
            tWork.end    = end;
            tWork.Task   = task;
            return(tWork);
        }
Beispiel #5
0
        private List <TurnoWork> GetTurnos(List <ScheduledTask> evt)
        {
            var events = evt.Where(x => x.GeneticProcess != GeneticTask.GeneticProcess.Empty && x.end - x.start > 0).ToList();;
            List <TurnoWork> turnos = new List <TurnoWork>();


            lastProcessTime  = new DateTime[Tasks.Count, MaxProcessCount];
            lastMachineMolde = new string[MaxMachines];
            lastMachineTime  = new DateTime[MaxMachines];
            for (int i = 0; i < MaxMachines; i++)
            {
                lastMachineMolde[i] = null;
                lastMachineTime[i]  = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 8, 0, 0);
                for (int j = 0; j < MaxProcessCount; j++)
                {
                    lastProcessTime[i, j] = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 8, 0, 0);;
                }
            }
            var totalTime = events.Sum(x => x.HourDuration);

            // there is work to be done
            // HORAS -> Turnos
            // Turno(mquina, TurnosExistents, duraçao) -> devolve lista de turnos para esta produçao
            events.Sort((x, y) =>
            {
                if (x.start < y.start)
                {
                    return(-1);
                }
                if (x.start > y.start)
                {
                    return(1);
                }
                if (x.start == y.start)
                {
                    if (x.HourDuration > y.HourDuration)
                    {
                        return(1);
                    }
                    else
                    {
                        return(-1);
                    }
                }
                return(0);
            });

            List <TurnoWork> currentTurnos = new List <TurnoWork>();
            var startDate = DateTime.Now;

            foreach (var task in events)
            {
                task.GeneticTask    = Tasks[task.JobId];
                task.GeneticProcess = task.GeneticTask.Processes[task.ProcessId];
                task.MachineId      = ResourcesNeeded.First(x => x.maquina.TipoMaquina == task.GeneticProcess.Machine.TipoMaquina).MachineID;
                startDate           = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 8, 0, 0);
                var schedule = getTurnos(task, currentTurnos, startDate);
                currentTurnos.AddRange(schedule);
                var lastDate = schedule.Max(x => x.end);

                lastProcessTime[task.JobId, task.ProcessId] = lastDate;
                lastMachineTime[task.MachineId]             = lastDate;
                lastMachineMolde[task.MachineId]            = task.GeneticProcess.Machine.Molde;
            }
            var       RealTurnos = new List <TurnoWork>();
            TurnoWork current    = null;
            var       lastAdd    = false;

            foreach (var turno in currentTurnos)
            {
                lastAdd = false;
                if (current == null)
                {
                    current = turno;
                    continue;
                }
                if (current.frente.SequenceEqual(turno.frente) && current.tras.SequenceEqual(turno.tras) && turno.Task == current.Task && turno.start == current.end)
                {
                    current.end = turno.end;
                }
                else
                {
                    RealTurnos.Add(current);
                    current = turno;
                    lastAdd = true;
                }
            }
            if (!lastAdd)
            {
                RealTurnos.Add(current);
            }
            return(RealTurnos);
        }