Exemple #1
0
        /// <summary>
        /// Delete this shift
        /// </summary>
        /// <param name="shift">Shift</param>
        public void DeleteShift(Shift shift)
        {
            if (!Shifts.Contains(shift))
            {
                return;
            }

            // can't be in use
            foreach (Shift inUseShift in Shifts)
            {
                foreach (Team team in Teams)
                {
                    Rotation rotation = team.Rotation;

                    foreach (TimePeriod period in rotation.GetPeriods())
                    {
                        if (period.Equals(inUseShift))
                        {
                            string msg = String.Format(WorkSchedule.GetMessage("shift.in.use"), shift.Name);
                            throw new Exception(msg);
                        }
                    }
                }
            }

            Shifts.Remove(shift);
        }
Exemple #2
0
        /// <summary>
        /// Build a string representation of this rotation
        /// </summary>
        /// <returns>String</returns>
        public override string ToString()
        {
            string named = base.ToString();
            string rd    = WorkSchedule.GetMessage("rotation.duration");
            string rda   = WorkSchedule.GetMessage("rotation.days");
            string rw    = WorkSchedule.GetMessage("rotation.working");
            string rper  = WorkSchedule.GetMessage("rotation.periods");
            string on    = WorkSchedule.GetMessage("rotation.on");
            string off   = WorkSchedule.GetMessage("rotation.off");

            string periodsString = "";

            foreach (TimePeriod period in GetPeriods())
            {
                if (periodsString.Length > 0)
                {
                    periodsString += ", ";
                }

                string onOff = period.IsWorkingPeriod() ? on : off;
                periodsString += period.Name + " (" + onOff + ")";
            }

            string text = named + "\n" + rper + ": [" + periodsString + "], " + rd + ": " + GetDuration() + ", " + rda
                          + ": " + GetDuration().Days + ", " + rw + ": " + GetWorkingTime();

            return(text);
        }
Exemple #3
0
        /// <summary>
        /// Print shift instances to the console
        /// </summary>
        /// <param name="start">Starting date</param>
        /// <param name="end">Ending date</param>
        public void PrintShiftInstances(LocalDate start, LocalDate end)
        {
            if (start.CompareTo(end) > 0)
            {
                string msg = String.Format(WorkSchedule.GetMessage("end.earlier.than.start"), start, end);
                throw new Exception(msg);
            }

            long days = TimePeriod.DeltaDays(start, end) + 1;

            LocalDate day = start;

            for (long i = 0; i < days; i++)
            {
                Console.WriteLine("[" + (i + 1) + "] " + GetMessage("Shifts.day") + ": " + day);

                List <ShiftInstance> instances = GetShiftInstancesForDay(day);

                if (instances.Count == 0)
                {
                    Console.WriteLine("   " + GetMessage("Shifts.non.working"));
                }
                else
                {
                    int count = 1;
                    foreach (ShiftInstance instance in instances)
                    {
                        Console.WriteLine("   (" + count + ")" + instance);
                        count++;
                    }
                }
                day = day.PlusDays(1);
            }
        }
Exemple #4
0
        /// <summary>
        /// Calculate the working time between the specified times of day. The shift
        /// must not span midnight.
        /// </summary>
        /// <param name="from">Starting local time</param>
        /// <param name="to">Ending local time</param>
        /// <returns></returns>
        public Duration CalculateWorkingTime(LocalTime from, LocalTime to)
        {
            if (SpansMidnight())
            {
                String msg = String.Format(WorkSchedule.GetMessage("shift.spans.midnight"), Name, from, to);
                throw new Exception(msg);
            }

            return(this.CalculateWorkingTime(from, to, true));
        }
        /// <summary>
        /// Build a string representation of a shift instance
        /// </summary>
        /// <returns>String</returns>
        public override string ToString()
        {
            string t  = WorkSchedule.GetMessage("team");
            string s  = WorkSchedule.GetMessage("shift");
            string ps = WorkSchedule.GetMessage("period.start");
            string pe = WorkSchedule.GetMessage("period.end");

            string text = " " + t + ": " + Team.Name + ", " + s + ": " + Shift.Name + ", " + ps + ": "
                          + StartDateTime + ", " + pe + ": " + GetEndTime();

            return(text);
        }
Exemple #6
0
        /// <summary>
        /// Create a rotation
        /// </summary>
        /// <param name="name">Name</param>
        /// <param name="description">Description</param>
        /// <returns>Rotation</returns>
        public Rotation CreateRotation(string name, string description)
        {
            Rotation rotation = new Rotation(name, description);

            if (Rotations.Contains(rotation))
            {
                string msg = String.Format(WorkSchedule.GetMessage("rotation.already.exists"), name);
                throw new Exception(msg);
            }
            Rotations.Add(rotation);
            rotation.WorkSchedule = this;
            return(rotation);
        }
