private ScoringAssessmentDTO SafeParseForPost(ScoringAssessmentDTO scoring)
        {
            _mapper.SecuredStudentDTO(_mapper.MapStudentDTO(scoring.Student));

            scoring.Associations = scoring.Associations.Select(association =>
            {
                association.AssociationModel.AssessmentReference.Identifier = association.Assessment.Identifier;

                if (string.IsNullOrWhiteSpace(association.AssociationModel.AssessmentReference.NamespaceProperty))
                {
                    association.AssociationModel.AssessmentReference.NamespaceProperty = _odsApiSettingsProvider.GetAssessmentNamespace().Result;
                }

                association.AssociationModel.StudentReference.StudentUniqueId = scoring.Student.StudentUniqueId;

                association.AssociationModel.Items = association.AssociationModel.Items.Select(item =>
                {
                    item.AssessmentItemReference.AssessmentIdentifier = association.Assessment.Identifier;

                    if (string.IsNullOrWhiteSpace(item.AssessmentItemReference.NamespaceProperty))
                    {
                        item.AssessmentItemReference.NamespaceProperty = _odsApiSettingsProvider.GetAssessmentNamespace().Result;
                    }

                    return(item);
                }).ToList();

                return(association);
            }).ToList();

            return(scoring);
        }
Esempio n. 2
0
        public async Task <ScoringAssessmentDTO> CreateScoring(ScoringAssessmentDTO scoring)
        {
            var ods = await _odsApiClientProvider.NewResourcesClient();

            scoring = SafeParseForPost(scoring);

            var response = await ods.Post("studentAssessments", scoring.Associations.Last().AssociationModel);

            await ods.HandleHttpResponseGetCreatedResourceId(response);

            return(scoring);
        }
        private async Task <ScoringAssessmentDTO> GetAssessmentScoringsByStudent(StudentDTO student, string assessmentCategoryDescriptor = null)
        {
            var odsApi = await _odsApiClientProvider.NewResourcesClient();

            var studentAssessments = await odsApi.Get <IList <StudentAssessmentv3> >("studentAssessments", new Dictionary <string, string>
            {
                { "studentUniqueId", student.StudentUniqueId },
            });

            var associationDTO = new ScoringAssessmentDTO()
            {
                Student      = student,
                Associations = new List <StudentAssessmentAssociationDTO>(),
            };

            foreach (var studentAssessment in studentAssessments)
            {
                Assessment assessment;

                try
                {
                    assessment = await _assessments.GetByIdentifier(studentAssessment.AssessmentReference.AssessmentIdentifier);
                }
                catch (Exception ex)
                {
                    // Prevent loop from ending
                    continue;
                }

                if (!string.IsNullOrWhiteSpace(assessmentCategoryDescriptor))
                {
                    if (assessment.CategoryDescriptor != assessmentCategoryDescriptor)
                    {
                        continue;
                    }
                }

                associationDTO.Associations = associationDTO.Associations.Append(new StudentAssessmentAssociationDTO
                {
                    Assessment       = assessment,
                    AssociationModel = studentAssessment?.MapToStudentAssessmentv2(),
                });
            }

            return(associationDTO);
        }
        public async Task <ScoringAssessmentDTO> CreateScoring(ScoringAssessmentDTO scoring)
        {
            scoring = SafeParseForPost(scoring);

            var studentAssessmentv3 = scoring
                                      .Associations
                                      .Last()
                                      .AssociationModel
                                      .MapToStudentAssessmentv3();

            var odsApi = await _odsApiClientProvider.NewResourcesClient();

            var response = await odsApi.Post("studentAssessments", studentAssessmentv3);

            await odsApi.HandleHttpResponse(response);

            return(scoring);
        }
 public async Task <ScoringAssessmentDTO> CreateScoring([FromBody] ScoringAssessmentDTO scoring)
 {
     return(await ScoringAssessmentsService.CreateScoring(scoring));
 }