Esempio n. 1
0
        public virtual bool Assess(AssessorArgs args, out List<string> errors)
        {
            bool result;
            LogSession.Main.EnterMethod(this, "Assess");
            try
            {
                /*--------- Your code goes here-------*/
                errors = null;
                LogSession.Main.LogBool("Enabled", Enabled);

                if (Enabled)
                    result = this.Assessor.Assess(args, out errors);
                else
                    result = true;

                if (result)
                    LogSession.Main.LogColored(Color.Green, "PASSED");
                else if(this.RuleType == BusinessRules.RuleType.HardRule)
                    LogSession.Main.LogColored(Color.Red, "FAILED");
                else
                    LogSession.Main.LogColored(Color.Yellow, "FAILED");
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "Assess");
            }

            return result;
        }
        public virtual bool Assess(AssessorArgs args, out List<string> errors)
        {
            bool result = true;
            errors = new List<string>();
            ShiftSchedule schedule = null;
            ShiftRuleValue ruleValue = null;

            LogSession.Main.EnterMethod(this, "Assess");
            try
            {
                /*--------- Your code goes here-------*/
                int employeeId = args.EmployeeId;
                ruleValue = (ShiftRuleValue)this.ReferenceValue;

                if (args.ItemToAssess == null)
                {
                    errors.Add(string.Format("Shift Schedule passed as argument is null"));
                    return false;
                }

                schedule = (ShiftSchedule)args.ItemToAssess;

                foreach (var weekItem in schedule.Weeks)
                {
                    Week weekToValidate = weekItem.Value;
                    int shiftsAssignedToEmployee = 0;

                    //foreach day of the week under evaluation
                    foreach (var wDay in weekToValidate.WorkingDays)
                    {
                        if (wDay.Value.Shifts[1].AssignedEmployees.ContainsKey(employeeId))
                            shiftsAssignedToEmployee++;
                    }

                    if (!IsShiftsAssignedToEmployeeCompliantWithRule(shiftsAssignedToEmployee))
                    {
                        string error;

                        result = result & false;
                        error = GetNotCompliantFormatMessage(shiftsAssignedToEmployee, employeeId, weekToValidate.Id, ruleValue.value);
                        LogSession.Main.LogError(error);
                        errors.Add(error);
                    }
                }
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "Assess");
            }

            return result;
        }
        public virtual bool Assess(AssessorArgs args, out List<string> errors)
        {
            bool result = true;
            ShiftSchedule schedule = null;
            errors = new List<string>();

            LogSession.Main.EnterMethod(this, "Assess");
            try
            {
                /*--------- Your code goes here-------*/
                if (args.ItemToAssess == null)
                {
                    errors.Add(string.Format("Shift Schedule passed as argument is null"));
                    return false;
                }
                else
                    schedule = (ShiftSchedule)args.ItemToAssess;

                foreach (var weekItem in schedule.Weeks)
                {
                    Week week = weekItem.Value;
                    foreach (var wDay in week.WorkingDays)
                    {
                        Shift itemToAssess = wDay.Value.Shifts[1];
                        if (itemToAssess.AssignedEmployees.Count == (int)this.ReferenceValue)
                            result = result & true;
                        else
                        {
                            string error;
                            result = result & false;
                            error = string.Format("Shift:{0} of WorkingDay:{1} - Week:{4} has {2} employees and does not comply with the Number of employees required per shift which is {3}",
                                itemToAssess.Id, itemToAssess.WorkingDay, itemToAssess.AssignedEmployees.Count, (int)this.ReferenceValue, week.Id);
                            LogSession.Main.LogError(error);
                            errors.Add(error);
                        }
                    }
                }
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "Assess");
            }

            return result;
        }
 protected override void Because_of()
 {
     ShiftSchedule shiftSchedule = new ShiftSchedule();
     shiftSchedule.Weeks.Add(_weekToTest.Id, _weekToTest);
     AssessorArgs args = new AssessorArgs() { EmployeeId = _shiftRule.EmployeeId, ItemToAssess = shiftSchedule };
     _result = _shiftRule.Assess(args, out _errors);
 }
        public virtual bool Assess(AssessorArgs args, out List<string> errors)
        {
            bool result = true;
            ShiftSchedule schedule = null;
            Week weekToValidate = null;
            errors = new List<string>();

            LogSession.Main.EnterMethod(this, "Assess");
            try
            {
                /*--------- Your code goes here-------*/

                if (args.ItemToAssess == null)
                {
                    errors.Add(string.Format("Shift Schedule passed as argument is null"));
                    return false;
                }

                schedule = (ShiftSchedule)args.ItemToAssess;

                DTimeOffRequest TimeOffRequest = (DTimeOffRequest)this.ReferenceValue;

                //If week number used by this assessor cannot be found in schedule instance, then it passes the assessment
                if (!schedule.Weeks.TryGetValue(TimeOffRequest.week, out weekToValidate))
                {
                    LogSession.Main.LogWarning("Week number: {0} used by this assessor cannot be found in schedule instance. This assessor will automatically return a TRUE value for the assessment", TimeOffRequest.week);
                    return true;
                }

                if(args.EmployeeId != TimeOffRequest.employee_id)
                {
                    LogSession.Main.LogWarning("Employee ID: {0} passed as argument to this assessor is different from the employee id {1} for whom this assesor is exclusively for . This assessor will automatically return a TRUE value for the assessment", args.EmployeeId, TimeOffRequest.employee_id);
                    return true;
                }

                //if time off request applies to the week under evaluation
                if (weekToValidate.Id == TimeOffRequest.week)
                {
                    //foreach day off requested by employee
                    foreach (int dayOff in TimeOffRequest.days)
                    {

                        if (weekToValidate.WorkingDays[dayOff].Shifts[1].AssignedEmployees.ContainsKey(args.EmployeeId))
                        {
                            string error;

                            result = false;
                            error = string.Format("Time off request for day {0} of week {1} made by employee {2} was not met.",
                                                    dayOff, TimeOffRequest.week, TimeOffRequest.employee_id);
                            LogSession.Main.LogError(error);
                            errors.Add(error);
                        }
                    }
                }
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "Assess");
            }

            return result;
        }
        public virtual bool IsValid(ShiftSchedule item, out List<string> hardErrors, out List<string> softErrors)
        {
            bool result = true;
            bool softResult = true;

            hardErrors = new List<string>();
            softErrors = new List<string>();

            ShiftRuleCollection hardRules = null;
            ShiftRuleCollection softRules = null;

            LogSession.Main.EnterMethod(this, "IsValid");
            try
            {
                /*--------- Your code goes here-------*/
                List<Employee> employeeList = this.ShiftRuleFactory.DataAccess.GetEmployees();

                foreach (var employee in employeeList)
                {
                    LogSession.Main.LogMessage(string.Format("Assessing schedule for employee {0}", employee.id));
                    hardRules = this.ShiftRuleFactory.GetHardRules(employee.id);
                    softRules = this.ShiftRuleFactory.GetSoftRules(employee.id);

                    #region LogRules
                    foreach (var hardRule in hardRules)
                    {
                        LogSession.Main.LogObject(string.Format("Hard Rule {0} for employee {1}", hardRule.Name, employee.id), hardRule);
                    }
                    foreach (var softRule in softRules)
                    {
                        LogSession.Main.LogObject(string.Format("Soft Rule {0} for employee {1}", softRule.Name, employee.id), softRule);
                    }
                    #endregion

                    AssessorArgs args = new AssessorArgs() { EmployeeId = employee.id, ItemToAssess = item };

                    //Assess hard rules first
                    List<string> hardRulesErrors = null;
                    result = result & AssessRules(args, hardRules, out hardRulesErrors);
                    if (hardRulesErrors != null)
                        hardErrors.AddRange(hardRulesErrors);

                    //Assess soft rules
                    List<string> softRulesErrors = null;
                    softResult = softResult & AssessRules(args, softRules, out softRulesErrors);
                    if (softRulesErrors != null)
                        softErrors.AddRange(softRulesErrors);

                    LogSession.Main.LogSeparator();
                }
                /*------------------------------------*/
            }
            catch (Exception ex)
            {
                LogSession.Main.LogException(ex);
                throw ex;
            }
            finally
            {
                LogSession.Main.LeaveMethod(this, "IsValid");
            }

            return result;
        }
        protected virtual bool AssessRules(AssessorArgs args, ShiftRuleCollection rules, out List<string> errors)
        {
            bool result = true;
            errors = new List<string>();

            foreach (var rule in rules)
            {
                List<string> ruleErrors = null;
                result = result & rule.Assess(args, out ruleErrors);
                if (ruleErrors != null)
                    errors.AddRange(ruleErrors);
            }

            return result;
        }
        protected override void Because_of()
        {
            List<string> errors = null;
            AssessorArgs args = null;
            ShiftSchedule shiftSchedule = new ShiftSchedule();
            Week week = new Week();
            week.Id = 50;
            week.Start_Date = new DateTime(2015,07,12);
            WorkingDay wDay = new WorkingDay();
            wDay.Id = 1;
            wDay.Week = week.Id;
            wDay.Shifts.Add(1,_shift);
            week.WorkingDays.Add(wDay.Id, wDay);

            shiftSchedule.Weeks.Add(week.Id, week);
            args = new AssessorArgs() { EmployeeId = _shiftRule.EmployeeId, ItemToAssess = shiftSchedule };
            _result = _shiftRule.Assess(args, out errors);
        }