public async Task <AssessmentDto> Get(long id)
{
AssessmentDto assessmentDto = null;
var patientRequestDisptacher = CreateAsyncRequestDispatcher();
patientRequestDisptacher.Add(new GetPatientDtoByAssessmentKeyRequest {
AssessmentKey = id
});
var patientResponse = patientRequestDisptacher.Get <GetPatientDtoResponse>();
if (patientResponse != null && patientResponse.DataTransferObject != null &&
_patientAccessControlManager.CanAccessPatient(patientResponse.DataTransferObject.Key))
{
var requestDispatcher = CreateAsyncRequestDispatcher();
requestDispatcher.Add(new GetAssessmentByKeyRequest {
AssessmentKey = id
});
var response = await requestDispatcher.GetAsync <GetAssessmentResponse> ();
assessmentDto = response.DataTransferObject;
}
if (assessmentDto == null)
{
HttpContext.Current.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
return(assessmentDto);
}
public List <AssessmentDto> GetAllAssessment(AssessmentDto input)
{
var query = (from assessment in _context.Assessment.ToList()
join question in _context.Question.ToList()
on assessment.QuestionId equals question.Id
join answer in _context.Answer.ToList()
on assessment.AnswerId equals answer.Id
select new AssessmentDto
{
AnswerName = answer.Answers,
QuestionName = question.Questions,
Id = assessment.Id,
DateCreated = assessment.DateCreated,
Status = assessment.Status,
UserId = assessment.UserId
}).ToList().Skip((input.PagedResultDto.Page - 1) * input.PagedResultDto.SkipCount).Take(input.PagedResultDto.MaxResultCount);
// Map Records
List <AssessmentDto> ratingDto = MappingProfile.MappingConfigurationSetups().Map <List <AssessmentDto> >(query);
//Apply Sort
ratingDto = Sort(input.PagedResultDto.Sort, input.PagedResultDto.SortOrder, ratingDto);
// Apply search
if (!string.IsNullOrEmpty(input.PagedResultDto.Search))
{
ratingDto = ratingDto.Where(p => p.Status != null && p.Status.ToLower().ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.Answers != null && p.Answers.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.DateCreated != null && p.DateCreated.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.AnswerName != null && p.AnswerName.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower()) ||
p.QuestionName != null && p.QuestionName.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower())
).ToList();
}
return(ratingDto);
}
protected virtual async Task Create(AssessmentDto input)
{
Assessment assessment = MappingProfile.MappingConfigurationSetups().Map <Assessment>(input);
_context.Assessment.Add(assessment);
await _context.SaveChangesAsync();
}
public void EditAssessment(AssessmentDto input)
{
_userService.CheckUserPermissions(new List <Enum.RoleType> {
Enum.RoleType.Administrator
});
var userClaim = _userService.UserClaim();
if (input.Id.HasValue)
{
var assessment = _assessmentRepository.FirstOrDefault(t => t.Id == input.Id && t.IsDeleted == false);
if (assessment != null)
{
if (assessment.SchoolYear != input.SchoolYear && _assessmentRepository.Count(t => t.SchoolYear == input.SchoolYear) > 0)
{
throw new UserFriendlyException("学年[" + input.SchoolYear + "]的考核已经存在");
}
assessment.SchoolYear = input.SchoolYear;
assessment.StartTime = input.RangeTime[0].Date;
assessment.EndTime = input.RangeTime[1].Date;
assessment.Deadline = input.Deadline;
assessment.UpdateTime = Clock.Now;
assessment.UpdateUserId = userClaim.UserId;
_assessmentRepository.UpdateAsync(assessment);
}
}
else
{
if (_assessmentRepository.Count(t => t.SchoolYear == input.SchoolYear) > 0)
{
throw new UserFriendlyException("学年[" + input.SchoolYear + "]的考核已经存在");
}
var assessment = new AssessmentEntity
{
Id = Guid.NewGuid(),
CreateUserId = userClaim.UserId,
SchoolYear = input.SchoolYear,
StartTime = input.RangeTime[0].Date,
EndTime = input.RangeTime[1].Date,
Deadline = input.Deadline
};
_assessmentRepository.InsertAsync(assessment);
input.DepartmentList.ForEach(t =>
{
_assessmentDepartmentRepository.InsertAsync(new AssessmentDepartmentEntity
{
Id = Guid.NewGuid(),
CreateUserId = userClaim.UserId,
AssessmentId = assessment.Id,
DepartmentId = t.Id
});
});
}
}
protected virtual async Task Update(AssessmentDto input)
{
var assessment = await _context.Assessment.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (assessment != null)
{
Assessment assessmentDto = MappingProfile.MappingConfigurationSetups().Map <Assessment>(input);
_context.Assessment.Update(assessmentDto);
await _context.SaveChangesAsync();
}
}
public async Task CreateOrEditAssessment(AssessmentDto input)
{
if (input.Id == 0)
{
await Create(input);
}
else
{
await Update(input);
}
}
public async Task <AssessmentDto> AddAssessment(AssessmentDto assessment)
{
var request = new RestRequest(Method.POST);
request.Resource = @"assessments/add";
request.RequestFormat = DataFormat.Json;
request.AddBody(assessment);
var response = await restClient.ExecuteTaskAsync(request);
return(Newtonsoft.Json.JsonConvert.DeserializeObject <AssessmentDto>(response.Content));
}
/// <summary>
/// Reload the assessment in module when new assessment added
/// </summary>
/// <param name="assessmentDto"></param>
private void ReloadAssessment(AssessmentDto assessmentDto)
{
if (assessmentDto.ModuleId == _moduleDto.Id)
{
if (_moduleDto.Assessments == null)
{
_moduleDto.Assessments = new ObservableCollection <AssessmentDto>();
}
_moduleDto.Assessments.Add(assessmentDto);
AssessmentList = _moduleDto.Assessments;
}
}
public async Task <AssessmentDto> GetAssessmentForEdit(AssessmentDto input)
{
var users = await _context.Assessment.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
Assessment answerDto = MappingProfile.MappingConfigurationSetups().Map <Assessment>(input);
_context.Assessment.Update(answerDto);
await _context.SaveChangesAsync();
return(MappingProfile.MappingConfigurationSetups().Map <AssessmentDto>(answerDto));
}
return(new AssessmentDto());
}
private async void okBtn_Click(object sender, System.Windows.RoutedEventArgs e)
{
string assigmentName = assigmentNameText.Text;
double assigmentPrecentage = double.Parse(assigmentPrecentageText.Text);
if ((assigmentPrecentage + _sumofCurrentAssessmentWeight) > 100)
{
MessageBox.Show("Sorry sum of the assessment weight in module cannot be greater than 100");
}
else if (assigmentName.Trim() != string.Empty && assigmentPrecentage > 0)
{
try
{
_sumofCurrentAssessmentWeight += assigmentPrecentage;
AssessmentDto assigmentDto = new AssessmentDto
{
Name = assigmentName,
Weight = assigmentPrecentage,
ModuleId = _moduleId
};
if (SelectedAssigmentType == "Exam")
{
assigmentDto.AssessmentType = Shared.Enum.AssessmentType.EXAM;
}
else
{
assigmentDto.AssessmentType = Shared.Enum.AssessmentType.CourseWork;
}
assigmentDto = await _assessmentController.AddAssesment(assigmentDto);
_eventAggregator.GetEvent <AssessmentLoadEvent>().Publish(assigmentDto);
assigmentNameText.Text = string.Empty;
assigmentPrecentageText.Text = "0";
SelectedAssigmentType = "Exam";
MessageBox.Show("Assessment saved successfully");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
else
{
MessageBox.Show("Please provide valid inputs");
}
}
public async Task <AssessmentDto> AddAssesment(AssessmentDto assigmentDto)
{
return(await httpClient.AddAssessment(assigmentDto));
}
public List <AssessmentDto> GetAllAssessment(AssessmentDto input)
{
return(_unitOfWork.Assessments.GetAllAssessment(input));
}
public async Task GetAssessmentForEdit(AssessmentDto input)
{
await _unitOfWork.Assessments.GetAssessmentForEdit(input);
}
public async Task CreateOrEditAssessment(AssessmentDto input)
{
await _unitOfWork.Assessments.CreateOrEditAssessment(input);
}
