コード例 #1
0
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Button b = sender as Button;

            if (b.Name == "btnRemove")
            {
                //Look for the row in the database, in order to remove it.
                if ((dg.SelectedItem as ScheduleSlot).idTimeSlot != 0)
                {
                    int          tsId = (dg.SelectedItem as ScheduleSlot).idTimeSlot;
                    ScheduleSlot sl   = (from r in bdModel.ScheduleSlots where r.idTimeSlot == tsId select r).SingleOrDefault();
                    bdModel.ScheduleSlots.Remove(sl);
                    bdModel.SaveChanges();
                    dg.ItemsSource = bdModel.ScheduleSlots.ToList();
                }
            }
            else if (b.Name == "btnUpdate")
            {
                int          tsId = (dg.SelectedItem as ScheduleSlot).idTimeSlot;
                ScheduleSlot s1   = (from r in bdModel.ScheduleSlots where r.idTimeSlot == tsId select r).SingleOrDefault();
                ScheduleSlot tmp  = s1;

                AddPlotWindow apw = new AddPlotWindow(tmp, bdModel);
                //bd.ScheduleSlots.Remove(s1);
                apw.ShowDialog();

                bdModel.SaveChanges();
                dg.ItemsSource = bdModel.ScheduleSlots.ToList();
            }
        }
コード例 #2
0
        // <summary>
        /// Populate data in the fields with the existing ScheduleSlot
        /// set the (ScheduleSlot) current as the current scheduleslot
        /// </summary>
        /// <param name = "ss" >A Schedule slot already existing to get the data</param>
        /// /// <param name = "bd" >the current easyplanner entity</param>
        public AddPlotWindow(ScheduleSlot ss, bd_easyplannerEntities bd)
        {
            InitializeComponent();
            foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
            {
                cbxDayOfWeek.Items.Add(DateTimeFormatInfo.CurrentInfo.GetDayName(day));
            }
            cbxDayOfWeek.SelectedIndex = ss.dayOfWeek;
            cbxStartHourHour.Text      = formatHoursMinutes(ss.startHour.Hours);
            cbxStartHourMinute.Text    = formatHoursMinutes(ss.startHour.Minutes);
            cbxEndHourHour.Text        = formatHoursMinutes(ss.endHour.Hours);
            cbxEndHourMinute.Text      = formatHoursMinutes(ss.endHour.Minutes);
            cbxAttendency.Text         = ss.minAttendency.ToString();

            if (ss.firstDay.ToString() != "")
            {
                DateTime dt = (DateTime)ss.firstDay;
                dpFirstDay.SelectedDate = dt;
            }
            if (ss.lastDay.ToString() != "")
            {
                DateTime dt = (DateTime)ss.lastDay;
                dpLastDay.SelectedDate = dt;
            }

            this.bdModel       = bd;
            this.current       = ss;
            current.idTimeSlot = ss.idTimeSlot;
            modified           = true;
        }
コード例 #3
0
 // <summary>
 /// create a ScheduleSlot
 /// Populate an enum with days of week
 /// </summary>
 /// <param>None</param>
 public AddPlotWindow()
 {
     InitializeComponent();
     current  = new ScheduleSlot();
     bdModel  = bd_easyplannerEntities.OpenWithFallback();
     modified = false;
     foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
     {
         cbxDayOfWeek.Items.Add(DateTimeFormatInfo.CurrentInfo.GetDayName(day));
     }
     cbxDayOfWeek.SelectedIndex = 1;
     dpFirstDay.SelectedDate    = DateTime.Today;
     dpLastDay.SelectedDate     = DateTime.Today;
 }
