public SubjectsResponse GetAllSubjects(SubjectRequest request)
{
SubjectsResponse response = new SubjectsResponse
{
Subjects =
_repository.GetAll()
.Where(x => x.IsActive == 1)
.Select(b => new BookCategoryView
{
Id = b.Id,
CategoryNameBengali = b.NameB,
CategoryNameEnglish = b.NameE
})
};
var bookCategoryViews = response.Subjects as BookCategoryView[] ?? response.Subjects.ToArray();
response.Initials =
bookCategoryViews.Select(summary => summary.CategoryNameBengali.ToArray()[0].ToString()).ToList();
response.CategoryCount = bookCategoryViews.Count();
if (!string.IsNullOrEmpty(request.SearchString))
{
bookCategoryViews = bookCategoryViews.Where(x => x.CategoryNameBengali.StartsWith(request.SearchString)).ToArray();
}
response.Subjects = bookCategoryViews.Skip(request.Skip).Take(request.Take);
return(response);
}
public ActionResult Put(Guid id, [FromBody] SubjectRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var subject = subjectRepository.Get(id);
if (subject != null)
{
subject.Name = request.Name;
subject.Description = request.Description;
this.subjectRepository.Update(subject);
return(Ok());
//TODO: Add audit info in response
//var response = new UpdateSubjectResponse(subject.Id);
//return Ok(response);
}
return(NotFound());
}
catch (Exception e)
{
return(GenericServerErrorResult(e));
}
}
public ActionResult <NewRecordResponse> Post([FromBody] SubjectRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var subject = new Subject
{
Name = request.Name,
Description = request.Description
};
this.subjectRepository.Create(subject);
var response = new NewRecordResponse(subject.Id);
return(CreatedAtAction(nameof(Get), new { id = subject.Id }, response));
}
catch (Exception e)
{
return(GenericServerErrorResult(e));
}
}
public async Task <ActionResult <Subject> > PutStudent(string id, [FromBody] SubjectRequest subject)
{
var students = (await _repository.GetSubject(id)).Students;
await _repository.DeleteSubject(id);
await _repository.AddSubject(new Subject(subject.Id, subject.Name, students));
return(Ok(new Subject(subject.Id, subject.Name, students)));
}
public async Task <ActionResult <Subject> > Create(SubjectRequest subject)
{
var result = await _subjects.Create(subject, HttpContext.RequestAborted);
if (result == null)
{
return(Conflict());
}
return(result);
}
public async Task <IActionResult> CreateSubject([FromBody] SubjectRequest request)
{
Subject model = _mapper.Map <Subject>(request);
IOperationResult <Subject> operationResult = await _subjectsManager.CreateSubject(model);
if (!operationResult.Success)
{
return(BadRequest(operationResult.Message));
}
var response = _mapper.Map <SubjectResponse>(operationResult.Entity);
return(Ok(response));
}
private bool IsValidNewSubject(SubjectRequest request, ref string message)
{
if (string.IsNullOrEmpty(request.Title))
{
message = "subject title cannot be empty.";
return(false);
}
if (CheckIfNewSubjectAlreadyExist(request.Title))
{
message = "subject already exists.";
return(false);
}
return(true);
}
// adds new subject to Subject table if validation is passed
public async Task ApproveNewSubjectRequest(int requestID)
{
SubjectRequest subjectRequest = await GetSubjectRequestByID(requestID);
string message = "added";
if (IsValidNewSubject(subjectRequest, ref message))
{
AddNewSubject(subjectRequest.Title);
await DenyNewSubjectRequest(subjectRequest.ID);
}
else
{
throw new ArgumentException("request cannot be approved: " + message);
}
}
void Verify()
{
var serializer = new ConfigurationContainer().ConfigureType <SubjectRequest>()
.Member(x => x.SomeInterface)
.Name("YourName")
.EnableImplicitTypingFromNested <Issue186Tests>()
.Create()
.ForTesting();
var request = new SubjectRequest {
SomeInterface = new Subject2 {
Message = "message1", Message2 = "message2"
}
};
var serialize = serializer.Serialize(request);
serialize.Should()
.Be(@"<?xml version=""1.0"" encoding=""utf-8""?><Issue186Tests-SubjectRequest><YourName xmlns:exs=""https://extendedxmlserializer.github.io/v2"" exs:type=""Issue186Tests-Subject2""><Message>message1</Message><Message2>message2</Message2></YourName></Issue186Tests-SubjectRequest>");
}
public async Task <ActionResult <Subject> > Update(Guid id, [CustomizeValidator(RuleSet = "Update")] SubjectRequest subject)
{
var currentUser = HttpContext.GetUser();
var currentSubject = await _subjects.Get(id, HttpContext.RequestAborted);
if (currentSubject == null)
{
return(NotFound());
}
if (!await _authorization.HasWriteAccess(currentUser, currentSubject, HttpContext.RequestAborted))
{
return(Unauthorized());
}
var result = await _subjects.Update(id, subject, HttpContext.RequestAborted);
if (result == null)
{
return(Conflict());
}
return(result);
}
public async Task Update_Subject_Or_409(Mock <ISubjectService> service, Mock <IAuthorizationService> authorization, SubjectRequest validRequest, SubjectRequest invalidRequest, Subject valid, Subject invalid, User user)
{
authorization.Setup(x => x.HasWriteAccess(user, It.IsAny <It.IsAnyType>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
service.Setup(x => x.Exists(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
service.Setup(x => x.Get(valid.Id, It.IsAny <CancellationToken>())).ReturnsAsync(valid);
service.Setup(x => x.Get(invalid.Id, It.IsAny <CancellationToken>())).ReturnsAsync(invalid);
service.Setup(x => x.Update(valid.Id, validRequest, It.IsAny <CancellationToken>())).ReturnsAsync(valid);
service.Setup(x => x.Update(invalid.Id, invalidRequest, It.IsAny <CancellationToken>())).ReturnsAsync((Subject)null);
var controller = TestSetup.SetupController <SubjectsController>(service.Object, authorization.Object).SetupSession(user);
var goodResult = await controller.Update(valid.Id, validRequest);
var invalidResult = await controller.Update(invalid.Id, invalidRequest);
goodResult.Value.Should().BeEquivalentTo(valid);
invalidResult.Value.Should().BeNull();
invalidResult.Result.Should().BeOfType <ConflictResult>();
}
public async Task Create_Subject_Or_409(Mock <ISubjectService> service, IAuthorizationService authorization, SubjectRequest request, Subject subject, User user)
{
service.Setup(x => x.Create(request, It.IsAny <CancellationToken>())).ReturnsAsync(subject);
service.Setup(x => x.Create(null, It.IsAny <CancellationToken>())).ReturnsAsync((Subject)null);
var controller = TestSetup.SetupController <SubjectsController>(service.Object, authorization).SetupSession(user);
var goodResult = await controller.Create(request);
var invalidResult = await controller.Create(null);
goodResult.Value.Should().NotBeNull();
invalidResult.Value.Should().BeNull();
invalidResult.Result.Should().BeOfType <ConflictResult>();
}
public async Task <ActionResult <Subject> > PostSubject([FromBody] SubjectRequest subject)
{
await _repository.AddSubject(new Subject(subject.Id, subject.Name, new List <StudentDomain>()));
return(Created(Request.Path.Value + "/" + subject.Id, subject));
}
public void Post([FromBody] SubjectRequest request)
{
}