Exemple #7
0
        /// <summary>
        /// Create a shift
        /// </summary>
        /// <param name="name">Name</param>
        /// <param name="description">Description</param>
        /// <param name="start">Start of shift</param>
        /// <param name="duration">Duration of shift</param>
        /// <returns>Shift</returns>
        public Shift CreateShift(string name, string description, LocalTime start, Duration duration)
        {
            Shift shift = new Shift(name, description, start, duration);

            if (Shifts.Contains(shift))
            {
                string msg = String.Format(WorkSchedule.GetMessage("shift.already.exists"), name);
                throw new Exception(msg);
            }
            Shifts.Add(shift);
            shift.WorkSchedule = this;
            return(shift);
        }
Exemple #8
0
        /// <summary>
        /// Create a team
        /// </summary>
        /// <param name="name">Name</param>
        /// <param name="description">Description</param>
        /// <param name="rotation">Shift rotation</param>
        /// <param name="rotationStart">Start of rotation</param>
        /// <returns>Team</returns>
        public Team CreateTeam(string name, string description, Rotation rotation, LocalDate rotationStart)
        {
            Team team = new Team(name, description, rotation, rotationStart);

            if (Teams.Contains(team))
            {
                string msg = String.Format(WorkSchedule.GetMessage("team.already.exists"), name);
                throw new Exception(msg);
            }

            Teams.Add(team);
            team.WorkSchedule = this;
            return(team);
        }
Exemple #9
0
        internal NonWorkingPeriod(string name, string description, LocalDateTime startDateTime, Duration duration) : base(name, description)
        {
            if (startDateTime == null)
            {
                throw new Exception(WorkSchedule.GetMessage("start.not.defined"));
            }

            if (duration == null || duration.TotalSeconds == 0)
            {
                throw new Exception(WorkSchedule.GetMessage("duration.not.defined"));
            }

            StartDateTime = startDateTime;
            Duration      = duration;
        }
Exemple #10
0
        /// <summary>
        /// Get the day number in the rotation for this local date
        /// </summary>
        /// <param name="date">Date in rotation</param>
        /// <returns>Day number</returns>
        public int GetDayInRotation(LocalDate date)
        {
            // calculate total number of days from start of rotation
            long deltaDays = TimePeriod.DeltaDays(RotationStart, date);

            if (deltaDays < 0)
            {
                string msg = string.Format(WorkSchedule.GetMessage("end.earlier.than.start"), RotationStart, date);
                throw new Exception(msg);
            }

            int dayInRotation = (int)(deltaDays % Rotation.GetDuration().Days) + 1;

            return(dayInRotation);
        }
Exemple #11
0
        /// <summary>
        /// Build a string representation of this shift
        /// </summary>
        /// <returns>String</returns>
        public override string ToString()
        {
            string text = base.ToString();

            if (Breaks.Count > 0)
            {
                text += "\n      " + Breaks.Count + " " + WorkSchedule.GetMessage("breaks") + ":";
            }

            foreach (Break breakPeriod in Breaks)
            {
                text += "\n      " + breakPeriod.ToString();
            }
            return(text);
        }
Exemple #12
0
        /// <summary>
        /// Build a string value for this period
        /// </summary>
        /// <returns>String</returns>
        public override string ToString()
        {
            string text  = "";
            string start = WorkSchedule.GetMessage("period.start");
            string end   = WorkSchedule.GetMessage("period.end");

            try
            {
                text = base.ToString() + ", " + start + ": " + StartTime + " (" + Duration + ")" + ", " + end + ": "
                       + GetEnd();
            }
            catch (Exception)
            {
            }
            return(text);
        }
Exemple #13
0
        /// <summary>
        /// Create a non-working period of time
        /// </summary>
        /// <param name="name">Name</param>
        /// <param name="description">Description</param>
        /// <param name="startDateTime">Starting date and time of day</param>
        /// <param name="duration">Durtation of period</param>
        /// <returns>NonWorkingPeriod</returns>
        public NonWorkingPeriod CreateNonWorkingPeriod(string name, string description, LocalDateTime startDateTime,
                                                       Duration duration)
        {
            NonWorkingPeriod period = new NonWorkingPeriod(name, description, startDateTime, duration);

            if (NonWorkingPeriods.Contains(period))
            {
                string msg = String.Format(WorkSchedule.GetMessage("nonworking.period.already.exists"), name);
                throw new Exception(msg);
            }
            period.WorkSchedule = this;
            NonWorkingPeriods.Add(period);

            NonWorkingPeriods.Sort();

            return(period);
        }
