public DomainModelResponse AddPost(PostAddRequest request)
{
EntityModel.Post parent = null;
if (request.ParentPostTime != null && !string.IsNullOrWhiteSpace(request.ParentPostUserName))
{
parent = _repPost.Get(filter: f => f.TimePosted == request.ParentPostTime && f.UserName == request.ParentPostUserName).FirstOrDefault();
}
Group grp = _repGroup.Get(filter: f => f.GroupCode == request.GroupCode).FirstOrDefault();
EntityModel.Post post = new EntityModel.Post()
{
UserName = request.UserName,
TimePosted = request.TimePosted,
PostText = request.PostText,
Group = grp,
GroupId = grp.GroupId,
LastChangedTime = DateTime.UtcNow
};
if (parent != null)
{
post.ParentId = parent.PostId;
}
else
{
post.ParentId = null;
}
_repPost.Add(post);
_uow.Commit();
_postResponse.addResponse("Add", MessageCodes.InfoCreatedSuccessfully, "Post");
return(_postResponse);
}
public bool AddPost(PostAddRequest request)
{
try
{
post.AddPost(request);
return(true);
}
catch
{
return(false);
}
}
public ActionResult <ItemResponse <int> > CreatePost(PostAddRequest req)
{
ActionResult result = null;
ItemResponse <int> response = null;
try
{
int newPostId = _postService.CreatePost(req);
response = new ItemResponse <int>();
response.Item = newPostId;
result = Ok(response.Item);
}
catch (Exception ex)
{
result = StatusCode(500, new ErrorResponse(ex.Message.ToString()));
}
return(result);
}
public ActionResult NewPost(PostModel model)
{
if (ModelState.IsValid)
{
PostAddRequest par = new PostAddRequest()
{
PostText = model.PostText,
TimePosted = DateTime.UtcNow,
GroupCode = currentGroupCode,
UserName = User.Identity.Name
};
bool result = _postCom.AddPost(par);
if (result)
{
return(RedirectToAction("GroupDetail", "Group", routeValues: new { groupCode = currentGroupCode }));
}
}
ModelState.AddModelError("", "Oops! Something wrong happened! Please try again.");
return(View(model));
}
public ActionResult <ItemResponse <int> > PostInsert(PostAddRequest model)
{
ObjectResult result = null;
try
{
int userId = _authService.GetCurrentUserId();
int id = _service.PostInsert(model, userId);
ItemResponse <int> response = new ItemResponse <int>();
response.Item = id;
result = Created201(response);
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
ErrorResponse response = new ErrorResponse(ex.Message);
result = StatusCode(500, response);
}
return(result);
}
public async Task <ServiceResult <PostLongDto> > CreatePostAsync(PostAddRequest request, int userId)
{
var user = await _unitOfWork.UserRepository.GetSingleAsync(u => u.Id == userId);
if (!user.IsValidated)
{
return(ServiceResult <PostLongDto> .Fail(EOperationResult.ValidationError,
"Please, validate your email first"));
}
var utcNow = _dateHelper.GetDateTimeUtcNow();
var newPost = new Post(title: request.Title, description: request.Description, subjectId: request.SubjectId,
semester: request.Semester, postLocationTypeId: (int)request.PostLocationType,
postValueTypeId: (int)request.PostValueType, givenAt: request.GivenAt, userId: userId,
groupId: request.GroupId, createdAtUtc: utcNow, modifiedAtUtc: utcNow, lastVisit: utcNow);
_unitOfWork.PostRepository.Add(newPost);
var newFiles = CreateFilesForPost(newPost, request.FileInfoRequests, utcNow);
_unitOfWork.FileRepository.AddRange(newFiles);
var userAvailablePost = new UserAvailablePost(post: newPost, userId: userId);
_unitOfWork.UserAvailablePostRepository.Add(userAvailablePost);
// TODO: move rest of method to separate func or class
user.CurrencyCount = TradingConstants.NewPostUnicoinsBonus + user.CurrencyCount;
var newPostVote = new PostVote(post: newPost, userId: userId, voteTypeId: (int)EPostVoteType.Upvote);
_unitOfWork.PostVoteRepository.Add(newPostVote);
newPost.VotesCount = CountNewVotes(EPostVoteType.Upvote, newPost.VotesCount);
await _unitOfWork.CommitAsync();
return(ServiceResult <PostLongDto> .Ok(_mapper.Map <Post, PostLongDto>(newPost)));
}
public int PostInsert(PostAddRequest model, int userId)
{
int id = 0;
_data.ExecuteNonQuery("dbo.Posts_Insert",
delegate(SqlParameterCollection col)
{
col.AddWithValue("@Content", model.Content);
col.AddWithValue("@ThreadId", model.ThreadId);
col.AddWithValue("@CreatedBy", userId);
SqlParameter idOut = new SqlParameter("@Id", SqlDbType.Int);
idOut.Direction = ParameterDirection.Output;
col.Add(idOut);
},
delegate(SqlParameterCollection returnCol)
{
object returnId = returnCol["@Id"].Value;
Int32.TryParse(returnId.ToString(), out id);
});
return(id);
}
public int CreatePost(PostAddRequest req)
{
int id = 0;
try
{
using (SqlConnection connection = new SqlConnection(connString))
{
connection.Open();
SqlCommand cmd = new SqlCommand("dbo.Posts_Insert", connection);
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter outputParam = new SqlParameter();
outputParam.ParameterName = "@Id";
outputParam.SqlDbType = SqlDbType.Int;
outputParam.Direction = ParameterDirection.Output;
cmd.Parameters.Add(outputParam);
cmd.Parameters.AddWithValue("@Title", req.Title);
cmd.Parameters.AddWithValue("@Body", req.Body);
cmd.Parameters.AddWithValue("@CreatedBy", req.CreatedBy);
cmd.ExecuteNonQuery();
connection.Close();
id = (int)outputParam.Value;
return(id);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ActionResult <PostLongDto> > AddPostAsync([FromBody] PostAddRequest request)
=> _viewMapper.ServiceResultToContentResult(
await _postService.CreatePostAsync(request, UserId));
