public virtual void DeleteKnowledgebaseCategoryModel(KnowledgebaseCategory knowledgebaseCategory)
{
_knowledgebaseService.DeleteKnowledgebaseCategory(knowledgebaseCategory);
_customerActivityService.InsertActivity("DeleteKnowledgebaseCategory", knowledgebaseCategory.Id,
_localizationService.GetResource("ActivityLog.DeleteKnowledgebaseCategory"), knowledgebaseCategory.Name);
}
public async Task CanGetPublicKnowledgebaseCategories()
{
ClearCategoryRepository();
var category1 = new KnowledgebaseCategory {
Name = "CanGetPublicKnowledgebaseCategoriesPublic1", Published = true
};
var category2 = new KnowledgebaseCategory {
Name = "CanGetPublicKnowledgebaseCategoriesPublic2", Published = true
};
var category3 = new KnowledgebaseCategory {
Name = "CanGetPublicKnowledgebaseCategoriesNotPublic", Published = false
};
await _knowledgebaseService.InsertKnowledgebaseCategory(category1);
await _knowledgebaseService.InsertKnowledgebaseCategory(category2);
var found = await _knowledgebaseService.GetPublicKnowledgebaseCategories();
Assert.AreEqual(2, found.Count);
Assert.AreEqual(true, found.Any(x => x.Name == "CanGetPublicKnowledgebaseCategoriesPublic1"));
Assert.AreEqual(true, found.Any(x => x.Name == "CanGetPublicKnowledgebaseCategoriesPublic2"));
Assert.AreEqual(false, found.Any(x => x.Name == "CanGetPublicKnowledgebaseCategoriesNotPublic"));
}
/// <summary>
/// Get category breadcrumb
/// </summary>
/// <param name="category">Category</param>
/// <param name="allCategories">All categories</param>
/// <param name="aclService">ACL service</param>
/// <param name="storeMappingService">Store mapping service</param>
/// <param name="showHidden">A value indicating whether to load hidden records</param>
/// <returns>Category breadcrumb </returns>
public static IList <KnowledgebaseCategory> GetCategoryBreadCrumb(this KnowledgebaseCategory category, IList <KnowledgebaseCategory> allCategories)
{
if (category == null)
{
throw new ArgumentNullException("category");
}
var result = new List <KnowledgebaseCategory>();
//used to prevent circular references
var alreadyProcessedCategoryIds = new List <string>();
while (category != null && !alreadyProcessedCategoryIds.Contains(category.Id)) //prevent circular references
{
result.Add(category);
alreadyProcessedCategoryIds.Add(category.Id);
category = (from c in allCategories
where c.Id == category.ParentCategoryId
select c).FirstOrDefault();
}
result.Reverse();
return(result);
}
public virtual async Task DeleteKnowledgebaseCategoryModel(KnowledgebaseCategory knowledgebaseCategory)
{
await _knowledgebaseService.DeleteKnowledgebaseCategory(knowledgebaseCategory);
await _customerActivityService.InsertActivity("DeleteKnowledgebaseCategory", knowledgebaseCategory.Id,
_translationService.GetResource("ActivityLog.DeleteKnowledgebaseCategory"), knowledgebaseCategory.Name);
}
/// <summary>
/// Get category breadcrumb
/// </summary>
/// <param name="category">Category</param>
/// <param name="categoryService">Category service</param>
/// <param name="aclService">ACL service</param>
/// <param name="storeMappingService">Store mapping service</param>
/// <param name="showHidden">A value indicating whether to load hidden records</param>
/// <returns>Category breadcrumb </returns>
public static IList <KnowledgebaseCategory> GetCategoryBreadCrumb(this KnowledgebaseCategory category,
IKnowledgebaseService knowledgebaseService,
IAclService aclService,
IStoreMappingService storeMappingService,
bool showHidden = false)
{
if (category == null)
{
throw new ArgumentNullException("category");
}
var result = new List <KnowledgebaseCategory>();
//used to prevent circular references
var alreadyProcessedCategoryIds = new List <string>();
while (category != null && //not null
(showHidden || category.Published) && //published
(showHidden || aclService.Authorize(category)) && //ACL
(showHidden || storeMappingService.Authorize(category)) && //Store mapping
!alreadyProcessedCategoryIds.Contains(category.Id)) //prevent circular references
{
result.Add(category);
alreadyProcessedCategoryIds.Add(category.Id);
category = knowledgebaseService.GetKnowledgebaseCategory(category.ParentCategoryId);
}
result.Reverse();
return(result);
}
/// <summary>
/// Edits knowledgebase category
/// </summary>
/// <param name="kc"></param>
public virtual void UpdateKnowledgebaseCategory(KnowledgebaseCategory kc)
{
kc.UpdatedOnUtc = DateTime.UtcNow;
_knowledgebaseCategoryRepository.Update(kc);
_cacheManager.RemoveByPattern(ARTICLES_PATTERN_KEY);
_cacheManager.RemoveByPattern(CATEGORIES_PATTERN_KEY);
_eventPublisher.EntityUpdated(kc);
}
public void GetFormattedBreadCrumb_ReturnExpectedValue()
{
var category = _allCategories.First();
var result = category.GetFormattedBreadCrumb(_allCategories);
var category2 = new KnowledgebaseCategory() { Id = "2", Name = "category2", ParentCategoryId = "3" };
Assert.AreEqual("category4 >> category3 >> category2 >> category1", result);
Assert.AreEqual("category4 // category3 // category2 // category1", category.GetFormattedBreadCrumb(_allCategories,separator:"//"));
Assert.AreEqual("category4 >> category3 >> category2", category2.GetFormattedBreadCrumb(_allCategories));
}
/// <summary>
/// Inserts knowledgebase category
/// </summary>
/// <param name="kc"></param>
public virtual async Task InsertKnowledgebaseCategory(KnowledgebaseCategory kc)
{
kc.CreatedOnUtc = DateTime.UtcNow;
kc.UpdatedOnUtc = DateTime.UtcNow;
await _knowledgebaseCategoryRepository.InsertAsync(kc);
_cacheManager.RemoveByPattern(ARTICLES_PATTERN_KEY);
_cacheManager.RemoveByPattern(CATEGORIES_PATTERN_KEY);
await _eventPublisher.EntityInserted(kc);
}
/// <summary>
/// Edits knowledgebase category
/// </summary>
/// <param name="kc"></param>
public virtual async Task UpdateKnowledgebaseCategory(KnowledgebaseCategory kc)
{
kc.UpdatedOnUtc = DateTime.UtcNow;
await _knowledgebaseCategoryRepository.UpdateAsync(kc);
await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
await _mediator.EntityUpdated(kc);
}
/// <summary>
/// Edits knowledgebase category
/// </summary>
/// <param name="kc"></param>
public virtual async Task UpdateKnowledgebaseCategory(KnowledgebaseCategory kc)
{
kc.UpdatedOnUtc = DateTime.UtcNow;
await _knowledgebaseCategoryRepository.UpdateAsync(kc);
await _cacheManager.RemoveByPattern(ARTICLES_PATTERN_KEY);
await _cacheManager.RemoveByPattern(CATEGORIES_PATTERN_KEY);
await _mediator.EntityUpdated(kc);
}
public async Task CanDeleteKnowledgebaseCategory()
{
ClearCategoryRepository();
var toDelete = new KnowledgebaseCategory();
await _knowledgebaseService.InsertKnowledgebaseCategory(toDelete);
Assert.AreEqual(1, _categoryRepository.Table.Count());
await _knowledgebaseService.DeleteKnowledgebaseCategory(toDelete);
Assert.AreEqual(0, _categoryRepository.Table.Count());
}
public async Task CanGetKnowledgebaseCategory()
{
var category = new KnowledgebaseCategory()
{
Name = "CanGetKnowledgebaseCategory"
};
await _knowledgebaseService.InsertKnowledgebaseCategory(category);
var actual = _categoryRepository.Table.Where(x => x.Name == "CanGetKnowledgebaseCategory").First();
var found = await _knowledgebaseService.GetKnowledgebaseCategory(actual.Id);
Assert.AreEqual(actual.Name, found.Name);
}
public virtual KnowledgebaseCategory UpdateKnowledgebaseCategoryModel(KnowledgebaseCategory knowledgebaseCategory, KnowledgebaseCategoryModel model)
{
knowledgebaseCategory = model.ToEntity(knowledgebaseCategory);
knowledgebaseCategory.UpdatedOnUtc = DateTime.UtcNow;
knowledgebaseCategory.Locales = model.Locales.ToLocalizedProperty(knowledgebaseCategory, x => x.Name, _urlRecordService);
model.SeName = knowledgebaseCategory.ValidateSeName(model.SeName, knowledgebaseCategory.Name, true);
knowledgebaseCategory.SeName = model.SeName;
_knowledgebaseService.UpdateKnowledgebaseCategory(knowledgebaseCategory);
_urlRecordService.SaveSlug(knowledgebaseCategory, model.SeName, "");
_customerActivityService.InsertActivity("UpdateKnowledgebaseCategory", knowledgebaseCategory.Id,
_localizationService.GetResource("ActivityLog.UpdateKnowledgebaseCategory"), knowledgebaseCategory.Name);
return(knowledgebaseCategory);
}
public void GetKnowledgebaseCategory()
{
KnowledgebaseCategoryCollection knowledgebaseCategories = TestSetup.KayakoApiService.Knowledgebase.GetKnowledgebaseCategories();
Assert.IsNotNull(knowledgebaseCategories, "No knowledgebase categories were returned");
Assert.IsNotEmpty(knowledgebaseCategories, "No knowledgebase categories were returned");
KnowledgebaseCategory knowledgebaseCategoryToGet = knowledgebaseCategories[new Random().Next(knowledgebaseCategories.Count)];
Trace.WriteLine("GetKnowledgebaseCategory using knowledgebase category id: " + knowledgebaseCategoryToGet.Id);
KnowledgebaseCategory knowledgebaseCategory = TestSetup.KayakoApiService.Knowledgebase.GetKnowledgebaseCategory(knowledgebaseCategoryToGet.Id);
AssertObjectXmlEqual(knowledgebaseCategory, knowledgebaseCategoryToGet);
}
public void CanGetKnowledgebaseCategories()
{
ClearCategoryRepository();
var category1 = new KnowledgebaseCategory();
var category2 = new KnowledgebaseCategory();
var category3 = new KnowledgebaseCategory();
_knowledgebaseService.InsertKnowledgebaseCategory(category1);
_knowledgebaseService.InsertKnowledgebaseCategory(category2);
_knowledgebaseService.InsertKnowledgebaseCategory(category3);
var all = _knowledgebaseService.GetKnowledgebaseCategories();
Assert.AreEqual(3, all.Count());
}
/// <summary>
/// Deletes knowledgebase category
/// </summary>
/// <param name="id"></param>
public virtual void DeleteKnowledgebaseCategory(KnowledgebaseCategory kc)
{
var children = _knowledgebaseCategoryRepository.Table.Where(x => x.ParentCategoryId == kc.Id).ToList();
_knowledgebaseCategoryRepository.Delete(kc);
foreach (var child in children)
{
child.ParentCategoryId = "";
UpdateKnowledgebaseCategory(child);
}
_cacheManager.RemoveByPattern(ARTICLES_PATTERN_KEY);
_cacheManager.RemoveByPattern(CATEGORIES_PATTERN_KEY);
_eventPublisher.EntityDeleted(kc);
}
public async Task CanUpdateKnowledgebaseCategory()
{
ClearCategoryRepository();
var category = new KnowledgebaseCategory()
{
Name = "CanUpdateKnowledgebaseCategory"
};
await _knowledgebaseService.InsertKnowledgebaseCategory(category);
category.Name = "CanUpdateKnowledgebaseCategory1";
await _knowledgebaseService.UpdateKnowledgebaseCategory(category);
var found = _categoryRepository.Table.Where(x => x.Name == "CanUpdateKnowledgebaseCategory1");
Assert.AreEqual(1, found.Count());
}
/// <summary>
/// Deletes knowledgebase category
/// </summary>
/// <param name="id"></param>
public virtual async Task DeleteKnowledgebaseCategory(KnowledgebaseCategory kc)
{
var children = _knowledgebaseCategoryRepository.Table.Where(x => x.ParentCategoryId == kc.Id).ToList();
await _knowledgebaseCategoryRepository.DeleteAsync(kc);
foreach (var child in children)
{
child.ParentCategoryId = "";
await UpdateKnowledgebaseCategory(child);
}
await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
await _mediator.EntityDeleted(kc);
}
/// <summary>
/// Deletes knowledgebase category
/// </summary>
/// <param name="id"></param>
public virtual async Task DeleteKnowledgebaseCategory(KnowledgebaseCategory kc)
{
var children = await _knowledgebaseCategoryRepository.Table.Where(x => x.ParentCategoryId == kc.Id).ToListAsync();
await _knowledgebaseCategoryRepository.DeleteAsync(kc);
foreach (var child in children)
{
child.ParentCategoryId = "";
await UpdateKnowledgebaseCategory(child);
}
await _cacheManager.RemoveByPattern(ARTICLES_PATTERN_KEY);
await _cacheManager.RemoveByPattern(CATEGORIES_PATTERN_KEY);
await _mediator.EntityDeleted(kc);
}
/// <summary>
/// Get formatted category breadcrumb
/// Note: ACL and store mapping is ignored
/// </summary>
/// <param name="category">Category</param>
/// <param name="allCategories">All categories</param>
/// <param name="separator">Separator</param>
/// <param name="languageId">Language identifier for localization</param>
/// <returns>Formatted breadcrumb</returns>
public static string GetFormattedBreadCrumb(this KnowledgebaseCategory category,
IList <KnowledgebaseCategory> allCategories,
string separator = ">>", string languageId = "")
{
string result = string.Empty;
var breadcrumb = GetCategoryBreadCrumb(category, allCategories);
for (int i = 0; i <= breadcrumb.Count - 1; i++)
{
var categoryName = breadcrumb[i].GetLocalized(x => x.Name, languageId);
result = String.IsNullOrEmpty(result)
? categoryName
: string.Format("{0} {1} {2}", result, separator, categoryName);
}
return(result);
}
public void CanGetPublicKnowledgebaseCategory()
{
ClearCategoryRepository();
var category1 = new KnowledgebaseCategory {
Name = "CanGetPublicKnowledgebaseCategoryPublic", Published = true
};
var category2 = new KnowledgebaseCategory {
Name = "CanGetPublicKnowledgebaseCategoryNotPublic", Published = false
};
_knowledgebaseService.InsertKnowledgebaseCategory(category1);
_knowledgebaseService.InsertKnowledgebaseCategory(category2);
var found1 = _knowledgebaseService.GetPublicKnowledgebaseCategory(category1.Id);
var found2 = _knowledgebaseService.GetPublicKnowledgebaseCategory(category2.Id);
Assert.AreEqual("CanGetPublicKnowledgebaseCategoryPublic", found1.Name);
Assert.AreEqual(null, found2);
}
public static KnowledgebaseCategoryModel ToModel(this KnowledgebaseCategory entity)
{
return(entity.MapTo <KnowledgebaseCategory, KnowledgebaseCategoryModel>());
}
public static KnowledgebaseCategory ToEntity(this KnowledgebaseCategoryModel model, KnowledgebaseCategory destination)
{
return(model.MapTo(destination));
}
public virtual async Task <KnowledgebaseCategory> UpdateKnowledgebaseCategoryModel(KnowledgebaseCategory knowledgebaseCategory, KnowledgebaseCategoryModel model)
{
knowledgebaseCategory = model.ToEntity(knowledgebaseCategory);
knowledgebaseCategory.UpdatedOnUtc = DateTime.UtcNow;
knowledgebaseCategory.Locales = await model.Locales.ToTranslationProperty(knowledgebaseCategory, x => x.Name, _seoSettings, _slugService, _languageService);
model.SeName = await knowledgebaseCategory.ValidateSeName(model.SeName, knowledgebaseCategory.Name, true, _seoSettings, _slugService, _languageService);
knowledgebaseCategory.SeName = model.SeName;
await _knowledgebaseService.UpdateKnowledgebaseCategory(knowledgebaseCategory);
await _slugService.SaveSlug(knowledgebaseCategory, model.SeName, "");
await _customerActivityService.InsertActivity("UpdateKnowledgebaseCategory", knowledgebaseCategory.Id,
_translationService.GetResource("ActivityLog.UpdateKnowledgebaseCategory"), knowledgebaseCategory.Name);
return(knowledgebaseCategory);
}
protected virtual List <LocalizedProperty> UpdateLocales(KnowledgebaseCategory category, KnowledgebaseCategoryModel model)
{
List <LocalizedProperty> localized = new List <LocalizedProperty>();
foreach (var local in model.Locales)
{
var seName = category.ValidateSeName(local.SeName, local.Name, false);
_urlRecordService.SaveSlug(category, seName, local.LanguageId);
if (!(String.IsNullOrEmpty(local.Name)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "Name",
LocaleValue = local.Name,
});
}
if (!(String.IsNullOrEmpty(local.Description)))
{
localized.Add(new LocalizedProperty()
{
LanguageId = local.LanguageId,
LocaleKey = "Description",
LocaleValue = local.Description,
});
}
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);
}
/// <summary>
/// Get category breadcrumb
/// </summary>
/// <param name="category">Category</param>
/// <param name="categoryService">Category service</param>
/// <param name="aclService">ACL service</param>
/// <param name="storeLinkService">Store link service</param>
/// <param name="showHidden">A value indicating whether to load hidden records</param>
/// <returns>Category breadcrumb </returns>
public static async Task <IList <KnowledgebaseCategory> > GetCategoryBreadCrumb(this KnowledgebaseCategory category,
IKnowledgebaseService knowledgebaseService,
IAclService aclService,
IWorkContext workContext,
bool showHidden = false)
{
if (category == null)
{
throw new ArgumentNullException(nameof(category));
}
var result = new List <KnowledgebaseCategory>();
//used to prevent circular references
var alreadyProcessedCategoryIds = new List <string>();
while (category != null && //not null
(showHidden || category.Published) && //published
(showHidden || aclService.Authorize(category, workContext.CurrentCustomer)) && //ACL
(showHidden || aclService.Authorize(category, workContext.CurrentStore.Id)) && //Store acl
!alreadyProcessedCategoryIds.Contains(category.Id)) //prevent circular references
{
result.Add(category);
alreadyProcessedCategoryIds.Add(category.Id);
category = await knowledgebaseService.GetKnowledgebaseCategory(category.ParentCategoryId);
}
result.Reverse();
return(result);
}