Exemple #14
0
        /// <summary>
        /// Build a string value for this team
        /// </summary>
        /// <returns>String</returns>
        public override string ToString()
        {
            string rpct = WorkSchedule.GetMessage("rotation.percentage");

            string rs  = WorkSchedule.GetMessage("rotation.start");
            string avg = WorkSchedule.GetMessage("team.hours");

            string text = "";

            try
            {
                text = base.ToString() + ", " + rs + ": " + RotationStart + ", " + Rotation + ", " + rpct + ": "
                       + GetPercentageWorked().ToString("0.00") + "%" + ", " + avg + ": " + GetHoursWorkedPerWeek();
            }
            catch (Exception)
            {
            }

            return(text);
        }
Exemple #15
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="name">Name</param>
        /// <param name="description">Desription</param>
        /// <param name="startTime">Starting time</param>
        /// <param name="duration">Duration</param>
        protected TimePeriod(string name, string description, LocalTime startTime, Duration duration) : base(name, description)
        {
            if (startTime == null)
            {
                throw new Exception(WorkSchedule.GetMessage("start.not.defined"));
            }

            if (duration == null || duration.TotalSeconds == 0)
            {
                throw new Exception(WorkSchedule.GetMessage("duration.not.defined"));
            }

            if (duration.TotalSeconds > SECONDS_PER_DAY)
            {
                throw new Exception(WorkSchedule.GetMessage("duration.not.allowed"));
            }

            this.StartTime = startTime;
            this.Duration  = duration;
        }
Exemple #16
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="name">Name</param>
 /// <param name="description">Description</param>
 protected Named(string name, string description)
 {
     Name        = name ?? throw new Exception(WorkSchedule.GetMessage("name.not.defined"));
     Description = description;
 }
Exemple #17
0
        /// <summary>
        /// Calculate the schedule working time between the specified dates and times
        /// </summary>
        /// <param name="from">Starting date and time</param>
        /// <param name="to">Ending date and time</param>
        /// <returns>Duration</returns>
        public Duration CalculateWorkingTime(LocalDateTime from, LocalDateTime to)
        {
            if (from.CompareTo(to) > 0)
            {
                string msg = string.Format(WorkSchedule.GetMessage("end.earlier.than.start"), to, from);
                throw new Exception(msg);
            }

            Duration sum = Duration.Zero;

            LocalDate thisDate = from.Date;
            LocalTime thisTime = from.TimeOfDay;
            LocalDate toDate   = to.Date;
            LocalTime toTime   = to.TimeOfDay;
            int       dayCount = Rotation.GetDayCount();

            // get the working shift from yesterday
            Shift lastShift = null;

            LocalDate     yesterday         = thisDate.PlusDays(-1);
            ShiftInstance yesterdayInstance = GetShiftInstanceForDay(yesterday);

            if (yesterdayInstance != null)
            {
                lastShift = yesterdayInstance.Shift;
            }

            // step through each day until done
            while (thisDate.CompareTo(toDate) < 1)
            {
                if (lastShift != null && lastShift.SpansMidnight())
                {
                    // check for days in the middle of the time period
                    bool lastDay = thisDate.CompareTo(toDate) == 0 ? true : false;

                    if (!lastDay || (lastDay && !toTime.Equals(LocalTime.Midnight)))
                    {
                        // add time after midnight in this day
                        int afterMidnightSecond = TimePeriod.SecondOfDay(lastShift.GetEnd());
                        int fromSecond          = TimePeriod.SecondOfDay(thisTime);

                        if (afterMidnightSecond > fromSecond)
                        {
                            Duration seconds = Duration.FromSeconds(afterMidnightSecond - fromSecond);
                            sum = sum.Plus(seconds);
                        }
                    }
                }

                // today's shift
                ShiftInstance instance = GetShiftInstanceForDay(thisDate);

                Duration duration;

                if (instance != null)
                {
                    lastShift = instance.Shift;
                    // check for last date
                    if (thisDate.CompareTo(toDate) == 0)
                    {
                        duration = lastShift.CalculateWorkingTime(thisTime, toTime, true);
                    }
                    else
                    {
                        duration = lastShift.CalculateWorkingTime(thisTime, LocalTime.MaxValue, true);
                    }
                    sum = sum.Plus(duration);
                }
                else
                {
                    lastShift = null;
                }

                int n = 1;
                if (GetDayInRotation(thisDate) == dayCount)
                {
                    // move ahead by the rotation count if possible
                    LocalDate rotationEndDate = thisDate.PlusDays(dayCount);

                    if (rotationEndDate.CompareTo(toDate) < 0)
                    {
                        n   = dayCount;
                        sum = sum.Plus(Rotation.GetWorkingTime());
                    }
                }

                // move ahead n days starting at midnight
                thisDate = thisDate.PlusDays(n);
                thisTime = LocalTime.Midnight;
            }             // end day loop

            return(sum);
        }