public async Task <ActionResult> PostBlog([FromBody] BlogPosts blog)
{
this.DB.Blogs.Add(blog);
await DB.SaveChangesAsync();
return(CreatedAtAction("getBlogs", new { id = blog.Id }, blog));
}
public ActionResult Create([Bind(Include = "Id,Title,Body,MediaURL,Published")] BlogPosts blogPosts, HttpPostedFileBase image)
{
if (ModelState.IsValid)
{
var Slug = StringUtilites.URLFriendly(blogPosts.Title);
if (String.IsNullOrWhiteSpace(Slug))
{
ModelState.AddModelError("Title", "Invalid title");
return(View(blogPosts));
}
if (db.Posts.Any(p => p.Slug == Slug))
{
ModelState.AddModelError("Title", "The title must be unique");
return(View(blogPosts));
}
if (ImageUploadValidator.IsWebFriendlyImage(image))
{
var fileName = Path.GetFileName(image.FileName);
image.SaveAs(Path.Combine(Server.MapPath("~/Uploads/"), fileName));
blogPosts.MediaUrl = "/Uploads/" + fileName;
}
blogPosts.Slug = Slug;
blogPosts.Created = DateTimeOffset.Now;
db.Posts.Add(blogPosts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(blogPosts));
}
public bool Delete(BlogPosts blogPost)
{
QuaintDatabaseManager db = new QuaintDatabaseManager(true);
try
{
bool flag = false;
db.AddParameters("BlogPostId", blogPost.BlogPostId);
int affectedRows = db.ExecuteNonQuery("Delete_BlogPost", true);
if (affectedRows > 0)
{
flag = true;
}
return(flag);
}
catch (Exception)
{
throw;
}
finally
{
db.Disconnect();
}
}
public ActionResult Create([Bind(Include = "ID,PostTitle,PostAuthor,PostTags,PostText,TitlePic,EditDate")] BlogPosts posts)
{
if (ModelState.IsValid)
{
String aDate = DateTime.UtcNow.ToString("yyMMddHHmmss");
posts.EditDate = aDate;
db.BlogPosts.Add(posts);
db.SaveChanges();
//grab id for new record
//Posts posts = db.Posts.
//int aId = int.Parse(db.Posts
// .OrderByDescending(b => b.ID)
// .Select(c => c.ID)
// .First()
// .ToString());
int aId = posts.ID;
//return RedirectToAction("Index");
return(RedirectToAction("Details", new { id = aId }));
}
//nn to drive to edit action...f**k f**k f**k --- done done done m**********r
return(View(posts));
}
public Guid Create(BlogPost blogPost)
{
blogPost.UniqueId = Guid.NewGuid();
blogPost.CreateDate = blogPost.ModifiedDate = DateTime.Now.ToJavaScriptMilliseconds();
BlogPosts.Add(blogPost);
return(blogPost.UniqueId);
}
protected void btnDisplay_Click(object sender, EventArgs e)
{
DataSet dat = BlogPosts.getPost(Convert.ToInt32(drpPosts.SelectedValue));
frmPosts.DataSource = dat;
frmPosts.DataBind();
}
public async Task <BlogPost> UpdateBlogPost(string slug, BlogPost blogPost)
{
BlogPosts existingBlogPost = await _rubiconContext.BlogPosts.FirstOrDefaultAsync(f => f.Slug == slug);
if (existingBlogPost == null)
{
throw new ArgumentException("There is no blog post for the provided slug.");
}
if (!string.IsNullOrEmpty(blogPost.Title))
{
existingBlogPost.Slug = SlugResolver.GetSlugFromTitle(blogPost.Title);
existingBlogPost.Title = blogPost.Title;
}
if (!string.IsNullOrEmpty(blogPost.Description))
{
existingBlogPost.Description = blogPost.Description;
}
if (!string.IsNullOrEmpty(blogPost.Body))
{
existingBlogPost.Body = blogPost.Body;
}
existingBlogPost.UpdatedAt = DateTime.Now;
await _rubiconContext.SaveChangesAsync();
return(Mapper.Map <BlogPost>(existingBlogPost));
}
private BlogPosts GetPostsByPage(int currentPage)
{
var posts = _posts.BlogPosts.Page(currentPage, PostsOnPageCount);
var model = new BlogPosts(currentPage, TotalPages(), posts.ToList());
return(model);
}
public void DeleteBlog(int id)
{
BlogPost toRemove = GetBlog(id);
BlogPosts.Remove(toRemove);
SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Title,Content,CategoryName,ImagePath,PostCreated,DateCreated,DateLastModified")] BlogPosts blogPosts)
{
if (id != blogPosts.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(blogPosts);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BlogPostsExists(blogPosts.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(blogPosts));
}
public void AddBlog(BlogPost toAdd)
{
toAdd.BlogWriter = Users.Single(u => u.Id == toAdd.BlogWriter.Id);
BlogPosts.Add(toAdd);
SaveChanges();
}
protected void btnDelete_Command(object sender, CommandEventArgs e)
{
try
{
string id = Convert.ToString(e.CommandArgument);
if (!string.IsNullOrEmpty(id))
{
BlogPostBLL blogPostBLL = new BlogPostBLL();
BlogPosts blogPost = new BlogPosts();
blogPost.BlogPostId = Convert.ToInt32(QuaintSecurityManager.Decrypt(id));
if (blogPost.BlogPostId > 0)
{
if (blogPostBLL.Delete(blogPost))
{
Alert(AlertType.Success, "Deleted successfully.");
LoadList();
}
else
{
Alert(AlertType.Error, "Failed to delete.");
}
}
}
}
catch (Exception)
{
Alert(AlertType.Error, "Failed to delete.");
}
}
/// <summary>
/// Gets the blog posts on a specified page
/// </summary>
/// <param name="i">The 0-based index of the page whose blog posts are queried.</param>
/// <returns>The blog posts on the specified page.</returns>
public async Task <BlogPostEntity[]> GetBlogPostsOnPageAsync(int i)
{
if (HasNotInitialized)
{
await InitAsync();
}
if (BlogPosts[i] == null)
{
BlogPosts[i] = (await _client.GetQueryBlogPostsResponseAsync(
selectColumns: new List <string>()
{
"PartitionKey",
"RowKey",
"Timestamp",
"Author",
"Text"
},
takeCount: numOfBlogPostsOnPage,
nextKeys: (PartitionKeys[i * numOfBlogPostsOnPage], RowKeys[i * numOfBlogPostsOnPage])
)).BlogPosts.ToArray();
await _localStorage.SetItemAsync(blogPostsKey, BlogPosts);
}
return(BlogPosts[i]);
}
private static void Run()
{
const int numberOfTestRuns = 1;
const int numberOfRecordsPerTestRun = 1;
BlogPosts.GenerateData(numberOfRecordsPerTestRun);
var sqliteTestRuns = new List <SQLiteTestRun>();
var doubletsTestRuns = new List <DoubletsTestRun>();
for (int i = 0; i < numberOfTestRuns; i++)
{
var sqliteTestRun = new SQLiteTestRun("test.db");
sqliteTestRun.Run();
sqliteTestRuns.Add(sqliteTestRun);
var doubletsTestRun = new DoubletsTestRun("test.links");
doubletsTestRun.Run();
doubletsTestRuns.Add(doubletsTestRun);
}
Console.WriteLine("SQLite results:");
var averageSqliteResults = GetResultsAverage(sqliteTestRuns);
Console.WriteLine(averageSqliteResults.ToString());
Console.WriteLine("Doublets results:");
var averageDoubletsResults = GetResultsAverage(doubletsTestRuns);
Console.WriteLine(averageDoubletsResults.ToString());
}
public void View_WhenCalled_ReturnsOKResult()
{
//Given //Arrange
/*
* var postList = new List<Post> {
* new Post {Id = 1, Title = "Post 1", Body = "Cuerpo del post 1", Autor = "Luis" },
* new Post {Id = 2, Title = "Post 2", Body = "Cuerpo del post 2", Autor = "Eduardo" },
* new Post {Id = 3, Title = "Post 3", Body = "Cuerpo del post 3", Autor = "Marcelo" }
* };
*/
var mockService = new Mock <IPostService>();
var fakePost = new Post {
Id = 1, Title = "Post 1", Body = "Cuerpo del post 1", Autor = "Luis"
};
mockService.Setup(serv => serv.GetById(1)).Returns(fakePost);
BlogPosts post = new BlogPosts(mockService.Object);
Post data = new Post {
Id = 1
};
// When // Act
var result = post.View(data.Id);
// Then // Assert
Assert.IsType <OkObjectResult>(result);
}
private bool IsTitleExist(BlogPosts blogPost)
{
try
{
DataTable dtList = GetAll();
var rows = dtList.AsEnumerable().Where(x => ((string)x["Title"]).ToString() == blogPost.Title);
DataTable dt = rows.Any() ? rows.CopyToDataTable() : dtList.Clone();
if (dt != null)
{
if (dt.Rows.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception)
{
throw;
}
}
public IActionResult DisplayFullBlogPost(int id)
{
var blogPost = (from item in _assignContext.BlogPosts where item.BlogPostId == id select item).FirstOrDefault();
if (blogPost != null)
{
BlogPosts blog = new BlogPosts();
blog.BlogPostId = blogPost.BlogPostId;
blog.Content = blogPost.Content;
blog.Posted = blogPost.Posted;
blog.Title = blogPost.Title;
var commentHash = (from c in _assignContext.Comments where c.BlogPostId == id select c).ToList();
foreach (Comments com in commentHash)
{
//Comments comment = new Comments();
blog.Comments.Add(com);
}
blog.User = (from user in _assignContext.Users where user.UserId == blogPost.UserId select user).FirstOrDefault();
return(View(blog));
}
else
{
return(NotFound());
}
}
// GET: Posts/Details/5
public ActionResult Details(int?id)
{
//if (id == null)
//{
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//}
//Posts posts = db.Posts.Find(id);
//if (posts == null)
//{
// return HttpNotFound();
//}
//return View(posts);
BlogPosts posts = db.BlogPosts.Find(id);
var qPict = db.BlogPicts.Where(q => q.PostFK == id).ToList();
var viewModel = new PostDetailViewModel
{
ID = posts.ID,
PostTitle = posts.PostTitle,
PostAuthor = posts.PostAuthor,
PostTags = posts.PostTags,
PostText = posts.PostText,
TitlePic = posts.TitlePic,
EditDate = posts.EditDate,
BlogPicts = qPict,
};
return(View(viewModel));
}
public void Add_WhenCalled_ReturnsOKResult()
{
//Given //Arrange
var mockService = new Mock <IPostService>();
Post data = new Post {
Title = "Titulo",
Body = "contenido del post",
Autor = "el equipo"
};
Post expected = new Post {
Id = 1,
Title = "Titulo",
Body = "contenido del post",
Autor = "el equipo"
};
mockService.Setup(serv => serv.Add(data)).Returns(expected);
BlogPosts post = new BlogPosts(mockService.Object);
// When // Act
var result = post.Add(data);
// Then // Assert
Assert.IsType <OkObjectResult>(result);
}
public IActionResult CreateBlogPost(BlogPosts blog, string userid, int IsAvailable)
{
var id = Convert.ToInt32(userid);
var currentTime = DateTime.Now;
bool choice = true;
blog.UserId = id;
blog.Posted = currentTime;
if (IsAvailable == 0)
{
choice = false;
}
else
{
choice = true;
}
var tempBlog = new BlogPosts()
{
UserId = id, Posted = currentTime, IsAvailable = choice, Content = blog.Content, ShortDescription = blog.ShortDescription, Title = blog.Title
};
_blogsterDataContext.BlogPosts.Add(tempBlog);
_blogsterDataContext.SaveChanges();
return(RedirectToAction("AddPhotos", "Home", new { id = tempBlog.BlogPostID }));
}
public void Index_WhenCalled_ReturnsOKResult()
{
//Given //Arrange
var mockService = new Mock <IPostService>();
var postList = new List <Post> {
new Post {
Id = 1, Title = "Post 1", Body = "Cuerpo del post 1", Autor = "Luis"
},
new Post {
Id = 2, Title = "Post 2", Body = "Cuerpo del post 2", Autor = "Eduardo"
},
new Post {
Id = 3, Title = "Post 3", Body = "Cuerpo del post 3", Autor = "Marcelo"
}
};
mockService.Setup(serv => serv.GetAll()).Returns(postList);
BlogPosts post = new BlogPosts(mockService.Object);
// When // Act
var result = (OkObjectResult)post.Index();
// Then // Assert
Assert.IsType <OkObjectResult>(result); // esto si esta pasando
//result.Value.Should().BeEquivalentTo(postList); // esto no esta pasando...
}
public BlogPosts GetPostsByTag(TagList tags)
{
using (BlogDatabaseContext context = new BlogDatabaseContext())
{
UnitOfWork uow = new UnitOfWork(context);
var efposts = uow.Blogs.GetBlogsByTag(tags.tagList);
List <BlogPost> blogPosts = new List <BlogPost>();
foreach (var efpost in efposts)
{
blogPosts.Add(_mapper.Map <BlogPost>(efpost));
blogPosts.Last().taglist = efpost.Taglist.Split(",").ToList();
}
blogPosts.OrderByDescending(u => u.updatedat.Date).ThenBy(u => u.updatedat.TimeOfDay);
BlogPosts blogPostsToReturn = new BlogPosts();
blogPostsToReturn.blogPosts = blogPosts;
blogPostsToReturn.postCount = blogPosts.Count();
return(blogPostsToReturn);
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
BlogPosts.Clear();
var items = await BlogStore.GetItemsAsync();
foreach (var item in items)
{
BlogPosts.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public ActionResult Create([Bind(Include = "Title,Abstract,BlogBody,Photo,Published")] BlogPosts blog, HttpPostedFileBase photo)
{
if (ModelState.IsValid)
{
if (ImageUploadValidator.IsWebFriendlyImage(photo))
{
var fileName = Path.GetFileName(photo.FileName);
fileName = Path.GetFileNameWithoutExtension(fileName) + "_" + DateTime.Now.Ticks + Path.GetExtension(fileName);
photo.SaveAs(Path.Combine(Server.MapPath("~/Uploads/"), fileName));
blog.Photo = "/Uploads/" + fileName;
}
var Slug = StringUtilities.URLFriendly(blog.Title);
if (String.IsNullOrWhiteSpace(Slug))
{
ModelState.AddModelError("Title", "Invalid Title");
return(View(blog));
}
if (db.Blogs.Any(p => p.Slug == Slug))
{
ModelState.AddModelError("Title", "Title must be unique");
return(View(blog));
}
blog.Slug = Slug;
blog.Created = DateTime.Now;
db.Blogs.Add(blog);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(blog));
}
public async Task <IActionResult> PutBlogPosts(int id, BlogPosts blogPosts)
{
if (id != blogPosts.BlogPostsId)
{
return(BadRequest());
}
_context.Entry(blogPosts).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BlogPostsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static BlogPosts.Buzzwords.BusinessEntities.Buzzword TranslateBuzzwordToBuzzword(BlogPosts.Buzzwords.DataContracts.Buzzword from)
{
BlogPosts.Buzzwords.BusinessEntities.Buzzword to = new BlogPosts.Buzzwords.BusinessEntities.Buzzword();
to.id = from.Id;
to.name = from.Name;
return to;
}
public ActionResult DeleteConfirmed(int id)
{
BlogPosts blogPosts = db.BlogPosts.Find(id);
db.BlogPosts.Remove(blogPosts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Blog/month/{month}
public ActionResult IndexMonth(string month)
{
string section = "blog";
string qString = "/blog";
Language language = new Language("en-US");
ContentPage contentPage = new ContentPage(qString);
if (contentPage.PageID != Guid.Empty)
{
ViewData = contentPage.GetSections();
ViewBag.Meta = contentPage.MetaTags;
MenuItem sideMenu = new MenuItem(Request.Url.AbsolutePath);
ViewBag.SideMenu = sideMenu.SiblingMenuCode();
ViewBag.Highlight = "$('." + section + "').addClass('active');";
}
DateTime currentMonth;
if (DateTime.TryParse(month.Substring(0, 2) + "/1/" + month.Substring(2), out currentMonth))
{
ViewBag.BlogHeaderExt = "Blogs From: " + currentMonth.ToString("MMMM yyyy");
}
else
{
ViewBag.BlogHeaderExt = "Blogs From: " + month.Substring(0, 2) + "-" + month.Substring(2);
}
//Paging defaults
int pg = 1;
int sz = 20;
//Retrieve / Store paging parameters
if (Request.QueryString["pg"] != null)
{
if (!Int32.TryParse(Request.QueryString["pg"].ToString(), out pg))
{
pg = 1;
}
}
if (Request.QueryString["sz"] != null)
{
if (!Int32.TryParse(Request.QueryString["sz"].ToString(), out sz))
{
sz = 20;
}
}
BlogPosts posts = new BlogPosts();
List <BlogPost> blogs = posts.PostsInMonth(month, pg, sz);
ViewBag.Pager = posts.MonthPager(month, pg, sz);
return(View("Index", blogs));
}
public void Delete(Guid uniqueId)
{
var blogPostToDelete = BlogPosts.FirstOrDefault(i => i.UniqueId == uniqueId);
if (blogPostToDelete != null)
{
BlogPosts.Remove(blogPostToDelete);
}
}
public void DeleteBlog(int id)
{
var toRemove = GetBlog(id);
if (toRemove == null)
{
throw new Exception();
}
BlogPosts.Remove(toRemove);
}
public ActionResult Edit([Bind(Include = "Id,Created,Updated,Title,Slug,Body,MediaURL,Published")] BlogPosts blogPosts)
{
if (ModelState.IsValid)
{
db.Entry(blogPosts).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(blogPosts));
}
public void Insert(BlogPosts.Buzzwords.DataContracts.Buzzword request)
{
Buzzword BuzzwordEntity = TranslateBetweenBuzzwordAndBuzzword.TranslateBuzzwordToBuzzword(request);
BuzzwordManager Manager = new BuzzwordManager();
Manager.Insert(BuzzwordEntity);
}
