public TeamDetailModel RemovePost(TeamDetailModel teamModel, PostDetailModel postModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
var teamEntity = dbContext.Teams
.Include(p => p.Posts)?
.ThenInclude(c => c.Comments)
.ThenInclude(a => a.Author)
.Include(m => m.Members)
.ThenInclude(u => u.User)
.First(t => t.Id == teamModel.Id);
var postEntity = dbContext.Posts
.Include(a => a.Author)
.Include(c => c.Comments)
.ThenInclude(a => a.Author)
.First(p => p.Id == postModel.Id);
teamEntity.Posts.Remove(postEntity);
dbContext.SaveChanges();
return(TeamMapper.MapToDetailModel(teamEntity));
}
}
private void AddNewPost()
{
try
{
var team = _teamRepository.GetById(SelectedTeam.Id);
}
catch
{
Title = "";
Content = "";
return;
}
var newPost = new PostDetailModel();
newPost.Title = Title;
newPost.Content = Content;
var returnedPost = _postRepository.Create(newPost, CurrentUser);
_teamRepository.AddPost(SelectedTeam, returnedPost);
Title = "";
Content = "";
_mediator.Send(new PostsUpdatedMessage {
post = returnedPost
});
}
public void UpdateCommentContent_Test()
{
//Arrange
var postDetailModel = new PostDetailModel()
{
Title = "NewTitle",
};
var commentModelOld = new CommentDetailModel()
{
CreationTime = new DateTime(),
Content = "OldContent"
};
var userDetailModel = new UserDetailModel()
{
Name = "NewUser",
Email = "*****@*****.**",
Password = "******"
};
//Act
var returnedUserModel = _userRepository.Create(userDetailModel);
var returnedPostDetailModel = _postRepository.Create(postDetailModel, returnedUserModel);
var returnedCommentDetailModel = _commentRepository.Create(commentModelOld, returnedUserModel, returnedPostDetailModel);
returnedPostDetailModel = _postRepository.AddComment(returnedPostDetailModel, returnedCommentDetailModel);
var returnedUpdatedComment = _commentRepository.UpdateContent(returnedCommentDetailModel, "NewContent");
//Assert
Assert.Equal("NewContent", returnedUpdatedComment.Content);
//Teardown
_commentRepository.Delete(returnedCommentDetailModel);
_postRepository.Delete(returnedPostDetailModel);
_userRepository.Delete(returnedUserModel);
}
private void SearchInPost(PostDetailModel post, HashSet <PostDetailModel> postWithSearchedText)
{
if (post.Title.Contains(SearchText) || post.Content.Contains(SearchText))
{
postWithSearchedText.Add(post);
}
}
public void InsertAndRemoveTest()
{
var post = new PostDetailModel()
{
Title = "First post",
Comments = new List <CommentDetailModel>(),
Author = new UserDetailModel(),
Timestamp = new DateTime(),
Content = "Tak toto budem testovat"
};
var insertedPost = _posRepository.Insert(post);
Assert.NotNull(insertedPost);
Assert.Equal(post.Title, insertedPost.Title);
Assert.Equal(post.Timestamp, insertedPost.Timestamp);
Assert.Equal(post.Content, insertedPost.Content);
var getById = _posRepository.GetById(insertedPost.Id);
Assert.NotNull(getById);
Assert.Equal(post.Title, getById.Title);
Assert.Equal(post.Timestamp, getById.Timestamp);
Assert.Equal(post.Content, getById.Content);
_posRepository.Remove(insertedPost.Id);
getById = _posRepository.GetById(insertedPost.Id);
Assert.Null(getById);
}
private void DeleteComments(PostDetailModel post)
{
foreach (var comment in post.Comments)
{
_postRepository.RemoveComment(post, comment);
_commentRepository.Delete(comment);
}
}
public void Delete(PostDetailModel detailModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
RemovePostFromUserActivity(detailModel.Id, dbContext);
dbContext.Remove(dbContext.Find(typeof(Post), detailModel.Id));
dbContext.SaveChanges();
}
}
public async Task <IActionResult> Detail([FromRoute] string cat, [FromRoute] string slug)
{
try
{
if (string.IsNullOrEmpty(cat))
{
return(NotFound());
}
if (string.IsNullOrEmpty(slug))
{
return(NotFound());
}
var post = await _blogService.GetPostAsync(slug.ToLowerInvariant());
if (post == null)
{
return(NotFound());
}
if (post.Category.Slug.ToLowerInvariant() != cat.ToLowerInvariant())
{
return(NotFound());
}
var popularPosts = await _blogService.GetPopularPostsAsync();
var relatedPosts = await _blogService.GetRelatedPostsAsync(new Data.RelatedPostFindRequest
{
PostId = post.Id,
CategoryId = post.CategoryId,
CreatedUserId = post.CreatedUserId,
Top = 2
});
var categories = await _categoryService.GetAllCategoriesAsync();
var model = new PostDetailModel
{
Entity = post,
RelatedPosts = relatedPosts
};
model.RightBar.Categories = categories;
model.RightBar.Popular = popularPosts;
model.RightBar.CurrentCategory = post.Category;
SetTitle(post.Title, post.GetUrl(), $"https://{Request.Host}{post.PhotoUrl}");
return(View($"{Common.WebSetting.ThemeId}/Detail", model));
}
catch (Exception ex)
{
Log.Fatal(ex, "BlogController > Detail");
return(NotFound());
}
}
public static PostListModel DetailToListModel(PostDetailModel postModel)
{
return(new PostListModel
{
Id = postModel.Id,
Author = postModel.Author,
Content = postModel.Content,
CreationTime = postModel.CreationTime,
Title = postModel.Title
});
}
public PostDetailModel Create(PostDetailModel post, Guid teamId)
{
using (var dbContext = _dbContextFactory.CreateDbContext())
{
var entity = _mapper.MapPostToEntity(post);
dbContext.Entry(entity).State = EntityState.Unchanged;
dbContext.Posts.Add(entity);
dbContext.SaveChanges();
return(_mapper.MapPostDetailModelFromEntity(entity));
}
}
public static Post MapDetailModelToEntity(PostDetailModel postDetailModel)
{
return(new Post
{
Id = postDetailModel.Id,
Title = postDetailModel.Title,
Author = UserMapper.MapListModelToEntity(postDetailModel.Author),
Content = postDetailModel.Content,
CreationTime = postDetailModel.CreationTime,
Comments = postDetailModel.Comments.Select(CommentMapper.MapToEntity).ToList()
});
}
public void Add_Remove_Post_TeamModel_Test()
{
var teamOne = new TeamDetailModel
{
Name = "ICS Team",
};
var user = new UserDetailModel
{
Name = "Brisk",
Email = "*****@*****.**",
Password = "******",
};
var postOne = new PostDetailModel
{
Title = "Post v tymu",
Content = "Jeste neni konec",
};
var postTwo = new PostDetailModel
{
Title = "Post v tymu",
Content = "Uz je konec",
};
var userModel = _userRepository.Create(user);
var postOneModel = _postRepository.Create(postOne, userModel);
var postTwoModel = _postRepository.Create(postTwo, userModel);
var teamModel = _teamRepository.Create(teamOne);
Assert.NotNull(teamModel);
Assert.Equal(teamOne.Name, teamModel.Name);
teamModel = _teamRepository.AddPost(teamModel, postOneModel);
Assert.Single(teamModel.Posts);
teamModel = _teamRepository.AddPost(teamModel, postTwoModel);
Assert.Equal(2, teamModel.Posts.Count);
teamModel = _teamRepository.RemovePost(teamModel, postOneModel);
Assert.Single(teamModel.Posts);
//Teardown
_userRepository.Delete(userModel.Id);
_teamRepository.Delete(teamModel.Id);
}
public Post MapPostToEntity(PostDetailModel post)
{
return(new Post
{
Id = post.Id,
Title = post.Title,
Text = post.Text,
PostAdditionTime = post.PostAdditionTime,
User = MapUserToEntity(post.User),
Team = MapTeamToEntity(post.Team)
});
}
public void GetUserLastPostTest()
{
var userRepository = new UserRepository(new InMemoryDbContextFactory());
var author = new UserDetailModel();
var dbAuthor = userRepository.Insert(author);
var postFirst = new PostDetailModel()
{
Title = "First post",
Comments = new List <CommentDetailModel>(),
Author = author,
Timestamp = new DateTime(2019, 4, 4),
Content = "Tak toto budem testovat"
};
var postSecond = new PostDetailModel()
{
Title = "Second post",
Comments = new List <CommentDetailModel>(),
Author = author,
Timestamp = new DateTime(2019, 4, 5),
Content = "A toto taky budem testovat"
};
var postLast = new PostDetailModel()
{
Title = "Last post",
Comments = new List <CommentDetailModel>(),
Author = author,
Timestamp = new DateTime(2019, 4, 6),
Content = "Toto uz nebudem testovat"
};
var postFirstDb = _posRepository.Insert(postFirst);
var postSecondDb = _posRepository.Insert(postSecond);
var postDetail = _posRepository.Insert(postLast);
var postsDatabase = _posRepository.GetUserLastPosts(author.Id, 2);
Assert.Equal(2, postsDatabase.Count());
Assert.Equal(postSecond.Title, postsDatabase.Last().Title);
Assert.Equal(postSecond.Content, postsDatabase.Last().Content);
Assert.Equal(postLast.Title, postsDatabase.First().Title);
Assert.Equal(postLast.Content, postsDatabase.First().Content);
_posRepository.Remove(postFirstDb.Id);
_posRepository.Remove(postSecondDb.Id);
_posRepository.Remove(postDetail.Id);
}
public PostDetailModel UpdateContent(PostDetailModel postModel, string content)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
var postEntity = dbContext.Posts
.Include(a => a.Author)
.Include(c => c.Comments)
.ThenInclude(c => c.Author)
.First(p => p.Id == postModel.Id);
postEntity.Content = content;
dbContext.Posts.Update(postEntity);
dbContext.SaveChanges();
return(PostMapper.MapToDetailModel(postEntity));
}
}
public IEnumerable <CommentDetailModel> GetAllCommentsInPost(Guid postId)
{
PostDetailModel PostModel = GetPostById(postId);
var entityPost = _mapper.MapPostToEntity(PostModel);
var foundEntity = _dbContextFactory.CreateDbContext()
.Comments
.Include(u => u.User)
.Include(p => p.Post)
.Include(u => u.Post.Team)
.Include(u => u.Post.User)
.Where(p => p.Post == entityPost)
.Select(c => _mapper.MapCommentDetailModelFromEntity(c));
return(foundEntity);
}
protected virtual void PreparePostDetailModel(PostDetailModel model, Post entity)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var labels = _postLabelService.GetPostLabelsByPostId(entity.Id);
model.ContentLabels = labels.Select(l =>
{
var label = _labelService.GetContentLabelById(l.LabelId);
var labelModel = label.MapTo <ContentLabelModel>();
return(labelModel);
}).ToList();
}
public async Task <IActionResult> Detail(long postId)
{
ListContentPostDTO post;
ListUserDTO user;
string postCache = await RedisHelper.GetAsync($"postDetail_{postId}");
string userCache = await RedisHelper.GetAsync($"user_{postId}");
if (!string.IsNullOrEmpty(postCache) && !string.IsNullOrEmpty(userCache))
{
post = JsonConvert.DeserializeObject <ListContentPostDTO>(postCache);
user = JsonConvert.DeserializeObject <ListUserDTO>(userCache);
}
else
{
post = await PostSvc.GetByIdAsync(postId);
user = await UserSvc.GetByIdAsync(post.UserId);
if (post == null)
{
return(Json(new AjaxResult {
Status = "redirect", Data = "/Error/Error404"
}));
}
if (user == null)
{
return(Json(new AjaxResult {
Status = "error", Data = UserSvc.ErrorMsg
}));
}
await RedisHelper.SetAsync($"postDetail_{postId}", post);
await RedisHelper.SetAsync($"user_{postId}", user);
}
long count = await RedisHelper.IncrByAsync("post_" + postId);
PostDetailModel model = new PostDetailModel();
model.Post = post;
model.User = user;
model.LookCount = count;
return(Json(new AjaxResult {
Status = "ok", Data = model
}));
}
public PostEntity MapToPostEntity(PostDetailModel model)
{
if (model == null)
{
return(null);
}
return(new PostEntity()
{
Id = model.Id,
Author = _mappers.UserMapper.MapToUserEntity(model.Author),
Comments = model.Comments.AsEnumerable().Select(_mappers.CommentMapper.MapToCommentEntity).ToList(),
Title = model.Title,
Timestamp = model.Timestamp,
Content = model.Content,
});
}
public void Get_ReturnsAViewResult_WithAListOfPosts()
{
//Arrage
var mockService = new Mock <IDataService>();
mockService.Setup(x => x.GetPostDetail(It.IsAny <int>())).Returns(new PostExtended
{
PostId = 1,
Title = "Testing Post Controller using Moq",
Score = 60,
PostBody = "First time using Unit Test with Moq to test the controller!",
Answers = new List <string> {
"Well, hope this works...", "Ohlala it works"
},
UserName = "******"
});
var mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelper.Setup(x => x.Link(It.IsAny <string>(), It.IsAny <object>()))
//Using Func + Reflection, because the id was created as an Anonymous Type in ModelFactory.
.Returns((string urlString, object idObject) =>
{
Type typeOfIdObject = idObject.GetType();
int valueOfIdObject =
(int)typeOfIdObject.GetProperty("id").GetValue(idObject, null);
return("http://localhost/api/posts/" + valueOfIdObject);
});
var controller = new PostController(mockService.Object);
controller.Url = mockUrlHelper.Object;
//Action
IActionResult actionResult = controller.Get(1);
OkObjectResult okObjectResult = actionResult as OkObjectResult;
PostDetailModel asPostDetailModel = (PostDetailModel)okObjectResult.Value;
//Assert
Assert.Equal("http://localhost/api/posts/1", asPostDetailModel.Url);
Assert.Equal("Testing Post Controller using Moq", asPostDetailModel.Title);
Assert.Equal(60, asPostDetailModel.Score);
Assert.Equal("First time using Unit Test with Moq to test the controller!", asPostDetailModel.PostBody);
Assert.Equal("Well, hope this works...", asPostDetailModel.Answers[0]);
Assert.Equal("Ohlala it works", asPostDetailModel.Answers[1]);
Assert.Equal("Group 7 RAWDATA", asPostDetailModel.UserName);
}
public void GetAllByTeamId_PostModelTest()
{
var postOneModel = new PostDetailModel
{
Title = "Test Post"
};
var postTwoModel = new PostDetailModel
{
Title = "Test Post 2"
};
var teamModel = new TeamDetailModel
{
Name = "Test Team",
};
var authorModel = new UserDetailModel
{
Name = "Test Author",
Password = "******"
};
teamModel = _teamRepository.Create(teamModel);
authorModel = _userRepository.Create(authorModel);
postOneModel = _postRepository.Create(postOneModel, authorModel);
postTwoModel = _postRepository.Create(postTwoModel, authorModel);
teamModel = _teamRepository.AddPost(teamModel, postOneModel);
teamModel = _teamRepository.AddPost(teamModel, postTwoModel);
var posts = _postRepository.GetAllByTeamId(teamModel.Id);
Assert.NotNull(posts);
Assert.NotEmpty(posts);
Assert.Equal(2, posts.Count());
foreach (var post in posts)
{
_console.WriteLine(post.Title);
}
//Teardown
_postRepository.Delete(postOneModel.Id);
_postRepository.Delete(postTwoModel.Id);
_userRepository.Delete(authorModel.Id);
_teamRepository.Delete(teamModel.Id);
}
public static PostDetailModel MapToDetailModel(Post post)
{
var detailModel = new PostDetailModel
{
Id = post.Id,
Title = post.Title,
Author = UserMapper.MapToListModel(post.Author),
Content = post.Content,
CreationTime = post.CreationTime,
};
foreach (var comment in post.Comments)
{
detailModel.Comments.Add(CommentMapper.MapToDetailModel(comment));
}
return(detailModel);
}
public PostDetailModel Get(string sessionKey, int id)
{
var responseMsg = this.PerformOperationAndHandleExceptions(
() =>
{
VerifySessionKey(sessionKey);
IRepository <Post> postRepository = this.data.GetPostsRepository();
Post post = postRepository.Get(id);
PostDetailModel postModel = ModelFunctions.GetSinglePostDetails(post);
return(postModel);
});
return(responseMsg);
}
public void SearchInPostsTest()
{
var author = new UserDetailModel();
var dbAuthor = _userRepository.Insert(author);
var post = new PostDetailModel()
{
Title = "First post",
Comments = new List <CommentDetailModel>(),
Author = dbAuthor,
Timestamp = new DateTime(),
Content = "Tak toto budem testovat"
};
var insertedPost = _posRepository.Insert(post);
var postsSearchedList = _search.SearchInPosts(_posRepository.GetPostDetailModels(), "Toto");
var dbPost = _posRepository.GetById(insertedPost.Id);
Assert.NotEmpty(postsSearchedList);
Assert.Single(postsSearchedList);
var updatedPost = new PostDetailModel()
{
Id = insertedPost.Id,
Title = "Updated post",
Comments = new List <CommentDetailModel>(),
Author = dbAuthor,
Timestamp = new DateTime(),
Content = "Nic a nikto"
};
_posRepository.Update(updatedPost);
postsSearchedList = _search.SearchInPosts(_posRepository.GetPostDetailModels(), "a nikto");
Assert.NotEmpty(postsSearchedList);
Assert.Single(postsSearchedList);
postsSearchedList = _search.SearchInPosts(_posRepository.GetPostDetailModels(), "Tu uz nenajdem");
Assert.Empty(postsSearchedList);
_posRepository.Remove(insertedPost.Id);
}
public PostDetailModel Create(PostDetailModel postModel, UserDetailModel authorModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
postModel.CreationTime = DateTime.Now;
postModel.Author = UserMapper.DetailToListModel(authorModel);
var postEntity = PostMapper.MapDetailModelToEntity(postModel);
postEntity.Author = UserMapper.MapToEntity(authorModel);
var userEntity = dbContext.Users
.First(u => u.Id == authorModel.Id);
userEntity.Activities.Add(postEntity);
dbContext.Users.Update(userEntity);
dbContext.Posts.Update(postEntity);
dbContext.SaveChanges();
return(PostMapper.MapToDetailModel(postEntity));
}
}
public void GetAllByPostId_CommentModel_Test()
{
//Arrange
var postDetailModel = new PostDetailModel()
{
Title = "NewTitle",
Comments = new List <CommentDetailModel>(5)
};
var date = new DateTime();
var postListModel = new PostListModel()
{
Title = "NewTitle"
};
var commentModel = new CommentDetailModel()
{
CreationTime = date,
BelongsTo = postListModel,
};
var userDetailModel = new UserDetailModel()
{
Name = "NewUser",
Email = "*****@*****.**",
Password = "******"
};
//Act
var returnedUserModel = _userRepository.Create(userDetailModel);
var returnedPostDetailModel = _postRepository.Create(postDetailModel, returnedUserModel);
var returnedCommentDetailModel = _commentRepository.Create(commentModel, returnedUserModel, returnedPostDetailModel);
returnedPostDetailModel = _postRepository.AddComment(returnedPostDetailModel, returnedCommentDetailModel);
var returnedGetAllByPostId = _commentRepository.GetAllByPostId(returnedPostDetailModel.Id);
//Assert
Assert.NotNull(returnedGetAllByPostId);
//Teardown
_commentRepository.Delete(returnedCommentDetailModel);
_postRepository.Delete(returnedPostDetailModel);
_userRepository.Delete(returnedUserModel);
}
public void AddCommentBasic_PostModel_Test()
{
var userModel = new UserDetailModel
{
Name = "Dan",
Email = "*****@*****.**",
Password = "******",
};
var userTwoModel = new UserDetailModel
{
Name = "Tester",
Email = "",
Password = "",
};
var postModel = new PostDetailModel
{
Title = "Funguje to",
};
var commentModel = new CommentDetailModel
{
Content = "aha"
};
userModel = _userRepository.Create(userModel);
userTwoModel = _userRepository.Create(userTwoModel);
postModel = _postRepository.Create(postModel, userModel);
commentModel = _commentRepository.Create(commentModel, userTwoModel, postModel);
Assert.Empty(postModel.Comments);
postModel = _postRepository.AddComment(postModel, commentModel);
Assert.NotEmpty(postModel.Comments);
Assert.Single(postModel.Comments);
postModel = _postRepository.RemoveComment(postModel, commentModel);
Assert.Empty(postModel.Comments);
//Teardown
_postRepository.Delete(postModel.Id);
}
public ActionResult Detail(string catURL, string postUrl)
{
PostDetailModel postDetai = new PostDetailModel();
var post = _PostServices.GetPost(catURL, postUrl);
//chi tiết
postDetai.Post = post.Convert(withFullDesc: true, withUser: true, withTag: true);
// liên quan tác giả
var postAuhor = _PostServices.GetPostAuthor(post.Id, post.CreateUser.Email);
postDetai.PostAuthor = postAuhor.Convert(withUser: true);
// bài viết liên quan
var postRelated = _PostServices.GetListPost(3, categoryId: postDetai.Post.Category.Id, PostID: postDetai.Post.Id);
postDetai.PostRelated = postRelated.Convert(catURL: catURL);
return(View(postDetai));
}
public static PostDetailModel ToDetailViewModel(this PostInfo postInfo)
{
var model = new PostDetailModel();
if (postInfo == null)
{
return(model);
}
model.Id = postInfo.Id;
model.Subject = postInfo.Subject;
model.Body = postInfo.Body;
model.AuthorId = postInfo.AuthorId;
model.AuthorName = string.IsNullOrEmpty(postInfo.AuthorName) ? postInfo.AuthorId : postInfo.AuthorName;
model.CreatedOn = postInfo.CreatedOn.ToString("MM-dd HH:mm");
model.ReplyCount = postInfo.ReplyCount;
model.SectionId = postInfo.SectionId;
model.SectionName = postInfo.SectionName;
if (postInfo.ReplyList != null)
{
var replyList = new List <ReplyModel>();
foreach (var reply in postInfo.ReplyList)
{
var replyModel = new ReplyModel
{
Id = reply.Id,
Body = reply.Body,
AuthorId = reply.AuthorId,
AuthorName = reply.AuthorName,
CreatedOn = reply.CreatedOn.ToString("MM-dd HH:mm"),
Floor = reply.Floor
};
replyList.Add(replyModel);
}
model.Replies = replyList;
}
return(model);
}
public PostDetailModel RemoveComment(PostDetailModel postModel, CommentDetailModel commentModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
var postEntity = dbContext.Posts
.Include(c => c.Comments)
.ThenInclude(a => a.Author)
.Include(a => a.Author)
.First(p => p.Id == postModel.Id);
var commentEntity = dbContext.Comments
.Include(a => a.Author)
.First(c => c.Id == commentModel.Id);
postEntity.Comments.Remove(commentEntity);
commentEntity.BelongsTo = null;
dbContext.Posts.Update(postEntity);
dbContext.SaveChanges();
return(PostMapper.MapToDetailModel(postEntity));
}
}
public async Task<IHttpActionResult> Post(CreatePostModel postModel)
{
try
{
var user = _userRepository.GetById(postModel.UserId);
var post = Discussions.Entities.Post.CreatePost(postModel.Content, user);
var discussion = _discussionRepository.Get(postModel.DiscussionId);
discussion.AddPost(post);
_context.DiscussionRepository.Add(discussion);
_context.Entry(discussion).State = EntityState.Modified;
//_context.Entry(discussion.Posts[0].PostedBy).State = EntityState.Unchanged;
_context.Save();
PostDetailModel pdm = new PostDetailModel
{
Id = post.Id,
PostedBy = user.Username,
Posted = post.PostedOn.ToShortDateString(),
Post = post.Content,
Votes = 0
};
// return Ok(post);
return Ok(pdm);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
