public void MapsNonFurtherEducationToQtsPgde(string profpostFlag)
        {
            var qualificationMapper = new QualificationMapper();
            var courseQualification = qualificationMapper.MapQualification(profpostFlag, isFurtherEducationCourse: false, isPgde: true);

            courseQualification.Should().Be(CourseQualification.QtsWithPgde);
        }
Exemple #2
0
        public async Task <ActionResult> Detail(int id, bool partial = false)
        {
            UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
            var       usersRolesLanguages = await _applicationUsersService.GetUsersAndRolesAndLanguages();

            var qualification = await _prepareService.GetQualification(id);

            if (!user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Evaluator, KnownRoles.Trainer, KnownRoles.Documentalist }.Contains(r))) && qualification.UserId != user.UserId)
            {
                return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
            }
            // Retrieve all the action of the publication
            var actionSorted = qualification.Publication.PublishedActions.Distinct()
                               .OrderBy(a => a.WBSParts, new WBSPartsComparer())
                               .ToList();

            var qualificationSteps   = GetQualificationStepAndChilds(qualification, actionSorted);
            var trainingPublications = await _prepareService.GetTrainingPublications(new[] { qualification.PublicationId });

            var qualificationManageViewModel = QualificationMapper.ToQualificationViewModel(
                qualification, qualificationSteps, usersRolesLanguages.Users.ToList(), trainingPublications);

            if (partial)
            {
                return(PartialView(qualificationManageViewModel));
            }
            return(View(qualificationManageViewModel));
        }
Exemple #3
0
        public async Task ExportToExcel(string GridModel, string gridId, int id, string process, int?userId)
        {
            ExcelExport    exp = new ExcelExport();
            GridProperties obj = (GridProperties)Syncfusion.JavaScript.Utils.DeserializeToModel(typeof(GridProperties), GridModel);

            //Clear if there are any filter columns
            //syncfusion bug in exporting while in filter mode
            obj.FilterSettings.FilteredColumns.Clear();
            grid  = gridId;
            count = 0;
            var usersRolesLanguages = await _applicationUsersService.GetUsersAndRolesAndLanguages();

            var users     = new List <User>();
            var userPools = await LicenseMapper.GetUserPools();

            users = usersRolesLanguages.Users.Where(u => userPools.Any(p => p == u.UserId)).ToList();

            if (gridId == "Qualification")
            {
                var lastTrainingPublications = await _prepareService.GetLastPublications((int)PublishModeEnum.Formation);

                var lastEvaluationPublications = await _prepareService.GetLastPublications((int)PublishModeEnum.Evaluation);

                var qualificationManageViewModel = await QualificationMapper.ToQualificationManageViewModel(lastTrainingPublications, lastEvaluationPublications, users, userId);

                var dataSource = qualificationManageViewModel.Qualifications.ToList();
                qualificationViewModelData = qualificationManageViewModel.Qualifications.ToList();
                var currentDate = DateTime.Today.ToShortDateString().Replace("/", "-");
                obj.Columns[10].Field        = "Result";
                obj.ServerExcelQueryCellInfo = QueryCellInfo;
                exp.Export(obj, dataSource, LocalizedStrings.GetString("Qualification") + " " + currentDate + ".xlsx", ExcelVersion.Excel2013, false, false, "flat-saffron");
            }
            if (gridId == "QualificationDetail")
            {
                var qualification = await _prepareService.GetQualification(id);

                // Retrieve all the action of the publication
                var actionSorted = qualification.Publication.PublishedActions.Distinct()
                                   .OrderBy(a => a.WBSParts, new WBSPartsComparer())
                                   .ToList();

                var qualificationSteps   = GetQualificationStepAndChilds(qualification, actionSorted);
                var trainingPublications = await _prepareService.GetTrainingPublications(new[] { qualification.PublicationId });

                var qualificationManageViewModel = QualificationMapper.ToQualificationViewModel(qualification, qualificationSteps, users, trainingPublications);
                var dataSource = qualificationManageViewModel.Steps.ToList();
                qualificationStepViewModelData = qualificationManageViewModel.Steps.ToList();
                var currentDate = DateTime.Today.ToShortDateString().Replace("/", "-");
                obj.Columns[5].Field         = HeadersHelper.IsQualified;
                obj.ServerExcelQueryCellInfo = QueryCellInfo;
                exp.Export(obj, dataSource, LocalizedStrings.GetString("QualificationDetail") + " " + process + " " + currentDate + ".xlsx", ExcelVersion.Excel2013, false, false, "flat-saffron");
            }
        }
