public void AddPageShouldAddPage()
{
var page = new PageInputModel()
{
DiaryId = 1,
User = "******",
Content = null,
CreatedOn = DateTime.UtcNow,
Title = "TitleTests"
};
var pageService = new Mock <IPageService>();
var controller = new Web.Controllers.PagesController(pageService.Object);
var result = controller.AddPage(page);
int diaryId = page.DiaryId;
string redirectActionName = "Details";
string controlerToRedirectTo = "Diaries";
result.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be(redirectActionName);
result.Should().BeOfType <RedirectToActionResult>().Which.ControllerName.Should().Be(controlerToRedirectTo);
result.Should().BeOfType <RedirectToActionResult>()
.Which.RouteValues.Values.Count
.Should().Be(1).And.Subject
.Should().Be(diaryId);
}
public void AddPageShouldAddNewPageToDiary()
{
//arrange
var user = new GetShreddedUser
{
Id = "UserId",
UserName = "******",
};
var diary = new GetShreddedDiary
{
Id = 1,
User = user,
Summary = "Summary",
Title = "Title",
UserId = "UserId",
};
var page = new Page
{
Id = 2,
Content = "Content",
UserId = user.Id,
GetShreddedUser = user,
GetShreddedDiary = diary,
GetShreddedDiaryId = diary.Id,
Title = "Title",
CreatedOn = DateTime.UtcNow
};
var newPage = new PageInputModel
{
User = user.UserName,
Content = "Some New Content",
CreatedOn = DateTime.Now,
DiaryId = diary.Id,
Title = "New Page"
};
userManager.CreateAsync(user).GetAwaiter();
this.Context.Pages.Add(page);
this.Context.GetShreddedDiaries.Add(diary);
this.Context.SaveChanges();
//act
this.pageService.AddPage(newPage);
//assert
var result = this.Context.Pages.OrderBy(x => x.CreatedOn).Last(x => x.GetShreddedDiaryId == diary.Id);
result.Should().NotBeNull()
.And.Subject.As <Page>()
.Title.Should().BeSameAs(newPage.Title);
}
public IActionResult AddPage(PageInputModel inputModel)
{
if (!ModelState.IsValid)
{
this.ViewData[GlobalConstants.PageLength] = inputModel.Content?.Length ?? 0;
this.ViewData[GlobalConstants.DiaryId] = inputModel.DiaryId;
return(this.View(inputModel));
}
this.PageService.AddPage(inputModel);
return(RedirectToAction("Details", "Diaries", new { id = inputModel.DiaryId }));
}
public Task <ActionResult <IEnumerable <AssignmentViewModel> > > GetAsync([FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <AssignmentViewModel> >(async() =>
{
var assignments = await _assignmentsRepository.GetPageDescendingAsync(
skip: inputModel?.Skip,
take: inputModel?.Take
);
if (!assignments.Any())
{
return(NoContent());
}
return(Ok(assignments.Select(a => (AssignmentViewModel)a)));
});
// TODO timeframe
public Task <ActionResult <IEnumerable <PostViewModel> > > GetPostsAsync([FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <PostViewModel> >(async() =>
{
var skip = inputModel?.Skip ?? PaginationDefaults.DefaultSkip;
var take = inputModel?.Take ?? PaginationDefaults.DefaultTake;
var posts = await _postsRepository.GetPageAsync(p => true, p => p.Rating, p => p.Include(e => e.User), skip, take);
if (!posts.Any())
{
return(NoContent());
}
return(Ok(posts.Select(p => (PostViewModel)p)));
});
public Task <ActionResult <IEnumerable <UserViewModel> > > GetUsersAsync([FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <UserViewModel> >(async() =>
{
var skip = inputModel?.Skip ?? PaginationDefaults.DefaultSkip;
var take = inputModel?.Take ?? PaginationDefaults.DefaultTake;
var users = await _usersRepository.GetPageAsync(skip, take);
if (!users.Any())
{
return(NoContent());
}
return(Ok(users.Select(u => (UserViewModel)u)));
});
public void AddPage(PageInputModel inputModel)
{
var user = this.UserManager.FindByNameAsync(inputModel.User).GetAwaiter().GetResult();
var page = Mapper.Map <Page>(inputModel);
page.UserId = user.Id;
var diary = this.Context.GetShreddedDiaries.Find(inputModel.DiaryId);
diary.LastEditedOn = inputModel.CreatedOn;
this.Context.GetShreddedDiaries.Update(diary);
this.Context.Pages.Add(page);
this.Context.SaveChanges();
this.NotificationService.AddNotification(inputModel.DiaryId, inputModel.User, diary.Title);
}
public async Task <bool> EditPage(PageInputModel pageInput)
{
var page = this.db.SitePages.FirstOrDefault(x => x.Id == pageInput.Id);
page.Title = pageInput.Title;
page.Content = pageInput.Content;
page.ImageUrl = pageInput.ImageUrl;
page.ModifiedOn = DateTime.UtcNow;
int result = await this.db.SaveChangesAsync();
if (!(result == 0))
{
return(false);
}
return(true);
}
public Task <ActionResult <IEnumerable <EventViewModel> > > GetAsync([FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <EventViewModel> >(async() =>
{
var events = await _eventsRepository.GetPageDescendingAsync(
includes: e => e
.Include(r => r.Attendees)
.ThenInclude(a => a.User),
skip: inputModel?.Skip,
take: inputModel?.Take
);
if (!events.Any())
{
return(NoContent());
}
return(Ok(events.Select(e => (EventViewModel)e)));
});
public void AddPageShouldReturnErrorAddPage()
{
var page = new PageInputModel()
{
DiaryId = 1,
User = "******",
Content = null,
CreatedOn = DateTime.UtcNow,
Title = "TitleTests"
};
var pageService = new Mock <IPageService>();
var controller = new Web.Controllers.PagesController(pageService.Object);
controller.ModelState.AddModelError("Content", "StringLength");
var result = controller.AddPage(page);
result.Should().BeOfType <ViewResult>().Which.Model.Should().BeOfType <PageInputModel>();
}
public Task <ActionResult <IEnumerable <ClassViewModel> > > GetAsync([FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <ClassViewModel> >(async() =>
{
var classes = await _classesRepository.GetPageDescendingAsync(
includes: c => c
.Include(r => r.Assignments)
.Include(r => r.SchoolYear)
.Include(r => r.Students)
.ThenInclude(s => s.Attendance)
.Include(r => r.Subject)
.Include(r => r.Teacher),
skip: inputModel?.Skip,
take: inputModel?.Take
);
if (!classes.Any())
{
return(NoContent());
}
return(Ok(classes.Select(c => (ClassViewModel)c)));
});
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
var isAuthorize = User.IsInRole(Constants.AdministratorRole);
if (!isAuthorize)
{
return(new ChallengeResult());
}
var pageResult = await RedisplayPage(id.Value);
var user = await _context.FindUserByWorkerIdAsync(id.Value);
if (WorkerCrossPageData == null || user == null)
{
return(NotFound());
}
var roles = await _userManager.GetRolesAsync(user);
InputModel = new PageInputModel
{
Email = user.Email,
WorkerId = id.Value,
Role = roles.Count == 0 ? string.Empty : roles[0],
};
InputModel.WorkerId = WorkerCrossPageData.WorkerID;
return(pageResult);
}
public Task <ActionResult <IEnumerable <PostViewModel> > > GetPostsAsync(Guid id, [FromQuery] PageInputModel inputModel = null)
=> ExecuteAsync <IEnumerable <PostViewModel> >(async() =>
{
var skip = inputModel?.Skip ?? PaginationDefaults.DefaultSkip;
var take = inputModel?.Take ?? PaginationDefaults.DefaultTake;
var posts = await _postsRepository.GetPageDescendingAsync(p => p.UserId == id, p => p.CreatedAt, skip, take);
if (!posts.Any())
{
return(NoContent());
}
return(Ok(posts.Select(p => (PostViewModel)p)));
});
