public async Task <ActionResult <Blog> > AddBlog(Blog newBlog)
{
try
{
if (newBlog == null)
{
return(BadRequest());
}
var CheckIfExists = await blogRepository.GetBlog(newBlog.Id);
if (CheckIfExists != null)
{
ModelState.AddModelError("Id", "Blog Already Exists");
return(BadRequest(ModelState));
}
var result = await blogRepository.AddBlog(newBlog);
return(CreatedAtAction(nameof(GetBlog), new { Id = newBlog.Id }, newBlog));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error retrieving data from the database"));
}
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
IdentityUser user = new IdentityUser {
Email = model.Email, UserName = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var blog = new Blog();
blog.User = user;
blog.Title = "Home";
_blogRepository.AddBlog(blog);
await _userManager.AddToRoleAsync(user, "user");
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
public ActionResult Create(Blog blog)
{
User user = _repository.FindByName(User.Identity.Name);
blog.ID = user.ID;
_repository.AddBlog(blog);
return(RedirectToAction("Index", "Post"));
}
public Blog Post([FromBody] Blog Blog)
{
if (ModelState.IsValid)
{
Blog = _Blogs.AddBlog(Blog);
_logger.Log(LogLevel.Information, this, LogFunction.Create, "Blog Added {Blog}", Blog);
}
return(Blog);
}
public Blog Post([FromBody] Blog Blog)
{
if (ModelState.IsValid && Blog.ModuleId == _authEntityId[EntityNames.Module])
{
Blog = _BlogRepository.AddBlog(Blog);
_logger.Log(LogLevel.Information, this, LogFunction.Create, "Blog Added {Blog}", Blog);
}
return(Blog);
}
public IActionResult Create(Blog entity)
{
if (ModelState.IsValid)
{
_blogRepository.AddBlog(entity);
return(RedirectToAction("List"));
}
ViewBag.Categories = new SelectList(_categoryRepository.GetAll(), "CategoryId", "Name");
return(View(entity));
}
public IActionResult Create(Blog entitiy)
{
if (ModelState.IsValid)
{
_blogRepository.AddBlog(entitiy);
TempData["message"] = Messages.BlogCreated;
return(RedirectToAction("List"));
}
ViewBag.Categories = new SelectList(_categoryRepository.GetAll(), "Id", "Name");
return(View(entitiy));
}
public IActionResult Create(Blog blog)
{
blog.Date = DateTime.Now;
if (ModelState.IsValid)
{
repository.AddBlog(blog);
return(RedirectToAction("Index"));
}
return(View(blog));
}
public ActionResult Create([Bind(Include = "Title,Body,Created")] Blog blog)
{
if (ModelState.IsValid)
{
if (_db.AddBlog(blog) && _db.Save())
{
return(RedirectToAction("Index"));
}
}
return(View(blog));
}
public ActionResult AddBlog([Bind(Exclude = "Id")] BlogVM blog)
{
//validation of model
if (ModelState.IsValid)
{
var newblogdata = Mapper.Map <BlogVM, Blog>(blog);
newblogdata.CreatedDate = DateTime.Now;
_blogRepository.AddBlog(newblogdata);
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Create(Blog entity)
{
entity.Date = DateTime.Now;
if (ModelState.IsValid)
{
_blogRepo.AddBlog(entity);
TempData["message"] = $"{entity.Title} kayıt edildi.";
return(RedirectToAction("List", "Blog"));
}
ViewBag.Categories = new SelectList(_categoryRepo.GetAll(), "CategoryId", "Name");
return(View(entity));
}
public IActionResult Create(Blog blog)
{
blog.Date = DateTime.Now;
if (ModelState.IsValid)
{
_blogRepository.AddBlog(blog);
return(RedirectToAction("List"));
}
ViewBag.Categories = new SelectList(_categoryRepository.GetAll(), "Id", "Name");
return(View(blog));
}
public async Task AddBlog(Blog blog, int blogStyleId)
{
var style = Mapper.Map <BlogStyle>(await _repository.GetBlogStyleById(blogStyleId));
blog.BlogStyle = style;
if (blog.ImagePath == null)
{
blog.ImagePath = style.DefaultImagePath;
}
await _repository.AddBlog(Mapper.Map <DAL.Interface.DTO.Blog>(blog));
}
public ActionResult Create(FormCollection formValues)
{
Blog blog = new Blog {
UserName = "******", RecCreationTime = DateTime.Now, ApplicationName = "/aalferez"
};
if (TryUpdateModel(blog))
{
BlogRepo.AddBlog(blog);
BlogRepo.SaveChanges();
return(RedirectToAction("Details", new { id = blog.BlogID }));
}
return(View());
}
public async Task <IActionResult> AddBlog(Blog blog)
{
if (ModelState.IsValid)
{
blog.User = await _userManager.GetUserAsync(HttpContext.User);
_blogRepository.AddBlog(blog);
return(RedirectToAction("Index"));
}
else
{
return(View(blog));
}
}
public ActionResult Create(Blog blog)
{
if (ModelState.IsValid)
{
var user = manager.FindById(User.Identity.GetUserId());
blog.Owner = user;
repository.AddBlog(blog);
TempData["message"] = string.Format("{0} has been saved", blog.BlogTitel);
return(RedirectToAction("Index"));
}
else
{
return(View(blog));
}
}
public IActionResult Create(BlogTablesViewModel model)
{
if (model == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var blog = _mapper.Map <BlogTablesViewModel, Blog>(model);
blog.AddedBy = _admin.Name;
blog.AddedDate = DateTime.Now;
_blogrepository.AddBlog(blog);
return(RedirectToAction("index"));
}
return(View(model));
}
public IActionResult Create(Blog entity)
{
if (ModelState.IsValid)
{
if (blogRepository.AddBlog(entity))
{
TempData["CreateBlogSuccess"] = "Blog başarılı bir şekilde oluşturuldu.";
}
else
{
TempData["CreateBlogError"] = "Blog oluşturulurken bir hata oluştu!";
}
}
return(RedirectToAction("EditSelect", new { id = entity.BlogId }));
}
public ActionResult Create(Blog newBlog, IFormCollection collection)
{
if (!ModelState.IsValid)
{
return(View(newBlog));
}
try
{
_blogRepo.AddBlog(newBlog);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public Blog Post([FromBody] Blog Blog)
{
try
{
if (ModelState.IsValid && Blog.ModuleId == EntityId)
{
Blog = Blogs.AddBlog(Blog);
logger.Log(LogLevel.Information, this, LogFunction.Create, "Blog Added {Blog}", Blog);
}
return(Blog);
}
catch (Exception ex)
{
logger.Log(LogLevel.Error, this, LogFunction.Create, ex, "Post Error {Error}", ex.Message);
throw;
}
}
public IActionResult Add(Blog entity, IFormFile pic)
{
if (ModelState.IsValid)
{
string filename = Path.Combine(he.WebRootPath, Path.GetFileName(pic.FileName));
string photo = filename.Split('/').Last();
pic.CopyTo(new FileStream("wwwroot/img/" + photo, FileMode.Create));
entity.Date = DateTime.Now;
entity.Image = photo;
repositoryblog.AddBlog(entity);
return(RedirectToAction("List"));
}
else
{
ViewBag.Categories = new SelectList(repositorycategory.GetAll(), "CategoryId", "Name");
}
return(View(entity));
}
public void ImportModule(Module module, string content, string version)
{
List <Blog> Blogs = null;
if (!string.IsNullOrEmpty(content))
{
Blogs = JsonSerializer.Deserialize <List <Blog> >(content);
}
if (Blogs != null)
{
foreach (Blog Blog in Blogs)
{
Blog _Blog = new Blog();
_Blog.ModuleId = module.ModuleId;
_Blog.Title = Blog.Title;
_Blog.Content = Blog.Content;
_Blogs.AddBlog(_Blog);
}
}
}
public async Task <IActionResult> Create(Blog model, IFormFile file)
{
if (file != null)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\img", file.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await file.CopyToAsync(stream);
}
model.Image = file.FileName;
}
model.Date = DateTime.Now;
if (ModelState.IsValid)
{
blogRepository.AddBlog(model);
return(RedirectToAction("List"));
}
return(View(model));
}
public async Task <IActionResult> Edit(Blog blog)
{
if (blog.Id > 0)
{
_blogRepository.UpdateBlog(blog);
}
else
{
_blogRepository.AddBlog(blog);
}
if (await _blogRepository.SaveChangesAsync())
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
public async Task <IActionResult> Create(Blog entity, IFormFile file)
{
if (ModelState.IsValid)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/img", file.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await file.CopyToAsync(stream);
}
entity.Image = file.FileName;
_blogRepo.AddBlog(entity);
return(RedirectToAction("Index"));
}
ViewBag.Authors = new SelectList(_authorRepo.GetAll(), "Id", "Fullname");
ViewBag.BlogDesc = new SelectList(_blogDescrepo.GetAll(), "Id", "Image");
return(View(entity));
}
public async Task <IActionResult> AddBlog([FromBody] BlogInfo blogInfo)
{
return(Ok(await _blogRepository.AddBlog(blogInfo)));
}
public void CreateBlog(Blog blog)
{
_blogRepository.AddBlog(blog);
}
public bool AddBlog(Blog blog, string[] ids) => _blogRepository.AddBlog(blog, ids);
public ActionResult <Blog> CreateBlog(Blog blog)
{
_logger.LogInformation("A blog is added");
_blogRepository.AddBlog(blog);
return(CreatedAtRoute("GetBlogById", new { Id = blog.BlogId }, blog));
}
