public TaxonomyNavigationProvider(
     IContentManager contentManager,
     ITaxonomyService taxonomyService)
 {
     _contentManager = contentManager;
     _taxonomyService = taxonomyService;
 }

        public TermsPartHandler(
            IContentDefinitionManager contentDefinitionManager,
            IRepository<TermsPartRecord> repository,
            ITaxonomyService taxonomyService,
            IContentManager contentManager,
            IProcessingEngine processingEngine,
            ShellSettings shellSettings,
            IShellDescriptorManager shellDescriptorManager) {
            _contentDefinitionManager = contentDefinitionManager;
            _contentManager = contentManager;

            Filters.Add(StorageFilter.For(repository));
            OnPublished<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part));
            OnUnpublished<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part));
            OnRemoved<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part));

            // Tells how to load the field terms on demand, when a content item it loaded or when it has been created
            OnInitialized<TermsPart>((context, part) => InitializerTermsLoader(part));
            OnLoading<TermsPart>((context, part) => InitializerTermsLoader(part));
            OnUpdating<TermsPart>((context, part) => InitializerTermsLoader(part));

            OnIndexing<TermsPart>(
                (context, part) => {

                    foreach (var term in part.Terms) {
                        var termContentItem = context.ContentManager.Get(term.TermRecord.Id);
                        context.DocumentIndex.Add(term.Field, termContentItem.As<TitlePart>().Title).Analyze();
                        context.DocumentIndex.Add(term.Field + "-id", termContentItem.Id).Store();
                        // tag the current content item with all parent terms
                        foreach (var parent in taxonomyService.GetParents(termContentItem.As<TermPart>())) {
                            context.DocumentIndex.Add(term.Field + "-id", parent.Id).Store();
                        }
                    }
                });
        }

 public TaxonomyImportService(ISiteService siteService, IContentManager contentManager, ITaxonomyService taxonomyService, IMembershipService membershipService)
 {
     _siteService = siteService;
     _contentManager = contentManager;
     _taxonomyService = taxonomyService;
     _membershipService = membershipService;
 }

        public TermPartHandler(
            IRepository<TermPartRecord> repository, 
            ITaxonomyService taxonomyService,
            ITermPathConstraint termPathConstraint ) {
            Filters.Add(StorageFilter.For(repository));

            OnRemoved<IContent>(
                (context, tags) =>
                    taxonomyService.DeleteAssociatedTerms(context.ContentItem)
                );

            OnInitializing<TermPart>(
                (context, part) => 
                    part.Selectable = true
                );

            OnPublished<TermPart>(
                (context, part) => {
                    termPathConstraint.AddPath(part.Slug);
                    foreach (var child in taxonomyService.GetChildren(part)) {
                        termPathConstraint.AddPath(child.Slug);
                    }
                });

            OnUnpublishing<TermPart>(
                (context, part) =>
                    termPathConstraint.RemovePath(part.Slug)
                );
        }

        public TermsPartHandler(
            IContentDefinitionManager contentDefinitionManager,
            IRepository<TermsPartRecord> repository,
            ITaxonomyService taxonomyService,
            IContentManager contentManager) {
            _contentDefinitionManager = contentDefinitionManager;
            _contentManager = contentManager;

            Filters.Add(StorageFilter.For(repository));

            OnPublished<TermsPart>((context, part) => RecalculateCount(contentManager, taxonomyService, part));
            OnUnpublished<TermsPart>((context, part) => RecalculateCount(contentManager, taxonomyService, part));
            OnRemoved<TermsPart>((context, part) => RecalculateCount(contentManager, taxonomyService, part));
            
            // tells how to load the field terms on demand
            OnLoaded<TermsPart>((context, part) => {
                foreach(var field in part.ContentItem.Parts.SelectMany(p => p.Fields).OfType<TaxonomyField>()) {
                    var tempField = field.Name;
                    var fieldTermRecordIds = part.Record.Terms.Where(t => t.Field == tempField).Select(tci => tci.TermRecord.Id);
                    field.Terms.Loader(value => fieldTermRecordIds.Select(id => _contentManager.Get<TermPart>(id)));
                }
            });

            OnIndexing<TermsPart>(
                (context, part) => {
                    foreach (var term in part.Terms) {
                        var value = context.ContentManager.Get(term.TermRecord.Id).As<TitlePart>().Title;
                        context.DocumentIndex.Add(term.Field, value).Analyze();
                        context.DocumentIndex.Add(term.Field + "-id", term.Id).Store();
                    }
                });
        }

 public SameTermsFilter(ITaxonomyService taxonomyService,
     IWorkContextAccessor workContextAccessor)
 {
     _taxonomyService = taxonomyService;
     _workContextAccessor = workContextAccessor;
     T = NullLocalizer.Instance;
 }

 public CodeSamplesFilterController(ICommonDataService commonDataService, ITaxonomyService taxonomyService, IContentManager contentManager)
 {
     _commonDataService = commonDataService;
     _taxonomyService = taxonomyService;
     _contentManager = contentManager;
     Logger = NullLogger.Instance;
 }

 public TermsFilterForms(
     IShapeFactory shapeFactory,
     ITaxonomyService taxonomyService) {
     _taxonomyService = taxonomyService;
     Shape = shapeFactory;
     T = NullLocalizer.Instance;
 }

 public TermFeedQuery(
     IContentManager contentManager,
     ITaxonomyService taxonomyService)
 {
     _contentManager = contentManager;
     _taxonomyService = taxonomyService;
 }

        public DefaultTaxonomyUpdater(ITaxonomyService taxonomyService,
            ITaxonomyImportService taxonomyImportService)
        {
            _taxonomyService = taxonomyService;
            _taxonomyImportService = taxonomyImportService;

            Logger = NullLogger.Instance;
        }

 public OEmbedController(
     ITaxonomyService taxonomyService, 
     IMediaLibraryService mediaManagerService, 
     IOrchardServices services) {
     _taxonomyService = taxonomyService;
     _mediaLibraryService = mediaManagerService;
     Services = services;
 }

 /// <summary>
 /// Constructor to inject the view model dependencies
 /// </summary>
 /// <param name="wallPostRepository">Wall post data access</param>
 /// <param name="wallReplyRepository">Wall reply data access</param>
 /// <param name="taxonomyService">Taxonomy service</param>
 /// <param name="resourceLocator">Resource utility</param>
 /// <param name="log">Logging utility</param>
 public WallViewModel(IWallPostRepository wallPostRepository, IWallReplyRepository wallReplyRepository, ITaxonomyService taxonomyService, IResourceLocator resourceLocator, ILogger log)
 {
     this._wallPostRepository = wallPostRepository;
     this._wallReplyRepository = wallReplyRepository;
     this._taxonomyService = taxonomyService;
     this._resourceLocator = resourceLocator;
     this._log = log;
 }

 public TermRuleProvider(
     IWorkContextAccessor workContextAccessor,
     ITaxonomyService taxonomyService
 )
 {
     _workContextAccessor = workContextAccessor;
     _taxonomyService = taxonomyService;
 }

 public GalleryFeatureHandler(ITaxonomyService taxonomyService, IOrchardServices services, IContentDefinitionManager contentDefinitionManager,
     IMembershipService membershipService, IUserkeyService userkeyService) {
     _taxonomyService = taxonomyService;
     _userkeyService = userkeyService;
     _membershipService = membershipService;
     _services = services;
     _contentDefinitionManager = contentDefinitionManager;
 }

 public ProductService(IContentManager contentManager, 
     IContentDefinitionManager contentDefinitionManager, 
     ITaxonomyService taxonomyService, IAuthorizationService authorizationService, IOrchardServices orchardServices) {
     _contentManager = contentManager;
     _contentDefinitionManager = contentDefinitionManager;
     _taxonomyService = taxonomyService;
     _authorizationService = authorizationService;
     _orchardServices = orchardServices;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TargetingProfileTaxonomySyncService" /> class.
 /// </summary>
 /// <param name="taxonomyService">The taxonomy service.</param>
 /// <param name="userProfilePropertyHelper">The user profile property helper.</param>
 /// <param name="logger">The logger.</param>
 public TargetingProfileTaxonomySyncService(
     ITaxonomyService taxonomyService, 
     IUserProfilePropertyHelper userProfilePropertyHelper,
     ILogger logger)
 {
     this.taxonomyService = taxonomyService;
     this.userProfilePropertyHelper = userProfilePropertyHelper;
     this.logger = logger;
 }

        private static void RecalculateCount(IContentManager contentManager, ITaxonomyService taxonomyService, TermsPart part) {
            // submits any change to the db so that GetContentItemsCount is accurate
            contentManager.Flush();

            foreach (var term in part.Terms) {
                var termPart = taxonomyService.GetTerm(term.TermRecord.Id);
                term.TermRecord.Count = (int)taxonomyService.GetContentItemsCount(termPart);
            }
        }

 public MediaLibraryService(
     ITaxonomyService taxonomyService, 
     IContentManager contentManager, 
     IMimeTypeProvider mimeTypeProvider,
     IEnumerable<IMediaFactorySelector> mediaFactorySelectors ) {
     _taxonomyService = taxonomyService;
     _contentManager = contentManager;
     _mimeTypeProvider = mimeTypeProvider;
     _mediaFactorySelectors = mediaFactorySelectors;
 }

        public TagsController(
            ITaxonomyService taxonomyService,
            IContentManager contentManager,
			IAuthorizer authorizer) {
            _taxonomyService = taxonomyService;
            T = NullLocalizer.Instance;
            _contentManager = contentManager;
	        _authorizer = authorizer;
            Logger = NullLogger.Instance;
        }

 public TaxonomyTreeNodeProvider(
     ITaxonomyService taxonomyService,
     IContentManager contentManager,
     UrlHelper urlHelper)
 {
     _taxonomyService = taxonomyService;
     _contentManager = contentManager;
     _url = urlHelper;
     T = NullLocalizer.Instance;
 }