public EmployeeRelativeValidator(ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;

            RuleFor(x => x.EmployeeCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã nhân viên", 20));

            RuleFor(x => x.OriginProvinceCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã tỉnh thành"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã tỉnh thành", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã tỉnh thành", 20))
            .Must(IsValidProvinceCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã tỉnh thành"));


            RuleFor(x => x.OriginAddress).NotEmpty().WithMessage(CommonMessageGlobal.Require("Địa chỉ"));

            RuleFor(x => x.Job).NotEmpty().WithMessage(CommonMessageGlobal.Require("Công việc"));

            RuleFor(x => x.Phone).NotEmpty().WithMessage(CommonMessageGlobal.Require("Số điện thoại"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Số điện thoại", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Số điện thoại", 20));

            RuleFor(x => x.Name).NotEmpty().WithMessage(CommonMessageGlobal.Require("Họ và tên"));

            RuleFor(x => x.RelativeType).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã mối quan hệ"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã mối quan hệ", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã mối quan hệ", 20))
            .Must(IsValidRelativeCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã mối quan hệ"));
        }
Example #2
0
        public EmployeeSaveChangeValidator(ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;

            RuleFor(x => x.FirstName).NotEmpty().WithMessage(CommonMessageGlobal.Require("Họ nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Họ nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Họ nhân viên", 20));

            RuleFor(x => x.LastName).NotEmpty().WithMessage(CommonMessageGlobal.Require("Tên nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Tên nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Tên nhân viên", 20));

            RuleFor(x => x.FullName)
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Họ và tên nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Họ và tên nhân viên", 256));

            RuleFor(x => x.DepartmentCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã bộ phận"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã bộ phận", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã bộ phận", 20))
            .Must(IsValidDepartmentCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã bộ phận"));

            RuleFor(x => x.ReligionCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã tôn giáo", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã tôn giáo", 20));

            RuleFor(x => x.GroupCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã tổ nhóm", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã tổ nhóm", 20));

            RuleFor(x => x.PersonalEmail).EmailAddress().WithMessage(CommonMessageGlobal.Invalid("Email cá nhân"));

            RuleFor(x => x.CompanyEmail).EmailAddress().WithMessage(CommonMessageGlobal.Invalid("Email công ty"));

            RuleFor(x => x.StatusCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Trạng thái nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Trạng thái nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Trạng thái nhân viên", 20))
            .Must(IsValidStatusCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Trạng thái nhân viên"));

            RuleFor(x => x.TitleCode)
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Danh xưng", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Danh xưng", 20));


            RuleFor(x => x.GenderCode)
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Giới tính", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Giới tính", 20));

            RuleFor(x => x.PositionCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Vị trí", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Vị trí", 20));

            RuleFor(x => x.BankCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Ngân hàng", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Ngân hàng", 20));

            RuleFor(x => x.JobCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Công việc", 2))
            .MaximumLength(10).WithMessage(CommonMessageGlobal.Maximum("Công việc", 10));

            RuleFor(x => x.LaborGroupCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Nhóm lao động", 2))
            .MaximumLength(10).WithMessage(CommonMessageGlobal.Maximum("Nhóm lao động", 10));
        }
        public RecruitmentPlanSaveChangeValidator(ICategoryRepository _categoryRepository)
        {
            categoryRepository = _categoryRepository;

            RuleFor(x => x.Title).NotEmpty().WithMessage(CommonMessageGlobal.Require("Tiêu đề kế hoạch tuyển dụng"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Tiêu đề kế hoạch tuyển dụng", 2));

            RuleFor(x => x.DepartmentCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã bộ phận"))
            .Must(IsValidDepartmentCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã bộ phận"));

            RuleFor(x => x.JobCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Vị trí công việc"))
            .Must(IsValidJobCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Vị trí công việc"));
        }
Example #4
0
        public CheckInOutDeviceUpdateValidator(ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;

            RuleFor(x => x.Code).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã thiết bị"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã nhân viên", 2))
            .MaximumLength(50).WithMessage(CommonMessageGlobal.Maximum("Mã nhân viên", 50));


            RuleFor(x => x.StatusCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Trạng thái"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Trạng thái", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Trạng thái", 20))
            .Must(IsValidStatusCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Trạng thái"));
        }
Example #5
0
        public CandidatePaperCreateValidator(ICandidateRepository candidateRepository, ICategoryRepository categoryRepository)
        {
            this._candidateRepository = candidateRepository;
            this._categoryRepository  = categoryRepository;

            RuleFor(x => x.CandidateCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã ứng viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã ứng viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã ứng viên", 20))
            .Must(IsValidCandidateCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã ứng viên"));

            RuleFor(x => x.TypeCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Loại giấy tờ"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Loại giấy tờ", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Loại giấy tờ", 20))
            .Must(IsValidTypeCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Loại giấy tờ"));
        }
        public RoleGroupDetailCreateValidator(IRoleGroupRepository roleGroupRepository, ICategoryRepository categoryRepository)
        {
            this._categoryRepository  = categoryRepository;
            this._roleGroupRepository = roleGroupRepository;

            RuleFor(x => x.RoleGroupCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã nhóm phân quyền"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã nhóm phân quyền", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã nhóm phân quyền", 20))
            .Must(IsValidRoleGroupCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã hợp đồng"));

            RuleFor(x => x.NavigationCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã phân quyền"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã phân quyền", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã phân quyền", 20))
            .Must(IsValidNavigationCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã phân quyền"));
        }
Example #7
0
        public CategoryValidator(ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;

            RuleFor(x => x.Id).NotEmpty().WithMessage(CommonMessageGlobal.Require("Id"))
            .GreaterThanOrEqualTo(0).WithMessage(CommonMessageGlobal.GreaterThanOrEqual("Id", 0));

            RuleFor(x => x.Entity).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã Entity"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Entity", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Entity", 20));

            RuleFor(x => x.Name).NotEmpty().WithMessage(CommonMessageGlobal.Require("Tên danh mục"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Tên danh mục", 2))
            .MaximumLength(256).WithMessage(CommonMessageGlobal.Maximum("Tên danh mục", 256));

            RuleFor(x => x.ParentCode).Must(IsValidParentCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Danh mục cha"));
        }
Example #8
0
        public RoleUpdateValidator(IUserRepository userRepository, ICategoryRepository categoryRepository)
        {
            RuleFor(x => x.Id).NotEmpty().WithMessage(CommonMessageGlobal.Require("Id"))
            .GreaterThanOrEqualTo(0).WithMessage(CommonMessageGlobal.GreaterThanOrEqual("Id", 0));

            RuleFor(x => x.Username).NotEmpty().WithMessage(CommonMessageGlobal.Require("Username"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Username", 2))
            .MaximumLength(50).WithMessage(CommonMessageGlobal.Maximum("Username", 50))
            .Must(IsValidUsername).WithMessage(CommonMessageGlobal.NotExistInCategory("Username"));

            RuleFor(x => x.NavigationCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã phân quyền"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã phân quyền", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã phân quyền", 20))
            .Must(IsValidNavigationCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã phân quyền"));

            RuleFor(x => x.Entity).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Entity", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Entity", 20));
        }
Example #9
0
        public RoleCreateValidator(IUserRepository userRepository, ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;
            this._userRepository     = userRepository;

            RuleFor(x => x.Username).NotEmpty().WithMessage(CommonMessageGlobal.Require("Username"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Username", 2))
            .MaximumLength(50).WithMessage(CommonMessageGlobal.Maximum("Username", 50))
            .Must(IsValidUsername).WithMessage(CommonMessageGlobal.NotExistInCategory("Username"));

            RuleFor(x => x.NavigationCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã phân quyền"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã phân quyền", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã phân quyền", 20))
            .Must(IsValidNavigationCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã phân quyền"));

            RuleFor(x => x.Entity).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Entity", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Entity", 20));
        }
        public RecruitmentPlanUpdateValidator(ICategoryRepository _categoryRepository)
        {
            categoryRepository = _categoryRepository;

            RuleFor(x => x.Title).NotEmpty().WithMessage(CommonMessageGlobal.Require("Tiêu đề kế hoạch tuyển dụng"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Tiêu đề kế hoạch tuyển dụng", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Tiêu đề kế hoạch tuyển dụng", 100));

            RuleFor(x => x.DepartmentCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã bộ phận"))
            .Must(IsValidDepartmentCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã bộ phận"));

            RuleFor(x => x.JobCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Vị trí công việc"))
            .Must(IsValidJobCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Vị trí công việc"));

            RuleFor(x => x.Status).NotEmpty().WithMessage(CommonMessageGlobal.Require("Trạng thái kế hoạch"))
            .Must(IsValidStatusCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Trạng thái kế hoạch"));

            RuleFor(x => x.Quantity).NotEmpty().WithMessage(CommonMessageGlobal.Require("Số lượng"));
        }
Example #11
0
        public EmployeeDayOffValidator(ICategoryRepository categoryRepository)
        {
            this._categoryRepository = categoryRepository;

            RuleFor(x => x.EmployeeCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã nhân viên", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã nhân viên", 20));

            RuleFor(x => x.Reason).NotEmpty().WithMessage(CommonMessageGlobal.Require("Lý do nghỉ"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Lý do nghỉ", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Lý do nghỉ", 20))
            .Must(IsValidReasonCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Lý do nghỉ"));


            RuleFor(x => x.ApproveStatus).NotEmpty().WithMessage(CommonMessageGlobal.Require("Trạng thái duyệt"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Trạng thái duyệt", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Trạng thái duyệt", 20))
            .Must(IsValidApproveCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Trạng thái duyệt"));
        }
        public ImportEmployeeExcelFileValidator(ICategoryRepository categoryRepository)
        {
            this.categoryRepository = categoryRepository;

            RuleFor(x => x.Code).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã nhân viên"));

            RuleFor(x => x.LastName).NotEmpty().WithMessage(CommonMessageGlobal.Require("Tên nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Tên nhân viên", 20))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Tên nhân viên", 20));

            RuleFor(x => x.FullName).NotEmpty().WithMessage(CommonMessageGlobal.Require("Họ và tên nhân viên"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Họ và tên nhân viên", 2))
            .MaximumLength(256).WithMessage(CommonMessageGlobal.Maximum("Họ và tên nhân viên", 256));

            RuleFor(x => x.DepartmentCode).NotEmpty().WithMessage(CommonMessageGlobal.Require("Mã bộ phận"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã bộ phận", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã bộ phận", 20))
            .Must(IsValidDepartmentCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã bộ phận"));
        }
Example #13
0
        public EmployeeContractUpdateValidator(IEmployeeContractRepository employeeContractRepository,
                                               IEmployeeRepository employeeRepository)
        {
            this._employeeContractRepository = employeeContractRepository;
            this._employeeRepository         = employeeRepository;

            RuleFor(x => x.SignDate).NotEmpty().WithMessage(CommonMessageGlobal.Require("Ngày ký"));
            RuleFor(x => x.EffectiveDate).NotEmpty().WithMessage(CommonMessageGlobal.Require("Ngày hiệu lực"));

            RuleFor(x => x.CompanySignPerson).NotEmpty().WithMessage(CommonMessageGlobal.Require("Chữ ký công ty"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Chữ ký công ty", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Chữ ký công ty", 20))
            .Must(IsValidEmployeeCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Chữ ký công ty"));

            RuleFor(x => x.EmployeeSignPerson).NotEmpty().WithMessage(CommonMessageGlobal.Require("Chữ ký người lao động"))
            .MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Chữ ký người lao động", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Chữ ký người lao động", 20))
            .Must(IsValidEmployeeCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Chữ ký người lao động"));


            RuleFor(x => x.ParentCode).MinimumLength(2).WithMessage(CommonMessageGlobal.Minimum("Mã hợp đồng", 2))
            .MaximumLength(20).WithMessage(CommonMessageGlobal.Maximum("Mã hợp đồng", 20))
            .Must(IsValidNumberCode).WithMessage(CommonMessageGlobal.NotExistInCategory("Mã hợp đồng"));
        }