public TaxonomyTypeManager(EntityTypeManager entityTypeManager, ITaxonomyHelper taxonomyManager, UserManager <User> userManager) { var supperUser = userManager.FindByNameAsync(AppKey.SupperAdminUserName).Result; ConstructionCategory = taxonomyManager.RegisterTaxonomyType( entityTypeManager.Construction, "construction-category", new Dictionary <string, string> { { "title", "Category" }, }, supperUser ); ProjectCategory = taxonomyManager.RegisterTaxonomyType( entityTypeManager.Project, "project-category", new Dictionary <string, string> { { "title", "Category" }, }, supperUser ); CollectionCategory = taxonomyManager.RegisterTaxonomyType( entityTypeManager.Collection, "collection-category", new Dictionary <string, string> { { "title", "Category" }, }, supperUser ); }
public MediaHelper( CoreInDbContext dbContext, ITaxonomyHelper taxonomyHelper, IEntityHelper <FileEntity, FileEntityDetail> entityHelper, IHostingEnvironment environment, IStringLocalizer <Language> stringLocalizer, IEntityTypeManager entityTypeManager, IEntityTaxonomyRelationHelper <FileEntityTaxonomy> entityTaxonomyRelationHelper, IHttpContextAccessor context ) { _dbContext = dbContext; _taxonomyHelper = taxonomyHelper; _entityHelper = entityHelper; _entityHelper.SetContext(_dbContext); _entityTypeManager = entityTypeManager; _environment = environment; _stringLocalizer = stringLocalizer; _entityTaxonomyRelationHelper = entityTaxonomyRelationHelper; _context = context; }
/// <summary> /// Default constructor with dependency injection /// </summary> /// <param name="taxonomyHelper">The taxonomy helper</param> /// <param name="fieldSchemaHelper">Field schema builder</param> /// <param name="fieldValueWriter">Field value wirter</param> /// <param name="log">Logging utility</param> public FieldHelper(ITaxonomyHelper taxonomyHelper, IFieldSchemaHelper fieldSchemaHelper, IFieldValueWriter fieldValueWriter, ILogger log) { this.taxonomyHelper = taxonomyHelper; this.fieldSchemaHelper = fieldSchemaHelper; this.fieldValueWriter = fieldValueWriter; this.log = log; }
public AdminController( ISession session, IContentManager contentManager, IAuthorizationService authorizationService, IContentItemDisplayManager contentItemDisplayManager, IContentDefinitionManager contentDefinitionManager, INotifier notifier, IHtmlLocalizer <AdminController> localizer, IUpdateModelAccessor updateModelAccessor, IEnumerable <ITaxonomyTermValidator> validators, IEnumerable <ITaxonomyTermHandler> handlers, ITaxonomyHelper taxonomyHelper) { _contentManager = contentManager; _authorizationService = authorizationService; _contentItemDisplayManager = contentItemDisplayManager; _contentDefinitionManager = contentDefinitionManager; _session = session; _notifier = notifier; _updateModelAccessor = updateModelAccessor; H = localizer; _validators = validators; _handlers = handlers; _taxonomyHelper = taxonomyHelper; }
/// <summary> /// Initializes a new instance of the <see cref="SiteTaxonomyCache"/> class. /// </summary> /// <param name="site"> /// The site. /// </param> /// <param name="termStoreName"> /// The term store name. /// </param> /// <param name="taxonomyHelper">The taxonomy helper.</param> public SiteTaxonomyCache(SPSite site, string termStoreName, ITaxonomyHelper taxonomyHelper) { SPMonitoredScope monitor = null; this.taxonomyHelper = taxonomyHelper; try { monitor = new SPMonitoredScope("GSoft.Dynamite - Site taxonomy cache initialization"); } catch (TypeInitializationException) { // Failed to initialize local diagnostics service. Fail to log monitor trace. } catch (ArgumentNullException) { // Failed to initialize local diagnostics service. Fail to log monitor trace. } if (site == null) { throw new ArgumentNullException("site", "SPSite is currently null, please pass a valid site as argument."); } this.SiteId = site.ID; // Don't send in the updateCache=true setting - let the SharePoint inner Taxonomy cache refresh itself normally (every 10 seconds or so) this.TaxonomySession = new TaxonomySession(site); if (!string.IsNullOrEmpty(termStoreName)) { this.SiteCollectionGroup = this.TaxonomySession.TermStores[termStoreName].GetSiteCollectionGroup(site); } else { // Use default term store TermStore termStore = null; if (taxonomyHelper != null) { termStore = this.taxonomyHelper.GetDefaultSiteCollectionTermStore(this.TaxonomySession); } else { termStore = this.TaxonomySession.DefaultSiteCollectionTermStore; } if (termStore != null) { this.SiteCollectionGroup = termStore.GetSiteCollectionGroup(site); } } if (monitor != null) { monitor.Dispose(); } }
/// <summary> /// Initializes a new instance of the <see cref="UserProfilePropertyHelper" /> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="taxonomyHelper">The taxonomy helper.</param> /// <param name="siteTaxonomyCacheManager">The site taxonomy cache manager.</param> public UserProfilePropertyHelper( ILogger logger, ITaxonomyHelper taxonomyHelper, ISiteTaxonomyCacheManager siteTaxonomyCacheManager) { this.logger = logger; this.taxonomyHelper = taxonomyHelper; this.siteTaxonomyCacheManager = siteTaxonomyCacheManager; }
public PageLocationsTaxonomyValidator( IContentItemsService contentItemsService, ITaxonomyHelper taxonomyHelper, IEnumerable <ITaxonomyTermValidator> validators) { _contentItemsService = contentItemsService; _taxonomyHelper = taxonomyHelper; _validators = validators; }
public EntityControllerWithTaxonomy(CoreInDbContext dbContext, IEntityHelper <TEntity, TEntityDetail> fieldEntityHelper, IMediaHelper mediaHelper, IStringLocalizer <TLocalizer> localizer, IOptions <RequestLocalizationOptions> localizationOptions, ITaxonomyHelper taxonomyHelper) : base(dbContext, fieldEntityHelper, mediaHelper, localizer, localizationOptions) { TaxonomyHelper = taxonomyHelper; }
/// <summary> /// Initializes a new instance of the <see cref="NavigationService" /> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="navigationHelper">The navigation helper.</param> /// <param name="searchHelper">The search helper.</param> /// <param name="catalogNavigation">The catalog navigation.</param> /// <param name="taxonomyHelper">The taxonomy helper.</param> public NavigationService( ILogger logger, INavigationHelper navigationHelper, ISearchHelper searchHelper, IVariationNavigationHelper catalogNavigation, ITaxonomyHelper taxonomyHelper) { this.logger = logger; this.navigationHelper = navigationHelper; this.searchHelper = searchHelper; this.catalogNavigation = catalogNavigation; this.taxonomyHelper = taxonomyHelper; }
public PageLocationTaxonomyTermHandler( ISession session, ITaxonomyHelper taxonomyHelper, ISyncOrchestrator syncOrchestrator, IContentItemsService contentItemsService, IGraphSyncNotifier notifier, IEnumerable <IContentOrchestrationHandler> contentOrchestrationHandlers) { _session = session; _taxonomyHelper = taxonomyHelper; _syncOrchestrator = syncOrchestrator; _contentItemsService = contentItemsService; _notifier = notifier; _contentOrchestrationHandlers = contentOrchestrationHandlers; }
public TaxonomyTypeManager(EntityTypeManager entityTypeManager, ITaxonomyHelper taxonomyManager, UserManager <User> userManager) { var supperUser = userManager.FindByNameAsync(AppKey.SupperAdminUserName).Result; PostCategory = taxonomyManager.RegisterTaxonomyType( entityTypeManager.Liblary, "liblary-blog-category", new Dictionary <string, string> { { "title", "Category" }, }, supperUser); PostCategory = taxonomyManager.RegisterTaxonomyType( entityTypeManager.Liblary, "liblary-blog-tag", new Dictionary <string, string> { { "title", "Tag" }, }, supperUser); }
/// <summary> /// The get site taxonomy cache. /// </summary> /// <param name="site"> /// The site. /// </param> /// <param name="termStoreName"> /// The term store name. /// </param> /// <param name="taxonomyHelper">The taxonomy helper.</param> /// <returns> /// The <see cref="SiteTaxonomyCache"/>. /// </returns> public SiteTaxonomyCache GetSiteTaxonomyCache(SPSite site, string termStoreName, ITaxonomyHelper taxonomyHelper) { // No caching if outside HttpContext if (HttpContext.Current == null) { return new SiteTaxonomyCache(site, termStoreName, taxonomyHelper); } string cacheKey = KeyPrefix + site.ID.ToString(); // Create the Site Taxonomy Cache because it does not yet exist. No need for locking because // we only cache per-request using the HttpContext cache. if (HttpContext.Current.Items[cacheKey] == null) { var newTaxCache = new SiteTaxonomyCache(site, termStoreName, this.taxonomyHelper); HttpContext.Current.Items[cacheKey] = newTaxCache; } // Return the existing Session return (SiteTaxonomyCache)HttpContext.Current.Items[cacheKey]; }
/// <summary> /// Per-request taxonomy cache manager (using HttpContext.Items) /// </summary> /// <param name="taxonomyHelper">The taxonomy helper.</param> public PerRequestSiteTaxonomyCacheManager(ITaxonomyHelper taxonomyHelper) { this.taxonomyHelper = taxonomyHelper; }
public PageLocationModificationValidator(IContentItemsService contentItemsService, ITaxonomyHelper taxonomyHelper) { _contentItemsService = contentItemsService; _taxonomyHelper = taxonomyHelper; }
public PageLocationTitleValidator(ITaxonomyHelper taxonomyHelper) { _taxonomyHelper = taxonomyHelper; }
public TaxonomyPartDisplayDriver(ITaxonomyHelper taxonomyHelper, IEnumerable <ITaxonomyValidator> validators) { _taxonomyHelper = taxonomyHelper; _validators = validators; }
public static TEntity Update <TEntity, TEntityDetail, TEntityTaxonomy>(IEntityHelper <TEntity, TEntityDetail> entityHelper, ITaxonomyHelper taxonomyHelper, long entityId, IEnumerable <TEntityDetail> details, Dictionary <long, long[]> taxonomyTypeIdTaxonomyIds = null, User user = null, bool deleteExcept = true) where TEntity : BaseEntity, new() where TEntityDetail : BaseEntityDetail, new() where TEntityTaxonomy : BaseEntityTaxonomy, new() { var entity = entityHelper.Entity(entityId); //entity.Name = entityHelper.GenerateEntityName(details.FirstOrDefault(o => o.Field == "title")?.Value); entityHelper.UpdateDetails(entity, details, user, deleteExcept); taxonomyHelper.UpdateTaxonomiesForEntity <TEntityTaxonomy>(entity.Id, entity.EntityTypeId ?? 0, taxonomyTypeIdTaxonomyIds); return(entity); }
/// <summary> /// Initializes a new instance of the <see cref="TaxonomyService" /> class. /// </summary> /// <param name="taxonomyCacheManager">The taxonomy cache manager</param> /// <param name="taxonomyHelper">The taxonomy helper to use.</param> public TaxonomyService(ISiteTaxonomyCacheManager taxonomyCacheManager, ITaxonomyHelper taxonomyHelper) { this.taxonomyCacheManager = taxonomyCacheManager; this.taxonomyHelper = taxonomyHelper; }
public PageLocationUrlValidator(ISession session, IContentManager contentManager, ITaxonomyHelper taxonomyHelper) { _session = session; _contentManager = contentManager; _taxonomyHelper = taxonomyHelper; }
private void InitDatabase(UserManager <User> userManager, IMenuHelper menuHelper, ITaxonomyHelper taxonomyHelper) { var supperUser = userManager.FindByNameAsync(AppKey.SupperAdminUserName).Result; var appMenu = menuHelper.Menu(AppKey.AppMenuName); taxonomyHelper.RegisterTaxonomyType( entityTypeName: AppKey.FileTypeImage, name: "file-image-category", detailDictionary: new Dictionary <string, string> { { "title", "Category" } }, byUser: supperUser); taxonomyHelper.RegisterTaxonomyType( entityTypeName: AppKey.FileTypeImage, name: "file-image-tag", detailDictionary: new Dictionary <string, string> { { "title", "Tag" } }, byUser: supperUser); menuHelper.MenuItem( menu: appMenu, name: "file-manager", detailDictionary: new Dictionary <string, string> { { "title", "File Manager" }, { "controller", "filemanager" }, { "action", "index" }, { "url", "/filemanager" }, { "icon", "<i class=\"icon-docs icons\"></i>" } }, byUser: supperUser); }
/// <summary> /// The get site taxonomy cache. /// </summary> /// <param name="site"> /// The site. /// </param> /// <param name="termStoreName"> /// The term store name. /// </param> /// <param name="taxonomyHelper">The taxonomy helper.</param> /// <returns> /// The <see cref="SiteTaxonomyCache"/>. /// </returns> public SiteTaxonomyCache GetSiteTaxonomyCache(SPSite site, string termStoreName, ITaxonomyHelper taxonomyHelper) { // No caching if outside HttpContext if (HttpContext.Current == null) { return(new SiteTaxonomyCache(site, termStoreName, taxonomyHelper)); } string cacheKey = KeyPrefix + site.ID.ToString(); // Create the Site Taxonomy Cache because it does not yet exist. No need for locking because // we only cache per-request using the HttpContext cache. if (HttpContext.Current.Items[cacheKey] == null) { var newTaxCache = new SiteTaxonomyCache(site, termStoreName, this.taxonomyHelper); HttpContext.Current.Items[cacheKey] = newTaxCache; } // Return the existing Session return((SiteTaxonomyCache)HttpContext.Current.Items[cacheKey]); }
public TaxonomyUI(ITaxonomyHelper taxonomyHelper, UserManager <User> userNamager) { _taxonomyHelper = taxonomyHelper; _userManager = userNamager; }
public PageLocationPartDisplayDriver(ISession session, ITaxonomyHelper taxonomyHelper) { _session = session; _taxonomyHelper = taxonomyHelper; }