/// <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;
}
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 ProviderSetup(ProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
Mandate.ParameterNotNull(unitFactory, "unitFactory");
UnitFactory = unitFactory;
}
public IndexController(IndexConfiguration configuration, IFrameworkContext frameworkContext)
{
Configuration = configuration;
FrameworkContext = frameworkContext;
_manualResetter = new ManualResetEvent(false);
Queue = new IndexModificationQueue();
}
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="EntityRepositoryFactory"/> class. This constructor is used internally for unit testing where a single session must be used
/// irrespective of the NHibernate session factory mechanisms.
/// </summary>
/// <param name="providerMetadata">The provider metadata.</param>
/// <param name="revisionRepositoryFactory">The revision repository factory.</param>
/// <param name="schemaRepositoryFactory">The schema repository factory.</param>
/// <param name="frameworkContext">The framework context.</param>
/// <param name="singleProvidedSession">The single provided session.</param>
/// <param name="leaveSessionOpenOnDispose">if set to <c>true</c> [leave session open on dispose].</param>
/// <remarks></remarks>
internal EntityRepositoryFactory(ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext, ISession singleProvidedSession, bool leaveSessionOpenOnDispose)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(new NhFactoryHelper(null, singleProvidedSession, leaveSessionOpenOnDispose, false, frameworkContext), providerMetadata))
{
}
/// <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)
{
}
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;
}
public NhFactoryHelper(Configuration config, ISession singleProvidedSession, bool leaveSessionOpenOnDispose, bool isSingleSessionFinalized, IFrameworkContext frameworkContext)
{
Config = config;
SingleProvidedSession = singleProvidedSession;
LeaveSessionOpenOnDispose = leaveSessionOpenOnDispose;
IsSingleSessionFinalized = isSingleSessionFinalized;
FrameworkContext = frameworkContext;
}
/// <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 DataContext(IHiveProvider hiveProvider, string supportedExtensions, string rootPath, string applicationRelativeRoot, string excludeExtensions)
: base(hiveProvider)
{
_frameworkContext = hiveProvider.FrameworkContext;
_supportedExtensions = supportedExtensions;
_rootPath = rootPath;
_applicationRelativeRoot = applicationRelativeRoot;
_excludeExtensions = excludeExtensions;
}
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 });
}
}
public PugpigDataset(IPropertyEditorFactory propertyEditorFactory, IFrameworkContext frameworkContext, IAttributeTypeRegistry attributeTypeRegistry)
{
_frameworkContext = frameworkContext;
PropertyEditorFactory = propertyEditorFactory;
//InitCreators();
// Anthony's code
var helper = new UmbracoXmlImportHelper(attributeTypeRegistry, propertyEditorFactory);
_templates = helper.InitTemplates();
_dataTypes = helper.InitDataTypes(_frameworkContext);
_docTypes = helper.InitDocTypes();
// get content node xml
_nodeData = XDocument.Parse(Files.umbraco);
}
public UmbracoApplicationContext(
//ICmsHiveManager hive,
//HiveManager hive,
UmbracoSettings settings,
IFrameworkContext frameworkContext,
ISecurityService securityService)
{
//Hive = hive;
Settings = settings;
FrameworkContext = frameworkContext;
Security = securityService;
//Hive2 = hive2;
//Hive2 = DependencyResolver.Current.GetService<HiveManager>();
//TODO: Use this cache mechanism! But in order to do so , we need triggers working from Hive providers, currently they are not setup
//clear our status cache when any hive install status changes
frameworkContext.TaskManager.AddDelegateTask(
TaskTriggers.Hive.InstallStatusChanged,
x => _installStatuses = null);
}
public static ProviderMappingGroup GenerateProviderGroup(int numberOfProviders, int numberOfPassthroughProviders, int numberOfMockedEntities, IFrameworkContext frameworkContext)
{
Func<int, bool, IEnumerable<Tuple<ProviderSetup, ReadonlyProviderSetup>>> generate = (count, isPassthrough) =>
{
var generateProviders = new List<Tuple<ProviderSetup, ReadonlyProviderSetup>>();
for (int i = 0; i < count; i++)
{
var mockKey = "test" + (isPassthrough ? "_passthrough" : String.Empty) + i;
var metadata = new ProviderMetadata(mockKey, new Uri("content://"), true, isPassthrough);
var factory = MockEntityRepositoryFactory(numberOfMockedEntities, metadata, frameworkContext);
var setup = new ProviderSetup(new ProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
var readonlySetup = new ReadonlyProviderSetup(new ReadonlyProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
generateProviders.Add(new Tuple<ProviderSetup, ReadonlyProviderSetup>(setup, readonlySetup));
}
return generateProviders;
};
var uris = new[] { "content://boots/", "content://bags/", "content://shoes/" };
var uriMatches = EnumerableExtensions.Range(count => new WildcardUriMatch(new Uri(uris[count])), 3);
var injectMockedProviders = generate.Invoke(numberOfProviders, false)
.Concat(generate.Invoke(numberOfPassthroughProviders, true));
return new ProviderMappingGroup("test", uriMatches, injectMockedProviders.Select(x => x.Item2), injectMockedProviders.Select(x => x.Item1), new FakeFrameworkContext());
}
public ProviderMappingGroup(string key,
IEnumerable<WildcardUriMatch> matches,
IEnumerable<ReadonlyProviderSetup> readers,
IEnumerable<ProviderSetup> writers,
IFrameworkContext frameworkContext)
{
Mandate.ParameterNotNullOrEmpty(key, "key");
Mandate.ParameterNotNull(readers, "readers");
Mandate.ParameterNotNull(writers, "writers");
var readerCount = readers.Count();
var writerCount = writers.Count();
Mandate.That(readerCount > 0 || writerCount > 0,
x => new ArgumentOutOfRangeException("readers / writers",
"ProviderMappingGroup '{0}' must be supplied with at least one reader or writer. Given Readers: {1}, Writers: {2}"
.InvariantFormat(key, readerCount, writerCount)));
Mandate.ParameterNotNull(frameworkContext, "frameworkContext");
Key = key;
FrameworkContext = frameworkContext;
WildcardUriMatches = matches;
Readers = readers;
Writers = writers;
}
public EntityRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext, DependencyHelper helper)
: base(providerMetadata, providerTransaction, frameworkContext)
{
_helper = helper;
}
internal HiveManager(ProviderMappingGroup singleProvider, IFrameworkContext frameworkContext)
: this(Enumerable.Repeat(singleProvider, 1), frameworkContext)
{
}
protected AbstractReadonlySchemaRepository(ProviderMetadata providerMetadata, AbstractReadonlyRevisionRepository <EntitySchema> revisions, IFrameworkContext frameworkContext)
: base(providerMetadata, frameworkContext)
{
Revisions = revisions;
EntitiesAddedOrUpdated = new HashSet <AbstractSchemaPart>();
}
/// <summary>
/// TEMPORARY method to install all data required for dev data set excluding all of the core data
/// </summary>
/// <param name="manager"></param>
/// <param name="framework"></param>
internal void InstallDevDataset(IHiveManager manager, IFrameworkContext framework)
{
//a list of all the schemas we've added
var schemas = new List <EntitySchema>();
using (var writer = manager.OpenWriter <IContentStore>())
{
//create all of the document type's and their associated tabs first
//foreach (var d in _devDataSet.ContentData.Select(x => x.DocumentType).DistinctBy(x => x.Id))
foreach (var d in DocTypes)
{
var schema = new EntitySchema(d.Alias, d.Name);
schema.Id = d.Id;
schema.AttributeGroups.AddRange(
framework.TypeMappers.Map <IEnumerable <Tab>, IEnumerable <AttributeGroup> >(
d.DefinedTabs));
writer.Repositories.Schemas.AddOrUpdate(schema);
schemas.Add(schema);
foreach (var parentId in d.InheritFrom.Where(x => x.Selected).Select(x => HiveId.Parse(x.Value)))
{
writer.Repositories.AddRelation(new Relation(FixedRelationTypes.DefaultRelationType, parentId, d.Id));
}
}
writer.Complete();
}
using (var writer = manager.OpenWriter <IContentStore>())
{
//now we can hopefully just map the schema and re-save it so it maps all properties
//foreach (var d in _devDataSet.ContentData.Select(x => x.DocumentType).DistinctBy(x => x.Id))
foreach (var d in DocTypes)
{
var schema = framework.TypeMappers.Map <DocumentTypeEditorModel, EntitySchema>(d);
writer.Repositories.Schemas.AddOrUpdate(schema);
}
writer.Complete();
}
using (var writer = manager.OpenWriter <IContentStore>())
{
//now just map the entire content entities and persist them, since the attribution definitions and attribution
//groups are created these should just map up to the entities in the database.
var mappedCollection = framework
.TypeMappers.Map <IEnumerable <ContentEditorModel>, IEnumerable <Revision <TypedEntity> > >(ContentData)
.ToArray();
mappedCollection.ForEach(x => x.MetaData.StatusType = FixedStatusTypes.Published);
//var allAttribTypes = AllAttribTypes(mappedCollection);
writer.Repositories.Revisions.AddOrUpdate(mappedCollection);
writer.Complete();
}
////now that the data is in there, we need to setup some structure... probably a nicer way to do this but whatevs... its just for testing
//using (var writer = mappingGroup.CreateReadWriteUnitOfWork())
//{
// var homeSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1045));
// var contentSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1045));
// var faqContainerSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1055));
// var faqCatSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1056));
// var faqSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1057));
//}
}
public RevisionRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, frameworkContext, dependencyHelper)
{
}
public GroupUnit(IEnumerable <ProviderUnit> providerUnits, Uri idRoot, AbstractScopedCache scopedCache, bool canDisposeCache, IFrameworkContext frameworkContext, RepositoryContext hiveContext)
{
// Only check that providerUnits is not null, it's OK if it's empty - might be a group unit for a group that can't do anything :)
Mandate.ParameterNotNull(providerUnits, "providerUnits");
Mandate.ParameterNotNull(idRoot, "idRoot");
Mandate.ParameterNotNull(scopedCache, "scopedCache");
ProviderUnits = providerUnits;
IdRoot = idRoot;
_canDisposeCache = canDisposeCache;
UnitScopedCache = scopedCache;
FrameworkContext = frameworkContext ?? providerUnits.First().EntityRepository.FrameworkContext;
WasAbandoned = false;
var enumerable = ProviderUnits.ToArray();
var entityRepositories = enumerable.Select(y =>
{
y.EntityRepository.HiveContext = hiveContext;
return(y.EntityRepository);
}).ToList();
var providerEntityRevisionRepositories = enumerable.Select(y =>
{
y.EntityRepository.Revisions.HiveContext = hiveContext;
return(y.EntityRepository.Revisions);
}).ToList();
var schemaRepositories = enumerable.Select(y =>
{
y.EntityRepository.Schemas.HiveContext = hiveContext;
return(y.EntityRepository.Schemas);
}).ToList();
var providerSchemaRevisionRepositories = enumerable.Select(y =>
{
y.EntityRepository.Schemas.Revisions.HiveContext = hiveContext;
return(y.EntityRepository.Schemas.Revisions);
}).ToList();
_entityRepository = new EntityRepositoryGroup <TFilter>(entityRepositories,
providerEntityRevisionRepositories,
schemaRepositories,
providerSchemaRevisionRepositories,
IdRoot,
UnitScopedCache,
FrameworkContext,
hiveContext);
}
protected AbstractReadonlyRevisionRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, frameworkContext, dependencyHelper)
{
}
public SchemaRepositoryFactory(ProviderMetadata providerMetadata, AbstractRevisionRepositoryFactory <EntitySchema> revisionRepositoryFactory, IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper) : base(providerMetadata, revisionRepositoryFactory, frameworkContext, dependencyHelper)
{
}
protected AbstractFluentMappingEngine(IFrameworkContext frameworkContext)
{
FrameworkContext = frameworkContext;
}
public static AbstractEntityRepositoryFactory MockEntityRepositoryFactory(int allItemCount, ProviderMetadata metadata, IFrameworkContext frameworkContext)
{
var entitySession = Substitute.For <AbstractEntityRepository>(metadata, new TransactionMock(), frameworkContext);
entitySession.CanReadRelations.Returns(true);
entitySession.CanWriteRelations.Returns(true);
entitySession
.PerformGet <TypedEntity>(Arg.Any <bool>(), Arg.Any <HiveId[]>())
.Returns(x => EnumerableExtensions.Range(count => HiveModelCreationHelper.MockTypedEntity(HiveId.ConvertIntToGuid(count + 1)), 3));
entitySession
.PerformGetAll <TypedEntity>()
.Returns(x => EnumerableExtensions.Range(count => HiveModelCreationHelper.MockTypedEntity(HiveId.ConvertIntToGuid(count + 5)), allItemCount));
entitySession
.PerformGetAncestorRelations(Arg.Any <HiveId>(), Arg.Any <RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetDescendentRelations(Arg.Any <HiveId>(), Arg.Any <RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetParentRelations(Arg.Any <HiveId>(), Arg.Any <RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetChildRelations(Arg.Any <HiveId>(), Arg.Any <RelationType>())
.Returns(MockRelations(MockRelationCount));
var factory = Substitute.For <AbstractEntityRepositoryFactory>(null, null, null, frameworkContext, null);
factory.GetRepository().Returns(entitySession);
return(factory);
}
public static ProviderMappingGroup GenerateProviderGroup(int numberOfProviders, int numberOfPassthroughProviders, int numberOfMockedEntities, IFrameworkContext frameworkContext)
{
Func <int, bool, IEnumerable <Tuple <ProviderSetup, ReadonlyProviderSetup> > > generate = (count, isPassthrough) =>
{
var generateProviders = new List <Tuple <ProviderSetup, ReadonlyProviderSetup> >();
for (int i = 0; i < count; i++)
{
var mockKey = "test" + (isPassthrough ? "_passthrough" : String.Empty) + i;
var metadata = new ProviderMetadata(mockKey, new Uri("content://"), true, isPassthrough);
var factory = MockEntityRepositoryFactory(numberOfMockedEntities, metadata, frameworkContext);
var setup = new ProviderSetup(new ProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
var readonlySetup = new ReadonlyProviderSetup(new ReadonlyProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
generateProviders.Add(new Tuple <ProviderSetup, ReadonlyProviderSetup>(setup, readonlySetup));
}
return(generateProviders);
};
var uris = new[] { "content://boots/", "content://bags/", "content://shoes/" };
var uriMatches = EnumerableExtensions.Range(count => new WildcardUriMatch(new Uri(uris[count])), 3);
var injectMockedProviders = generate.Invoke(numberOfProviders, false)
.Concat(generate.Invoke(numberOfPassthroughProviders, true));
return(new ProviderMappingGroup("test", uriMatches, injectMockedProviders.Select(x => x.Item2), injectMockedProviders.Select(x => x.Item1), new FakeFrameworkContext()));
}
protected ProviderInstallTask(IFrameworkContext context) : base(context)
{
}
public HiveManager(IEnumerable <ProviderMappingGroup> providerGroups, HiveCounterManager perfCounterManager, IFrameworkContext frameworkContext)
: this(providerGroups, frameworkContext)
{
PerfCounterManager = perfCounterManager;
}
public HiveManager(IEnumerable <ProviderMappingGroup> providerGroups, IFrameworkContext frameworkContext)
: this()
{
ProviderGroups = providerGroups;
FrameworkContext = frameworkContext;
}
public ExamineModelMapper(ExamineHelper helper, IFrameworkContext frameworkContext)
: base(frameworkContext)
{
_helper = helper;
}
protected AbstractSchemaRepository(ProviderMetadata providerMetadata, AbstractRevisionRepository <EntitySchema> revisions, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext)
: base(providerMetadata, revisions, frameworkContext)
{
CanWrite = true;
Transaction = providerTransaction;
Revisions = revisions;
Revisions.RelatedEntitiesLoader = x => ProviderRepositoryHelper.CreateRelationLazyLoadDelegate(this, x).Invoke(x);
}
protected AbstractRevisionRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext)
: base(providerMetadata, frameworkContext)
{
CanWrite = true;
Transaction = providerTransaction;
RevisionDataAddedOrUpdated = new HashSet <RevisionData>();
EntityDataAddedOrUpdated = new HashSet <T>();
}
internal RevisionRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, ISession singleProvidedSession, bool leaveSessionOpenOnDispose)
: base(providerMetadata, frameworkContext, new DependencyHelper(new NhFactoryHelper(null, singleProvidedSession, leaveSessionOpenOnDispose, false, frameworkContext), providerMetadata))
{
}
public UninstalledReadonlyProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.EventArgs"/> class.
/// </summary>
public TaskEventArgs(IFrameworkContext frameworkContext, EventArgs callerEventArgs)
{
FrameworkContext = frameworkContext;
CallerEventArgs = callerEventArgs;
}
public ReadonlyProviderSetup(ReadonlyProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
ReadonlyUnitFactory = unitFactory;
}
public NullProviderSchemaRepositoryFactory(ProviderMetadata providerMetadata, AbstractRevisionRepositoryFactory<EntitySchema> revisionRepositoryFactory, IFrameworkContext frameworkContext)
: base(providerMetadata, revisionRepositoryFactory, frameworkContext, new NullProviderDependencyHelper(providerMetadata))
{
}
public MembershipWrapperModelMapper(IAttributeTypeRegistry attributeTypeRegistry, IFrameworkContext frameworkContext)
: base(frameworkContext)
{
_attributeTypeRegistry = attributeTypeRegistry;
}
public GroupUnitFactory(IEnumerable <ProviderSetup> providers, Uri idRoot, RepositoryContext hiveContext, IFrameworkContext frameworkContext)
: base(providers, idRoot, hiveContext, frameworkContext)
{
}
protected AbstractSchemaRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext)
: this(providerMetadata, new NullProviderRevisionRepository <EntitySchema>(providerMetadata, frameworkContext), providerTransaction, frameworkContext)
{
Transaction = providerTransaction;
}
public NullProviderRevisionRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
: base(providerMetadata, frameworkContext, new NullProviderDependencyHelper(providerMetadata))
{
}
public static RepositoryContext CreateFakeRepositoryContext(IFrameworkContext frameworkContext)
{
return(new RepositoryContext(new NullCachingProvider(), new NullCachingProvider(), frameworkContext));
}
protected AbstractSchemaRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
: this(providerMetadata, new NullProviderTransaction(), frameworkContext)
{
}
protected AbstractTask(IFrameworkContext context)
{
Context = context;
}
public EntityRepository(ProviderMetadata providerMetadata, AbstractSchemaRepository schemas, IFrameworkContext frameworkContext, DependencyHelper helper)
: base(providerMetadata, schemas, frameworkContext)
{
_helper = helper;
}
public NullProviderSchemaRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
: this(providerMetadata, new NullProviderRevisionRepositoryFactory<EntitySchema>(providerMetadata, frameworkContext), frameworkContext)
{
}
public EntityRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, AbstractRevisionRepository <TypedEntity> revisions, AbstractSchemaRepository schemas, IFrameworkContext frameworkContext, DependencyHelper helper)
: base(providerMetadata, providerTransaction, revisions, schemas, frameworkContext)
{
_helper = helper;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.EventArgs"/> class.
/// </summary>
public TaskEventArgs(IFrameworkContext frameworkContext, EventArgs callerEventArgs)
{
FrameworkContext = frameworkContext;
CallerEventArgs = callerEventArgs;
}
protected AbstractReadonlySchemaRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
: this(providerMetadata, new NullProviderRevisionRepository <EntitySchema>(providerMetadata, frameworkContext), frameworkContext)
{
}
