public IActionResult BlogAdd(BlogViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.PhotoPath != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "BlogImages");
uniqueFileName = Guid.NewGuid().ToString().Replace("-", "") + "_" + model.PhotoPath.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.PhotoPath.CopyTo(new FileStream(filePath, FileMode.Create));
imageOptimizer.Optimize(filePath, logger);
}
Blog findedBlog = blogService.Get(x => x.Title.Equals(model.Title) && x.WebSite == CurrentWebsite, CurrentLanguage.id);
if (findedBlog != null)
{
findedBlog.Description = model.Description;
findedBlog.MetaTags = model.MetaTags;
findedBlog.Keywords = model.Keywords;
findedBlog.Content = model.Content;
findedBlog.Title = model.Title;
findedBlog.UpdateDate = DateTime.UtcNow;
findedBlog.UpdateUserid = LoginUser.id;
findedBlog.IsActive = model.IsActive;
findedBlog.Language = CurrentLanguage;
findedBlog.Name = model.Name;
findedBlog.WebSite = CurrentWebsite;
findedBlog.Priority = model.Priority;
if (!string.IsNullOrWhiteSpace(uniqueFileName))
{
findedBlog.PhotoPath = uniqueFileName;
}
blogService.Update(findedBlog);
}
else
{
findedBlog = new Blog()
{
Title = model.Title,
Name = model.Name,
PhotoPath = uniqueFileName,
Description = model.Description,
MetaTags = model.MetaTags,
Keywords = model.Keywords,
Content = model.Content,
CreateUserid = LoginUser.id,
CreateDate = DateTime.UtcNow,
IsActive = model.IsActive,
WebSite = CurrentWebsite,
Language = CurrentLanguage,
Priority = model.Priority
};
blogService.Add(findedBlog);
}
blogService.Save();
cacheService.Remove($"{CacheInfo.OrderedBlogs}-{CurrentWebsite.id}-{CurrentLanguage.id}");
cacheService.Remove($"{CacheInfo.Blog}-{findedBlog.id}-{CurrentWebsite.id}");
}
return(RedirectToAction("BlogAdd", "Pages", new { area = "Admin" }));
}
public IActionResult SaveEntity(BlogViewModel blogVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
if (blogVm != null && !string.IsNullOrEmpty(blogVm.SeoAlias))
{
blogVm.SeoAlias = TextHelper.ToUnsignString(blogVm.SeoAlias);
}
if (blogVm.Id == 0)
{
_blogService.Add(blogVm);
}
else
{
_blogService.Update(blogVm);
}
_blogService.Save();
return(new OkObjectResult(blogVm));
}
}
public IActionResult Post([FromBody] Blog data)
{
data.isActive = true;
var createdAbout = service.Add(data);
return(CreatedAtAction("Get", new { id = createdAbout.Data.Id }, createdAbout));
}
public IActionResult Add([FromQuery] Blog blog)
{
var blogResponse = blogService.Add(blog);
if (blogResponse.IsSucceeded && blogResponse.Result != null)
{
LogHelper.Info(_logger, new LogHelperModel
{
UserNo = "1",
UserName = "******",
Message = $"{blog.Title} Başlıklı Blog Eklendi.",
ActionTaken = "AddBlog"
});
return(Ok(new BlogViewModel()
{
Id = blogResponse.Result.Id,
CategoryTitle = blogResponse.Result.Category.Title,
Title = blogResponse.Result.Title,
Content = blogResponse.Result.Content,
PublishDate = blogResponse.Result.PublishDate,
ImageUrl = ImageHelper.GetImageUrlById(blogResponse.Result.ImageId)
}));
}
return(blogResponse.HttpGetResponse());
}
public ActionResult <ItemResponse <Blog> > Add(BlogAddRequest model)
{
int iCode = 200;
BaseResponse response;
try
{
int createdById = _authenticationService.GetCurrentUserId();
UserVeteranBase user = _authenticationService.GetCurrentUser();
int id = _blogService.Add(model, createdById);
response = new ItemResponse <int>()
{
Item = id
};
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
iCode = 500;
response = new ErrorResponse($"Generic Exception: {ex.Message}");
}
return(StatusCode(iCode, response));
}
public ActionResult <ItemResponse <int> > Create(BlogAddRequest model)
{
ObjectResult result = null;
try
{
int userId = _authService.GetCurrentUserId();
int id = _service.Add(model, userId);
ItemResponse <int> response = new ItemResponse <int>()
{
Item = id
};
result = Created201(response);
}
catch (Exception ex)
{
base.Logger.LogError(ex.ToString());
ErrorResponse response = new ErrorResponse(ex.Message);
result = StatusCode(500, response);
}
return(result);
}
public ActionResult Index(BlogViewModel data)
{
try
{
data.Blog.UserId = _BaseUser.Id;
data.Blog.InsDate = DateTime.Now;
data.Blog.EditDate = DateTime.Now;
if (data.Blog.Id <= 0)
{
_blogService.Add(data.Blog);
ViewBag.ErrMessage = "Added";
}
else
{
_blogService.Update(data.Blog);
ViewBag.ErrMessage = "Updated";
}
data.Blogs = _blogService.GetList(_BaseUser.Id);
return(View(data));
}
catch (Exception ex)
{
ViewBag.ErrMessage = ex.Message;
return(View(new BlogViewModel()));
}
}
public IActionResult Create(Blog blog)
{
if (HttpContext.Session.GetString("Name") == null)
{
return(RedirectToAction("Login", "Admin"));
}
if (blog.Order != 0)
{
var result = blogService.Get(x => x.Order == blog.Order && x.isDelete == false).Data;
if (blog.Id == 0)
{
if (result == null)
{
blog.DateTime = DateTime.Now;
var kayıt = blogService.Add(blog);
TempData["Mesaj"] = kayıt.BasariliMi ? "Kayıt Eklendi." : kayıt.Mesaj;
return(RedirectToAction("Create", "Blog"));
}
else
{
TempData["Mesaj"] = "Aynı sıra numarasına ait iki kayıt olamaz.";
return(View());
}
}
else
{
var kayıt = blogService.Get(x => x.Id == blog.Id).Data;
if (result == null)
{
blog.ImageUrl = kayıt.ImageUrl;
blog.DateTime = DateTime.Now;
blogService.Update(blog);
return(RedirectToAction("Index", "Blog"));
}
else
{
if (result.Order == kayıt.Order)
{
blog.ImageUrl = kayıt.ImageUrl;
blog.DateTime = DateTime.Now;
blogService.Update(blog);
return(RedirectToAction("Index", "Blog"));
}
else
{
TempData["Mesaj"] = "Aynı sıra numarasına ait iki kayıt olamaz.";
return(View());
}
}
}
}
else
{
TempData["Mesaj"] = "Sıra numarası giriniz.";
return(View());
}
}
public IActionResult YeniBlog(BlogAddDto blogAddDto)
{
if (ModelState.IsValid)
{
_blogService.Add(_mapper.Map <Blog>(blogAddDto));
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Post([FromBody] Blog blog)
{
try
{
return(Ok(_blogService.Add(blog).ToApiModel()));
}
catch (Exception ex)
{
ModelState.AddModelError("AddBlog", ex.Message);
return(BadRequest(ModelState));
}
}
//增加文章
public string Add(Blog blog)
{
blog.CreateDate = DateTime.Now;
if (blogService.Add(blog))
{
return("ok");
}
else
{
return("no");
}
}
public async Task <IActionResult> Add(CreateBlogDto createBlogDto)
{
var createBlogViewModel = CustomMapper.GetCreateBlogViewModel(createBlogDto);
var validationResult = await _blogService.Add(createBlogViewModel);
if (validationResult.IsValid)
{
return(Ok());
}
return(BadRequest(validationResult.Errors));
}
public async Task <IActionResult> Add([FromBody] BlogViewModel blogVm)
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "BLOG", Operations.Create);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
if (ModelState.IsValid)
{
int id = _blogService.Add(blogVm);
_blogService.SaveChanges();
return(new OkObjectResult(new { Id = id }));
}
return(new BadRequestObjectResult(ModelState));
}
public IActionResult SaveEntity(BlogViewModel pageVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (pageVm.Id == 0)
{
_blogService.Add(pageVm);
}
else
{
_blogService.Update(pageVm);
}
_blogService.Save();
return(new OkObjectResult(pageVm));
}
public IActionResult Create(BlogCreateViewModel model)
{
if (ModelState.IsValid)
{
SessionUser user = userSessionService.Get("LoginUser");
Category category = categoryService.Get(x => x.IsActive == true && x.id == model.Categoryid);
if (user != null && category != null)
{
Blog blog = new Blog()
{
Category = category,
Content = model.Content,
Title = model.Title,
Description = model.Discription,
Userid = user.id,
Tags = model.Tags,
CreateUserid = user.id
};
blogService.Add(blog);
blogService.Save();
}
else
{
ViewBag.ErrorMassage = "Kritik Hata";
}
}
else
{
ViewBag.ErrorMassage = "Tüm bilgileri eksiksiz giriniz.";
}
return(View(new BlogCreateViewModel()
{
Categories = categoryService.GetMany(x => x.IsActive == true).Select(a =>
new SelectListItem
{
Value = a.id.ToString(),
Text = a.Name
}).ToList(),
Categoryid = model.Categoryid,
Content = model.Content,
Title = model.Title
}));
}
public async Task <IActionResult> Create(Blog entity, IFormFile file)
{
if (ModelState.IsValid)
{
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);
entity.Image = file.FileName;
}
}
_blogService.Add(entity);
return(RedirectToAction("List"));
}
return(View(entity));
}
public async Task <IActionResult> Add(BlogViewModel model)
{
Blog blog;
try
{
ValidateModelState();
blog = await _service.Add(model.ToModel());
SetSuccess();
}
catch (BusinessException ex)
{
SetError(ex);
return(View(model));
}
return(RedirectToAction("details", new { id = blog.Id }));
}
public async Task <IActionResult> SaveEntity(BlogViewModel blogVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
blogVm.SeoAlias = TextHelper.ToUnsignString(blogVm.Name);
if (blogVm.Id == 0)
{
await _blogService.Add(blogVm);
}
else
{
await _blogService.Update(blogVm);
}
_blogService.Save();
return(new OkObjectResult(blogVm));
}
}
public IActionResult AddOrUpdateBlog(string dataJson)
{
var dataObj = JsonConvert.DeserializeObject <BlogModel>(dataJson);
try
{
if (!string.IsNullOrWhiteSpace(dataObj.Id))
{
var entity = _blogService.GetById(dataObj.Id);
entity = dataObj.ToEntity(entity);
_blogService.Update(entity);
_blogService.UpdateToCategory(entity.Id, dataObj.CategoryId);
}
else
{
var entity = dataObj.ToEntity();
_blogService.Add(entity);
_blogService.AddToCategory(new BlogCategory()
{
BlogId = entity.Id, CategoryId = dataObj.CategoryId
});
}
}
catch (Exception ex)
{
return(Json(new
{
status = false,
message = ex.Message
}));
}
return(Json(new {
status = true,
message = "Lưu dữ liệu thành công"
}));
}
public async Task <IActionResult> SaveBlog(BlogViewModel blogViewModel)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
if (Request.Form.Files != null && Request.Form.Files.Count > 0)
{
var file = Request.Form.Files[0];
var imagePhysicalPath = $@"{_hostingEnvironment.WebRootPath}\client-side\images\blog\{file.FileName}";
using (FileStream fs = System.IO.File.Create(imagePhysicalPath))
{
await file.CopyToAsync(fs);
await fs.FlushAsync();
}
}
blogViewModel.SeoAlias = TextHelper.ToUnsignString(blogViewModel.Name);
blogViewModel.SeoDescription = blogViewModel.Description;
blogViewModel.SeoKeyword = $"Blog: {blogViewModel.Name} - {DateTime.Now}";
blogViewModel.SeoPageTitle = $"Blog: {blogViewModel.Name}";
if (blogViewModel.Id != 0)
{
_blogService.Update(blogViewModel);
}
else
{
_blogService.Add(blogViewModel);
}
_blogService.Save();
return(new OkResult());
}
public void Add(Blog blog)
{
_blogService.Add(blog);
}
public BlogViewModel Create(BlogViewModel viewModel)
{
return(_blogService.Add(viewModel));
}
public IActionResult AddBlog([FromBody] Blog entity)
{
_blogService.Add(entity);
_logger.LogInformation("Added | " + entity.Title);
return(Ok());
}
public ActionResult <Blog> PostBlog(Blog blog)
{
blogService.Add(blog);
return(CreatedAtAction("GetBlog", new { id = blog.Id }, blog));
}
public IActionResult Index()
{
_blogService.Add();
return(View());
}
public IActionResult Add(BlogContract contract)
{
return(Ok(_blogService.Add(contract)));
}
