public async Task <ActionResult> DeleteSubmission(int id)
{
var cmd = new DeleteSubmissionCommand(id, "This feature is not yet implemented").SetUserContext(User);
var result = await cmd.Execute();
return(JsonResult(result));
}
public async Task <ActionResult> DeleteSubmission(int submissionId)
{
var cmd = new DeleteSubmissionCommand(submissionId, "This feature is not yet implemented");
var result = await cmd.Execute();
if (result.Success)
{
if (Request.IsAjaxRequest())
{
return(new HttpStatusCodeResult(HttpStatusCode.OK, result.Message));
}
else
{
return(Redirect(Request.Url.AbsolutePath));
}
}
else
{
if (Request.IsAjaxRequest())
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, result.Message));
}
else
{
return(Redirect(Request.Url.AbsolutePath));
}
}
}
public async Task AllowSubmittingDeletedLink()
{
var user = TestHelper.SetPrincipal("UnitTestUser31");
var cmd = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Subverse = SUBVERSES.Unit, Title = "I need to think of better titles but I don't want to get in trouble", Url = "http://i.deleted.this.on/purpose.jpg"
}).SetUserContext(user);
var r = await cmd.Execute();
VoatAssert.IsValid(r);
var id = r.Response.ID;
var cmd2 = new DeleteSubmissionCommand(id).SetUserContext(user);
var r2 = await cmd2.Execute();
VoatAssert.IsValid(r);
cmd = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Subverse = SUBVERSES.Unit, Title = "Hello Man - Longer because of Rules", Url = "http://i.deleted.this.on/purpose.jpg"
}).SetUserContext(user);
r = await cmd.Execute();
VoatAssert.IsValid(r);
}
public async Task DeleteSubmission_Moderator()
{
var user = TestHelper.SetPrincipal("TestUser13");
var cmd = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Subverse = SUBVERSES.Unit, Title = "This is a title", Content = "This is content a mod would hate"
}).SetUserContext(user);
var r = await cmd.Execute();
VoatAssert.IsValid(r);
Assert.IsNotNull(r.Response, "Expecting a non null response");
Assert.AreNotEqual(0, r.Response.ID);
user = TestHelper.SetPrincipal(USERNAMES.Unit);
var d = new DeleteSubmissionCommand(r.Response.ID, "This is content I hate").SetUserContext(user);
var r2 = await d.Execute();
VoatAssert.IsValid(r2);
//verify
using (var db = new Voat.Data.Repository(user))
{
var s = db.GetSubmission(r.Response.ID);
Assert.AreEqual(true, s.IsDeleted);
//Content should remain unchanged in mod deletion
Assert.AreEqual(s.Content, r.Response.Content);
Assert.AreEqual(s.FormattedContent, r.Response.FormattedContent);
//Assert.IsTrue(s.Content.StartsWith("Deleted by"));
//Assert.AreEqual(s.FormattedContent, Utilities.Formatting.FormatMessage(s.Content));
}
}
public async Task AllowSubmittingDeletedLink()
{
TestHelper.SetPrincipal("UnitTestUser31");
var cmd = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Subverse = "unit", Title = "I need to think of better titles but I don't want to get in trouble", Url = "http://i.deleted.this.on/purpose.jpg"
});
var r = await cmd.Execute();
Assert.IsNotNull(r, "Response was null");
Assert.IsTrue(r.Success, r.Message);
var id = r.Response.ID;
var cmd2 = new DeleteSubmissionCommand(id);
var r2 = await cmd2.Execute();
Assert.IsTrue(r2.Success, r2.Message);
cmd = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Subverse = "unit", Title = "Hello Man - Longer because of Rules", Url = "http://i.deleted.this.on/purpose.jpg"
});
r = await cmd.Execute();
Assert.IsNotNull(r, "Response was null");
Assert.IsTrue(r.Success, r.Message);
}
public async Task DeleteSubmission()
{
TestHelper.SetPrincipal("anon");
var cmd = new DeleteSubmissionCommand(3);
var r = await cmd.Execute();
Assert.IsTrue(r.Success, r.Message);
//Assert.Inconclusive();
}
public async Task <ActionResult> ModeratorDelete(string subverse, int submissionID, ModeratorDeleteContentViewModel model)
{
//New Domain Submission
//var q = new QuerySubmission(submissionID);
//var s = await q.ExecuteAsync();
//Legacy Data Submission (Since views expect this type, we use it for now)
var s = DataCache.Submission.Retrieve(submissionID);
ViewBag.Submission = s;
if (s == null || s.ID != model.ID)
{
ModelState.AddModelError("", "Can not find submission. Is it hiding?");
return(View(model));
}
if (s.IsDeleted)
{
ModelState.AddModelError("", "Can not delete a deleted post. Do you have no standards?");
return(View(model));
}
if (!ModeratorPermission.HasPermission(User, s.Subverse, Domain.Models.ModeratorAction.DeletePosts))
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.Unauthorized)));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var cmd = new DeleteSubmissionCommand(model.ID, model.Reason).SetUserContext(User);
var r = await cmd.Execute();
if (r.Success)
{
return(RedirectToRoute(Models.ROUTE_NAMES.SUBVERSE_INDEX, new { subverse = s.Subverse }));
}
else
{
ModelState.AddModelError("", r.Message);
return(View(model));
}
}
public async Task Bug_Trap_Positive_ContributionPoints_Removed()
{
//Test that when a user deletes comments and submissions with positive points, that the points are reset
var altList = new[] { "UnitTestUser10", "UnitTestUser11", "UnitTestUser12", "UnitTestUser13", "UnitTestUser14", "UnitTestUser15" };
var primaryUser = "******";
var currentUser = TestHelper.SetPrincipal(primaryUser);
var cmdSubmission = new CreateSubmissionCommand(new Domain.Models.UserSubmission()
{
Title = "Test Positive SCP Removed upon Delete", Content = "Does this get removed?", Subverse = "unit"
}).SetUserContext(currentUser);
var subResponse = await cmdSubmission.Execute();
VoatAssert.IsValid(subResponse);
var submissionID = subResponse.Response.ID;
var cmdComment = new CreateCommentCommand(submissionID, null, "This is my manipulation comment. Upvote. Go.").SetUserContext(currentUser);
var commentResponse = await cmdComment.Execute();
VoatAssert.IsValid(commentResponse);
var commentID = commentResponse.Response.ID;
var vote = new Func <int, Domain.Models.ContentType, string[], Task>(async(id, contentType, users) => {
foreach (string user in users)
{
var userIdentity = TestHelper.SetPrincipal(user);
switch (contentType)
{
case Domain.Models.ContentType.Comment:
var c = new CommentVoteCommand(id, 1, Guid.NewGuid().ToString()).SetUserContext(userIdentity);
var cr = await c.Execute();
VoatAssert.IsValid(cr);
break;
case Domain.Models.ContentType.Submission:
var s = new SubmissionVoteCommand(id, 1, Guid.NewGuid().ToString()).SetUserContext(userIdentity);
var sr = await s.Execute();
VoatAssert.IsValid(sr);
break;
}
}
});
await vote(commentID, Domain.Models.ContentType.Comment, altList);
var deleteComment = new DeleteCommentCommand(commentID).SetUserContext(currentUser);
var deleteCommentResponse = await deleteComment.Execute();
VoatAssert.IsValid(deleteCommentResponse);
//verify ups where reset
using (var context = new Voat.Data.Models.VoatDataContext())
{
var votes = context.CommentVoteTracker.Where(x => x.CommentID == commentID);
Assert.AreEqual(altList.Length, votes.Count());
var anyInvalid = votes.Any(x => x.VoteValue != 0);
Assert.IsFalse(anyInvalid, "Found comment votes with a non-zero vote value");
}
await vote(submissionID, Domain.Models.ContentType.Submission, altList);
var deleteSubmission = new DeleteSubmissionCommand(submissionID).SetUserContext(currentUser);
var deleteSubmissionResponse = await deleteSubmission.Execute();
VoatAssert.IsValid(deleteSubmissionResponse);
//verify ups where reset
using (var context = new Voat.Data.Models.VoatDataContext())
{
var votes = context.SubmissionVoteTracker.Where(x => x.SubmissionID == submissionID);
Assert.AreEqual(altList.Length + 1, votes.Count()); //author has a vote
var anyInvalid = votes.Any(x => x.VoteValue != 0);
Assert.IsFalse(anyInvalid, "Found submission votes with a non-zero vote value");
}
}
