public EnsureCoreDataTask(IFrameworkContext context, IHiveManager coreManager, IEnumerable<Lazy<Permission, PermissionMetadata>> permissions,
     ISecurityService securityService)
     : base(context, coreManager)
 {
     _permissions = permissions;
     _securityService = securityService;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderBootstrapper"/> class if sufficient configuration information has been supplied by the user.
        /// </summary>
        /// <param name="existingConfig">The existing config.</param>
        /// <param name="frameworkContext"></param>
        /// <remarks></remarks>
        public ProviderBootstrapper(ProviderConfigurationSection existingConfig, IFrameworkContext frameworkContext)
        {
            _existingConfig = existingConfig;
            _frameworkContext = frameworkContext;

        
        }

        /// <summary>
        /// Creates the test data types
        /// </summary>
        public List<DataType> InitDataTypes(IFrameworkContext frameworkContext)
        {
            // much neater :)
            _dataTypes = CoreFakeCmsData.RequiredCoreUserAttributeTypes()
                            .Select(x => frameworkContext.TypeMappers.Map<DataType>(x))
                            .ToList();

            //_dataTypes = new List<DataType>();
            //foreach (var v in CoreCmsData.RequiredCoreUserAttributeTypes())
            //{
            //    var a = frameworkContext.TypeMappers.Map<DataType>(v);
            //    _dataTypes.Add(a);
            //}

            //get the data types from the CoreCmsData
            //var dataTypes = new List<DataType>()
            //        {
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("rte-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("sltb-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("csp-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("tag-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("mltb-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("media-picker-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("integer-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("uploader-pe".EncodeAsGuid())))
            //        };

            //_dataTypes = dataTypes;
            LogHelper.Error<UmbracoXmlImportHelper>(String.Format("There were {0} data types found", _dataTypes.Count), new Exception());
            return _dataTypes;
        }

        //public EntityRepositoryFactory(ProviderMetadata providerMetadata, 
        //    ProviderRevisionSessionFactory<TypedEntity> revisionRepositoryFactory, 
        //    ProviderSchemaSessionFactory schemaRepositoryFactory,
        //    IFrameworkContext frameworkContext, global::NHibernate.Cfg.Configuration nhConfig)
        //    : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext)
        //{
        //    Helper = new NhFactoryHelper(nhConfig, null, false, false, frameworkContext);
        //}

        public EntityRepositoryFactory(ProviderMetadata providerMetadata,
            AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
            AbstractSchemaRepositoryFactory schemaRepositoryFactory,
            IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper)
            : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, dependencyHelper)
        {
        }

        public ProviderSetup(ProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
            : base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
        {
            Mandate.ParameterNotNull(unitFactory, "unitFactory");

            UnitFactory = unitFactory;
        }

 protected ReadonlyProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal) 
     : base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
 {
     Mandate.ParameterNotNull(frameworkContext, "frameworkContext");
     Mandate.ParameterNotNull(bootstrapper, "bootstrapper");
     Mandate.ParameterNotNull(providerMetadata, "providerMetadata");
 }

 public IndexController(IndexConfiguration configuration, IFrameworkContext frameworkContext)
 {
     Configuration = configuration;
     FrameworkContext = frameworkContext;
     _manualResetter = new ManualResetEvent(false);
     Queue = new IndexModificationQueue();
 }

 internal EntityRepositoryFactory(ProviderMetadata providerMetadata,
     AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
     AbstractSchemaRepositoryFactory schemaRepositoryFactory, Settings settings,
     IFrameworkContext frameworkContext)
     : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(settings, providerMetadata))
 {
 }

 public AbstractProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
 {
     ProviderMetadata = providerMetadata;
     FrameworkContext = frameworkContext;
     Bootstrapper = bootstrapper;
     PriorityOrdinal = priorityOrdinal;
 }

 /// <summary>
 /// Constructor used for testing
 /// </summary>
 /// <param name="providerMetadata"></param>
 /// <param name="revisionRepositoryFactory"></param>
 /// <param name="frameworkContext"></param>
 /// <param name="helper"></param>
 internal SchemaRepositoryFactory(
     ProviderMetadata providerMetadata,
     AbstractRevisionRepositoryFactory<EntitySchema> revisionRepositoryFactory,
     IFrameworkContext frameworkContext,
     ExamineHelper helper)
     : base(providerMetadata, revisionRepositoryFactory, frameworkContext, new DependencyHelper(helper, providerMetadata))
 {
 }

 public NhFactoryHelper(Configuration config, ISession singleProvidedSession, bool leaveSessionOpenOnDispose, bool isSingleSessionFinalized, IFrameworkContext frameworkContext)
 {
     Config = config;
     SingleProvidedSession = singleProvidedSession;
     LeaveSessionOpenOnDispose = leaveSessionOpenOnDispose;
     IsSingleSessionFinalized = isSingleSessionFinalized;
     FrameworkContext = frameworkContext;
 }

 public DevDatasetInstallTask(
     IFrameworkContext frameworkContext,
     IPropertyEditorFactory propertyEditorFactory,
     IHiveManager hiveManager,
     IAttributeTypeRegistry attributeTypeRegistry)
     : base(frameworkContext, hiveManager)
 {
     _devDataSet = new DevDataset(propertyEditorFactory, frameworkContext, attributeTypeRegistry);
 }

        protected AbstractProviderRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
        {
            CanRead = true;
            ProviderMetadata = providerMetadata;
            FrameworkContext = frameworkContext;
            RepositoryScopedCache = new DictionaryScopedCache();

            //HiveContext = new RepositoryContext(RuntimeCacheProvider.Default, PerHttpRequestCacheProvider.Default, frameworkContext);
        }

        public PublicAccessService(IHiveManager hive, IMembershipService<Member> membersMembershipService,
            IFrameworkContext framework)
        {
            Mandate.That<NullReferenceException>(hive != null);
            Mandate.That<NullReferenceException>(membersMembershipService != null);

            _hive = hive;
            _members = membersMembershipService;
            _framework = framework;
        }

 public ProviderMappingGroup(string key,
     WildcardUriMatch singleMatch,
     ReadonlyProviderSetup singleReader,
     ProviderSetup singleWriter,
     IFrameworkContext frameworkContext)
     : this(key, Enumerable.Repeat(singleMatch, 1), Enumerable.Repeat(singleReader, 1), Enumerable.Repeat(singleWriter, 1), frameworkContext)
 {
     Mandate.ParameterNotNull(singleReader, "singleReader");
     Mandate.ParameterNotNull(singleWriter, "singleWriter");
 }

        //public SchemaRepositoryFactory MembershipSchemaRepositoryFactory { get { return base.SchemaRepositoryFactory as SchemaRepositoryFactory; } }

        /// <summary>
        /// Internal constructor for testing
        /// </summary>
        /// <param name="providerMetadata"></param>
        /// <param name="revisionRepositoryFactory"></param>
        /// <param name="schemaRepositoryFactory"></param>
        /// <param name="frameworkContext"></param>
        /// <param name="membershipProviders"></param>
        /// <param name="configuredProviders"></param>
        internal EntityRepositoryFactory(
            ProviderMetadata providerMetadata,
            AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
            AbstractSchemaRepositoryFactory schemaRepositoryFactory,
            IFrameworkContext frameworkContext,
            Lazy<IEnumerable<MembershipProvider>> membershipProviders,
            IEnumerable<ProviderElement> configuredProviders)
            : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(configuredProviders, membershipProviders, providerMetadata))
        {
        }

        public DevDataset(IPropertyEditorFactory propertyEditorFactory, IFrameworkContext frameworkContext, IAttributeTypeRegistry attributeTypeRegistry)
        {
            _frameworkContext = frameworkContext;
            _attributeTypeRegistry = attributeTypeRegistry;
            PropertyEditorFactory = propertyEditorFactory;
            InitCreators();
            InitDataTypes();
            InitTemplates();
            InitDocTypes();
            _nodeData = XDocument.Parse(Files.umbraco);

        }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:System.Object"/> class.
        /// </summary>
        public MapResolverContext(
            IFrameworkContext frameworkContext,
            IHiveManager hive, 
            IPropertyEditorFactory propertyEditorFactory,
            IParameterEditorFactory parameterEditorFactory)
        {
            ApplicationId = Guid.NewGuid();
            FrameworkContext = frameworkContext;
            Hive = hive;

            PropertyEditorFactory = propertyEditorFactory;
            ParameterEditorFactory = parameterEditorFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderBootstrapper"/> class if sufficient configuration information has been supplied by the user.
        /// </summary>
        /// <param name="existingConfig">The existing config.</param>
        /// <param name="examineManager"></param>
        /// <param name="frameworkContext"></param>
        /// <remarks></remarks>
        public ProviderBootstrapper(ProviderConfigurationSection existingConfig, ExamineManager examineManager, IFrameworkContext frameworkContext)
        {
            _existingConfig = existingConfig;
            _examineManager = examineManager;
            _frameworkContext = frameworkContext;

            //bind to all of the Examine events
            foreach (var i in _examineManager.IndexProviderCollection.OfType<BaseIndexProvider>())
            {
                i.IndexingError += (sender, e) => LogHelper.Error<Exception>("[Examine] " + e.Message, e.InnerException);
                i.IndexDeleted += (sender, e) => LogHelper.TraceIfEnabled<ExamineManager>("[Examine] Item {0} has been removed from the index", () => e.DeletedTerm.Value);
                i.NodeIndexed += (sender, e) => LogHelper.TraceIfEnabled<ExamineManager>("[Examine] Item {0} has been indexed", () => e.Item.Id);
            }
        }

        public NHibernateInMemoryRepository(IFrameworkContext fakeFrameworkContext, ISessionFactory sessionFactory = null, ISession sessionForTest = null)
        {
            using (DisposableTimer.TraceDuration<NHibernateInMemoryRepository>("Start setup", "End setup"))
            {
                if (sessionFactory == null && sessionForTest == null)
                {
                    var builder = new NHibernateConfigBuilder("data source=:memory:", "unit-tester",
                                                              SupportedNHDrivers.SqlLite, "thread_static", false);
                    var config = builder.BuildConfiguration();
                    _sessionFactory = config.BuildSessionFactory();
                    SessionForTest = _sessionFactory.OpenSession();

                    // See http://stackoverflow.com/questions/4325800/testing-nhibernate-with-sqlite-no-such-table-schema-is-generated
                    // and also http://nhforge.org/doc/nh/en/index.html#architecture-current-session
                    // regarding contextual sessions and GetCurrentSession()

                    // We pass in our own TextWriter because a bug in VS's testing framework means directly passing in Console.Out causes an ObjectDisposedException
                    new SchemaExport(config).Execute(false, true, false, SessionForTest.Connection, _schemaWriter);
                }
                else
                {
                    _sessionFactory = sessionFactory;
                    SessionForTest = sessionForTest;
                }

                _dataContextFactory = new DataContextFactory(fakeFrameworkContext, SessionForTest, true);

                // Create reader
                ReadOnlyUnitOfWorkFactory = new ReadOnlyUnitOfWorkFactory();
                _hiveReadProvider = new HiveReadProvider(new HiveProviderSetup(fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), ReadOnlyUnitOfWorkFactory, null, _dataContextFactory));

                // Create writer
                ReadWriteUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory();
                _writeProvider = new HiveReadWriteProvider(new HiveProviderSetup(fakeFrameworkContext, "rw-unit-tester", new FakeHiveProviderBootstrapper(), ReadOnlyUnitOfWorkFactory, ReadWriteUnitOfWorkFactory, _dataContextFactory));

                //setup nhibernate mappers
                var manualMapper = new ManualMapper(new NhLookupHelper(_dataContextFactory), _writeProvider);
                fakeFrameworkContext.TypeMappers.Add(new Lazy<AbstractTypeMapper, TypeMapperMetadata>(() => manualMapper, new TypeMapperMetadata(true)));


                // Create hive wrappers for the readers and writers
                var governorRUowFactory = new ReadOnlyUnitOfWorkFactoryWrapper(new[] { _hiveReadProvider });

                var governorRWUowFactory = new ReadWriteUnitOfWorkFactoryWrapper(new[] { _writeProvider });

                _hiveReadProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadProvider(new HiveProviderSetup(fakeFrameworkContext, "r-unit-wrapper", new FakeHiveProviderBootstrapper(), governorRUowFactory, null, null), new[] { _hiveReadProvider });
                _hiveReadWriteProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadWriteProvider(new HiveProviderSetup(fakeFrameworkContext, "rw-unit-wrapper", new FakeHiveProviderBootstrapper(), governorRUowFactory, governorRWUowFactory, null), new[] { _writeProvider });
            }
        }