コード例 #4
0
        /// <summary>
        /// Spliting slots before simulation
        /// !!! slot list will be modified so
        /// use a copy if you don't want that
        /// </summary>
        /// <param name="slots"></param>
        /// <param name="absences"></param>
        /// <returns></returns>
        private List <ScheduleSlot> SplitSlots(List <ScheduleSlot> slots, List <AbsenceDemand> absences)
        {
            int count = slots.Count;

            // parsing slots
            for (int i = 0; i < count; i++)
            {
                ScheduleSlot slot = slots[i];
                // parsing absences
                for (int j = 0; j < absences.Count; j++)
                {
                    AbsenceDemand absence = absences[j];
                    // check on absence's end
                    if ((int)absence.end.DayOfWeek == slot.dayOfWeek)
                    {
                        if (absence.end.TimeOfDay > slot.startHour && absence.end.TimeOfDay < slot.endHour)
                        {
                            ScheduleSlot newSlot = new ScheduleSlot();
                            newSlot.dayOfWeek     = slot.dayOfWeek;
                            newSlot.firstDay      = slot.firstDay;
                            newSlot.lastDay       = slot.lastDay;
                            newSlot.minAttendency = slot.minAttendency;
                            newSlot.startHour     = absence.end.TimeOfDay;
                            newSlot.endHour       = slot.endHour;
                            slots.Add(newSlot);
                            slot.endHour = absence.end.TimeOfDay;
                        }
                    }
                    // check on absence's start
                    if ((int)absence.start.DayOfWeek == slot.dayOfWeek)
                    {
                        if (absence.start.TimeOfDay > slot.startHour && absence.start.TimeOfDay < slot.endHour)
                        {
                            ScheduleSlot newSlot = new ScheduleSlot();
                            newSlot.dayOfWeek     = slot.dayOfWeek;
                            newSlot.firstDay      = slot.firstDay;
                            newSlot.lastDay       = slot.lastDay;
                            newSlot.minAttendency = slot.minAttendency;
                            newSlot.startHour     = absence.start.TimeOfDay;
                            newSlot.endHour       = slot.endHour;
                            slots.Add(newSlot);
                            slot.endHour = absence.start.TimeOfDay;
                        }
                    }
                }
            }
            return(slots);
        }
コード例 #5
0
 /// <summary>
 /// Save to the database the slots showed in the scheduler.
 /// </summary>
 private void btnSlotScheduleGeneration_Click(object sender, RoutedEventArgs e)
 {
     //Create a ScheduleSlot foreach event in the scheduler
     foreach (Event ev in slotGenerationScheduler.Events)
     {
         if (ev.IdShift == 0) //it's a new slot
         {
             bdModel.ScheduleSlots.Add(new ScheduleSlot()
             {
                 dayOfWeek     = ev.DayOfWeek,
                 firstDay      = ev.FirstDay,
                 lastDay       = ev.LastDay,
                 minAttendency = ev.MinAttendency,
                 startHour     = new TimeSpan(ev.Start.Hour, ev.Start.Minute, 0),
                 endHour       = new TimeSpan(ev.End.Hour, ev.End.Minute, 0),
             });
         }
         else if (ev.Color.ToString() == Colors.Red.ToString())   //if the color is red, then remove it from the database
         {
             ScheduleSlot ss = bdModel.ScheduleSlots.Single(s => s.idTimeSlot == ev.IdShift);
             bdModel.ScheduleSlots.Remove(ss);
         }
         else //otherwise update it
         {
             ScheduleSlot ss = bdModel.ScheduleSlots.Single(s => s.idTimeSlot == ev.IdShift);
             ss.dayOfWeek     = ev.DayOfWeek;
             ss.lastDay       = ev.LastDay;
             ss.firstDay      = ev.FirstDay;
             ss.minAttendency = ev.MinAttendency;
             ss.startHour     = new TimeSpan(ev.Start.Hour, ev.Start.Minute, 0);
             ss.endHour       = new TimeSpan(ev.End.Hour, ev.End.Minute, 0);
         }
     }
     bdModel.SaveChanges();
     MessageBox.Show("Traitement terminé", "Plages horaires sauvegardées dans la BD");
     this.Close();
 }
