public IUserSubredditService GetService(IRedditCloneUnitOfWork unitOfWork, UserManager <User> userManager)
{
var mapper = CommonTestMethods.GetAutoMapper();
var service = new UserSubredditService(unitOfWork, mapper, userManager);
return(service);
}
public IUserCommentService GetService(IRedditCloneUnitOfWork unitOfWork, UserManager <User> userManager)
{
var commentMapper = new CommentMapper();
var service = new UserCommentService(unitOfWork, userManager, commentMapper);
return(service);
}
public IUserAccountService GetService(IRedditCloneUnitOfWork unitOfWork)
{
var mapper = CommonTestMethods.GetAutoMapper();
var service = new UserAccountService(unitOfWork, mapper);
return(service);
}
public IQuestSubredditService GetService(IRedditCloneUnitOfWork unitOfWork)
{
var autoMapper = CommonTestMethods.GetAutoMapper();
var service = new QuestSubredditService(unitOfWork, autoMapper);
return(service);
}
internal IUserVotePostService GetService(IRedditCloneUnitOfWork unitOfWork, string userId)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
CommonTestMethods.SetupMockedUserManagerGetUserId(mockedUserManager, userId);
var service = this.GetService(unitOfWork, mockedUserManager.Object);
return(service);
}
public IQuestPostService GetService(IRedditCloneUnitOfWork unitOfWork)
{
var cookieSerive = new Mock <ICookieService>().Object;
var autoMapper = CommonTestMethods.GetAutoMapper();
var postMapper = new PostMapper(autoMapper);
var service = new QuestPostService(unitOfWork, cookieSerive, postMapper);
return(service);
}
public UserCommentService(
IRedditCloneUnitOfWork unitOfWork,
UserManager <User> userManager,
ICommentMapper commentMapper)
{
this.unitOfWork = unitOfWork;
this.userManager = userManager;
this.commentMapper = commentMapper;
}
public QuestPostService(
IRedditCloneUnitOfWork redditCloneUnitOfWork,
ICookieService cookieService,
IPostMapper postMapper)
{
this.redditCloneUnitOfWork = redditCloneUnitOfWork;
this.cookieService = cookieService;
this.postMapper = postMapper;
}
public UserSubredditService(
IRedditCloneUnitOfWork redditCloneUnitOfWork,
IMapper mapper,
UserManager <User> userManager)
{
this.redditCloneUnitOfWork = redditCloneUnitOfWork;
this.mapper = mapper;
this.userManager = userManager;
}
private async Task <PostsViewModel> CallGetOrderedPostsAsync(IRedditCloneUnitOfWork unitOfWork)
{
var service = this.GetService(unitOfWork);
var requestCookieCollection = new Mock <IRequestCookieCollection>().Object;
var model = await service.GetOrderedPostsAsync(requestCookieCollection);
return(model);
}
private async Task <bool> CallAddResponseToCommentAsync(IRedditCloneUnitOfWork unitOfWork, CommentBindingModel model)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var claimsPrincipal = new Mock <ClaimsPrincipal>().Object;
var result = await service.AddResponseToCommentAsync(claimsPrincipal, model);
return(result);
}
public UserPostService(
IRedditCloneUnitOfWork redditCloneUnitOfWork,
UserManager <User> userManager,
ICookieService cookieService,
IPostMapper postMapper)
{
this.redditCloneUnitOfWork = redditCloneUnitOfWork;
this.userManager = userManager;
this.cookieService = cookieService;
this.postMapper = postMapper;
}
private async Task <bool> CallCreateSubredditAsync(
IRedditCloneUnitOfWork unitOfWork,
SubredditCreationBindingModel model)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
var mockedClaimsPrincipal = new Mock <ClaimsPrincipal>();
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var result = await service.CreateSubredditAsync(model, mockedClaimsPrincipal.Object);
return(result);
}
private async Task <PostViewModel> CallGetPostWithOrderedCommentsAsync(
IRedditCloneUnitOfWork unitOfWork, string postId)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var claimsPrincipal = new Mock <ClaimsPrincipal>().Object;
var mockedRequestCookies = new Mock <IRequestCookieCollection>();
var model = await service.GetPostWithOrderedCommentsAsync(claimsPrincipal, postId, mockedRequestCookies.Object);
return(model);
}
private async Task <PostCreationBindingModel> CallPrepareModelForCreatingAsync(
IRedditCloneUnitOfWork unitOfWork,
User user,
string subredditId)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
CommonTestMethods.SetupMockedUserManagerGetUserId(mockedUserManager, user.Id);
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var mockedClaimsPrincipal = new Mock <ClaimsPrincipal>();
var model = await service.PrepareModelForCreatingAsync(mockedClaimsPrincipal.Object, subredditId);
return(model);
}
public static ISubredditSortStrategy GetSubredditSortStrategy(
IRedditCloneUnitOfWork unitOfWork,
SubredditSortType postSortType)
{
switch (postSortType)
{
case SubredditSortType.New:
return(new SortSubredditByNew(unitOfWork));
case SubredditSortType.Old:
return(new SortSubredditByOld(unitOfWork));
case SubredditSortType.Top:
return(new SortSubredditByTop(unitOfWork));
default:
throw new InvalidEnumArgumentException();
}
}
private async Task <PostsViewModel> CallGetOrderedPostsAsyncWithUser(IRedditCloneUnitOfWork unitOfWork, User user)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
mockedUserManager.Setup(um => um.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns(user.Id);
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var claimsPricipal = new Mock <ClaimsPrincipal>().Object;
var requestCookieCollection = new Mock <IRequestCookieCollection>().Object;
var responseCookies = new Mock <IResponseCookies>().Object;
var model = await service.GetOrderedPostsAsync(
claimsPricipal,
requestCookieCollection,
responseCookies);
return(model);
}
public static ISortPostsStrategy GetSortPostsStrategy(
IRedditCloneUnitOfWork unitOfWork,
TimeSpan timeFrame,
PostSortType postSortType)
{
switch (postSortType)
{
case PostSortType.New:
return(new SortPostsByNew(unitOfWork));
case PostSortType.Top:
return(new SortPostsByTop(unitOfWork, timeFrame));
case PostSortType.Controversial:
return(new SortPostsByControversial(unitOfWork, timeFrame));
case PostSortType.Best:
return(new SortPostsByBest(unitOfWork));
default:
throw new InvalidEnumArgumentException();
}
}
public static ISortCommentsStrategy GetSortPostsStrategy(
IRedditCloneUnitOfWork unitOfWork, CommentSortType sortType)
{
switch (sortType)
{
case CommentSortType.New:
return(new SortCommentsByNew(unitOfWork));
case CommentSortType.Old:
return(new SortCommentsByOld(unitOfWork));
case CommentSortType.Top:
return(new SortCommentsByTop(unitOfWork));
case CommentSortType.Controversial:
return(new SortCommentsByControversial(unitOfWork));
case CommentSortType.Best:
return(new SortCommentsByBest(unitOfWork));
default:
throw new InvalidEnumArgumentException();
}
}
public SortCommentsByNew(IRedditCloneUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
}
private async Task <Post> GetPostWithByAuthorIdAsync(IRedditCloneUnitOfWork unitOfWork, string authorId)
{
var dbPosts = await unitOfWork.Posts.FindAsync(p => p.AuthorId == authorId);
return(dbPosts.First());
}
private void AddSubredditToDatabase(IRedditCloneUnitOfWork unitOfWork, Subreddit subreddit)
{
unitOfWork.Subreddits.Add(subreddit);
unitOfWork.Complete();
}
private void AddUserToDatabase(IRedditCloneUnitOfWork unitOfWork, User user)
{
unitOfWork.Users.Add(user);
unitOfWork.Complete();
}
public QuestSubredditService(IRedditCloneUnitOfWork redditCloneUnitOfWork, IMapper mapper)
{
this.redditCloneUnitOfWork = redditCloneUnitOfWork;
this.mapper = mapper;
}
internal void AddEnitytiesToUnitOfWork(IRedditCloneUnitOfWork unitOfWork, User user, Post post)
{
unitOfWork.Users.Add(user);
unitOfWork.Posts.Add(post);
unitOfWork.Complete();
}
private void AddPostsToUnitOfWork(IRedditCloneUnitOfWork unitOfWork, params Post[] posts)
{
unitOfWork.Posts.AddRange(posts);
unitOfWork.Complete();
}
private void AddEntitiesToUnitOfWork(IRedditCloneUnitOfWork unitOfWork, Post post, User user)
{
unitOfWork.Posts.Add(post);
unitOfWork.Users.Add(user);
unitOfWork.Complete();
}
public IUserVotePostService GetService(IRedditCloneUnitOfWork unitOfWork, UserManager <User> userManager)
{
var service = new UserVotePostService(unitOfWork, userManager);
return(service);
}
internal void AddEnitytiesToUnitOfWork(IRedditCloneUnitOfWork unitOfWork, User user, Post post, VotePost votePost)
{
this.AddEnitytiesToUnitOfWork(unitOfWork, user, post);
unitOfWork.VotePostRepository.Add(votePost);
unitOfWork.Complete();
}
public SortSubredditByNew(IRedditCloneUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
}
