Beispiel #1
0
        public ActionResult DelegationApproval(DelegationsViewModel DelegationVM, string BtnType)
        {
            Result      result  = null;
            ExpensesBLL expense = new BaseDelegationsBLL();

            expense.ApprovedBy = UserIdentity.EmployeeCodeID;
            if (BtnType == "Approve")
            {
                result = expense.Approve(DelegationVM.DelegationID);
            }
            else
            {
                result = expense.ApproveCancel(DelegationVM.DelegationID);
            }
            if ((System.Type)result.EnumType == typeof(DelegationsValidationEnum))
            {
                if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfAlreadyApprove.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationDelegationAlreadyApproveText);
                }
                if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfAlreadyApproveCancel.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationDelegationAlreadyApproveCancelText);
                }
            }
            return(View());
        }
Beispiel #2
0
        public ActionResult Approve(DelegationsViewModel DelegationVM)
        {
            Result result = new BaseDelegationsBLL()
            {
                ApprovedBy = UserIdentity.EmployeeCodeID
            }.Approve(DelegationVM.DelegationID);

            if ((System.Type)result.EnumType == typeof(DelegationsValidationEnum))
            {
                if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfAlreadyApprove.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationDelegationAlreadyApproveText);
                }
            }
            return(RedirectToAction("Index"));
        }
Beispiel #3
0
        public JsonResult GetEmployeesDelegationsAsRanksCategories(int DelegationTypeID, DateTime FromDate, DateTime ToDate, int OrganizationID)
        {
            IQueryable <EmployeesDelegationsBasedOnAssigngingsDTO> Delegations;

            Delegations = new BaseDelegationsBLL().GetEmployeesDelegationsBasedOnAssigningsAsRanksCategories(DelegationTypeID, FromDate, ToDate, OrganizationID);
            Session["EmployeesDelegationsDetails"] = Delegations;

            var DelegationsByRanksCategories = Delegations
                                               .GroupBy(x => x.RankCategoryName)
                                               .Select(y => new
            {
                KeyName = y.Key,
                Value   = y.Count()
            });

            return(Json(new { data = DelegationsByRanksCategories }, JsonRequestBehavior.AllowGet));
        }
Beispiel #4
0
        private DelegationsViewModel GetByDelegationID(int id)
        {
            BaseDelegationsBLL   DelegationBLL = new BaseDelegationsBLL().GetByDelegationID(id);
            DelegationsViewModel DelegationVM  = new DelegationsViewModel();

            if (DelegationBLL != null)
            {
                if (DelegationBLL.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.Internal)
                {
                    DelegationVM.KSARegion = ((InternalDelegationBLL)DelegationBLL).KSACity.KSARegion;
                    DelegationVM.KSACity   = ((InternalDelegationBLL)DelegationBLL).KSACity;
                }
                else if (DelegationBLL.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.External)
                {
                    DelegationVM.KSACity = new KSACitiesBLL();
                    DelegationVM.Country = ((ExternalDelegationBLL)DelegationBLL).Country;
                }

                DelegationVM.DelegationKind = new DelegationsKindsBLL()
                {
                    DelegationKindID = DelegationBLL.DelegationKind.DelegationKindID, DelegationKindName = DelegationBLL.DelegationKind.DelegationKindName
                };
                DelegationVM.DelegationType = new DelegationsTypesBLL()
                {
                    DelegationTypeID = DelegationBLL.DelegationType.DelegationTypeID, DelegationTypeName = DelegationBLL.DelegationType.DelegationTypeName
                };
                DelegationVM.DelegationID        = DelegationBLL.DelegationID;
                DelegationVM.DelegationStartDate = DelegationBLL.DelegationStartDate.Date;
                DelegationVM.DelegationEndDate   = DelegationBLL.DelegationEndDate;
                DelegationVM.DelegationReason    = DelegationBLL.DelegationReason;
                DelegationVM.Notes                    = DelegationBLL.Notes;
                DelegationVM.DelegationPeriod         = DelegationBLL.DelegationPeriod;
                DelegationVM.DelegationDistancePeriod = DelegationBLL.DelegationDistancePeriod;
                DelegationVM.CreatedDate              = DelegationBLL.CreatedDate;
                DelegationVM.CreatedBy                = DelegationVM.GetCreatedByDisplayed(DelegationBLL.CreatedBy);
                DelegationVM.IsApprove                = DelegationBLL.IsApproved;
            }
            return(DelegationVM);
        }