コード例 #6
0
        /// <summary>
        /// Generating of the workingshifts from the calculated flows
        /// </summary>
        /// <returns>List of coherents shifts given the constructed graph</returns>
        public Tuple <List <WorkingShift>, List <string> > GetShifts()
        {
            List <WorkingShift> shifts   = new List <WorkingShift>();
            List <string>       problems = new List <string>();

            CalculateMaximumFlow();

            // init quotas dict
            Dictionary <ScheduleSlot, List <Tuple <Person, double> > > quotas = new Dictionary <ScheduleSlot, List <Tuple <Person, double> > >();

            foreach (FlowNode node in this.Nodes)
            {
                if (node.Type == FlowNodeType.Slot)
                {
                    quotas.Add(((SlotFlowNode)node).Slot, new List <Tuple <Person, double> >());
                }
            }

            // recup quotas
            foreach (KeyValuePair <FlowArc, double> flowDict in this.Flows)
            {
                FlowArc arc = flowDict.Key; double flow = flowDict.Value;
                switch (arc.Start.Type)
                {
                case FlowNodeType.Virtual:
                    // si flow < capacité alors personne pas complètement occupée => trop de RH
                    if (flow < arc.Capacity)
                    {
                        Person person  = ((PersonFlowNode)arc.End).Person;
                        string problem = person.firstName + " " + person.name + " : " +
                                         (arc.Capacity - flow) + " heure(s) manquante(s) pour atteindre " + person.occupancyRate + "%";
                        problems.Add(problem);
                    }
                    break;

                case FlowNodeType.Person:
                    if (flow > 0)
                    {
                        quotas[((SlotFlowNode)arc.End).Slot].Add(new Tuple <Person, double>(((PersonFlowNode)arc.Start).Person, flow));
                    }
                    break;

                case FlowNodeType.Slot:
                    // si flow < capacité alors plage pas complètement couverte => pas assez de RH
                    if (flow < arc.Capacity)
                    {
                        ScheduleSlot slot    = ((SlotFlowNode)arc.Start).Slot;
                        string       problem = DateTimeFormatInfo.CurrentInfo.GetDayName((DayOfWeek)Enum.GetValues(typeof(DayOfWeek)).GetValue(slot.dayOfWeek)) +
                                               " " + slot.startHour.ToString(@"hh\:mm") + " - " + slot.endHour.ToString(@"hh\:mm") + " : " +
                                               (arc.Capacity - flow) + " heure(s) manquante(s) pour remplir " + slot.minAttendency + " présence(s)";
                        problems.Add(problem);
                    }
                    break;

                default:
                    break;
                }
            }

            // create shifts
            foreach (KeyValuePair <ScheduleSlot, List <Tuple <Person, double> > > quotaDict in quotas)
            {
                ScheduleSlot slot = quotaDict.Key; List <Tuple <Person, double> > liste = quotaDict.Value;
                TimeSpan     start     = slot.startHour;
                TimeSpan     end       = slot.endHour;
                TimeSpan     fromThere = start;
                foreach (Tuple <Person, double> quotaTuple in liste)
                {
                    Person person = quotaTuple.Item1;; double hours = quotaTuple.Item2;
                    while (hours > 0)
                    {
                        TimeSpan     toThere = TimeSpan.FromTicks(Math.Min(end.Ticks, fromThere.Add(TimeSpan.FromHours(hours)).Ticks));
                        WorkingShift shift   = new WorkingShift();
                        DateTime     theDay  = WeekStart.AddDays(((int)slot.dayOfWeek - (int)WeekStart.DayOfWeek) % 7);
                        shift.start  = theDay.Add(fromThere);
                        shift.end    = theDay.Add(toThere);
                        shift.Person = person;
                        shifts.Add(shift);
                        hours -= toThere.Subtract(fromThere).TotalHours;
                        if (toThere == end)
                        {
                            fromThere = start;
                        }
                        else
                        {
                            fromThere = toThere;
                        }
                    }
                }
            }

            // merging contiguous shifts
            int i = 0;

            while (i < shifts.Count)
            {
                WorkingShift shiftI = shifts[i];
                int          j      = i + 1;
                while (j < shifts.Count)
                {
                    WorkingShift shiftJ = shifts[j];
                    if (shiftJ.Person == shiftI.Person)
                    {
                        if (shiftJ.start == shiftI.end)
                        {
                            shiftI.end = shiftJ.end;
                            shifts.Remove(shiftJ);
                        }
                        else if (shiftJ.end == shiftI.start)
                        {
                            shiftI.start = shiftJ.start;
                            shifts.Remove(shiftJ);
                        }
                        else
                        {
                            j++;
                        }
                    }
                    else
                    {
                        j++;
                    }
                }
                i++;
            }

            return(new Tuple <List <WorkingShift>, List <string> >(shifts, problems));
        }
コード例 #7
0
 /// <summary>
 /// Constructor
 /// adds a slot's reference in addition of base constuctor
 /// </summary>
 /// <param name="slot">The Slot</param>
 public SlotFlowNode(ScheduleSlot slot) : base(slot.dayOfWeek + " : " + slot.startHour.ToString(@"hh\:mm") + "-" + slot.endHour.ToString(@"hh\:mm"))
 {
     this.Slot = slot;
     this.Type = FlowNodeType.Slot;
 }