public virtual async Task <IActionResult> KnowledgebaseArticle(string articleId, [FromServices] ICustomerService customerService)
{
if (!_knowledgebaseSettings.Enabled)
{
return(RedirectToRoute("HomePage"));
}
var customer = _workContext.CurrentCustomer;
var article = await _knowledgebaseService.GetKnowledgebaseArticle(articleId);
if (article == null)
{
return(RedirectToAction("List"));
}
//ACL (access control list)
if (!_aclService.Authorize(article, customer))
{
return(InvokeHttp404());
}
//Store mapping
if (!_storeMappingService.Authorize(article))
{
return(InvokeHttp404());
}
var model = new KnowledgebaseArticleModel();
await PrepareKnowledgebaseArticleModel(model, article, customerService);
return(View("Article", model));
}
public async Task <IActionResult> EditArticle(KnowledgebaseArticleModel model, bool continueEditing)
{
var knowledgebaseArticle = await _knowledgebaseService.GetKnowledgebaseArticle(model.Id);
if (knowledgebaseArticle == null)
{
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
knowledgebaseArticle = await _knowledgebaseViewModelService.UpdateKnowledgebaseArticleModel(knowledgebaseArticle, model);
SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.Knowledgebase.KnowledgebaseArticle.Updated"));
return(continueEditing ? RedirectToAction("EditArticle", new { knowledgebaseArticle.Id }) : RedirectToAction("EditCategory", new { id = model.ParentCategoryId }));
}
//If we got this far, something failed, redisplay form
await _knowledgebaseViewModelService.PrepareCategory(model);
//Store
await model.PrepareStoresMappingModel(knowledgebaseArticle, _storeService, true);
//ACL
await model.PrepareACLModel(knowledgebaseArticle, true, _customerService);
return(View(model));
}
public virtual KnowledgebaseArticleModel PrepareKnowledgebaseArticleModel()
{
var model = new KnowledgebaseArticleModel();
model.Published = true;
model.AllowComments = true;
PrepareCategory(model);
return(model);
}
public virtual async Task <KnowledgebaseArticleModel> PrepareKnowledgebaseArticleModel()
{
var model = new KnowledgebaseArticleModel
{
Published = true,
AllowComments = true
};
await PrepareCategory(model);
return(model);
}
public IActionResult EditArticle(KnowledgebaseArticleModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageKnowledgebase))
{
return(AccessDeniedView());
}
var knowledgebaseArticle = _knowledgebaseService.GetKnowledgebaseArticle(model.Id);
if (knowledgebaseArticle == null)
{
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
knowledgebaseArticle = model.ToEntity(knowledgebaseArticle);
knowledgebaseArticle.UpdatedOnUtc = DateTime.UtcNow;
knowledgebaseArticle.Locales = UpdateLocales(knowledgebaseArticle, model);
knowledgebaseArticle.CustomerRoles = model.SelectedCustomerRoleIds != null?model.SelectedCustomerRoleIds.ToList() : new List <string>();
model.SeName = knowledgebaseArticle.ValidateSeName(model.SeName, knowledgebaseArticle.Name, true);
knowledgebaseArticle.SeName = model.SeName;
knowledgebaseArticle.Stores = model.SelectedStoreIds != null?model.SelectedStoreIds.ToList() : new List <string>();
knowledgebaseArticle.AllowComments = model.AllowComments;
_knowledgebaseService.UpdateKnowledgebaseArticle(knowledgebaseArticle);
_urlRecordService.SaveSlug(knowledgebaseArticle, model.SeName, "");
_customerActivityService.InsertActivity("UpdateKnowledgebaseArticle", knowledgebaseArticle.Id,
_localizationService.GetResource("ActivityLog.UpdateKnowledgebaseArticle"), knowledgebaseArticle.Name);
model.AvailableCustomerRoles = _customerService
.GetAllCustomerRoles(true)
.Select(cr => cr.ToModel())
.ToList();
model.AvailableStores = _storeService
.GetAllStores()
.Select(s => s.ToModel())
.ToList();
SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.Knowledgebase.KnowledgebaseArticle.Updated"));
return(continueEditing ? RedirectToAction("EditArticle", new { knowledgebaseArticle.Id }) : RedirectToAction("EditCategory", new { id = model.ParentCategoryId }));
}
//If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> CreateArticle(KnowledgebaseArticleModel model, bool continueEditing)
{
if (ModelState.IsValid)
{
var knowledgebaseArticle = await _knowledgebaseViewModelService.InsertKnowledgebaseArticleModel(model);
Success(_translationService.GetResource("Admin.Content.Knowledgebase.KnowledgebaseArticle.Added"));
return(continueEditing ? RedirectToAction("EditArticle", new { knowledgebaseArticle.Id }) : RedirectToAction("EditCategory", new { id = model.ParentCategoryId }));
}
//If we got this far, something failed, redisplay form
await _knowledgebaseViewModelService.PrepareCategory(model);
return(View(model));
}
public virtual void PrepareCategory(KnowledgebaseArticleModel model)
{
model.Categories.Add(new SelectListItem {
Text = "[None]", Value = ""
});
var categories = _knowledgebaseService.GetKnowledgebaseCategories();
foreach (var category in categories)
{
model.Categories.Add(new SelectListItem
{
Value = category.Id,
Text = category.GetFormattedBreadCrumb(categories)
});
}
}
public IActionResult KnowledgebaseArticle(string articleId)
{
if (!_knowledgebaseSettings.Enabled)
{
return(RedirectToRoute("HomePage"));
}
var model = new KnowledgebaseArticleModel();
var article = _knowledgebaseService.GetPublicKnowledgebaseArticle(articleId);
if (article == null)
{
return(RedirectToAction("List"));
}
PrepareKnowledgebaseArticleModel(model, article);
return(View("Article", model));
}
public IActionResult CreateArticle(KnowledgebaseArticleModel model, bool continueEditing)
{
if (ModelState.IsValid)
{
var knowledgebaseArticle = _knowledgebaseViewModelService.InsertKnowledgebaseArticleModel(model);
SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.Knowledgebase.KnowledgebaseArticle.Added"));
return(continueEditing ? RedirectToAction("EditArticle", new { knowledgebaseArticle.Id }) : RedirectToAction("EditCategory", new { id = model.ParentCategoryId }));
}
//If we got this far, something failed, redisplay form
_knowledgebaseViewModelService.PrepareCategory(model);
//Stores
model.PrepareStoresMappingModel(null, true, _storeService);
//ACL
model.PrepareACLModel(null, true, _customerService);
return(View(model));
}
public IActionResult CreateArticle(string parentCategoryId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageKnowledgebase))
{
return(AccessDeniedView());
}
var model = new KnowledgebaseArticleModel();
model.Categories.Add(new SelectListItem {
Text = "[None]", Value = ""
});
var categories = _knowledgebaseService.GetKnowledgebaseCategories();
foreach (var category in categories)
{
model.Categories.Add(new SelectListItem
{
Value = category.Id,
Text = category.GetFormattedBreadCrumb(categories)
});
}
model.AvailableCustomerRoles = _customerService
.GetAllCustomerRoles(true)
.Select(cr => cr.ToModel())
.ToList();
model.Published = true;
model.AvailableStores = _storeService
.GetAllStores()
.Select(s => s.ToModel())
.ToList();
model.AllowComments = true;
if (!string.IsNullOrEmpty(parentCategoryId))
{
model.ParentCategoryId = parentCategoryId;
}
AddLocales(_languageService, model.Locales);
return(View(model));
}
public virtual KnowledgebaseArticle InsertKnowledgebaseArticleModel(KnowledgebaseArticleModel model)
{
var knowledgebaseArticle = model.ToEntity();
knowledgebaseArticle.CreatedOnUtc = DateTime.UtcNow;
knowledgebaseArticle.UpdatedOnUtc = DateTime.UtcNow;
knowledgebaseArticle.Locales = model.Locales.ToLocalizedProperty(knowledgebaseArticle, x => x.Name, _urlRecordService);
model.SeName = knowledgebaseArticle.ValidateSeName(model.SeName, knowledgebaseArticle.Name, true);
knowledgebaseArticle.SeName = model.SeName;
knowledgebaseArticle.AllowComments = model.AllowComments;
_knowledgebaseService.InsertKnowledgebaseArticle(knowledgebaseArticle);
_urlRecordService.SaveSlug(knowledgebaseArticle, model.SeName, "");
_customerActivityService.InsertActivity("CreateKnowledgebaseArticle", knowledgebaseArticle.Id,
_localizationService.GetResource("ActivityLog.CreateKnowledgebaseArticle"), knowledgebaseArticle.Name);
return(knowledgebaseArticle);
}
public virtual async Task <IActionResult> KnowledgebaseArticle(string articleId, [FromServices] ICustomerService customerService)
{
if (!_knowledgebaseSettings.Enabled)
{
return(RedirectToRoute("HomePage"));
}
var customer = _workContext.CurrentCustomer;
var article = await _knowledgebaseService.GetKnowledgebaseArticle(articleId);
if (article == null)
{
return(RedirectToAction("List"));
}
//ACL (access control list)
if (!_aclService.Authorize(article, customer))
{
return(InvokeHttp404());
}
//Store acl
if (!_aclService.Authorize(article, _workContext.CurrentStore.Id))
{
return(InvokeHttp404());
}
//display "edit" (manage) link
if (await _permissionService.Authorize(StandardPermission.AccessAdminPanel, customer) && await _permissionService.Authorize(StandardPermission.ManageKnowledgebase, customer))
{
DisplayEditLink(Url.Action("EditArticle", "Knowledgebase", new { id = article.Id, area = "Admin" }));
}
var model = new KnowledgebaseArticleModel();
await PrepareKnowledgebaseArticleModel(model, article, customerService);
return(View("Article", model));
}
public virtual async Task <IActionResult> ArticleCommentAdd(string articleId, KnowledgebaseArticleModel model, bool captchaValid,
[FromServices] IWorkContext workContext, [FromServices] ICustomerService customerService)
{
if (!_knowledgebaseSettings.Enabled)
{
return(RedirectToRoute("HomePage"));
}
var article = await _knowledgebaseService.GetPublicKnowledgebaseArticle(articleId);
if (article == null || !article.AllowComments)
{
return(RedirectToRoute("HomePage"));
}
if (workContext.CurrentCustomer.IsGuest() && !_knowledgebaseSettings.AllowNotRegisteredUsersToLeaveComments)
{
ModelState.AddModelError("", _localizationService.GetResource("Knowledgebase.Article.Comments.OnlyRegisteredUsersLeaveComments"));
}
//validate CAPTCHA
if (_captchaSettings.Enabled && _captchaSettings.ShowOnArticleCommentPage && !captchaValid)
{
ModelState.AddModelError("", _captchaSettings.GetWrongCaptchaMessage(_localizationService));
}
if (ModelState.IsValid)
{
var customer = _workContext.CurrentCustomer;
var comment = new KnowledgebaseArticleComment {
ArticleId = article.Id,
CustomerId = customer.Id,
CommentText = model.AddNewComment.CommentText,
CreatedOnUtc = DateTime.UtcNow,
ArticleTitle = article.Name,
};
await _knowledgebaseService.InsertArticleComment(comment);
if (!customer.HasContributions)
{
await customerService.UpdateContributions(customer);
}
//notify a store owner
if (_knowledgebaseSettings.NotifyAboutNewArticleComments)
{
await _workflowMessageService.SendArticleCommentNotificationMessage(article, comment, _localizationSettings.DefaultAdminLanguageId);
}
//activity log
await _customerActivityService.InsertActivity("PublicStore.AddArticleComment", comment.Id, _localizationService.GetResource("ActivityLog.PublicStore.AddArticleComment"));
//The text boxes should be cleared after a comment has been posted
//That' why we reload the page
TempData["Grand.knowledgebase.addarticlecomment.result"] = _localizationService.GetResource("Knowledgebase.Article.Comments.SuccessfullyAdded");
return(RedirectToRoute("KnowledgebaseArticle", new { SeName = article.GetSeName(_workContext.WorkingLanguage.Id) }));
}
//If we got this far, something failed, redisplay form
await PrepareKnowledgebaseArticleModel(model, article, customerService);
return(View("Article", model));
}
private async Task PrepareKnowledgebaseArticleModel(KnowledgebaseArticleModel model, KnowledgebaseArticle article, ICustomerService customerService)
{
model.Content = article.GetLocalized(y => y.Content, _workContext.WorkingLanguage.Id);
model.Name = article.GetLocalized(y => y.Name, _workContext.WorkingLanguage.Id);
model.Id = article.Id;
model.ParentCategoryId = article.ParentCategoryId;
model.SeName = article.GetLocalized(y => y.SeName, _workContext.WorkingLanguage.Id);
model.AllowComments = article.AllowComments;
model.AddNewComment.DisplayCaptcha = _captchaSettings.Enabled && _captchaSettings.ShowOnArticleCommentPage;
var articleComments = await _knowledgebaseService.GetArticleCommentsByArticleId(article.Id);
foreach (var ac in articleComments)
{
var customer = await customerService.GetCustomerById(ac.CustomerId);
var commentModel = new KnowledgebaseArticleCommentModel {
Id = ac.Id,
CustomerId = ac.CustomerId,
CustomerName = customer.FormatUserName(_customerSettings.CustomerNameFormat),
CommentText = ac.CommentText,
CreatedOn = _dateTimeHelper.ConvertToUserTime(ac.CreatedOnUtc, DateTimeKind.Utc),
AllowViewingProfiles = _customerSettings.AllowViewingProfiles && customer != null && !customer.IsGuest(),
};
if (_customerSettings.AllowCustomersToUploadAvatars)
{
commentModel.CustomerAvatarUrl = await _pictureService.GetPictureUrl(
customer.GetAttributeFromEntity <string>(SystemCustomerAttributeNames.AvatarPictureId),
_mediaSettings.AvatarPictureSize,
_customerSettings.DefaultAvatarEnabled,
defaultPictureType : PictureType.Avatar);
}
model.Comments.Add(commentModel);
}
foreach (var id in article.RelatedArticles)
{
var a = await _knowledgebaseService.GetPublicKnowledgebaseArticle(id);
if (a != null)
{
model.RelatedArticles.Add(new KnowledgebaseArticleModel {
SeName = a.SeName,
Id = a.Id,
Name = a.Name
});
}
}
var category = await _knowledgebaseService.GetKnowledgebaseCategory(article.ParentCategoryId);
if (category != null)
{
string breadcrumbCacheKey = string.Format(ModelCacheEventConst.KNOWLEDGEBASE_CATEGORY_BREADCRUMB_KEY,
article.ParentCategoryId,
string.Join(",", _workContext.CurrentCustomer.GetCustomerRoleIds()),
_storeContext.CurrentStore.Id,
_workContext.WorkingLanguage.Id);
model.CategoryBreadcrumb = await _cacheManager.GetAsync(breadcrumbCacheKey, async() =>
(await category.GetCategoryBreadCrumb(_knowledgebaseService, _aclService, _storeMappingService))
.Select(catBr => new KnowledgebaseCategoryModel {
Id = catBr.Id,
Name = catBr.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id),
SeName = catBr.GetSeName(_workContext.WorkingLanguage.Id)
})
.ToList()
);
}
}
public virtual async Task <KnowledgebaseArticle> UpdateKnowledgebaseArticleModel(KnowledgebaseArticle knowledgebaseArticle, KnowledgebaseArticleModel model)
{
knowledgebaseArticle = model.ToEntity(knowledgebaseArticle);
knowledgebaseArticle.UpdatedOnUtc = DateTime.UtcNow;
knowledgebaseArticle.Locales = await model.Locales.ToLocalizedProperty(knowledgebaseArticle, x => x.Name, _seoSettings, _urlRecordService, _languageService);
model.SeName = await knowledgebaseArticle.ValidateSeName(model.SeName, knowledgebaseArticle.Name, true, _seoSettings, _urlRecordService, _languageService);
knowledgebaseArticle.SeName = model.SeName;
knowledgebaseArticle.AllowComments = model.AllowComments;
await _knowledgebaseService.UpdateKnowledgebaseArticle(knowledgebaseArticle);
await _urlRecordService.SaveSlug(knowledgebaseArticle, model.SeName, "");
await _customerActivityService.InsertActivity("UpdateKnowledgebaseArticle", knowledgebaseArticle.Id,
_localizationService.GetResource("ActivityLog.UpdateKnowledgebaseArticle"), knowledgebaseArticle.Name);
return(knowledgebaseArticle);
}
private async Task PrepareKnowledgebaseArticleModel(KnowledgebaseArticleModel model, KnowledgebaseArticle article, ICustomerService customerService)
{
model.Content = article.GetTranslation(y => y.Content, _workContext.WorkingLanguage.Id);
model.Name = article.GetTranslation(y => y.Name, _workContext.WorkingLanguage.Id);
model.Id = article.Id;
model.ParentCategoryId = article.ParentCategoryId;
model.SeName = article.GetTranslation(y => y.SeName, _workContext.WorkingLanguage.Id);
model.AllowComments = article.AllowComments;
model.AddNewComment.DisplayCaptcha = _captchaSettings.Enabled && _captchaSettings.ShowOnArticleCommentPage;
model.MetaTitle = article.GetTranslation(y => y.MetaTitle, _workContext.WorkingLanguage.Id);
model.MetaDescription = article.GetTranslation(y => y.MetaDescription, _workContext.WorkingLanguage.Id);
model.MetaKeywords = article.GetTranslation(y => y.MetaKeywords, _workContext.WorkingLanguage.Id);
var articleComments = await _knowledgebaseService.GetArticleCommentsByArticleId(article.Id);
foreach (var ac in articleComments)
{
var customer = await customerService.GetCustomerById(ac.CustomerId);
var commentModel = new KnowledgebaseArticleCommentModel
{
Id = ac.Id,
CustomerId = ac.CustomerId,
CustomerName = customer.FormatUserName(_customerSettings.CustomerNameFormat),
CommentText = ac.CommentText,
CreatedOn = _dateTimeService.ConvertToUserTime(ac.CreatedOnUtc, DateTimeKind.Utc),
};
model.Comments.Add(commentModel);
}
foreach (var id in article.RelatedArticles)
{
var a = await _knowledgebaseService.GetPublicKnowledgebaseArticle(id);
if (a != null)
{
model.RelatedArticles.Add(new KnowledgebaseArticleModel
{
SeName = a.SeName,
Id = a.Id,
Name = a.Name
});
}
}
var category = await _knowledgebaseService.GetKnowledgebaseCategory(article.ParentCategoryId);
if (category != null)
{
string breadcrumbCacheKey = string.Format(CacheKeyConst.KNOWLEDGEBASE_CATEGORY_BREADCRUMB_KEY,
article.ParentCategoryId,
string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
_workContext.CurrentStore.Id,
_workContext.WorkingLanguage.Id);
model.CategoryBreadcrumb = await _cacheBase.GetAsync(breadcrumbCacheKey, async() =>
(await category.GetCategoryBreadCrumb(_knowledgebaseService, _aclService, _workContext))
.Select(catBr => new KnowledgebaseCategoryModel
{
Id = catBr.Id,
Name = catBr.GetTranslation(x => x.Name, _workContext.WorkingLanguage.Id),
SeName = catBr.GetSeName(_workContext.WorkingLanguage.Id)
})
.ToList()
);
}
}
public static KnowledgebaseArticle ToEntity(this KnowledgebaseArticleModel model)
{
return(model.MapTo <KnowledgebaseArticleModel, KnowledgebaseArticle>());
}
public static KnowledgebaseArticle ToEntity(this KnowledgebaseArticleModel model, KnowledgebaseArticle destination)
{
return(model.MapTo(destination));
}
protected virtual List <LocalizedProperty> UpdateLocales(KnowledgebaseArticle article, KnowledgebaseArticleModel model)
{
List <LocalizedProperty> localized = new List <LocalizedProperty>();
foreach (var local in model.Locales)
{
var seName = article.ValidateSeName(local.SeName, local.Name, false);
_urlRecordService.SaveSlug(article, seName, local.LanguageId);
if (!(String.IsNullOrEmpty(local.Name)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "Name",
LocaleValue = local.Name,
});
}
if (!(String.IsNullOrEmpty(local.Content)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "Content",
LocaleValue = local.Content,
});
}
if (!(String.IsNullOrEmpty(local.MetaDescription)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "MetaDescription",
LocaleValue = local.MetaDescription,
});
}
if (!(String.IsNullOrEmpty(local.MetaKeywords)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "MetaKeywords",
LocaleValue = local.MetaKeywords,
});
}
if (!(String.IsNullOrEmpty(local.MetaTitle)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "MetaTitle",
LocaleValue = local.MetaTitle,
});
}
if (!(String.IsNullOrEmpty(seName)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "SeName",
LocaleValue = seName,
});
}
}
return(localized);
}