Beispiel #5
0
        public ActionResult EditDelegation(DelegationsViewModel DelegationVM)
        {
            if (DelegationVM.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.Internal)
            {
                InternalDelegationBLL Delegation = new InternalDelegationBLL();
                Delegation.DelegationID   = DelegationVM.DelegationID;
                Delegation.DelegationKind = new DelegationsKindsBLL()
                {
                    DelegationKindID = DelegationVM.DelegationKind.DelegationKindID
                };
                Delegation.DelegationType = new DelegationsTypesBLL()
                {
                    DelegationTypeID = (int)DelegationsTypesEnum.Internal
                };
                Delegation.DelegationStartDate = DelegationVM.DelegationStartDate;
                Delegation.DelegationEndDate   = DelegationVM.DelegationEndDate;
                Delegation.DelegationReason    = DelegationVM.DelegationReason;
                Delegation.Notes = DelegationVM.Notes;
                Delegation.DelegationDistancePeriod = DelegationVM.DelegationDistancePeriod;
                Delegation.LoginIdentity            = UserIdentity;
                Delegation.KSACity = new KSACitiesBLL()
                {
                    KSACityID = DelegationVM.KSACity.KSACityID
                };
                Result result = Delegation.Update();

                BaseDelegationsBLL DelegationEntity = (BaseDelegationsBLL)result.Entity;
                if (result.EnumMember == DelegationsValidationEnum.Done.ToString())
                {
                    Session["DelegationID"] = ((InternalDelegationBLL)result.Entity).DelegationID;
                    ClearDelegationDetailsFromSession();
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfMaxLimit.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationAlreadyReachTheDelegationLimitText);
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseEmployeeRequired.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationEmployeeRequiredText);
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfAlreadyApprove.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationDelegationAlreadyApproveText);
                }

                Classes.Helpers.CommonHelper.ConflictValidationMessage(result);
            }
            else if (DelegationVM.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.External)
            {
                ExternalDelegationBLL Delegation = new ExternalDelegationBLL();
                Delegation.DelegationID   = DelegationVM.DelegationID;
                Delegation.DelegationKind = new DelegationsKindsBLL()
                {
                    DelegationKindID = DelegationVM.DelegationKind.DelegationKindID
                };
                Delegation.DelegationType = new DelegationsTypesBLL()
                {
                    DelegationTypeID = (int)DelegationsTypesEnum.External
                };
                Delegation.DelegationStartDate = DelegationVM.DelegationStartDate;
                Delegation.DelegationEndDate   = DelegationVM.DelegationEndDate;
                Delegation.DelegationReason    = DelegationVM.DelegationReason;
                Delegation.Notes = DelegationVM.Notes;
                Delegation.DelegationDistancePeriod = DelegationVM.DelegationDistancePeriod;
                Delegation.LoginIdentity            = UserIdentity;
                Delegation.Country = new CountriesBLL()
                {
                    CountryID = DelegationVM.Country.CountryID
                };
                Result result = Delegation.Update();
                //if ((System.Type)result.EnumType == typeof(DelegationsValidationEnum))
                //{
                BaseDelegationsBLL DelegationEntity = (BaseDelegationsBLL)result.Entity;
                if (result.EnumMember == DelegationsValidationEnum.Done.ToString())
                {
                    Session["DelegationID"] = ((ExternalDelegationBLL)result.Entity).DelegationID;
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfMaxLimit.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationAlreadyReachTheDelegationLimitText);
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseEmployeeRequired.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationEmployeeRequiredText);
                }
                //else if (result.EnumMember == NoConflictWithOtherProcessValidationEnum.RejectedBecauseOfConflictWithOverTime.ToString())
                //{
                //    throw new CustomException(Resources.Globalization.ValidationConflictWithOverTimeText);
                //}
                //else if (result.EnumMember == NoConflictWithOtherProcessValidationEnum.RejectedBecauseOfConflictWithDelegation.ToString())
                //{
                //    throw new CustomException(Resources.Globalization.ValidationConflictWithDelegationText);
                //}
                //else if (result.EnumMember == NoConflictWithOtherProcessValidationEnum.RejectedBecauseOfConflictWithInternshipScholarship.ToString())
                //{
                //    throw new CustomException(Resources.Globalization.ValidationConflictWithInternshipScholarshipText);
                //}
                //else if (result.EnumMember == NoConflictWithOtherProcessValidationEnum.RejectedBecauseOfConflictWithVacation.ToString())
                //{
                //    throw new CustomException(Resources.Globalization.ValidationConflictWithVacationText);
                //}
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfAlreadyApprove.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationDelegationAlreadyApproveText);
                }

                Classes.Helpers.CommonHelper.ConflictValidationMessage(result);
                //}
            }

            return(View(DelegationVM));
        }
