public async Task UserPosts(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var request = new UserPostsModel(user.Login);
request.ShowNsfw = true;
request.ShowLowRated = true;
// Act
var response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results.First().Body, Is.Not.Empty);
Assert.That(response.Result.Results.First().Title, Is.Not.Empty);
Assert.That(response.Result.Results.First().Url, Is.Not.Empty);
Assert.That(response.Result.Results.First().Category, Is.Not.Empty);
Assert.That(response.Result.Results.First().Author, Is.Not.Empty);
Assert.That(response.Result.Results.First().Avatar, Is.Not.Null);
Assert.That(response.Result.Results.First().AuthorRewards, Is.Not.Null);
Assert.That(response.Result.Results.First().AuthorReputation, Is.Not.Null);
Assert.That(response.Result.Results.First().NetVotes, Is.Not.Null);
Assert.That(response.Result.Results.First().Children, Is.Not.Null);
Assert.That(response.Result.Results.First().Created, Is.Not.Null);
Assert.That(response.Result.Results.First().CuratorPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().TotalPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().PendingPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().MaxAcceptedPayout, Is.Not.Null);
Assert.That(response.Result.Results.First().TotalPayoutReward, Is.Not.Null);
Assert.That(response.Result.Results.First().Vote, Is.Not.Null);
Assert.That(response.Result.Results.First().Tags, Is.Not.Empty);
Assert.That(response.Result.Results.First().Depth, Is.Not.Null);
}
public async Task EditCommentTest(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowLowRated = true;
userPostsRequest.ShowNsfw = true;
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
var post = userPostsResponse.Result.Results.FirstOrDefault(i => i.Children > 0);
Assert.IsNotNull(post);
var namedRequest = new NamedInfoModel(post.Url);
var comments = await Api[apiName].GetComments(namedRequest, CancellationToken.None);
var comment = comments.Result.Results.FirstOrDefault(i => i.Author.Equals(user.Login));
Assert.IsNotNull(comment);
var editCommentRequest = new CreateOrEditCommentModel(user, post, comment, comment.Body += $" edited {DateTime.Now}", AppSettings.AppInfo);
var result = await Api[apiName].CreateOrEditComment(editCommentRequest, CancellationToken.None);
AssertResult(result);
}
public async Task UserPosts_With_User_Some_Votes_True(KnownChains apiName)
{
var user = Users[apiName];
var request = new UserPostsModel(user.Login)
{
Login = user.Login
};
request.ShowNsfw = true;
request.ShowLowRated = true;
var voded = false;
for (var i = 0; i < 10; i++)
{
var response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
AssertResult(response);
voded = response.Result.Results.Any(x => x.Vote);
if (voded)
{
break;
}
request.Offset = response.Result.Results.Last().Url;
}
Assert.IsTrue(voded);
}
public async Task Flag_Down_Already_Flagged(KnownChains apiName)
{
// Load last post
var user = Users[apiName];
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowNsfw = true;
userPostsRequest.ShowLowRated = true;
var posts = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
var lastPost = posts.Result.Results.First();
// Arrange
var request = new VoteModel(Users[apiName], lastPost, VoteType.Down);
// Act
var response = await Api[apiName].Vote(request, CancellationToken.None);
var response2 = await Api[apiName].Vote(request, CancellationToken.None);
// Assert
AssertResult(response2);
AssertResult(response2);
Assert.That(response2.Error.Message.Contains("You have already voted in a similar way.") ||
response2.Error.Message.Contains("Can only vote once every 3 seconds.") ||
response2.Error.Message.Contains("Duplicate transaction check failed") ||
response2.Error.Message.Contains("Vote weight cannot be 0.") ||
response2.Error.Message.Contains("('Voter has used the maximum number of vote changes on this comment.',)"), response2.Error.Message);
}
public async Task CreateCommentTest(KnownChains apiName)
{
var user = Users[apiName];
// Load last created post
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowNsfw = true;
userPostsRequest.ShowLowRated = true;
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
AssertResult(userPostsResponse);
var lastPost = userPostsResponse.Result.Results.First();
// 2) Create new comment
// Wait for 20 seconds before commenting
Thread.Sleep(TimeSpan.FromSeconds(20));
var createCommentModel = new CreateOrEditCommentModel(user, lastPost, $"Test comment {DateTime.Now:G}", AppSettings.AppInfo);
var createCommentResponse = await Api[apiName].CreateOrEditComment(createCommentModel, CancellationToken.None);
AssertResult(createCommentResponse);
Assert.That(createCommentResponse.IsSuccess, Is.True);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
// Load comments for this post and check them
var getCommentsRequest = new NamedInfoModel(lastPost.Url);
var commentsResponse = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
AssertResult(commentsResponse);
Assert.IsNotNull(commentsResponse.Result.Results.FirstOrDefault(i => i.Url.EndsWith(createCommentModel.Permlink)));
}
//base
private void GetUserPostsTest(StringBuilder sb, int num)
{
sb.Append($"{num}) GetUserPostsTest : ");
StepFinished?.Invoke(sb.ToString());
var limit = 3;
var request = new UserPostsModel(_user.Login)
{
ShowNsfw = _user.IsNsfw, ShowLowRated = _user.IsLowRated, Limit = limit
};
var response = _api.GetUserPosts(request, CancellationToken.None).Result;
if (IsError1(sb, limit, response, response.Result.Results.Count))
{
return;
}
request.Offset = response.Result.Results.Last().Url;
response = _api.GetUserPosts(request, CancellationToken.None).Result;
if (IsError2(sb, limit, response, request.Offset))
{
return;
}
sb.AppendLine("pass.");
}
public async Task VoteCommentTest(KnownChains apiName)
{
var user = Users[apiName];
// Load last created post
var userPostsRequest = new UserPostsModel(user.Login)
{
ShowLowRated = true, ShowNsfw = true
};
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
AssertResult(userPostsResponse);
var lastPost = userPostsResponse.Result.Results.First(i => i.Children > 0);
// Load comments for this post and check them
var getCommentsRequest = new NamedInfoModel(lastPost.Url);
var commentsResponse = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// 5) Vote up comment
var post = commentsResponse.Result.Results.First();
var voteUpCommentRequest = new VoteModel(user, post, VoteType.Up);
var voteUpCommentResponse = await Api[apiName].Vote(voteUpCommentRequest, CancellationToken.None);
AssertResult(voteUpCommentResponse);
Assert.That(voteUpCommentResponse.Result.IsSuccess, Is.True);
Assert.That(voteUpCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
Assert.That(voteUpCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
getCommentsRequest.Login = user.Login;
var commentsResponse2 = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// Check if last comment was voted
AssertResult(commentsResponse2);
var comm = commentsResponse2.Result.Results.FirstOrDefault(i => i.Url.Equals(post.Url, StringComparison.OrdinalIgnoreCase));
Assert.IsNotNull(comm);
Assert.That(comm.Vote, Is.True);
// 6) Vote down comment
var voteDownCommentRequest = new VoteModel(user, post, VoteType.Down);
var voteDownCommentResponse = await Api[apiName].Vote(voteDownCommentRequest, CancellationToken.None);
AssertResult(voteDownCommentResponse);
Assert.That(voteDownCommentResponse.Result.IsSuccess, Is.True);
Assert.That(voteDownCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
Assert.That(voteDownCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
getCommentsRequest.Login = user.Login;
var commentsResponse3 = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// Check if last comment was voted
AssertResult(commentsResponse3);
comm = commentsResponse3.Result.Results.FirstOrDefault(i => i.Url.Equals(post.Url, StringComparison.OrdinalIgnoreCase));
Assert.IsNotNull(comm);
Assert.That(comm.Vote, Is.False);
}
public IActionResult Index()
{
if (isLogin)
{
ViewData["myPost"] = UserPostsModel.myPostList((int)ViewData["uid"]);
}
return(View());
}
public async Task UserPosts_Invalid_Username(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var request = new UserPostsModel(user.Login + "x");
// Act
var response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
// Assert
Assert.That(response.Error.Message.Contains("Cannot get posts for this username"));
}
public async Task UserPosts_Without_User_All_Votes_False(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var request = new UserPostsModel(user.Login);
// Act
var response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results.Where(x => x.Vote).Any, Is.False);
}
public async Task GetUserPostsTest(KnownChains apiName)
{
var user = Users[apiName];
var request = new UserPostsModel(user.Login)
{
ShowNsfw = true,
ShowLowRated = true
};
var result = await Gateway[apiName].GetUserPosts(request, CancellationToken.None);
Assert.IsTrue(result.IsSuccess, result.Error?.Message);
}
public ActionResult Update(int id, PostModel model)
{
using (var context = new foodiesEntities1())
{
// Fetch existing entity
var thePostToUpdate = context.Posts.FirstOrDefault(m => m.PostID == id);
// Update entity based on model
thePostToUpdate.PostTitle = model.PostTitle;
// Save Changes
context.SaveChanges();
}
var model2 = new UserPostsModel();
List <Post> postList = null;
// Use EF to get MemeModels from the Database
// Unit of Work
using (var context = new foodiesEntities1())
{
// Fetch the Meme Entities!
postList = context.Posts.Select(m => m).ToList();
}
if (postList != null)
{
// Convert Meme Entities to Meme Models
foreach (var post in postList)
{
model2.UserPosts.Add(new PostModel()
{
PostID = post.PostID,
PostTitle = post.PostTitle,
PostURL = post.PostURL
});
}
}
return(RedirectToAction("Gallery"));
}
public async Task CreateComment_20_Seconds_Delay(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowLowRated = true;
userPostsRequest.ShowNsfw = true;
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
var lastPost = userPostsResponse.Result.Results.First();
var body = $"Test comment {DateTime.Now:G}";
var createCommentModel = new CreateOrEditCommentModel(Users[apiName], lastPost, body, AppSettings.AppInfo);
// Act
var response1 = await Api[apiName].CreateOrEditComment(createCommentModel, CancellationToken.None);
var response2 = await Api[apiName].CreateOrEditComment(createCommentModel, CancellationToken.None);
// Assert
AssertResult(response1);
AssertResult(response2);
Assert.That(response2.Error.Message.Contains("You may only comment once every 20 seconds.") || response2.Error.Message.Contains("Duplicate transaction check failed"), response2.Error.Message);
}
private async Task <ErrorBase> LoadNextPosts(CancellationToken ct)
{
var request = new UserPostsModel(UserName)
{
Login = AppSettings.User.Login,
Offset = OffsetUrl,
Limit = string.IsNullOrEmpty(OffsetUrl) ? ItemsLimit : ItemsLimit + 1,
ShowNsfw = AppSettings.User.IsNsfw,
ShowLowRated = AppSettings.User.IsLowRated
};
ErrorBase error;
bool isNeedRepeat;
do
{
var response = await Api.GetUserPosts(request, ct);
isNeedRepeat = ResponseProcessing(response, ItemsLimit, out error, nameof(TryLoadNextPosts));
} while (isNeedRepeat);
return(error);
}
public ActionResult Gallery(PostModel model)
{
var userId = User.Identity.GetUserId();
var userEmail = UserManager.GetEmail(userId);
var model2 = new UserPostsModel();
List <Post> postList = null;
// Use EF to get MemeModels from the Database
// Unit of Work
using (var context = new foodiesEntities1())
{
var user = context.DaPrUsers.FirstOrDefault(m => m.UserEmail == userEmail);
// Fetch the Meme Entities!
postList = context.Posts.Where(m => m.UserID == user.UserID).ToList();
}
if (postList != null)
{
// Convert Meme Entities to Meme Models
foreach (var post in postList)
{
model2.UserPosts.Add(new PostModel()
{
PostID = post.PostID,
PostTitle = post.PostTitle,
PostURL = post.PostURL,
IsVideo = post.IsVideo
});
}
}
return(View(model2));
}
public async Task <OperationResult <ListResponse <Post> > > GetUserPosts(UserPostsModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results.Any())
{
return(new OperationResult <ListResponse <Post> >(new ValidationError(string.Join(Environment.NewLine, results.Select(i => i.ErrorMessage)))));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
AddLoginParameter(parameters, model.Login);
AddCensorParameters(parameters, model);
var endpoint = $"user/{model.Username}/posts";
return(await Gateway.Get <ListResponse <Post> >(GatewayVersion.V1P1, endpoint, parameters, token));
}
public async Task UserPosts_Offset_Limit(KnownChains apiName)
{
var user = Users[apiName];
var request = new UserPostsModel(user.Login)
{
Limit = 10,
ShowLowRated = true,
ShowNsfw = true
};
var response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
AssertResult(response);
Assert.IsTrue(response.Result.Count == request.Limit);
request.Offset = response.Result.Results[5].Url;
response = await Api[apiName].GetUserPosts(request, CancellationToken.None);
Assert.IsTrue(response.Result.Results != null);
var url = response.Result.Results.First().Url;
Assert.IsFalse(string.IsNullOrEmpty(url));
Assert.IsTrue(url.Equals(request.Offset));
}
public async Task <OperationResult <ListResponse <Post> > > GetUserPosts(UserPostsModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results != null)
{
return(new OperationResult <ListResponse <Post> >(results));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
AddLoginParameter(parameters, model.Login);
AddCensorParameters(parameters, model);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1P1}/user/{model.Username}/posts";
return(await HttpClient.Get <ListResponse <Post> >(endpoint, parameters, token));
}
public HomeController(IApiRepo apiRepo, UserPostsModel userPostsModel)
{
_apiRepo = apiRepo;
_userPostsModel = userPostsModel;
}
