private EntityContextFactory CreateEntityContextFactory() { return(EntityContextFactory .FromConfiguration(DescriptionConfigurationSection.Default.DefaultStoreFactoryName) .WithDefaultOntologies() .WithDotNetRDF(_tripleStore.Value)); }
private IEntityContext CreateEntityContext(IKernel kernel, CreationContext context) { IEntityContext result = null; lock (_lock) { EntityContextFactory entityContextFactory = _entityContextFactory.Value; if (!_isNamedGraphSelectorInitialized) { entityContextFactory = entityContextFactory.WithNamedGraphSelector(kernel.Resolve <INamedGraphSelector>()); _isNamedGraphSelectorInitialized = true; } if (!_isBaseUriInitialized) { var baseUri = kernel.Resolve <IHttpServerConfiguration>().BaseUri; if (baseUri != null) { _isBaseUriInitialized = true; result = entityContextFactory.WithBaseUri(policy => policy.Default.Is(baseUri)).CreateContext(); } } if (result == null) { result = entityContextFactory.CreateContext(); } } return(result); }
protected virtual void MoveItem(PlatformItem item, IPlatformModule targetModule) { if (item == null) { return; } var c = EntityContextFactory.CreateContext(); c.Attach(Entities); ReleaseLinks(item); c.SaveEntityStateAsyncAndDispose(); var context = EntityContextFactory.CreateContext(); context.Attach(((PlatformModule)targetModule).Entities); context.Attach(item); item.AssociatedPlatformModuleEntity = ((PlatformModule)targetModule).Entities; context.SaveEntityStateAsyncAndDispose(); Entities.PlatformItems.Remove(item); targetModule.AddItem(item); ItemRoutings.Remove(item); CurrentItemCountChangedEvent(this, new ItemCountChangedEventArgs(CurrentItemCount)); }
public void GivenTwoLinkedItems_WhenMoveOne_ShouldReleaseLinks() { var logger = new Mock <ILogger>(); var entityContextFactory = new EntityContextFactory(logger.Object); var dummy = new PlatformModule { EntityContextFactory = entityContextFactory, Logger = logger.Object, CompositeAlarmManager = new CompositeAlarmManager(logger.Object), Name = string.Empty }; dummy.Construct(); var item1 = new PlatformItem { ItemId = 1 }; var item2 = new PlatformItem { ItemId = 2 }; item1.ItemBehind = item2; item2.ItemInFront = item1; _testee.AddItem(item1); _testee.AddItem(item2); _testee.MoveItem(item1.ItemId, dummy); item1.ItemInFront.Should().BeNull(); item1.ItemBehind.Should().BeNull(); item2.ItemInFront.Should().BeNull(); item2.ItemBehind.Should().BeNull(); }
public EntityRepository( EntityContextFactory entityContextFactory, Deserializer deserializer) { _entityContextFactory = entityContextFactory; _deserializer = deserializer; }
/// <summary>Sets up the factory to use <see cref="BaseUriResolutionStrategyComposition" /> for resolving external resources.</summary> /// <remarks> /// This implementation checks if a resource's identifier matches given <paramref name="baseUris" /> /// and then resolves by making a <see cref="WebRequest" /> to resource's identifier. /// </remarks> /// <param name="factory">Target factory to be configured.</param> /// <param name="baseUris">Base Uris to match for external resources.</param> /// <returns>Given <paramref name="factory" />.</returns> public static EntityContextFactory WithUriMatchingResourceResulutionStrategy(this EntityContextFactory factory, IEnumerable <Uri> baseUris) { factory.WithDependencies <BaseUriResolutionStrategyComposition>(); var resolutionStrategy = new UrlMatchingResourceResolutionStrategy( factory.Ontologies, factory.MappingModelVisitors.OfType <BaseUriMappingModelVisitor>().First().MappingAssemblies, baseUris); return(factory.WithResourceResolutionStrategy(resolutionStrategy)); }
public static void InitContext() { var contextFactory = new EntityContextFactory(); contextFactory.WithMappings((MappingBuilder builder) => { builder.FromAssemblyOf <INode>(); }); store = new TripleStore(); contextFactory.WithDotNetRDF(store); contextFactory.WithMetaGraphUri(new Uri(clientURI)); context = contextFactory.CreateContext(); }
public void Setup() { var container = new ServiceContainer(); var logger = new Mock<ILogger>(); logger.Setup(instance => instance.Log(It.IsAny<LogLevel>(), It.IsAny<string>(), It.IsAny<object[]>())); logger.Setup(instance => instance.Log(It.IsAny<LogLevel>(), It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>())); container.RegisterInstance(logger.Object); container.Register<MappingFromAttributes>(); container.Register<MappingFromFluent>(); IEntityContextFactory factory = new EntityContextFactory(container) .WithDefaultOntologies() .WithMetaGraphUri(new Uri("http://app.magi/graphs")) .WithDependenciesInternal<Dependencies>(); _entityContext = factory.CreateContext(); }
private IEntityContext CreateEntityContext(IOntologyProvider ontologyProvider, IEnumerable <Assembly> mappingAssemblies) { var factory = new EntityContextFactory() .WithMappings(builder => BuildMappingAssemblies(builder, mappingAssemblies)) .WithDefaultOntologies() .WithMetaGraphUri(_metaGraph.BaseUri) .WithNamedGraphSelector(_namedGraphSelector) .WithDotNetRDF(_tripleStore); if (ontologyProvider != null) { factory = factory.WithOntology(ontologyProvider); } return(factory.CreateContext()); }
public void SetUp() { var entityContextFactory = new EntityContextFactory(new Mock <ILogger>().Object); _eventAggregator = new Mock <IEventAggregator>(); _logger = new Mock <ILogger>(); _fileSystem = new Mock <IPathExists>(); _jobContainer = new JobContainer(_logger.Object, entityContextFactory, new Mock <IPlatformModuleEntities>().Object); _testee = new JobManager(); var setupTestee = new PrivateObject(_testee); setupTestee.SetFieldOrProperty("Logger", _logger.Object); setupTestee.SetFieldOrProperty("EventAggregator", _eventAggregator.Object); setupTestee.SetFieldOrProperty("Jobs", _jobContainer); }
protected virtual void RemoveItem(PlatformItem item) { if (item == null) { return; } Entities.PlatformItems.Remove(item); var context = EntityContextFactory.CreateContext(); context.Delete(item); context.SaveEntityStateAsyncAndDispose(); ItemRoutings.Remove(item); CurrentItemCountChangedEvent(this, new ItemCountChangedEventArgs(CurrentItemCount)); }
public void Setup() { _store = new TripleStore(); _store.LoadTestFile("TriplesWithLiteralSubjects.trig"); var container = new ServiceContainer(); container.RegisterInstance <ITripleStore>(_store); IEntityContextFactory factory = new EntityContextFactory(container) .WithDefaultOntologies() .WithEntitySource <TripleStoreAdapter>() .WithMetaGraphUri(new Uri("http://app.magi/graphs")) .WithDependenciesInternal <Dependencies>(); _typeCache = (TestCache)container.GetInstance <IRdfTypeCache>(); _entityContext = factory.CreateContext(); }
/// <summary> /// Raises an event to notify LineControl that an item was discovered (independently whether it's a new or old item). /// </summary> protected void RaisePlatformItemDetected(long itemId) { var item = GetItem(itemId); if (item != null) { item.LastDetectionTime = DateTime.Now; item.DetectedInModuleCount++; item.DetectedCount++; using (var context = EntityContextFactory.CreateContext()) { context.UpdateField(item, a => a.DetectedCount); context.UpdateField(item, a => a.DetectedInModuleCount); context.UpdateField(item, a => a.LastDetectionTime); } } EventAggregator.Publish(new PlatformItemEvent(itemId, this, PlatformItemEventType.ItemDetected)); }
public void Setup() { Mappings = SetupMappings(); _container = new ServiceContainer(); _store = CreateTripleStore(); EntityContextFactory factory = new EntityContextFactory(_container) .WithOntology(new DefaultOntologiesProvider()) .WithOntology(new LifeOntology()) .WithOntology(new TestOntologyProvider(IncludeFoaf)) .WithOntology(new ChemOntology()) .WithMappings(BuildMappings) .WithMetaGraphUri(MetaGraphUri) .WithDotNetRDF(_store) .WithBaseUri(b => b.Default.Is(new Uri("http://example.com/"))); factory.ThreadSafe = ThreadSafe; factory.TrackChanges = TrackChanges; _factory = factory; ChildSetup(); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Initialises this object. /// </summary> ///------------------------------------------------------------------------------------------------- public static void Init() { EntityContextFactory.Initalize(); Container.Bind <IUnitOfWork>().ToMethod( () => { string nameOrConnectionString = null; var overriddenConnectionString = WebConfigurationManager.AppSettings["Framework.RepositoryContext"]; if (!string.IsNullOrWhiteSpace(overriddenConnectionString)) { nameOrConnectionString = overriddenConnectionString; } if (string.IsNullOrWhiteSpace(nameOrConnectionString)) { nameOrConnectionString = "AppContext"; } return(new UnitOfWork(nameOrConnectionString)); }).InRequestScope(); }
private static IEntityContext CreateEntityContext() { var entityContextFactory = new EntityContextFactory() .WithMetaGraphUri(MetaGraphUri) .WithMappings(builder => builder.FromAssemblyOf <IKnowSomething>()) .WithDefaultOntologies() .WithOntology(new IntegrationTestsBase.ChemOntology()) .WithOntology(new IntegrationTestsBase.LifeOntology()) .WithOntology(new TestOntologyProvider(false)) .WithNamedGraphSelector(new NamedGraphSelector()) .WithDependenciesInternal <BaseUriResolutionStrategyComposition>() .WithDotNetRDF(CreateTripleStore()); var resolutionStrategy = new UrlMatchingResourceResolutionStrategy( entityContextFactory.Ontologies, entityContextFactory.MappingModelVisitors.OfType <BaseUriMappingModelVisitor>().First().MappingAssemblies, BaseUris, CreateWebRequest); return(entityContextFactory .WithResourceResolutionStrategy(resolutionStrategy) .CreateContext()); }
/// <summary> /// Adds item to the module and schedules a persistance action to store the data in the db. /// The contract is that each item with Id = 0 is a new item to be created unless there is an item with the /// same ItemId already read from the database. In that case the database object is used. Otherwise /// a new platfrom item is created in the database. /// </summary> /// <param name="item"></param> public virtual void AddItem(PlatformItem item) { if (item == null) { return; } var context = EntityContextFactory.CreateContext(); context.Attach(Entities); if (item.Id == 0) { var previouslyAddedItem = PlatformModuleEntities.GetAll().SelectMany(a => a.PlatformItems).FirstOrDefault(b => b.ItemId == item.ItemId); if (previouslyAddedItem != null) { context.Detach(previouslyAddedItem); Entities.PlatformItems.Remove(previouslyAddedItem); item.Id = item.ItemId; context.Update(item); } else { item.Id = item.ItemId; context.Add(item); } } else { context.Attach(item); } item.AssociatedPlatformModuleEntity = Entities; context.SaveEntityStateAsyncAndDispose(); Entities.PlatformItems.Add(item); OverallItemCount++; CurrentItemCountChangedEvent(this, new ItemCountChangedEventArgs(CurrentItemCount)); }
static void Main() { ITripleStore store = new TripleStore(); store.LoadFromFile("input.trig"); var factory = new EntityContextFactory(); // it is also possible to add fluent/attribute mappings separately factory.WithMappings(mb => mb.FromAssemblyOf <IPerson>()); // this is necessary to tell where entities' data is stored in named graphs // see the input.trig file to find out how it does that factory.WithMetaGraphUri(new Uri("http://romanticweb.net/samples")); // this API bound to change in the future so that custom // namespaces can be added easily factory.WithOntology(new DefaultOntologiesProvider(BuiltInOntologies.DCTerms | BuiltInOntologies.FOAF)); factory.WithDotNetRDF(store); var context = factory.CreateContext(); foreach (var person in context.AsQueryable <IPerson>().Where(p => p.Name != "Karol")) { var pubId = "http://romanticweb.net/samples/publication/" + Guid.NewGuid(); var pub = context.Create <IPublication>(pubId); pub.Title = string.Format("Publication about RDF by {0} {1}", person.Name, person.LastName); pub.DatePublished = DateTime.Now; person.Publications.Add(pub); } context.Commit(); store.SaveToFile("output.trig", new TriGWriter()); }
/// <summary> /// Sets up the <paramref name="factory"/> with components required to use dotNetRDF /// and supplies a triple store name configured in app.config/web.config /// </summary> public static EntityContextFactory WithDotNetRDF(this EntityContextFactory factory, string storeName) { ((IComponentRegistryFacade)factory).Register(Configuration.StoresConfigurationSection.Default.CreateStore(storeName)); return(WithDotNetRDF(factory)); }
/// <summary>Sets up the <paramref name="factory"/> with components required to use dotNetRDF and supplies a triple store instance.</summary> public static EntityContextFactory WithDotNetRDF(this EntityContextFactory factory, ITripleStore store) { ((IComponentRegistryFacade)factory).Register(store); return(WithDotNetRDF(factory)); }
/// <summary>Sets up the <paramref name="factory"/> with components required to use dotNetRDF.</summary> public static EntityContextFactory WithDotNetRDF(this EntityContextFactory factory) { return(factory.WithDependencies <Components>() .WithEntitySource <TripleStoreAdapter>()); }
public void Setup() { _ontology = new Mock<IOntologyProvider>(); _ontology.Setup(provider => provider.ResolveUri(It.IsAny<string>(), It.IsAny<string>())).Returns((string prefix, string name) => new Uri(new Uri("http://base/"), name)); _entityContextFactory = new EntityContextFactory().WithOntology(_ontology.Object); }
/// <inheritdoc /> public virtual IUnitOfWorkContext BeginContext() { var entityContext = EntityContextFactory.Create(); return(new UnitOfWorkContext(entityContext, RepoProvider)); }
public void Should_include_pointed_mapping_assemblies() { EntityContextFactory.FromConfiguration("test").Mappings.FindEntityMappingFor <IProduct>(null).Should().NotBeNull(); }
public void Setup() { _ontology = new Mock <IOntologyProvider>(); _ontology.Setup(provider => provider.ResolveUri(It.IsAny <string>(), It.IsAny <string>())).Returns((string prefix, string name) => new Uri(new Uri("http://base/"), name)); _entityContextFactory = new EntityContextFactory().WithOntology(_ontology.Object); }