Beispiel #6
0
        public ActionResult Create(DelegationsViewModel DelegationVM)
        {
            if (DelegationVM.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.Internal)
            {
                InternalDelegationBLL Delegation = new InternalDelegationBLL();
                Delegation.DelegationKind = new DelegationsKindsBLL()
                {
                    DelegationKindID = DelegationVM.DelegationKind.DelegationKindID
                };
                Delegation.DelegationType = new DelegationsTypesBLL()
                {
                    DelegationTypeID = (int)DelegationsTypesEnum.Internal
                };
                Delegation.DelegationStartDate = DelegationVM.DelegationStartDate;
                Delegation.DelegationEndDate   = DelegationVM.DelegationEndDate;
                Delegation.DelegationReason    = DelegationVM.DelegationReason;
                Delegation.Notes   = DelegationVM.Notes;
                Delegation.KSACity = new KSACitiesBLL()
                {
                    KSACityID = DelegationVM.KSACity.KSACityID
                };
                Delegation.DelegationDistancePeriod = DelegationVM.DelegationDistancePeriod;
                Delegation.LoginIdentity            = UserIdentity;
                Delegation.DelegationsDetails       = GetDelegationDetailsFromSession();
                Result result = Delegation.Add();

                BaseDelegationsBLL DelegationEntity = (BaseDelegationsBLL)result.Entity;
                if (result.EnumMember == DelegationsValidationEnum.Done.ToString())
                {
                    DelegationVM.DelegationID = ((InternalDelegationBLL)result.Entity).DelegationID;
                    ClearDelegationDetailsFromSession();
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfDelegationDatesMustBeInSameFinancialYear.ToString())
                {
                    FinancialYearsBLL FinancialYearBLL = (FinancialYearsBLL)result.Entity;
                    throw new CustomException(Resources.Globalization.ValidationDelegationDatesMustBeInSameFinancialYearText + " NewLine" +
                                              Resources.Globalization.FinancialYearInfoText + FinancialYearBLL.FinancialYear + " NewLine" +
                                              Resources.Globalization.FinancialYearStartDateText + FinancialYearBLL.FinancialYearStartDate.Date.ToString(Classes.Helpers.CommonHelper.DateFormat) + " NewLine" +
                                              Resources.Globalization.FinancialYearEndDateText + FinancialYearBLL.FinancialYearEndDate.Date.ToString(Classes.Helpers.CommonHelper.DateFormat));
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfMaxLimit.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationAlreadyReachTheDelegationLimitText);
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseEmployeeRequired.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationEmployeeRequiredText);
                }

                Classes.Helpers.CommonHelper.ConflictValidationMessage(result);
            }
            else if (DelegationVM.DelegationType.DelegationTypeID == (Int32)DelegationsTypesEnum.External)
            {
                ExternalDelegationBLL Delegation = new ExternalDelegationBLL();
                Delegation.DelegationKind = new DelegationsKindsBLL()
                {
                    DelegationKindID = DelegationVM.DelegationKind.DelegationKindID
                };
                Delegation.DelegationType = new DelegationsTypesBLL()
                {
                    DelegationTypeID = (int)DelegationsTypesEnum.External
                };
                Delegation.DelegationStartDate = DelegationVM.DelegationStartDate;
                Delegation.DelegationEndDate   = DelegationVM.DelegationEndDate;
                Delegation.DelegationReason    = DelegationVM.DelegationReason;
                Delegation.Notes = DelegationVM.Notes;
                Delegation.DelegationDistancePeriod = DelegationVM.DelegationDistancePeriod;
                Delegation.LoginIdentity            = UserIdentity;
                Delegation.Country = new CountriesBLL()
                {
                    CountryID = DelegationVM.Country.CountryID
                };
                Delegation.DelegationsDetails = GetDelegationDetailsFromSession();
                Result result = Delegation.Add();
                //if ((System.Type)result.EnumType == typeof(DelegationsValidationEnum))
                //{
                BaseDelegationsBLL DelegationEntity = (BaseDelegationsBLL)result.Entity;
                if (result.EnumMember == DelegationsValidationEnum.Done.ToString())
                {
                    DelegationVM.DelegationID = ((ExternalDelegationBLL)result.Entity).DelegationID;
                    ClearDelegationDetailsFromSession();
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfDelegationDatesMustBeInSameFinancialYear.ToString())
                {
                    FinancialYearsBLL FinancialYearBLL = (FinancialYearsBLL)result.Entity;
                    throw new CustomException(Resources.Globalization.ValidationDelegationDatesMustBeInSameFinancialYearText + " NewLine" +
                                              Resources.Globalization.FinancialYearInfoText + FinancialYearBLL.FinancialYear + " NewLine" +
                                              Resources.Globalization.FinancialYearStartDateText + FinancialYearBLL.FinancialYearStartDate.Date.ToString(Classes.Helpers.CommonHelper.DateFormat) + " NewLine" +
                                              Resources.Globalization.FinancialYearEndDateText + FinancialYearBLL.FinancialYearEndDate.Date.ToString(Classes.Helpers.CommonHelper.DateFormat));
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseOfMaxLimit.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationAlreadyReachTheDelegationLimitText);
                }
                else if (result.EnumMember == DelegationsValidationEnum.RejectedBecauseEmployeeRequired.ToString())
                {
                    throw new CustomException(Resources.Globalization.ValidationEmployeeRequiredText);
                }

                Classes.Helpers.CommonHelper.ConflictValidationMessage(result);
            }

            return(Json(new { DelegationID = DelegationVM.DelegationID }, JsonRequestBehavior.AllowGet));
        }