public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
var article = articleService.GetArticle((int)id);
if (article == null)
{
return(HttpNotFound());
}
if (User.IsInRole("user"))
{
if (article.AuthorId != (await userService.GetUser(User.Identity.Name)).Id)
{
return(RedirectToAction("Login"));
}
}
EditArticleViewModel model = new EditArticleViewModel
{
Id = article.Id,
Name = article.Name,
Text = article.Text
};
return(View(model));
}
public async Task<IActionResult> Edit(EditArticleViewModel model)
{
if (ModelState.IsValid)
{
Article article = await applicationContext.Articles.FirstOrDefaultAsync(p => p.Id == model.Id);
article.Title = model.Title;
article.ShortDescription = model.ShortDescription;
article.FullDescription = model.FullDescription;
article.EditDate = DateTime.Now;
if (article != null)
{
applicationContext.Articles.Update(article);
Event evnt = new Event
{
Date = DateTime.Now,
Description = $"«{User.Identity.Name}» редактировал статью с названием «{article.Title}»"
};
await applicationContext.Events.AddAsync(evnt);
await applicationContext.SaveChangesAsync();
return RedirectToAction("Index", "Articles");
}
return NotFound();
}
return View();
}
public async Task <IActionResult> Save(EditArticleViewModel viewModel, Guid id, string backUrl)
{
if (ModelState.IsValid)
{
var userId = GetCurrentUserId();
var article = new Article
{
Id = id,
AuthorId = userId
};
if (await _articlesRepository.IsExist(id))
{
article = await _articlesRepository.GetById(id);
}
article.Title = viewModel.Title.Trim();
article.Content = viewModel.Content.Trim();
article.IsPublic = viewModel.IsPublic;
await _articlesRepository.Save(article);
return(Redirect(backUrl));
}
return(View("Edit", viewModel));
}
public bool UpdateArticle(EditArticleViewModel model, IIdentity identity)
{
if (string.IsNullOrEmpty(model.LID))
{
model.LID = model.DisplayTitle;
}
model.LID = SanitizeLID(model.LID);
var article = _repository.Articles.Where(x => x.ArticleID == model.ArticleID).FirstOrDefault();
if (article != null)
{
IgnoreSupportSameNameTypeInjection <Article> injection = new IgnoreSupportSameNameTypeInjection <Article>(
x => x.AddedBy,
x => x.AddedDate,
x => x.ArticleID
);
article.InjectFrom(injection, model);
article.UpdatedDate = DateTime.Now;
article.UpdatedBy = identity.Name;
return(_repository.SaveChanges() == 1);
}
return(false);
}
public EditArticleViewModel GetEditArticleModel(int id)
{
try
{
Article articleToEdit = dbHelper.GetArticleById(id);
//if (!articleToEdit.Publish) return null; // not published article will not be served
EditArticleViewModel model = new EditArticleViewModel
{
Id = articleToEdit.Id,
HtmlContent = articleToEdit.HtmlContent,
Name = articleToEdit.Name,
PublishDate = articleToEdit.PublishDate.ToShortDateString(),
Categories = dbHelper.GetAllCategories(),
SelectedCategoryId = articleToEdit.CategoryId,
Publish = articleToEdit.Publish,
Keywords = articleToEdit.Keywords
};
// Localize "Uncategorized" category
model.Categories.Where(c => c.Name == "Uncategorized").Single().Name = _localizer["Uncategorized"];
// URL rewriting
model.AllUrl = dbHelper.GetUrls(articleToEdit.Id);
model.ArticlesRoute = Configuration.WebsiteConfig.ArticleRoute;
return(model);
}
catch
{
return(null);
}
}
public async Task <IActionResult> Edit(Guid?id = null)
{
var model = new EditArticleViewModel
{
IsNew = true
};
var article = new Article();
if (id.HasValue)
{
var userId = GetCurrentUserId();
article = await _articlesRepository.GetById(id.Value);
//if it is not user own article
if (article.AuthorId != userId)
{
return(NotFound());
}
model.IsNew = false;
model.Title = article.Title;
model.Content = article.Content;
model.IsPublic = article.IsPublic;
}
model.ArticleId = article.Id.ToString();
var referer = Request.Headers["Referer"].ToString();
model.BackUrl = referer;
return(View(model));
}
public async Task <IActionResult> UpdateArticleAsync(Guid articleId, [FromBody] EditArticleViewModel model)
{
try
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status422UnprocessableEntity));
}
var endPoint = await BusConfigurator.GetEndPointAsync(RabbitMqConstants.ArticleWriteServiceQueue);
await endPoint.Send <IUpdateArticleCommand>(new
{
model.Id,
model.Body
});
return(Accepted());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public ActionResult Edit(EditArticleViewModel editArticleViewModel)
{
if (ModelState.IsValid)
{
ArticleModel article = db.Articles.Find(editArticleViewModel.Id);
var newDateTime = new DateTime(
editArticleViewModel.ArticleDate.Year,
editArticleViewModel.ArticleDate.Month,
editArticleViewModel.ArticleDate.Day,
editArticleViewModel.ArticleTime.Hour,
editArticleViewModel.ArticleTime.Minute,
editArticleViewModel.ArticleTime.Second
);
article.ArticleDateTime = newDateTime;
article.ArticleText = editArticleViewModel.ArticleText;
article.ArticleTitle = editArticleViewModel.ArticleTitle;
db.Entry(article).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(editArticleViewModel));
}
public void EditArticle(int id, EditArticleViewModel editArticleViewModel)
{
var articleToUpdate = this.DbContext.Articles.FirstOrDefault(a => a.Id == id);
if (articleToUpdate != null)
{
articleToUpdate.Title = editArticleViewModel.Title;
articleToUpdate.ShortDescription = editArticleViewModel.ShortDescription;
this.UploadArticleContent(editArticleViewModel.ArticleContent, articleToUpdate.ArticleContentFileName);
if (editArticleViewModel.MainPicture != null)
{
var oldImgFileName = this.DbContext.Articles.First(a => a.Id == id).MainPictureFileName;
if (File.Exists($"{GlobalConstants.ArticlesImageDirectoryPath}{oldImgFileName}"))
{
File.Delete($"{GlobalConstants.ArticlesImageDirectoryPath}{oldImgFileName}");
}
var newImgFileName = $"{Guid.NewGuid()}{GlobalConstants.JpegFileExtension}";
this.DbContext.Articles.First(a => a.Id == id).MainPictureFileName = this.FileService.UploadImageAsync(Constants.GlobalConstants.ArticlesImageDirectoryPath, newImgFileName, editArticleViewModel.MainPicture).Result;
}
this.DbContext.Articles.First(a => a.Id == id).EditedOn = DateTime.UtcNow;
this.DbContext.SaveChanges();
}
}
// GET: Topic/Edit/5
public ActionResult Edit(Guid?id)
{
CurrentAction.currentAction = "Manage-Article-Edit";
var Article = db.ApplicationArticles.Find(id);
if (Article == null)
{
return(HttpNotFound());
}
string tags = "";
foreach (var item in Article.Tags)
{
tags += (item.Tag + ",");
}
if (tags.Length > 0)
{
tags.Remove(tags.Length - 1, 1);
}
var model = new EditArticleViewModel
{
Id = Article.Id,
Title = Article.Title,
ArticleContent = Article.ArticleContent,
Tags = tags
};
return(View(model));
}
public ActionResult Edit(EditArticleViewModel model)
{
if (ModelState.IsValid)
{
var article = articleService.GetArticle(model.Id);
if (article == null)
{
ModelState.AddModelError("", "Article was not found");
}
else
{
article.Name = model.Name;
article.Text = model.Text;
var result = articleService.Update(article);
if (result.Succedeed)
{
article = articleService.GetArticle(model.Id);
return(View("Article", article));
}
else
{
ModelState.AddModelError("", result.Message);
}
}
}
return(View(model));
}
public async Task <IActionResult> EditArticle(EditArticleViewModel model)
{
if (!await _articleService.EditArticleAsync(model, _userId))
{
return(NotFound());
}
return(NoContent());
}
public void EditSelectedArticle(EditArticleViewModel eavm)
{
Article article = this.Context.Articles.Find(eavm.Id);
article.Content = eavm.Content;
article.Title = eavm.Title;
this.Context.SaveChanges();
}
public ActionResult Create(EditArticleViewModel model)
{
if (ModelState.IsValid)
{
_service.CreateArticle(model, User.Identity);
return(RedirectToAction("List"));
}
ViewBag.CategoryList = _categoryService.CategoriesLinks;
return(View("Edit", model));
}
public ActionResult EditArticle(EditArticleViewModel eavm)
{
if (ModelState.IsValid)
{
this._service.EditSelectedArticle(eavm);
return(RedirectToAction("All", "Articles"));
}
return(this.View(eavm));
}
public async Task <IActionResult> Edit(int id, EditArticleViewModel model)
{
var user = await GetCurrentUser();
try
{
var article = await _dbContext.Articles.FindAsync(id);
var origTitle = article.Title;
article.Title = model.Title;
if (article.Title != origTitle)
{
article.Slug = article.Title.Slugify();
}
var origBody = article.Body;
article.Body = model.Body;
article.UpdatedOn = _dateTimeService.GetNowUtc();
article.UpdatedUserId = user.Id;
article.RevisionCount++;
var revision = new ArticleRevision
{
ArticleId = id,
RevisionDate = _dateTimeService.GetNowUtc(),
Body = origBody,
Score = article.Score,
RevisionUserId = user.Id
};
_dbContext.ArticleRevisions.Add(revision);
await _dbContext.SaveChangesAsync();
try
{
await _searchService.IndexArticle(article);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error indexing article ID {article.Id}");
}
return(Redirect(Url.ViewArticleLink(id, article.Slug)));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error updating article ID {id}", model);
ModelState.AddModelError("", "Error updating article");
return(View(model));
}
}
public async Task <IActionResult> EditArticle(int id)
{
var articleDetailsViewModel = await _articleService.GetArticleDetailsViewModel(id);
var editArticleViewModel = new EditArticleViewModel
{
ArticleDetailsViewModel = articleDetailsViewModel
};
return(View(editArticleViewModel));
}
public async Task <ActionResult> EditArticle(EditArticleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IArticleManager articleManager = new ArticleManager();
await articleManager.EditArticle(model.Id, model.Title, model.Content, model.CategoryIds);
return(RedirectToAction("ArticleList"));
}
public ActionResult EditArticle(int?id)
{
if (!this._service.ArticleExists(id))
{
return(RedirectToAction("All", "Articles"));
}
EditArticleViewModel eavm = this._service.GetArticleToManage(id);
return(this.View(eavm));
}
public async Task <IActionResult> UpdateArticle(EditArticleViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("EditArticle", viewModel));
}
return(await articleService.UpdateArticle(viewModel.Id, viewModel.ArticleTitle, viewModel.Content)
? (IActionResult)RedirectToAction("Index").PushAlert("Article has been updated")
: View(viewModel.WithAlert("Updating article failed")));
}
public ActionResult EditArticle(EditArticleViewModel post)
{
if (string.IsNullOrEmpty(post.Article.Series.Slug))
{
this.ModelState.AddModelError(string.Empty, "A series is required");
}
if (string.IsNullOrEmpty(post.Article.Author.Slug))
{
this.ModelState.AddModelError(string.Empty, "An author is required");
}
if (!string.IsNullOrEmpty(post.Article.Author.Slug) && !this.User.IsAdmin && post.Article.Author.Slug != this.User.Identity.Name)
{
this.ModelState.AddModelError(string.Empty, "Only administrators can change authors.");
}
if (!this.ModelState.IsValid)
{
return(View(post));
}
try
{
if (post.OpenCommentDiscussionChecked && post.Article.DiscourseTopicId > 0)
{
DiscourseHelper.OpenCommentDiscussion((int)post.Article.Id, (int)post.Article.DiscourseTopicId);
}
Logger.Information("Creating or updating article \"{0}\".", post.Article.Title);
int?articleId = StoredProcs.Articles_CreateOrUpdateArticle(
post.Article.Id,
post.Article.Slug ?? this.User.Identity.Name,
post.PublishedDate,
post.Article.Status,
post.Article.Author.Slug,
post.Article.Title,
post.Article.Series.Slug,
post.Article.BodyHtml,
post.Article.DiscourseTopicId
).Execute();
post.Article.Id = post.Article.Id ?? articleId;
if (post.CreateCommentDiscussionChecked)
{
DiscourseHelper.CreateCommentDiscussion(post.Article);
}
return(RedirectToAction("index"));
}
catch (Exception ex)
{
post.ErrorMessage = ex.ToString();
return(View(post));
}
}
public async Task <IActionResult> EditArticle(EditArticleViewModel model)
{
var userId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (ModelState.IsValid)
{
adminService.EditArticle(model);
return(RedirectToAction("ArticlesForReview"));
}
return(RedirectToAction("NotPermitted"));
}
public JsonResult EditArticle(EditArticleViewModel model)
{
var errMsg = "";
if (!ModelState.IsValid)
{
foreach (var modelStateValue in ModelState.Values)
{
foreach (var error in modelStateValue.Errors)
{
errMsg += error.ErrorMessage + "\n";
}
}
return(Json(new ResponseData()
{
Success = false,
Message = "Bir hata oluştu, " + errMsg
}));
}
var dbArt = (_articleRepo as ArticleRepo);
var dbCat = (_categoryRepo as CategoryRepo);
var article = dbArt.GetAll().Include("Category")
.FirstOrDefault(x => x.Id == model.Id);
var category = dbCat.GetAll().FirstOrDefault(x => x.Name == model.Category);
if (category != null)
{
article.Category.Name = model.Category;
}
else
{
return(Json(new ResponseData()
{
Success = false,
Message = "Kaydetmek istediğiniz isimde kategori mevcut değildir."
}));
}
article.Title = model.Title;
article.ExistingTime = model.ExistingTime;
dbArt.Save();
return(Json(new ResponseData()
{
Success = true
}));
}
public ActionResult Edit(EditArticleViewModel model)
{
if (!ModelState.IsValid)
{
model.CategoriesList = CategorySelectList();
return(View(model));
}
var article = Mapper.Map <EditArticleViewModel, Article>(model);
_articleService.UpdateArticle(article);
Logger.Log.Info($"{User.Identity.Name} изменил статью №{article.ArticleId}");
return(RedirectToAction("Index", "Article"));
}
public IActionResult EditArticle(EditArticleViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(this.View(viewModel));
}
Article articleToEdit = mapper.Map <Article>(viewModel);
this.BlogService.EditArticle(articleToEdit);
return(RedirectToAction("Success", "Home", new { area = "" }));
}
public ActionResult Edit(EditArticleViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
_service.UpdateArticle(model, User.Identity);
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("List"));
}
ViewBag.CategoryList = _categoryService.CategoriesLinks;
return(View(model));
}
public ActionResult Add()
{
//Response.AddHeader("Access-Control-Allow-Origin", "http://storage.zigmaweb.com");
var viewModel = new EditArticleViewModel()
{
Content = new ContentRegistrationPM()
{
Published = false,
},
Tags = new List <string>()
};
return(View("Edit", viewModel));
}
public async Task <ActionResult> EditArticle(EditArticleViewModel model)
{
if (ModelState.IsValid)
{
IArticleManager articleManager = new ArticleManager();
await articleManager.EditArticle(model.ArticleId, model.Title, model.Content, model.CategoryIds);
return(RedirectToAction(nameof(ArticleList)));
}
var userId = Guid.Parse(Session["userId"].ToString());
ViewBag.CategoryIds = await new ArticleManager().GetAllCategories(userId);
return(View(model));
}
public ActionResult Save(EditArticleViewModel viewModel)
{
if (viewModel.Content.Id.HasValue)
{
ArticleService.EditArticle(viewModel.Content, viewModel.Tags);
}
else
{
viewModel.Content.AuthorId = User.UserId;
ArticleService.AddArticle(viewModel.Content, viewModel.Tags);
}
return(Json(new ProcessResult(new { ContentId = viewModel.Content.Id })));
}
public async Task <IActionResult> EditDraft(EditArticleViewModel model)
{
var userId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (ModelState.IsValid)
{
if (validationService.CheckDraftUserPermissions(userId, model.Id))
{
editorService.EditDraft(model);
}
return(RedirectToAction("AllDrafts"));
}
return(RedirectToAction("NotPermitted"));
}
