public async Task <IActionResult> createPostAsync(PostWriteDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var postData = new posts();
postData.user_id = model.user_Id;
postData.message = model.message;
postData.created_at = DateTime.Now;
postData.updated_at = null;
uow.Post.Create(postData);
await uow.save();
return(Ok(new { success = true }));
}
catch (Exception ex)
{
return(Ok(ex.Message));
}
}
public void Get_InputId_CalledFindMethodOfDBSetWithCorrectId()
{
// Arrange
DbContextOptions opt = new DbContextOptionsBuilder <PostContext>()
.Options;
var mockContext = new Mock <PostContext>(opt);
var mockDbSet = new Mock <DbSet <posts> >();
mockContext
.Setup(context =>
context.Set <posts>(
))
.Returns(mockDbSet.Object);
posts expectedStreet = new posts()
{
postID = 1
};
mockDbSet.Setup(mock => mock.Find(expectedStreet.postID))
.Returns(expectedStreet);
var repository = new TestPostRepository(mockContext.Object);
//Act
var actualStreet = repository.Get(expectedStreet.postID);
// Assert
mockDbSet.Verify(
dbSet => dbSet.Find(
expectedStreet.postID
), Times.Once());
Assert.Equal(expectedStreet, actualStreet);
}
/* <summary>
* Saves a given post to the database
* </summary>
* <param name="post">The post to be saved to the database</param>
* <returns>Nothing</returns>
* <author>Janus</author>
*/
static public void SavePostToDB(posts post)
{
var db = new VERK2015_H17Entities1();
db.posts.Add(post);
db.SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("post_id,post_titel,post_txt,post_date,post_like")] posts posts)
{
if (id != posts.post_id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(posts);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!postsExists(posts.post_id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(posts));
}
IPostService GetPostService()
{
var mockContext = new Mock <IUnitOfWork>();
var expectedPost = new posts()
{
postID = 1, postName = "testN", postDate = "testDate", postAuthor = 1
};
var mockDbSet = new Mock <IPostsRepository>();
mockDbSet.Setup(z =>
z.Find(
It.IsAny <Func <posts, bool> >(),
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(
new List <posts>()
{
expectedPost
}
);
mockContext
.Setup(context =>
context.postss)
.Returns(mockDbSet.Object);
IPostService postService = new PostService(mockContext.Object);
return(postService);
}
public IHttpActionResult Putposts(decimal id, posts posts)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != posts.id)
{
return(BadRequest());
}
db.Entry(posts).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!postsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/* <summary>Counts the bursts on a post</summary>
* <param name="postBurst">Post model</param>
* <returns>Number of bursts on a post</returns>
* <author>Sveinbjorn</author>
*/
static public List <post_likes> GetBurstCount(posts postBurst)
{
var db = new VERK2015_H17Entities1();
var burstCount = (from x in db.post_likes.Where(y => y.posts.C_ID == postBurst.C_ID && y.post_burst == true)
select x).ToList();
return(burstCount);
}
public ActionResult editPostToDB(posts editPost)
{
var oldPost = _context.posts.Where(p => p.postID == editPost.postID).FirstOrDefault();
_context.Entry(oldPost).CurrentValues.SetValues(editPost);
_context.SaveChanges();
return(RedirectToAction("goToPostById", "posts", new { oldPost.postID }));
}
public ActionResult DeleteConfirmed(int id)
{
posts posts = db.posts.Find(id);
db.posts.Remove(posts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private posts GetListOfPostFromDataReader(IDataReader datareader)
{
objPost = new posts();
objPost.PostId = SafeTypeHandling.ConvertStringToInt32(datareader["PostId"]);
objPost.PostedBy = SafeTypeHandling.ConvertToString(datareader["Postedby"]);
return(objPost);
}
public async Task <IActionResult> editAsync(posts posts)
{
_ctx.posts.Add(posts);
await _ctx.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult addPost(int forumID)
{
posts post1 = new posts();
post1.forumID = forumID;
post1.userID = User.Identity.GetUserId();
post1.score = 0;
return(View(post1));
}
private posts GetLikeCountFromDataReader(IDataReader datareader)
{
objPost = new posts();
objPost.PostId = SafeTypeHandling.ConvertStringToInt32(datareader["PostId"]);
objPost.LikeBy = SafeTypeHandling.ConvertToString(datareader["LikeBy"]);
objPost.Identifier = SafeTypeHandling.ConvertToString(datareader["Identifier"]);
return(objPost);
}
public ActionResult Edit([Bind(Include = "id,title,body,posted_at")] posts posts)
{
if (ModelState.IsValid)
{
db.Entry(posts).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(posts));
}
public posts Search(string tag)
{
Throttle();
logger.Info("Downloading Tag data: " + tag);
string rawXml = webClient.DownloadString(String.Format(ROOT, tag));
StringReader rawXmlReader = new StringReader(rawXml);
posts result = (posts)xmlSerializerPosts.Deserialize(rawXmlReader);
return(result);
}
// Changes the total likes of a post based on actions.
static void UpdateLikeCounter(int PostId, int Ammount)
{
snaptergramEntities db = new snaptergramEntities();
posts ToChange = db.posts.Find(PostId);
ToChange.likes += Ammount;
db.Entry(ToChange).State = EntityState.Modified;
db.SaveChanges();
}
public async Task <IActionResult> Create([Bind("post_id,post_titel,post_txt,post_date,post_like")] posts posts)
{
if (ModelState.IsValid)
{
_context.Add(posts);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(posts));
}
public ActionResult Create([Bind(Include = "id,title,body,posted_at")] posts posts)
{
if (ModelState.IsValid)
{
db.posts.Add(posts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(posts));
}
public IHttpActionResult Getposts(decimal id)
{
posts posts = db.posts.Find(id);
if (posts == null)
{
return(NotFound());
}
return(Ok(posts));
}
public IHttpActionResult Postposts(posts posts)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.posts.Add(posts);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = posts.id }, posts));
}
public void DGPredicateBuilder1()
{
List <posts> posts = null;
posts _posts = null;
Expression <Func <posts, bool> > predicate = null;
Expression <Func <posts, bool> > predicateor = null;
//add post
_posts = new posts();
_posts.blogs_id = samplemodel.Blogs.FirstOrDefault(a => a.blogs_title == "Blog1").blogs_id;
_posts.posts_title = "Post3";
_posts.posts_text = "test text 1";
_posts.posts_username = "******";
_posts.posts_email = "*****@*****.**";
samplemodel.Posts.Add(_posts);
_posts = new posts();
_posts.blogs_id = samplemodel.Blogs.FirstOrDefault(a => a.blogs_title == "Blog1").blogs_id;
_posts.posts_title = "Post4";
_posts.posts_text = "test text 4";
_posts.posts_username = "******";
_posts.posts_email = "*****@*****.**";
samplemodel.Posts.Add(_posts);
predicate = DGPredicateBuilder.True <posts>();
predicate = predicate.And(r => r.posts_title == "Post3");
predicate = predicate.And(r => r.posts_username == "username");
posts = samplemodel.Posts.List(predicate).ToList();
Assert.That(posts.Count, Is.EqualTo(1));
predicate = DGPredicateBuilder.True <posts>();
predicate = predicate.And(r => r.posts_title == "Post3");
predicate = predicate.And(r => r.posts_username == "username");
predicate = predicate.And(r => r.posts_email == "[email protected]");
posts = samplemodel.Posts.List(predicate).ToList();
Assert.That(posts.Count, Is.EqualTo(0));
predicate = DGPredicateBuilder.True <posts>();
predicateor = DGPredicateBuilder.False <posts>();
predicateor = predicateor.Or(r => r.posts_title == "Post4");
predicateor = predicateor.Or(r => r.posts_title == "Post3");
predicate = predicate.And(predicateor);
posts = samplemodel.Posts.List(predicate).ToList();
Assert.That(posts.Count, Is.EqualTo(2));
predicate = DGPredicateBuilder.True <posts>();
predicateor = DGPredicateBuilder.False <posts>();
predicateor = predicateor.Or(r => r.posts_title == "Post4");
predicateor = predicateor.Or(r => r.posts_title == "Post3");
predicate = predicate.And(predicateor);
predicate = predicate.And(r => r.posts_title == "Post3");
posts = samplemodel.Posts.List(predicate).ToList();
Assert.That(posts.Count, Is.EqualTo(1));
}
public ActionResult Create([Bind(Include = "id,title,content,image,postdate,active,onlyregistercanread,iduser,idtag")] posts posts, string active, string onlyregistercanread)
{
posts.active = active == "on" ? false : true;
posts.onlyregistercanread = onlyregistercanread == "on" ? true : false;
posts.image = Session["lastImageName"] != null ? Session["lastImageName"].ToString() : null;
db.posts.Add(posts);
db.SaveChanges();
ViewBag.idtag = new SelectList(db.tags, "id", "description", posts.idtag);
ViewBag.iduser = new SelectList(db.users, "id", "name", posts.iduser);
return(RedirectToAction("Index"));
}
private posts GetCommentListOnPostFromDataReader(IDataReader datareader)
{
objPost = new posts();
objPost.CommentId = SafeTypeHandling.ConvertStringToInt32(datareader["CommentId"]);
objPost.PostId = SafeTypeHandling.ConvertStringToInt32(datareader["PostId"]);
objPost.Message = SafeTypeHandling.ConvertToString(datareader["Message"]);
objPost.UserCode = SafeTypeHandling.ConvertToString(datareader["UserCode"]);
objPost.CommentedBy = SafeTypeHandling.ConvertToString(datareader["CommentedBy"]);
objPost.CommentedByName = SafeTypeHandling.ConvertToString(datareader["CommentedByName"]);
objPost.CommentedDate = SafeTypeHandling.ConvertToString(datareader["CommentedDate"]);
objPost.Identifier = SafeTypeHandling.ConvertToString(datareader["Identifier"]);
return(objPost);
}
private posts GetPostFromDataReader(IDataReader datareader)
{
objPost = new posts();
objPost.PostId = SafeTypeHandling.ConvertStringToInt32(datareader["PostId"]);
objPost.Message = SafeTypeHandling.ConvertToString(datareader["Message"]);
objPost.PostedBy = SafeTypeHandling.ConvertToString(datareader["Postedby"]);
objPost.UserCode = SafeTypeHandling.ConvertToString(datareader["UserCode"]);
objPost.PostedByName = SafeTypeHandling.ConvertToString(datareader["PostedByName"]);
objPost.PostedDate = SafeTypeHandling.ConvertToString(datareader["PostedDate"]);
objPost.Status = SafeTypeHandling.ConvertToString(datareader["Status"]);
objPost.Remarks = SafeTypeHandling.ConvertToString(datareader["Remarks"]);
return(objPost);
}
public IHttpActionResult Deleteposts(decimal id)
{
posts posts = db.posts.Find(id);
if (posts == null)
{
return(NotFound());
}
db.posts.Remove(posts);
db.SaveChanges();
return(Ok(posts));
}
// GET: posts/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
posts posts = db.posts.Find(id);
if (posts == null)
{
return(HttpNotFound());
}
return(View(posts));
}
// Deletes a post from the database.
public static bool DeletePost(int PostId)
{
snaptergramEntities db = new snaptergramEntities();
// Try removing from the database.
posts ToDelete = db.posts.Find(PostId);
db.posts.Remove(ToDelete);
db.SaveChanges();
return(true);
}
private void HandlePosts(posts posts, int sourcetag)
{
if (posts.post != null)
{
foreach (postsPost post in posts.post)
{
int postId = Convert.ToInt32(post.id);
if (!TestForPost(postId))
{
HandlePost(post, sourcetag);
}
}
}
}
private void AddSpoilers(mydbContext mydb, posts post)
{
foreach (SpoilersItem item in Spoilers)
{
spoilers spoiler = new spoilers
{
name = item.name,
content = item.content,
posts = post
};
mydb.spoilers.Add(spoiler);
}
mydb.SaveChanges();
}
public posts AddPost(posts post)
{
try
{
ping_pakistanEntities db = new ping_pakistanEntities();
db.posts.Add(post);
db.SaveChanges();
return(post);
}
catch (Exception ex)
{
return(post);
}
}