Exemple #4
0
        // NOT USED
        public async Task <bool> CollectAndSendEvaluation()
        {
            var evaluationTypes = await _notificationService.GetNotificationTypes(NotificationCategory.Evaluation);

            var evaluationType = evaluationTypes.FirstOrDefault();
            var evaluations    = await _notificationService.GetEvaluationReport();

            if (!evaluations.Any())
            {
                return(false);
            }
            var(Users, _, _, _) = await _applicationUsersService.GetUsersAndRolesAndLanguages();

            var trainingPublications = await _prepareService.GetTrainingPublications(evaluations.Select(e => e.PublicationId).Distinct().ToArray());

            var evaluationsModel = QualificationMapper.ToQualificationViewModels(evaluations, Users.ToList(), trainingPublications);

            //string body = _notificationService.RenderViewToString(evaluationsModel, bodyTemplatePath, evaluationType.NotificationTypeSetting.BodyTemplate);

            string pdfString = _notificationService.RenderViewToString(evaluationsModel, pdfTemplatePath, evaluationType.NotificationTypeSetting.PdfTemplate);

            _notificationService.RenderViewToPdf(pdfString, pdfBase, baseUrl);
            return(true);
        }
Exemple #5
0
        public async Task <ActionResult> Index(int?userId, bool partial = false)
        {
            UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);

            if (!userId.HasValue && !user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Evaluator, KnownRoles.Trainer, KnownRoles.Documentalist }.Contains(r))))
            {
                return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
            }
            _traceManager.TraceDebug("QualificationController starting index");
            var usersRolesLanguages = await _applicationUsersService.GetUsersAndRolesAndLanguages();

            var users = usersRolesLanguages.Users.ToList();
            var lastTrainingPublications = await _prepareService.GetLastSameMajorPublications((int)PublishModeEnum.Formation);

            var lastEvaluationPublications = await _prepareService.GetLastSameMajorPublications((int)PublishModeEnum.Evaluation);

            var qualificationManageViewModel = await QualificationMapper.ToQualificationManageViewModel(lastTrainingPublications, lastEvaluationPublications, users, userId);

            if (partial)
            {
                return(PartialView(qualificationManageViewModel));
            }
            return(View(qualificationManageViewModel));
        }
        public IActionResult Details(int id)
        {
            if (id < 1)
            {
                return(NotFound());
            }
            try
            {
                var employee = (employeeService.GetEmployeeById(id));

                var protocols = new List <ProtocolViewModel>();
                if (employee.Protocols != null && employee.Protocols.Any())
                {
                    protocols = ProtocolMapper.MapManyToViewModel(employee.Protocols).ToList();
                }

                var orders = new List <OrderViewModel>();
                if (employee.Orders != null && employee.Orders.Any())
                {
                    orders = OrderMapper.MapManyToViewModel(employee.Orders).ToList();
                }

                var mappedEmployee = EmployeeMapper.MapToViewModel(employee, employee.EmployeesQualifications, protocols, orders);

                var result = new EmployeeDetailsViewModel(QualificationMapper.MapManyToViewModel(qualificationService.GetQualifications()).ToList())
                {
                    Employee = mappedEmployee,
                };

                return(View(result));
            }
            catch (Exception ex)
            {
                return(NotFound(ex));
            }
        }
        public void MapsPgFurtherEducationToQtlsWithPgce()
        {
            var courseQualification = new QualificationMapper().MapQualification(ProfpostFlagPg, isFurtherEducationCourse: true, isPgde: false);

            courseQualification.Should().Be(CourseQualification.QtlsWithPgce, "this is a 'PG' course with further education");
        }
        public void MapsFurtherEducationToQtls()
        {
            var courseQualification = new QualificationMapper().MapQualification("", isFurtherEducationCourse: true, isPgde: false);

            courseQualification.Should().Be(CourseQualification.QtlsWithPgce, "this is a further education course, and we assume that these are always PGCE");
        }
        public void MapsBlankToNo()
        {
            var courseQualification = new QualificationMapper().MapQualification("", isFurtherEducationCourse: false, isPgde: false);

            courseQualification.Should().Be(CourseQualification.Qts);
        }
        public void MapsPgToYes()
        {
            var courseQualification = new QualificationMapper().MapQualification(ProfpostFlagPg, isFurtherEducationCourse: false, isPgde: false);

            courseQualification.Should().Be(CourseQualification.QtsWithPgce);
        }