public ReturnState AddResponseToPostReply(PostReplyModel model)
{
var filters = new UtilityService().GetFilterLisst();
model.Content = Utilities.Filter(model.Content, filters);
return(ForumOperator.AddResponseToPostReply(model) ? ReturnState.ReturnOK : ReturnState.ReturnError);
}
public ReturnState AddResponseToPostReply(PostReplyModel model)
{
ReturnState result;
forumClient.AddResponseToPostReply(model, out result, out specify);
return(result);
}
public IActionResult Edit(int id)
{
var userId = _userManager.GetUserId(User);
var reply = _postService.GetReplyById(id);
var post = _postService.GetById(reply.Post.Id);
var forum = _forumService.GetById(post.Forum.Id);
var model = new PostReplyModel
{
ForumName = forum.Title,
ForumId = forum.Id,
ForumImageUrl = forum.ImageUrl,
PostContent = post.Content,
PostTitle = post.Title,
PostId = post.Id,
PostImageURL = post.ImageUrl,
AuthorId = userId,
AuthorName = User.Identity.Name,
ReplyId = reply.Id,
ReplyContent = reply.Content,
ReplyImageUrl = reply.ImageUrl,
};
return(View(model));
}
public async Task <IActionResult> Create(int id)
{
if (!await this.postService.DoesItExist(id))
{
return(this.NotFound());
}
var post = await this.postService.GetByIdAsync(id);
var user = await this.userManager.FindByNameAsync(this.User.Identity.Name);
var model = new PostReplyModel
{
PostContent = post.Content,
PostTitle = post.Title,
PostId = post.Id,
AuthorId = user.Id,
AuthorName = this.User.Identity.Name,
AuthorImageUrl = user.ProfileImageUrl,
KarmaPoints = user.KarmaPoints,
IsAuthorAdmin = this.User.IsInRole("Admin"),
CategoryId = post.Category.Id,
CategoryName = post.Category.ImageUrl,
CategoryImageUrl = post.Category.ImageUrl,
};
return(this.View(model));
}
public async Task <IActionResult> EditReply(PostReplyModel model)
{
var imageUri = model.ReplyImageUrl;
if (model.ReplyImageUpload != null && model.ReplyImageUpload.Length != 0)
{
//var blockBlob = UploadForumImage(model.ImageUpload);
//imageUri = blockBlob.Uri.AbsoluteUri;
string pathRoot = _environment.WebRootPath;
string path_to_Images = pathRoot + "\\Images\\replies\\" + model.ReplyImageUpload.FileName;
using (var stream = new FileStream(path_to_Images, FileMode.Create))
{
await model.ReplyImageUpload.CopyToAsync(stream);
}
imageUri = "/Images/replies/" + model.ReplyImageUpload.FileName;
}
model.ReplyImageUrl = imageUri;
await _postService.EditReply(model.ReplyId, model.ReplyContent, model.ReplyImageUrl);
var id = model.PostId;
return(RedirectToAction("Index", "Post", new { id }));
}
public async Task <IActionResult> Create(int id)
{
var post = _postService.getById(id);
var forum = _forumService.getById(post.forum.id);
var userId = _userManager.GetUserId(User);
var user = _userManager.FindByIdAsync(userId).Result;
var model = new PostReplyModel
{
postContent = post.content,
postTitle = post.title,
postId = post.id,
forumName = forum.title,
forumId = forum.id,
forumImageUrl = forum.imageUrl,
authorName = User.Identity.Name,
authorId = user.Id,
created = DateTime.Now
};
return(View(model));
}
private async Task <PostReply> BuildReplyModel(PostReplyModel model, ApplicationUser user)
{
var post = _postService.GetById(model.PostId);
var imageUri = "";
if (model.ReplyImageUpload != null && model.ReplyImageUpload.Length != 0)
{
//var blockBlob = UploadForumImage(model.ImageUpload);
//imageUri = blockBlob.Uri.AbsoluteUri;
string pathRoot = _environment.WebRootPath;
string path_to_Images = pathRoot + "\\Images\\replies\\" + model.ReplyImageUpload.FileName;
using (var stream = new FileStream(path_to_Images, FileMode.Create))
{
await model.ReplyImageUpload.CopyToAsync(stream);
}
imageUri = "/Images/replies/" + model.ReplyImageUpload.FileName;
}
return(new PostReply
{
Post = post,
Content = model.ReplyContent,
Created = DateTime.Now,
User = user,
ImageUrl = imageUri
});
}
public async Task <IActionResult> Create(int id)
{
//Get post and track for reply
var post = _postService.GetById(id);
//Get the application user that will write the reply for this post
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var model = new PostReplyModel
{
PostContent = post.Content,
PostTitle = post.Title,
PostId = post.Id,
AuthorName = User.Identity.Name,
AuthorImageUrl = user.ImageUrl,
AuthorId = user.Id,
AuthorRating = user.Rating,
IsAuthorAdmin = User.IsInRole("Admin"),
OriginalPostWritter = post.User.UserName,
ForumName = post.Forum.Title,
ForumId = post.Forum.Id,
ForumImageUrl = post.Forum.ImageUrl,
Created = DateTime.Now
};
return(View(model));
}
public async Task <IActionResult> Create(int Id)
{
var post = _postService.GetById(Id);
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var model = new PostReplyModel
{
PostContent = post.Content,
PostTitle = post.Title,
PostId = post.Id,
AuthorId = user.Id,
AuthorName = User.Identity.Name,
AuthorImageUrl = user.ProfileImageUrl,
AuthorRating = user.Rating,
IsAuthorAdmin = User.IsInRole("Admin"),
ForumId = post.Forum.Id,
ForumName = post.Forum.Title,
ForumImageUrl = post.Forum.ImageUrl,
Created = DateTime.Now
};
return(View(model));
}
public static List <PostReplyModel> QueryReplyResponseListByPostId(int id)
{
var list = new List <PostReplyModel>();
using (var conn = new SqlConnection(connectionString))
{
conn.Open();
var cmdText = string.Format("select Id, Email, Reply, Content, RDate from PostReplyMsg where Reply = {0}", id);
using (var cmd = new SqlCommand(cmdText, conn))
{
var reader = cmd.ExecuteReader();
while (reader.Read())
{
var model = new PostReplyModel();
model.Id = Convert.ToInt32(reader.GetValue(0));
model.Responser = Convert.ToString(reader.GetValue(1));
model.ResponseTo = Convert.ToInt32(reader.GetValue(2));
model.Content = Convert.ToString(reader.GetValue(3));
model.ResponseDate = Convert.ToDateTime(reader.GetValue(4));
list.Add(model);
}
conn.Close();
}
}
return(list);
}
public async Task <IActionResult> Create(int id)
{
//get the post to reply to
var post = _postService.GetById(id);
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var model = new PostReplyModel
{
//Original post
PostContent = post.Content,
PostTitle = post.Title,
PostId = post.Id,
PostAuthorName = post.User.UserName,
PostAuthorRating = post.User.Rating,
PostAuthorId = post.User.Id,
PostAuthorImageUrl = post.User.ProfileImageUrl,
PostCreated = post.Created,
//Reply
AuthorName = User.Identity.Name,
AuthorImageUrl = user.ProfileImageUrl,
AuthorId = user.Id,
AuthorRating = user.Rating,
IsAdmin = User.IsInRole("Admin"),
//Forum details
ForumName = post.Forum.Title,
ForumId = post.Forum.Id,
ForumImageUrl = post.Forum.ImageUrl,
Created = DateTime.Now
};
return(View(model));
}
private PostReply BuildReply(ApplicationUser user, PostReplyModel model)
{
return(new PostReply
{
Content = model.ReplyContent,
User = user,
Post = _postService.GetPostById(model.PostId)
});
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId);
var reply = BuildReply(model, user);
await _postService.addReply(reply);
return(RedirectToAction("Index", "Post", new { id = model.postId }));
}
public async Task <IActionResult> EditReply(PostReplyModel model)
{
if (ModelState.IsValid)
{
await _postService.EditReply(model.Id, model.ReplyContent);
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
return(Edit(model.Id));
}
public async Task <ActionResult> AddReply(PostReplyModel model)
{
var userId = User.Identity.GetUserId();
var user = await _userManager.FindByIdAsync(userId);
var reply = BuildReply(model, user);
await _postService.AddReply(reply);
await _userService.UpdateUserRating(userId, typeof(PostReply));
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
private PostReply BuildReply(PostReplyModel model, ApplicationUser user)
{
var post = _postService.GetById(model.PostId);
return(new PostReply
{
Post = post,
Content = model.ReplyContent,
Created = DateTime.Now,
User = user
});
}
public PostReply BuildReply(PostReplyModel reply, ApplicationUser user)
{
var post = _postService.GetById(reply.PostId);
return(new PostReply
{
Post = post,
Content = reply.ReplyContent,
Created = DateTime.Now,
User = user
});
}
private PostReply BuildReply(PostReplyModel model, ApplicationUser user)
{
var post = _postRepositories.GetById(model.PostId);
return(new PostReply
{
Content = model.ReplyContent,
Created = DateTime.Now,
User_Id = user.Id,
Post_Id = post.Id
});
}
public async Task <ActionResult> AddReply(PostReplyModel model)
{
var userId = User.Identity.GetUserId();
var user = _userManager.FindByIdAsync(userId).Result;
var reply = BuildReply(model, user);
await _postRepositories.AddPostReply(reply);
await _applicationUserRepositories.IncrementUserRating(user.Id, typeof(PostReply));
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
private PostReply BuildReply(PostReplyModel model, ApplicationUser user)
{
var post = _postService.GetById(model.PostId);
return(new PostReply
{
Post = post,
Content = model.ReplyContent,
Created = DateTime.Now,
User = user
// id from the PostReplies data table is automated - No need to wire one for it
});
}
private PostReply BuildReply(PostReplyModel reply, ApplicationUser user)
{
var now = DateTime.Now;
var post = _postService.getById(reply.postId);
return(new PostReply
{
post = post,
content = reply.replyContent,
created = now,
user = user
});
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
var userId = this.userManager.GetUserId(User);
var user = await this.userManager.FindByIdAsync(userId);
var reply = this.BuilderReply(model, user);
await this.postService.AddReply(reply);
//User rating management's implementation
await this.userService.UpdateUserRating(userId, typeof(PostReply));
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId);
var reply = BuildReply(model, user);
if (model.ReplyContent != null)
{
await _postService.AddReply(reply);
await _userService.BumpRating(userId, typeof(PostReply));
}
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
public static bool AddResponseToPostReply(PostReplyModel model)
{
var result = false;
using (var conn = new SqlConnection(connectionString))
{
conn.Open();
var cmdText = string.Format("insert into PostReplyMsg values(N'{0}', {1}, N'{2}', '{3}')", model.Responser, model.ResponseTo, model.Content, DateTime.Now);
using (var cmd = new SqlCommand(cmdText, conn))
{
result = cmd.ExecuteNonQuery() > 0;
conn.Close();
}
}
return(result);
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
if (model == null)
{
return(NotFound());
}
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId).ConfigureAwait(false);
var reply = BuildReply(model, user) as PostReply;
await _postService.AddReply(reply).ConfigureAwait(false);
await _userService.UpdateUserRating(userId, typeof(PostReply)).ConfigureAwait(false);
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
private async Task <PostReplyModel> ParsePostReply(string result)
{
var model = new PostReplyModel();
var parser = new HtmlParser();
var reply = await parser.ParseAsync(result);
var titleCheck = reply.QuerySelector("div.page-title h1 a");
model.Title = titleCheck != null ? titleCheck.TextContent : "";
var userCheck = reply.QuerySelector("input[name='loggedinuser']");
if (userCheck != null)
{
model.UserId = userCheck.Attributes["value"].Value;
}
var threadIdCheck = reply.QuerySelector("input[name='t']");
if (threadIdCheck != null)
{
model.ThreadId = threadIdCheck.Attributes["value"].Value;
}
var subscriptionTypeCheck = reply.QuerySelector("select[name='emailupdate'] option[selected]");
if (subscriptionTypeCheck != null)
{
model.SubscriptionType = subscriptionTypeCheck.Attributes["value"].Value;
}
else
{
model.SubscriptionType = "9999";
}
var messageCheck = reply.QuerySelector("textarea");
if (messageCheck != null)
{
model.Message = WebUtility.HtmlDecode(messageCheck.InnerHtml);
}
return(model);
}
public IActionResult Edit(int replyId)
{
var reply = _postService.GetReplyById(replyId);
var forum = reply.Post.Forum;
var model = new PostReplyModel
{
ReplyContent = reply.Content,
PostId = reply.Post.Id,
Id = replyId,
PostTitle = reply.Post.Title,
PostContent = reply.Post.Content,
ForumId = forum.Id,
ForumImageUrl = forum.ImageUrl
};
return(View("Edit", model));
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
if (ModelState.IsValid)
{
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId);
var reply = BuildReply(model, user);
model.ForumName = reply.Post.Forum.Title;
reply.User.Rating++;
await _postService.AddReply(reply);
return(RedirectToAction("Index", "Post", new { id = model.PostId }));
}
return(await Create(model.PostId));
}
public async Task <IActionResult> AddReply(PostReplyModel model)
{
if (!await this.postService.DoesItExist(model.PostId))
{
return(this.NotFound());
}
var user = await this.userManager.FindByNameAsync(this.User.Identity.Name);
var reply = new Reply
{
PostId = model.PostId,
Content = new HtmlSanitizer().Sanitize(model.ReplyContent),
Author = user,
};
await this.replyService.CreateReplyAsync(reply);
return(this.RedirectToAction("Index", "Post", new { id = model.PostId }));
}
// GET: Reply
public async Task <ActionResult> Create(int id)
{
var post = _postRepositories.GetById(id);
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var model = new PostReplyModel
{
PostContent = post.Content,
PostId = post.Id,
PostTitle = post.Title,
AuthorName = user.UserName,
AuthorId = user.Id,
AuthorRating = user.Rating,
IsAuthorAdmin = User.IsInRole("Admin"),
ForumName = post.Forum.Title,
ForumId = post.Forum.Id,
DateCreated = DateTime.Now
};
return(View(model));
}
