public async Task <ActionResult <UserDTO> > PostUser(UserDTO data)
{
var user = await _context.Users.FindAsync(data.Id);
if (user != null)
{
var err = new ValidationErrors().Add("Pseudo already in use", nameof(user.Id));
return(BadRequest(err));
}
var newUser = new User()
{
Pseudo = data.Pseudo,
Password = data.Password,
LastName = data.LastName,
FirstName = data.FirstName,
BirthDate = data.BirthDate,
Email = data.Email,
Reputation = data.Reputation,
Role = data.Role,
PicturePath = data.PicturePath
};
_context.Users.Add(newUser);
var res = await _context.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(CreatedAtAction(nameof(GetOne), new { id = newUser.Id }, newUser.ToDTO()));
}
[HttpPost("{id}")]//return commentDTO
public async Task <ActionResult <PostDTO> > AddComment(int id, CommentDTO data)
{
var user = await model.Users.FindAsync(data.AuthorId);
if (user == null)
{
return(BadRequest());
}
var post = await model.Posts.FindAsync(id);
if (post == null)
{
return(BadRequest());
}
var newComment = new Comment()
{
Body = data.Body,
Timestamp = DateTime.Now,
AuthorId = data.AuthorId,
PostId = post.Id
};
model.Comments.Add(newComment);
var res = await model.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(CreatedAtAction(nameof(GetOneComment), new { id = newComment.Id }, newComment.ToDTO()));
}
public async Task <ActionResult <PostDTO> > AddPost(PostDTO data)
{
var user = await model.Users.FindAsync(data.AuthorId);
if (user == null)
{
return(BadRequest());
}
var newPost = new Post()
{
Title = data.Title,
Body = data.Body,
Timestamp = DateTime.Now,
User = user,
AuthorId = data.AuthorId,
ParentId = data.ParentId,
};
var newDateTime = newPost.Timestamp;
model.Posts.Add(newPost);
await model.SaveChangesAsyncWithValidation();
if (data.Tags != null)
{
foreach (var t in data.Tags)
{
var tag = await model.Tags.SingleOrDefaultAsync(p => p.Name == t);
var post = await model.Posts.SingleOrDefaultAsync(p => p.Title == data.Title && p.Body == data.Body && p.Timestamp == newDateTime);
var newPostTag = new PostTag()
{
PostId = post.Id,
TagId = tag.Id,
Post = post,
Tag = tag
};
model.PostTags.Add(newPostTag);
tag.PostTags.Add(newPostTag);
post.PostTags.Add(newPostTag);
}
}
await model.SaveChangesAsyncWithValidation();
return(CreatedAtAction(nameof(GetOnePost), new { id = newPost.Id }, newPost.ToDTO()));
}
public async Task <ActionResult <UserDTO> > PostUser(UserDTO data)
{
var user = await _context.Users.FindAsync(data.Id);
if (user != null)
{
var err = new ValidationErrors().Add("Pseudo already in use", nameof(user.Id));
return(BadRequest(err));
}
var currentUser = await _context.Users.SingleOrDefaultAsync(u => u.Pseudo == User.Identity.Name);
if (currentUser != null && !User.IsInRole(Role.Admin.ToString()))
{
return(NotFound());
}
if (data.FirstName == "")
{
data.FirstName = null;
}
if (data.LastName == "")
{
data.LastName = null;
}
var newUser = new User()
{
Pseudo = data.Pseudo,
Password = TokenHelper.GetPasswordHash(data.Password),
LastName = data.LastName,
FirstName = data.FirstName,
BirthDate = data.BirthDate,
Email = data.Email,
Reputation = data.Reputation,
Role = data.Role,
PicturePath = data.PicturePath
};
_context.Users.Add(newUser);
var res = await _context.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(CreatedAtAction(nameof(GetOne), new { id = newUser.Id }, newUser.ToDTO()));
}
public async Task <ActionResult <TagDTO> > AddTag(TagDTO data)
{
var tag = await model.Tags.SingleOrDefaultAsync(tg => tg.Name == data.Name);
if (tag != null)
{
var error = new ValidationErrors().Add("This tag already exists !", nameof(tag.Name));
return(BadRequest(error));
}
var newTag = new Tag()
{
Name = data.Name,
};
model.Tags.Add(newTag);
var res = await model.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(CreatedAtAction(nameof(GetOne), new { id = newTag.Id }, newTag.ToDTO()));
}
public async Task <IActionResult> AddVote(VoteDTO data)
{
var post = await model.Posts.FindAsync(data.PostId);
if (post == null)
{
return(NotFound());
}
var vote = await model.Votes.SingleOrDefaultAsync(p => p.AuthorId == data.AuthorId && p.PostId == data.PostId);
var user = await model.Users.SingleOrDefaultAsync(u => u.Pseudo == User.Identity.Name);
if (user == null)
{
return(NotFound());
}
else if (data.UpDown == 1 && user.Reputation < 15)
{
return(NotFound("Vous devez avoir au moins une réputation de 15 pour voter positivement."));
}
else if (data.UpDown == -1 && user.Reputation < 30)
{
return(NotFound("Vous devez avoir au moins une réputation de 30 pour voter négativement."));
}
Vote newVote = new Vote()
{
UpDown = data.UpDown,
AuthorId = data.AuthorId,
PostId = data.PostId
};
if (vote != null)
{
model.Votes.Remove(vote);
if (vote.UpDown == 1)
{
post.User.Reputation -= 10;
}
else
{
post.User.Reputation += 2;
user.Reputation += 1;
}
}
model.Votes.Add(newVote);
if (data.UpDown == 1)
{
post.User.Reputation += 10;
}
else
{
post.User.Reputation -= 2;
user.Reputation -= 1;
}
await model.SaveChangesAsyncWithValidation();
return(NoContent());
}
