public ExamResponse GetAllIndexResult(ExamRequest request, StringComparison comparisonType)
{
if (string.IsNullOrEmpty(request.Text))
{
throw new ArgumentNullException("Text is empty");
}
if (string.IsNullOrEmpty(request.Subtext))
{
throw new ArgumentNullException("Subtext is empty");
}
if (request.Subtext.Length > request.Text.Length)
{
throw new ArgumentNullException("Subtext is longer than text");
}
IList <int> resultIndex = new List <int>();
int index = request.Text.IndexOf(request.Subtext, comparisonType);
while (index != -1)
{
resultIndex.Add(index);
index = request.Text.IndexOf(request.Subtext, index + 1, comparisonType);
}
return(new ExamResponse {
Result = string.Join(",", resultIndex)
});
}
public static Exam ProjectTo(this ExamRequest request, IMapper mapper)
{
Exam ex = mapper.Map <Exam>(request);
ex.DateCreated = DateTime.Now;
return(ex);
}
public async Task <ExamRequest> SaveAsync <V>(int userId, ExamRequest examRequest) where V : AbstractValidator <ExamRequest>
{
var currentUser = await _userService.FindByIdAsync(userId);
if (currentUser.Medic == null)
{
Notify("Current user doesn't have permission to peform a exam request");
return(null);
}
Patient patient = await _patientService.FindByIdAsync(examRequest.Patient.Id);
if (patient == null)
{
Notify("Unable to find patient to peform a exam request");
return(null);
}
examRequest.Patient = patient;
examRequest.MedicId = currentUser.Medic.Id;
examRequest.PatientId = patient.Id;
examRequest.Medic = currentUser.Medic;
if (!Validate(Activator.CreateInstance <ExamRequestValidator>(), examRequest))
{
return(null);
}
await _examRequestRepository.InsertAsync(examRequest);
await _unitOfWork.CompleteAsync();
return(examRequest);
}
[InlineData("sample", "SampleMe")] // text length greater than subtext
public void StringSearch_ThrowsArgumentException(string valueText, string valueSubtext)
{
var request = new ExamRequest {
Text = valueText, Subtext = valueSubtext
};
var service = ServiceGenerator.GetService();
Assert.Throws <ArgumentNullException>(() => service.GetAllIndexResult(request, StringComparison.OrdinalIgnoreCase));
}
public IActionResult Update([FromBody] ExamRequest examRequest)
{
Exam exam = Mapper.Map <Exam>(examRequest);
Exam updated = _examManager.UpdateExam(exam);
ExamResponse response = Mapper.Map <Exam, ExamResponse>(updated);
return(Ok(response));
}
public void Post_ReturnsOk()
{
var req = new ExamRequest();
var mockService = MockServiceGenerator.GetMockTextService();
var controller = ControllerGenerator.GetTextController(mockService.Object);
var response = controller.Post(req);
var result = response as OkObjectResult;
Assert.NotNull(result);
Assert.Equal(200, result.StatusCode);
}
public void StringSearch_ReturnsListInt(string valueText, string valueSubtext, string valueResult)
{
var service = ServiceGenerator.GetService();
var request = new ExamRequest {
Text = valueText, Subtext = valueSubtext
};
var result = service.GetAllIndexResult(request, StringComparison.OrdinalIgnoreCase);
Assert.NotNull(result);
Assert.Equal(result.Result, valueResult);
}
public async override Task AddAsync(object request)
{
if (!(request is ExamRequest))
{
throw new Exception("Convert type not allowed");
}
ExamRequest rq = (ExamRequest)request;
var ex = rq.ProjectTo(_mapper);
await _repository.AddOrUpdateAsync(ex);
}
public object CreateEr(ExamRequest er)
{
var exam = uow.ExamRepository.Get(e => e.id == er.examId, includeProperties: "Requests").FirstOrDefault();
if (exam != null)
{
er.dateApplied = DateTime.UtcNow;
exam.Requests.Add(er);
uow.Save();
}
return(GetUIObject(exam));
}
public void Post_ModelStateInvalid_ReturnsBadRequest()
{
var req = new ExamRequest();
var mockService = MockServiceGenerator.GetMockTextService();
var controller = ControllerGenerator.GetTextController(mockService.Object);
controller.ModelState.AddModelError("key", "error message");
var response = controller.Post(req);
var result = response as BadRequestObjectResult;
Assert.NotNull(result);
Assert.Equal(400, result.StatusCode);
}
public void Post_ArgumentException_ReturnsBadRequest()
{
var req = new ExamRequest();
var mockService = MockServiceGenerator.GetMockTextService();
var controller = ControllerGenerator.GetTextController(mockService.Object);
mockService.Setup(i => i.GetAllIndexResult(It.IsAny <ExamRequest>(), StringComparison.OrdinalIgnoreCase))
.Throws <ArgumentException>();
var response = controller.Post(req);
var result = response as BadRequestObjectResult;
Assert.NotNull(result);
Assert.Equal(400, result.StatusCode);
}
public IActionResult Create(ExamRequest examRequest)
{
Exam exam = Mapper.Map <Exam>(examRequest);
Exam examResult = _examManager.AddExam(exam);
if (examResult == null)
{
return(BadRequest());
}
ExamResponse response = Mapper.Map <ExamResponse>(examResult);
return(Ok(response));
}
public object UpdateEr(ExamRequest er)
{
var exam = uow.ExamRepository.Get(e => e.id == er.examId, includeProperties: "Requests").FirstOrDefault();
if (exam != null)
{
var req = exam.Requests.FirstOrDefault(re => re.requestId == er.requestId);
if (req != null)
{
uow.CopyValues(req, er);
}
uow.Save();
}
return(GetUIObject(exam));
}
public async Task <IActionResult> AddExamAsync([FromBody] ExamRequest examRequest)
{
ExamResponse examResponse = new ExamResponse();
try
{
User user = await examRequest.GetRequestedUserAsync(_dbContext);
Exam exam = examRequest.Exam;
exam.Marks = 0F;
exam.LecturerUserId = user.Id;
if (exam.Questions != null)
{
foreach (Question q in exam.Questions)
{
if (q == null)
{
continue;
}
exam.Marks += q.Marks;
}
}
await _dbContext.Exams.AddAsync(exam);
await _dbContext.SaveChangesAsync();
examResponse.Exams = new List <Exam>()
{
await _dbContext.Exams
.Include(e => e.LecturerUser)
.Include(e => e.Questions)
.SingleOrDefaultAsync(e => e.Id == exam.Id)
};
examResponse.IsSuccess = true;
}
catch (Exception ex)
{
examResponse.Message = ex.Message;
}
return(StatusCode(examResponse.Status, examResponse));
}
public async Task <IActionResult> UpdateExamAsync([FromBody] ExamRequest examRequest)
{
ExamResponse examResponse = new ExamResponse();
try
{
User user = await examRequest.GetRequestedUserAsync(_dbContext);
Exam updatedExam = examRequest.Exam;
updatedExam.LecturerUserId = user.Id;
Exam exam = await _dbContext.Exams
.FirstOrDefaultAsync(e => e.Id == updatedExam.Id);
if (exam == null)
{
throw new Exception("Exam not found");
}
exam.Name = updatedExam.Name;
exam.Description = updatedExam.Description;
exam.GivenTimeSeconds = updatedExam.GivenTimeSeconds;
exam.IsPublish = updatedExam.IsPublish;
exam.EffectiveDateTime = updatedExam.EffectiveDateTime;
exam.ExpireDateTime = updatedExam.ExpireDateTime;
await _dbContext.SaveChangesAsync();
examResponse.Exams = new List <Exam>()
{
await _dbContext.Exams
.Include(e => e.LecturerUser)
.Include(e => e.Questions)
.SingleOrDefaultAsync(e => e.Id == exam.Id)
};
examResponse.IsSuccess = true;
}
catch (Exception ex)
{
examResponse.Message = ex.Message;
}
return(StatusCode(examResponse.Status, examResponse));
}
public async override Task UpdateAsync(object request)
{
if (!(request is ExamRequest))
{
throw new Exception("Convert type not allowed");
}
ExamRequest req = (ExamRequest)request;
Exam ex = await _repository.GetByIdAsync(req.Id);
if (ex == null)
{
throw new Exception("Exam not found");
}
req.ProjectTo(ex);
await _repository.AddOrUpdateAsync(ex);
}
public async Task <IActionResult> Delete(int examRequestId)
{
var userId = HttpContext.User.Claims.First()?.Value;
try
{
ExamRequest examRequest = await _examRequestService.DeleteAsync(int.Parse(userId), examRequestId);
if (examRequest == null)
{
return(CustomResponse(statusCode: StatusCodes.Status404NotFound));
}
return(Ok());
}
catch (Exception e)
{
return(Unauthorized(e.Message));
}
}
public async Task <IHttpActionResult> UpdateExam([FromBody] ExamRequest request)
{
try
{
if (ModelState.IsValid)
{
await _service.UpdateAsync(request);
await _service.CommitAsync();
return(Ok());
}
return(BadRequest(ModelState));
}
catch (Exception ex)
{
await _service.RollbackAsync();
return(BadRequest(GetError(ex)));
}
}
public async Task <ExamRequest> DeleteAsync(int userId, int examRequestId)
{
var currentUser = await _userService.FindByIdAsync(userId);
if (currentUser.Medic == null)
{
throw new UnauthorizedAccessException("Apenas médicos podem cancelar pedidos de exames");
}
ExamRequest examRequest = await FindByIdAsync(examRequestId);
if (examRequest == null)
{
Notify($"Unable to locate Exam with current ID {examRequestId}");
return(null);
}
await _examRequestRepository.RemoveAsync(examRequest.Id);
await _unitOfWork.CompleteAsync();
return(examRequest);
}
public async Task <ExamRequest> SaveAsync <V>(ExamRequest examRequest) where V : AbstractValidator <ExamRequest>
{
await _examRequestRepository.InsertAsync(examRequest);
return(examRequest);
}
public static void ProjectTo(this ExamRequest request, Exam exam)
{
exam.Name = request.Name;
}
public void CreateExamRequest(ExamRequest examRequest)
{
this._examRequests.Add(examRequest);
this._examRequests.SaveChanges();
}
public object Apply(int examId)
{
var userid = CurrentUser.id;
var exam = uow.ExamRepository.Get(e => e.id == examId, includeProperties: "Requests").FirstOrDefault();
if (exam != null)
{
var existing = uow.ExamRepository.Get(e => e.Requests.Any(r => r.Request.statusId != RequestStatus.PassedExam && r.Request.courseId == exam.courseId &&
r.Request.createdById == userid && (r.dateCancelled == null || r.dateApplied > r.dateCancelled)),
includeProperties: "Requests.Request").ToList();
if (existing.Count > 0 && existing.Count(e => e.id != examId) > 0)
{
return(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, Content = new StringContent("Već ste prijavljeni na drugi ispit iz ovog predmeta.")
});
}
var request = uow.RequestRepository.Get(r => r.createdById == CurrentUser.id && r.courseId == exam.courseId && r.statusId == RequestStatus.CodeApprovedPendingExam, includeProperties: "Course").FirstOrDefault();
if (request != null)
{
request.statusId = RequestStatus.ExamTimeSlotDecided;
var er = exam.Requests.FirstOrDefault(r => r.requestId == request.id);
if (er == null)
{
er = new ExamRequest {
examId = examId, requestId = request.id, dateApplied = DateTime.UtcNow
};
exam.Requests.Add(er);
}
else
{
er.dateApplied = DateTime.UtcNow;
}
var log = new RequestLog
{
createdById = CurrentUser.id,
dateCreated = DateTime.UtcNow,
requestId = request.id,
requestStatusId = request.statusId,
Description = $"Korisnik {CurrentUser.name} {CurrentUser.surname} je prijavio obranu iz predmeta {request.Course.name}. Datum obrane: {Utilities.GetUserTime(exam.examDateTime)?.ToString("dd.MM.yyyy HH:mm")}",
requestChanged = true
};
uow.RequestLogRepository.Insert(log);
uow.Save();
uow.RequestRepository.LoadReference(request, "Status");
request.examDateTime = exam.examDateTime;
log.CreatedBy = CurrentUser;
log.Request = request;
SendMailForRequest(request, $"Prijavljena obrana - {CurrentUser.name} {CurrentUser.surname} - {request.Course.shortname}",
log.Description);
return(new
{
exam = GetUIObject(exam),
log = RequestController.GetLogUIObject(log)
});
}
}
return(null);
}
public async Task <ExamRequest> UpdateAsync <V>(ExamRequest examRequest) where V : AbstractValidator <ExamRequest>
{
var existingExamRequest = await _examRequestRepository.FindByIdAsync(examRequest.Id);
return(_examRequestRepository.Update(examRequest));
}
