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); }