public async Task <IActionResult> Create(PostCreationBindingModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = this.User.Claims
.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)
.Value;
var post = new Post()
{
Title = model.Title,
Body = model.Body,
AuthorId = userId,
DatePosted = DateTime.Now,
CategoryId = int.Parse(model.CategoryId)
};
this.Context.Posts.Add(post);
await this.Context.SaveChangesAsync();
notificactionSender.SendNotification(String.Format(Constants.PostCreatedMessage, post.Title), MessageType.Success, controller: this);
return(Redirect("/home/index"));
}
public Post MapPost(PostCreationBindingModel model, string authorId)
{
var dbPost = this.mapper.Map <Post>(model);
dbPost.AuthorId = authorId;
return(dbPost);
}
public IActionResult Create()
{
var model = new PostCreationBindingModel
{
Categories = GetCategories()
};
return(View(model));
}
public async Task CreatePostAsync(string creatorId, PostCreationBindingModel model)
{
var post = this.Mapper.Map <Post>(model);
post.CreatorId = creatorId;
await this.Context.Posts.AddAsync(post);
this.Context.SaveChanges();
}
public async Task WithModelWithIncorrectSelectedSubredditId_ShouldReturnFalse()
{
var unitOfWork = this.GetRedditCloneUnitOfWork();
var dbUser = new User();
this.AddUserToDatabase(unitOfWork, dbUser);
var model = new PostCreationBindingModel();
var result = await this.CallCreatePostAsync(unitOfWork, model, dbUser.Id);
Assert.False(result);
}
public async Task <Post> AddPostAsync(PostCreationBindingModel model)
{
Validator.EnsureNotNull(model, ValidationConstants.PostDefinedMessage);
Validator.EnsureStringNotNullOrEmpty(model.Content, ValidationConstants.PostContentMessage);
var post = this.Mapper.Map <Post>(model);
await this.DbContext.Posts.AddAsync(post);
await this.DbContext.SaveChangesAsync();
return(post);
}
public async Task WithModelWithoutSelectedSubredditId_ShouldNotAddNewPost()
{
var unitOfWork = this.GetRedditCloneUnitOfWork();
var dbUser = new User();
this.AddUserToDatabase(unitOfWork, dbUser);
var model = new PostCreationBindingModel();
var result = await this.CallCreatePostAsync(unitOfWork, model, dbUser.Id);
var dbPosts = unitOfWork.Posts.GetAll();
Assert.Empty(dbPosts);
}
public async Task <IActionResult> Add(PostCreationBindingModel model)
{
var userId = this.userManager.GetUserId(this.User);
await this.postService.CreatePostAsync(userId, model);
this.TempData.Put("__Message", new MessageModel()
{
Type = MessageType.Info,
Message = "Post created successfully"
});
return(RedirectToPage("/Posts/Index", new { id = model.ThreadInstanceId }));
}
private async Task <bool> CallCreatePostAsync(
IRedditCloneUnitOfWork unitOfWork,
PostCreationBindingModel model,
string userId)
{
var mockedUserManager = CommonTestMethods.GetMockedUserManager();
CommonTestMethods.SetupMockedUserManagerGetUserId(mockedUserManager, userId);
var service = this.GetService(unitOfWork, mockedUserManager.Object);
var mockedClaimsPricipal = new Mock <ClaimsPrincipal>();
var result = await service.CreatePostAsync(mockedClaimsPricipal.Object, model);
return(result);
}
public async Task <IActionResult> Add(int id)
{
var instance = await this.instancesService.GetInstanceAsync(id);
if (instance == null)
{
return(NotFound());
}
var model = new PostCreationBindingModel()
{
ThreadInstanceId = id,
ThreadInstanceName = instance.Name.Substring(2, instance.Name.Length - 2)
};
return(View(model));
}
public async Task <bool> CreatePostAsync(ClaimsPrincipal user, PostCreationBindingModel model)
{
var dbSubreddit = await this.redditCloneUnitOfWork.Subreddits
.GetByIdAsync(model.SelectedSubredditId);
if (dbSubreddit == null)
{
return(false);
}
var dbUserId = this.userManager.GetUserId(user);
var dbPost = this.postMapper.MapPost(model, dbUserId);
redditCloneUnitOfWork.Posts.Add(dbPost);
var rowsAffected = await redditCloneUnitOfWork.CompleteAsync();
return(UnitOfWorkValidator.IsUnitOfWorkCompletedSuccessfully(rowsAffected));
}
public async Task WithUserWithIdAndSelectedSubredditId_ShouldAddNewPostWithCorrectAuthorId()
{
var unitOfWork = this.GetRedditCloneUnitOfWork();
var dbUser = new User();
var dbSubreddit = new Subreddit();
this.AddUserToDatabase(unitOfWork, dbUser);
this.AddSubredditToDatabase(unitOfWork, dbSubreddit);
var model = new PostCreationBindingModel()
{
SelectedSubredditId = dbSubreddit.Id
};
var result = await this.CallCreatePostAsync(unitOfWork, model, dbUser.Id);
var dbPost = await this.GetPostWithByAuthorIdAsync(unitOfWork, dbUser.Id);
Assert.Equal(dbPost.AuthorId, dbUser.Id);
}
public async Task <IActionResult> Create(PostCreationBindingModel model)
{
if (ModelState.IsValid == false)
{
this.AddStatusMessage(ModelState);
return(Redirect("/"));
}
var result = await this.userPostService.CreatePostAsync(this.User, model);
if (result == false)
{
this.AddStatusMessage(AlertConstants.ErrorMessageUnknownError, AlertConstants.AlertTypeDanger);
return(Redirect("/"));
}
this.AddStatusMessage(AlertConstants.MessagePostCreated, AlertConstants.AlertTypeSuccess);
return(Redirect("/"));
}
public PostCreationBindingModel MapPostCreationBindingModel(
IEnumerable <Subreddit> createdSubreddits,
IEnumerable <Subreddit> subscribedSubreddits,
string selectedSubredditId)
{
var model = new PostCreationBindingModel();
var createdSubredditGroupName = ModelsConstants.SelectListGroupNameCreatedSubreddits;
var createdSubredditsSelectListItems
= this.MapSelectListItemsBySubreddits(createdSubreddits, createdSubredditGroupName, selectedSubredditId);
var subscribedSubredditGroupName = ModelsConstants.SelectListGroupNameSubscribedSubreddits;
var subscribedSubredditsSelectListItem
= this.MapSelectListItemsBySubreddits(subscribedSubreddits, subscribedSubredditGroupName, selectedSubredditId);
model.Subreddits.AddRange(createdSubredditsSelectListItems);
model.Subreddits.AddRange(subscribedSubredditsSelectListItem);
model.SelectedSubredditId = selectedSubredditId;
return(model);
}
