public async Task VotePostTest(KnownChains apiName) { var user = Users[apiName]; // Load last created post var userPostsRequest = new PostsModel(PostType.New) { Login = user.Login }; var userPostsResponse = await Api[apiName].GetPosts(userPostsRequest, CancellationToken.None); AssertResult(userPostsResponse); var lastPost = userPostsResponse.Result.Results.First(i => !i.Vote); // 4) Vote up var voteUpRequest = new VoteModel(user, lastPost, VoteType.Up) { VoteDelay = 0 }; var voteUpResponse = await Api[apiName].Vote(voteUpRequest, CancellationToken.None); AssertResult(voteUpResponse); Assert.That(voteUpResponse.IsSuccess, Is.True); //Assert.IsTrue(lastPost.TotalPayoutReward <= voteUpResponse.Result.NewTotalPayoutReward); // Wait for data to be writed into blockchain Thread.Sleep(TimeSpan.FromSeconds(15)); userPostsRequest.Offset = lastPost.Url; var userPostsResponse2 = await Api[apiName].GetPosts(userPostsRequest, CancellationToken.None); // Check if last post was voted AssertResult(userPostsResponse2); var post = userPostsResponse2.Result.Results.FirstOrDefault(i => i.Url.EndsWith(lastPost.Url, StringComparison.OrdinalIgnoreCase)); Assert.IsNotNull(post); Console.WriteLine("The server still updates the history"); //Assert.That(post.Vote, Is.True); // 3) Vote down var voteDownRequest = new VoteModel(user, lastPost, VoteType.Down) { VoteDelay = 0 }; var voteDownResponse = await Api[apiName].Vote(voteDownRequest, CancellationToken.None); AssertResult(voteDownResponse); Assert.That(voteDownResponse.IsSuccess, Is.True); //Assert.IsTrue(lastPost.TotalPayoutReward >= voteDownResponse.Result.NewTotalPayoutReward); // Wait for data to be writed into blockchain Thread.Sleep(TimeSpan.FromSeconds(15)); var userPostsResponse3 = await Api[apiName].GetPosts(userPostsRequest, CancellationToken.None); // Check if last post was voted AssertResult(userPostsResponse3); post = userPostsResponse3.Result.Results.FirstOrDefault(i => i.Url.Equals(lastPost.Url, StringComparison.OrdinalIgnoreCase)); Assert.IsNotNull(post); Console.WriteLine("The server still updates the history"); //Assert.That(post.Vote, Is.False); }
public HttpResponseMessage EditPost(int id, [FromBody] PostsModel postModel) { try { using (var blogdb = new blogdbEntities()) { posts newPost = (from p in blogdb.posts where p.id == id && p.id_author == loginUserId select p).SingleOrDefault(); if (newPost != null) { newPost.content = postModel.content; blogdb.Entry(newPost).State = EntityState.Modified; blogdb.SaveChanges(); return(Request.CreateResponse(HttpStatusCode.OK, "The Post was updated successfully.")); } else { return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "The Post with Id: " + id.ToString() + " not found to update")); } } } catch (Exception e) { return(Request.CreateResponse(HttpStatusCode.BadRequest, e.Message)); } }
public static PostsModel postsEntityToModel(PostsPics entity) { PostsModel posts = new PostsModel(); posts.postsID = entity.postsID; posts.postsContent = entity.postsContent; posts.postsMaker = entity.postsMaker; posts.postsLoved = entity.postsLoved; posts.postsMakeDate = entity.postsMakeDate; posts.postsPicCount = entity.postsPicCount; posts.postsReaded = entity.postsReaded; posts.postsPics = entity.postsPics; posts.makerName = entity.makerName; posts.picsSimpPath = entity.picSimpPath; posts.whenPosts = dateDiff(entity.postsMakeDate.GetValueOrDefault()); posts.makerPhoto = entity.makerPhoto; posts.makerID = entity.openId; posts.postsLocation = entity.postsLocation; posts.latitude = entity.latitude; posts.longitude = entity.longitude; posts.postsType = entity.postsType; posts.postsStatus = entity.postsStatus.Value; posts.ifOfficial = entity.ifOfficial; posts.picsRate = entity.picsRate; posts.ifUserLoved = entity.ifUserLoved > 0; posts.ifLY = entity.ifLY; return(posts); }
public async Task <IActionResult> PutPostsModel(int id, PostsModel postsModel) { if (id != postsModel.ID) { return(BadRequest()); } _context.Entry(postsModel).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PostsModelExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <PostsModel> > PostPostsModel(PostsModel postsModel) { _context.Posts.Add(postsModel); await _context.SaveChangesAsync(); return(CreatedAtAction("GetPostsModel", new { id = postsModel.ID }, postsModel)); }
protected override async Task OnParametersSetAsync() { var topicNode = await NodeService.GetAsync(Id); Topic = Models.Topic.Create(topicNode); TopicUserName = !string.IsNullOrEmpty(topicNode.CreatedBy) ? await UserService.GetUserNameAsync(topicNode.CreatedBy) : string.Empty; var forumNode = await NodeService.GetAsync(Topic.ForumId); Forum = Models.Forum.Create(forumNode); Posts = new PostsModel(NodeService) { NodeSearch = new NodeSearch() { Module = Constants.ForumsModule, Type = Constants.PostType, ParentId = Topic.Id, OrderBy = new string[] { OrderBy.Hot, OrderBy.Latest } } }; await Posts.InitAsync(); var loggedInUserId = (await AuthenticationStateTask).LoggedInUserId(); CanEditTopic = await SecurityService.AllowedAsync( loggedInUserId, Topic.CreatedBy, Constants.ForumsModule, Constants.TopicType, Actions.Edit ); CanDeleteTopic = await SecurityService.AllowedAsync( loggedInUserId, Topic.CreatedBy, Constants.ForumsModule, Constants.TopicType, Actions.Delete ); CanAddPost = await SecurityService.AllowedAsync( loggedInUserId, null, Constants.ForumsModule, Constants.PostType, Actions.Add ); CanVote = await SecurityService.AllowedAsync( loggedInUserId, null, Constants.ForumsModule, Constants.TopicType, Actions.Vote ); }
public JsonResult getPostsDetail(string postsId, string userId, int from, int count, DateTime refreshTime, string openId) { PostsHandler handler = new PostsHandler(); handler.viewPosts(openId, postsId); PostsModel result = new PostsModel(); bool ifLoved = false; List <RepliesModel> replies = new List <RepliesModel>(); List <PicsModel> pics = new List <PicsModel>(); bool ifFollowed = false; string lovedTimes = "0"; string readCount = string.Empty; bool ifLegal = handler.ifLegalPosts(postsId); List <RepliesModel> myReplies = new List <RepliesModel>(); string repliesCount = string.Empty; string shareCount = string.Empty; pics = handler.getAllPicsByPostsId(postsId); result = handler.getPostsDetail(postsId); ifLoved = handler.ifUserLoved(postsId, userId); repliesCount = handler.getRepliesCount(postsId); lovedTimes = handler.postsLoved(postsId); myReplies = handler.getMyReplies(postsId, from, count, refreshTime, openId); //replies = handler.getReplies(postsId, from, count, refreshTime, openId); ifFollowed = new UserHandler().ifFollowed(userId, postsId); readCount = handler.getReadCount(postsId); ifLegal = ifLegal && result.postsStatus != 1; shareCount = handler.getShareCount(postsId); bool ifMuted = new UserHandler().getConfigModel(openId).videoMuted == 1 ? true : false; return(Json(new { result = result, ifLoved = ifLoved, lovedTimes = lovedTimes, pics = pics, repliesCount = repliesCount, shareCount = shareCount, replies = replies, ifFollowed = ifFollowed, readCount = readCount, ifLegal = ifLegal, myReply = myReplies, ifMuted = ifMuted })); }
public void PostsRequest(string method) { switch (method) { case "get": _statusCode = GetCodeStatus(_postsEndpoint); _jsonString = GetJsonString(_postsEndpoint); _postsList = Posts.GetObject(_jsonString); break; case "post": _testObj = _postObject.GetTestObject("post"); AddPostContent(GetJsonString(_testObj)); _statusCode = GetCodeStatus(_postsEndpoint); break; case "put": _testObj = _postObject.GetTestObject("put"); AddPostContent(GetJsonString(_testObj)); _statusCode = GetCodeStatus(_postsEndpoint + "/8"); break; case "delete": _statusCode = GetCodeStatus(_postsEndpoint + "/4"); break; default: throw new ArgumentException($"The method {method} is not valid."); } }
public async Task <IActionResult> AddPost(PostsModel pm) { var claimsidentity = (ClaimsIdentity)this.User.Identity; var claims = claimsidentity.FindFirst(ClaimTypes.NameIdentifier); if (ModelState.IsValid) { var files = HttpContext.Request.Form.Files; if (files.Count() > 0) { byte[] pic = null; using (var filestream = files[0].OpenReadStream()) { using (var memorystream = new MemoryStream()) { filestream.CopyTo(memorystream); pic = memorystream.ToArray(); } } pm.Post = pic; } pm.UserId = claims.Value; _db.PostsModel.Add(pm); await _db.SaveChangesAsync(); return(RedirectToAction(nameof(YourPosts))); } return(View(pm)); }
public void PostsValidations(string method) { switch (method) { case "get": _testObj = _postObject.GetTestObject("get"); Assert.AreEqual(200, _statusCode); Assert.AreEqual(_testObj.Title, _postsList.Find(x => x.id == 1).Title); Assert.AreEqual(_testObj.Author, _postsList.Find(x => x.id == 1).Author); break; case "post": Assert.AreEqual(201, _statusCode); break; case "put": Assert.AreEqual(200, _statusCode); break; case "delete": Assert.AreEqual(200, _statusCode); break; default: throw new ArgumentException($"The method {method} is not valid."); } }
public HttpResponseMessage CreatePost([FromBody] PostsModel postModel) { try { using (var blogdb = new blogdbEntities()) { int lastPostId = (!blogdb.posts.Any()) ? 0 : blogdb.posts.OrderByDescending(p => p.id).First().id; int nextPostId = lastPostId + 1; posts newPost = new posts { id = nextPostId, id_author = loginUserId, content = postModel.content }; blogdb.Entry(newPost).State = EntityState.Added; blogdb.SaveChanges(); return(Request.CreateResponse(HttpStatusCode.OK, "The Post was created successfully.")); } } catch (Exception e) { return(Request.CreateResponse(HttpStatusCode.BadRequest, e.Message)); } }
public IActionResult Posts(string id) { PostsModel model = new PostsModel(); model.Posts = blogService.GetById(id).Posts; return(PartialView("PostsPartialView", model)); }
public IActionResult Add([FromBody] PostsModel postModel) { var postCreated = this._postsRepository.Add(postModel); return(Created(new Uri($"{Request.Path}/{postCreated.Id}", UriKind.Relative), postCreated)); //return CreatedAtAction("Add", new { postId = postCreated.Id }, postCreated); }
private Post GetFirstPostWhere(StringBuilder sb, PostType postType, Func <Post, bool> func) { var getPosts = new PostsModel(postType); Post testPost; do { var postsResp = _api.GetPosts(getPosts, CancellationToken.None) .Result; if (!postsResp.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}"); return(null); } if (postsResp.Result.Results.Count == 0) { sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts!"); return(null); } testPost = postsResp.Result.Results.FirstOrDefault(func); if (testPost == null) { getPosts.Offset = postsResp.Result.Results.Last().Url; } } while (testPost == null); return(testPost); }
private void GetPostsTest(StringBuilder sb, int num) { sb.Append($"{num}) GetPostsTest : "); StepFinished?.Invoke(sb.ToString()); var limit = 3; var request = new PostsModel(PostType.New) { ShowNsfw = _user.IsNsfw, ShowLowRated = _user.IsLowRated, Limit = limit }; var response = _api.GetPosts(request, CancellationToken.None).Result; if (IsError1(sb, limit, response, response.Result.Results.Count)) { return; } request.Offset = response.Result.Results.Last().Url; response = _api.GetPosts(request, CancellationToken.None).Result; if (IsError2(sb, limit, response, request.Offset)) { return; } sb.AppendLine("pass."); }
private void GetPostInfoTest(StringBuilder sb, int num) { sb.Append($"{num}) GetPostInfoTest : "); StepFinished?.Invoke(sb.ToString()); var getPosts = new PostsModel(PostType.Top); var postsResp = _api.GetPosts(getPosts, CancellationToken.None) .Result; if (!postsResp.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}"); return; } if (postsResp.Result.Results.Count == 0) { sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts!"); return; } var testPost = postsResp.Result.Results.First(); var request = new NamedInfoModel(testPost.Url); var response = _api.GetPostInfo(request, CancellationToken.None).Result; if (!response.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}"); return; } sb.AppendLine("pass."); }
public override void Run() { var client = new HttpClient { BaseAddress = new Uri(BaseUlr) }; PostsModel request = new PostsModel(postsUserId, postsTitle, postsBody); string json = JsonConvert.SerializeObject(request, Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); Reporter.LogInfo("Request: " + json); StringContent content = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = client.PostAsync("posts", content).Result; PostsModel parsedResponse = JsonConvert.DeserializeObject <PostsModel>(response.Content.ReadAsStringAsync().Result); Assert.Multiple(() => { Assert.IsTrue(response.IsSuccessStatusCode, $"Current status code is {response.StatusCode.ToString()}"); Assert.AreEqual(101, parsedResponse.Id); }); }
public bool Delete(PostsModel model) { try { using (var db = new PORTALEntities()) { var item = (from c in db.CmsPosts where c.PostId == model.PostId select c).FirstOrDefault(); if (item == null) { return(false); } item.IsDelete = true; item.DeleteDate = model.UpdateDate; item.DeleteUid = model.UpdateUid; db.SaveChanges(); return(true); } } catch (Exception ex) { LogHelper.Error("PostsRepository Delete: " + ex.Message + " Inner exception: " + ex.InnerException.Message); return(false); } }
public IActionResult Create(PostsModel model) { if (!this.User.IsAuthenticated) { return(this.RedirectToLogin()); } if (!this.IsValidModel(model)) { this.ShowError(CreateError); return(this.View()); } this.post.Create( model.Title, model.Content, this.Profile.Id); if (this.IsAdmin) { this.Log(LogType.CreatePost, model.Title); } return(this.RedirectToHome()); }
// // GET: /Post/ public ActionResult Index() { IEnumerable <Post> listPosts = PostDAO.GetAllPosts(); IEnumerable <PostsModel> listModelPosts = PostsModel.GetListPosts(listPosts); return(View(listModelPosts)); }
public async Task GetPostsTest(KnownChains apiName) { var request = new PostsModel(PostType.Top); var result = await Gateway[apiName].GetPosts(request, CancellationToken.None); Assert.IsTrue(result.IsSuccess, result.Error?.Message); }
public IActionResult ViewPostDetails(int postID) { // return Content("ViewPostDetails"); PostsModel foundPost = _context.postsList.Include(p => p.postSteps).FirstOrDefault(p => p.id == postID); return(View(foundPost)); // return Content($"{foundPost.title} and {foundPost.postBody}"); }
public PostsModel Add(PostsModel post) { lock (lockObject) { post.Id = this._posts.Count <= 0 ? 1 : this._posts.Max(p => p.Id) + 1; _posts.Add(post); return(post); } }
private void FollowTest(StringBuilder sb, int num) { sb.Append($"{num}) FollowTest : "); StepFinished?.Invoke(sb.ToString()); // Load last created post var getPosts = new PostsModel(PostType.New) { Login = _user.Login }; var postsResp = _api.GetPosts(getPosts, CancellationToken.None) .Result; if (!postsResp.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}"); return; } if (postsResp.Result.Results.Count == 0) { sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts to Follow!"); return; } var testPost = postsResp.Result.Results.First(); var votereq = new FollowModel(_user, FollowType.Follow, testPost.Author); var rez = _api.Follow(votereq, CancellationToken.None) .Result; if (!rez.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {rez.Error.Message}"); return; } Task.Delay(10000); var userFriendsReq = new UserFriendsModel(_user.Login, FriendsType.Followers) { Login = _user.Login, Offset = testPost.Author, Limit = 1 }; var verifyResp = _api.GetUserFriends(userFriendsReq, CancellationToken.None).Result; if (!verifyResp.IsSuccess) { sb.AppendLine($"fail. Reason:{Environment.NewLine} {verifyResp.Error.Message}"); return; } if (verifyResp.Result.Results.Count != 1) { sb.AppendLine($"fail. Reason:{Environment.NewLine} user ({testPost.Author}) not found!"); return; } sb.AppendLine("pass."); }
public async Task Posts_Top_Limit_Default(KnownChains apiName) { // Arrange var request = new PostsModel(PostType.Top); // Act var response = await Api[apiName].GetPosts(request, CancellationToken.None); // Assert AssertResult(response); }
public void Update(int postId, PostsModel post) { lock (lockObject) { var currentPost = this.GetPostById(postId); if (currentPost != null) { currentPost.Title = post.Title; currentPost.Description = post.Description; } } }
public string Update(PostsModel model) { //model.Id = Guid.NewGuid(); model.CreateUid = User.GetClaimValue(ClaimTypes.PrimarySid); model.CreateDate = System.DateTime.Now; if ((new PostsRepository()).UpdateFaq(model)) { return("OK"); } return("Error"); }
public void InsertPhotoPost(PostsModel photoPost) { SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@USERID", photoPost.UserId), new SqlParameter("@IMAGEURL", photoPost.PostedImage), new SqlParameter("@FILTER", photoPost.Filter), new SqlParameter("@GUID", photoPost.Guid), }; ExecuteSPNonReturnData("InsertPhotoPost", parameters); }
public ActionResult Delete(int id) { var model = new PostsModel() { PostId = id, UpdateUid = User.GetClaimValue(ClaimTypes.PrimarySid), UpdateDate = DateTime.Now }; var repository = new PostsRepository(); return(Json(repository.Delete(model) ? new { result = "OK" } : new { result = "ERROR" })); }
public ActionResult Insert() { var controllerId = this.ControllerContext.RouteData.Values["controller"].ToString() + "Controller"; ViewBag.Rights = (new AuthorizationRepository()).GetRights(controllerId, User.GetClaimValue(ClaimTypes.Role)); var model = new PostsModel() { IsActive = true }; return(View(model)); }
public async Task Posts_New(KnownChains apiName) { // Arrange var request = new PostsModel(PostType.New); // Act var response = await Api[apiName].GetPosts(request, CancellationToken.None); // Assert AssertResult(response); Assert.That(response.Result.Results, Is.Not.Empty); }
public void UpdatePhotoPost(PostsModel photoPost) { SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@USERID", photoPost.UserId), new SqlParameter("@SHORTCOMMENT", photoPost.SmallComment), new SqlParameter("@COMMENT", photoPost.BigComment), new SqlParameter("@LOCATION", photoPost.Location), new SqlParameter("@GUID", photoPost.Guid), }; ExecuteSPNonReturnData("UpdateUserPost", parameters); }
public PostsModel InsertPost(PostsModel sentPost) { string[] sampleFoods = new string[] { "burger.jpg", "coffee.jpg", "nuggets.jpg", "dogfood.jpg" }; string imageURL = "http://ugoforweb.azurewebsites.net/www/img/" + sampleFoods[new Random(Guid.NewGuid().GetHashCode()).Next(0,4)]; SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@USERID", sentPost.UserId), new SqlParameter("@SHORTCOMMENT", sentPost.SmallComment), new SqlParameter("@IMAGEURL", imageURL), new SqlParameter("@COMMENT", sentPost.BigComment), new SqlParameter("@LOCATION", sentPost.Location), }; var postedUser = ExecuteSPReturnData<PostsModel>("InsertUserPost", parameters).First(); return new PostsModel { ProfilePicURL = postedUser.ProfilePicURL, SmallComment = sentPost.SmallComment, TimePosted = "1s", PostedImage = imageURL, BigComment = sentPost.BigComment, Username = postedUser.Username }; }
public override Task ExecutePostProcessingAsync() { //Calling this method for new registration SignUpModel signUp = new SignUpModel(); PostsModel newPost = new PostsModel(); bool isASignUp = false; bool isAPhotoPost = false; // NOTE: FileData is a property of MultipartFileStreamProvider and is a list of multipart // files that have been uploaded and saved to disk in the Path.GetTempPath() location. foreach (var fileData in FileData) { if (fileData.Headers.ContentDisposition.FileName == null) { //do something here with the form data var pair = fileData.Headers.ContentDisposition.Name.Trim('"').Split('-'); switch (pair[0]) { case("uname"): signUp.Username = pair[1]; isASignUp = true; break; case("email"): signUp.Email = pair[1]; isASignUp = true; break; case("pass"): signUp.Password = pair[1]; isASignUp = true; break; case ("userid"): newPost.UserId = Convert.ToInt32(pair[1]); isAPhotoPost = true; break; case ("filtername"): newPost.Filter = pair[1]; isAPhotoPost = true; break; case ("guid"): newPost.Guid = pair[1]; isAPhotoPost = true; break; } continue; } // Sometimes the filename has a leading and trailing double-quote character // when uploaded, so we trim it; otherwise, we get an illegal character exception var fileName = Path.GetFileName(fileData.Headers.ContentDisposition.FileName.Trim('"')); //signUp.Password = pair[1]; // Retrieve reference to a blob var blobContainer = BlobHelper.GetBlobContainer(); var blob = blobContainer.GetBlockBlobReference(fileName); // Set the blob content type blob.Properties.ContentType = fileData.Headers.ContentType.MediaType; // Upload file into blob storage, basically copying it from local disk into Azure using (var fs = File.OpenRead(fileData.LocalFileName)) { //APPLY FILTERS HERE string passedFilter = string.IsNullOrEmpty(newPost.Filter) ? "" : newPost.Filter; //convert stream into image, and apply filter Image filterApplied = UGoFilters.ApplyFilter(passedFilter, Image.FromStream(fs)); //convert image to stream and upload blob.UploadFromStream(Compression.ToStream(filterApplied, 75)); } // Delete local file from disk File.Delete(fileData.LocalFileName); //Adding New User int id = 0; if (isASignUp) { signUp.ProfilePicURL = blob.Uri.AbsoluteUri; id = new SignUpModel().InsertNewUser(signUp); } //Adding a New Post else if (isAPhotoPost) { newPost.PostedImage = blob.Uri.AbsoluteUri; new PostsModel().InsertPhotoPost(newPost); } // Create blob upload model with properties from blob info var blobUpload = new BlobUploadModel { FileName = blob.Name, FileUrl = blob.Uri.AbsoluteUri, FileSizeInBytes = blob.Properties.Length, CustomData = id.ToString() }; // Add uploaded blob to the list Uploads.Add(blobUpload); } return base.ExecutePostProcessingAsync(); }
// POST: api/Posts public void Post(PostsModel sentPost) { new PostsModel().UpdatePhotoPost(sentPost); }