public LanguageInterceptor(IPersister persister, ContentActivator activator, IWebContext context, ILanguageGateway gateway) { this.persister = persister; this.activator = activator; this.context = context; this.gateway = gateway; }
public ContentCacheDependency(IPersister persister) { this.persister = persister; persister.ItemMoved += new EventHandler<DestinationEventArgs>(persister_ItemMoved); persister.ItemSaved += new EventHandler<ItemEventArgs>(persister_ItemSaved); persister.ItemDeleted += new EventHandler<ItemEventArgs>(persister_ItemDeleted); }
public PopularityReordererScheduledAction(IDefinitionManager definitions, IPersister persister, IHost host, PopularityChildrenSorter sorter) { this.definitions = definitions; this.persister = persister; this.host = host; this.sorter = sorter; }
public Navigator(IPersister persister, IHost host, VirtualNodeFactory nodes, ContentSource sources) { this.persister = persister; this.host = host; this.virtualNodes = nodes; this.sources = sources; }
public Importer(IPersister persister, IItemXmlReader reader, IFileSystem fs) { this.persister = persister; this.reader = reader; this.fs = fs; //TODO: Initialize 'logger' ---> this.logger =; }
public LinkGenerator(IPersister persister, ConnectionMonitor connection, CacheWrapper cacheWrapper, IRequestLogger logger) { _logger = logger; // DON'T USE DISTRIBUTED CACHE FOR N2 internal data // _urlCache = cacheService.GetCache<string>(new CacheConfig("LinkGenerator_urlCache", 1800)); _urlCache = new HttpRuntimeCacheWrapper<string>("LinkGenerator_urlCache", cacheWrapper); _itemCache = new HttpRuntimeCacheWrapper<object>("LinkGenerator_urlCache_item", cacheWrapper); // hook up to persister events connection.Online += delegate { persister.ItemSaved += persister_ItemSaved; persister.ItemMoving += persister_ItemMoving; persister.ItemMoved += persister_ItemMoved; persister.ItemCopied += persister_ItemCopied; persister.ItemDeleted += persister_ItemDeleted; persister.FlushCache += persister_ItemInvalidated; }; connection.Offline += delegate { persister.ItemSaved -= persister_ItemSaved; persister.ItemMoving -= persister_ItemMoving; persister.ItemMoved -= persister_ItemMoved; persister.ItemCopied -= persister_ItemCopied; persister.ItemDeleted -= persister_ItemDeleted; persister.FlushCache -= persister_ItemInvalidated; }; }
public LanguageInterceptor(IPersister persister, IDefinitionManager definitions, IWebContext context, ILanguageGateway gateway) { this.persister = persister; this.definitions = definitions; this.context = context; this.gateway = gateway; }
public override void SetUp() { base.SetUp(); persister = TestSupport.SetupFakePersister(); persister.Save(root); }
public override void SetUp() { base.SetUp(); finder = new FakeTypeFinder(typeof(XmlableItem).Assembly, typeof(XmlableItem), typeof(XmlableItem2)); notifier = mocks.Stub<IItemNotifier>(); mocks.Replay(notifier); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, new InterceptingProxyFactory()); definitions = new DefinitionManager( new[] {new DefinitionProvider(new DefinitionBuilder(new DefinitionMap(), finder, new TransformerBase<IUniquelyNamed>[0], TestSupport.SetupEngineSection()))}, activator, new StateChanger(), new DefinitionMap()); definitions.Start(); parser = mocks.StrictMock<IUrlParser>(); Expect.On(parser) .Call(parser.BuildUrl(null)) .IgnoreArguments() .Do(new BuildUrl(delegate(ContentItem itemToBuild) { string url = "/" + itemToBuild.Name + ".aspx"; foreach (ContentItem parent in Find.EnumerateParents(itemToBuild, null)) { if (parent.Parent != null) url = "/" + parent.Name + url; } return url.ToUrl(); })) .Repeat.Any(); mocks.Replay(parser); persister = TestSupport.SetupFakePersister(); }
public CommandFactory(IPersister persister, ISecurityManager security, IVersionManager versionMaker, IEditUrlManager editUrlManager, IContentAdapterProvider adapters, StateChanger changer) { this.persister = persister; makeVersionOfMaster = On.Master(new MakeVersionCommand(versionMaker)); replaceMaster = new ReplaceMasterCommand(versionMaker); makeVersion = new MakeVersionCommand(versionMaker); useNewVersion = new UseNewVersionCommand(versionMaker); updateObject = new UpdateObjectCommand(); delete = new DeleteCommand(persister.Repository); showPreview = new RedirectToPreviewCommand(adapters); showEdit = new RedirectToEditCommand(editUrlManager); useMaster = new UseMasterCommand(); clone = new CloneCommand(); validate = new ValidateCommand(); this.security = security; save = new SaveCommand(persister); incrementVersionIndex = new IncrementVersionIndexCommand(versionMaker); draftState = new UpdateContentStateCommand(changer, ContentState.Draft); publishedState = new UpdateContentStateCommand(changer, ContentState.Published); saveActiveContent = new ActiveContentSaveCommand(); moveToPosition = new MoveToPositionCommand(); unpublishedDate = new EnsureNotPublishedCommand(); publishedDate = new EnsurePublishedCommand(); updateReferences = new UpdateReferencesCommand(); }
public ContentChangeTracker(IIndexer indexer, IPersister persister, IWorker worker, ConnectionMonitor connection, IErrorNotifier errors, DatabaseSection config) { this.indexer = indexer; this.persister = persister; this.worker = worker; this.errors = errors; this.async = config.Search.AsyncIndexing; this.handleErrors = config.Search.HandleErrors; RetryInterval = TimeSpan.FromMinutes(2); if(config.Search.Enabled) { connection.Online += delegate { persister.ItemSaved += persister_ItemSaved; persister.ItemMoving += persister_ItemMoving; persister.ItemMoved += persister_ItemMoved; persister.ItemCopied += persister_ItemCopied; persister.ItemDeleted += persister_ItemDeleted; }; connection.Offline += delegate { persister.ItemSaved -= persister_ItemSaved; persister.ItemMoving -= persister_ItemMoving; persister.ItemMoved -= persister_ItemMoved; persister.ItemCopied -= persister_ItemCopied; persister.ItemDeleted -= persister_ItemDeleted; }; } }
public AsyncTrashPurger(IWorker worker, ITrashHandler trash, IPersister persister, ISecurityManager security) { this.worker = worker; this.trash = trash; this.persister = persister; this.security = security; }
public XmlInstallationManager(IHost host, IPersister persister, XmlContentRepository repository, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator) : base(connectionContext, importer, webContext, persister, activator) { this.host = host; this.persister = persister; this.repository = repository; }
public MongoInstallationManager(MongoDatabaseProvider database, IHost host, IPersister persister, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator) : base(connectionContext, importer, webContext, persister, activator) { this.database = database; this.host = host; this.persister = persister; }
public CredentialStore(IPersister persister, IHost host) { _persister = persister; _host = host; DefaultRoles = new[] {"Everyone", "Members", "Editors", "Administrators"}; }
public CachingUrlParserDecorator(IUrlParser inner, IPersister persister, IWebContext webContext, CacheWrapper cache) { this.inner = inner; this.persister = persister; this.webContext = webContext; this.cache = cache; }
public ContentChangeTracker(IAsyncIndexer indexer, IPersister persister, ConnectionMonitor connection, DatabaseSection config) { this.indexer = indexer; if (!config.Search.Enabled) return; if (!string.IsNullOrEmpty(config.Search.IndexOnMachineNamed) && config.Search.IndexOnMachineNamed != Environment.MachineName) return; connection.Online += delegate { IsMonitoring = true; persister.ItemSaved += persister_ItemSaved; persister.ItemMoving += persister_ItemMoving; persister.ItemMoved += persister_ItemMoved; persister.ItemCopied += persister_ItemCopied; persister.ItemDeleted += persister_ItemDeleted; }; connection.Offline += delegate { IsMonitoring = false; persister.ItemSaved -= persister_ItemSaved; persister.ItemMoving -= persister_ItemMoving; persister.ItemMoved -= persister_ItemMoved; persister.ItemCopied -= persister_ItemCopied; persister.ItemDeleted -= persister_ItemDeleted; }; }
public CachingLanguageGatewayDecorator(ILanguageGateway inner, CacheWrapper cacheWrapper, IPersister persister, string masterKey) { this.inner = inner; this.cacheWrapper = cacheWrapper; this.persister = persister; this.masterKey = masterKey; }
public Repository(IPersister<List<CcdLevel>> persister) { _logger.Trace("Creating repository"); _persister = persister; Initialize(); }
public FolderNodeProvider(IFileSystem fs, IPersister persister, IDependencyInjector dependencyInjector) { UploadFolderPaths = new FolderPair[0]; this.fs = fs; this.persister = persister; this.dependencyInjector = dependencyInjector; }
public ContentMessageSource(IPersister persister, IIntegrityManager integrity, ISecurityManager security, IWebContext context) { this.persister = persister; this.integrity = integrity; this.security = security; this.context = context; }
public ExternalContentRepository(ContainerRepository<ExternalItem> containerRepository, IPersister persister, ContentActivator activator, EditSection config) { this.containerRepository = containerRepository; this.persister = persister; this.activator = activator; externalItemType = Type.GetType(config.Externals.ExternalItemType) ?? typeof(ExternalItem); }
public CommandFactory(IPersister persister, ISecurityManager security, IVersionManager versionMaker, IEditUrlManager editUrlManager, IContentAdapterProvider adapters, StateChanger changer) { //this.persister = persister; //makeVersionOfMaster = On.Master(new MakeVersionCommand(versionMaker)); //showEdit = new RedirectToEditCommand(editUrlManager); //clone = new CloneCommand(); //unpublishedDate = new EnsureNotPublishedCommand(); // moved to StateChanger //ensurePublishedDate = new EnsurePublishedCommand(); // moved to StateChanger this.security = security; save = new SaveCommand(persister); delete = new DeleteCommand(persister.Repository); replaceMaster = new ReplaceMasterCommand(versionMaker); makeVersion = new MakeVersionCommand(versionMaker); useDraftCmd = new UseDraftCommand(versionMaker); saveOnPageVersion = new SaveOnPageVersionCommand(versionMaker); draftState = new UpdateContentStateCommand(changer, ContentState.Draft); publishedState = new UpdateContentStateCommand(changer, ContentState.Published); updateObject = new UpdateObjectCommand(); useMaster = new UseMasterCommand(); validate = new ValidateCommand(); saveActiveContent = new ActiveContentSaveCommand(); moveToPosition = new MoveToPositionCommand(); updateReferences = new UpdateReferencesCommand(); }
public TreeSorter(IPersister persister, IEditManager editManager, IWebContext webContext, IVersionManager versionMaker) { this.persister = persister; this.editManager = editManager; this.webContext = webContext; this.versionMaker = versionMaker; }
public PublishScheduledAction(ContentVersionRepository versionRepository, IVersionManager versioner, IPersister persister, ISecurityManager security, StateChanger changer) { this.versionRepository = versionRepository; this.versioner = versioner; this.persister = persister; this.security = security; this.changer = changer; }
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ContentActivator activator, Navigator navigator) { this.persister = persister; this.managementPaths = editUrlManager; this.definitions = definitions; this.activator = activator; this.navigator = navigator; }
public CachingUrlParserDecorator(IUrlParser inner, IPersister persister, IWebContext webContext, CacheWrapper cache, HostSection config) { this.inner = inner; this.persister = persister; this.webContext = webContext; this.cache = cache; SlidingExpiration = config.OutputCache.SlidingExpiration ?? TimeSpan.FromMinutes(15); }
public SiteFilteringLanguageGateway(ILanguageGateway languages, Site site, IPersister persister, StructureBoundDictionaryCache<int, LanguageInfo[]> languagesCache, DescendantItemFinder descendantFinder) { this.languages = languages; this.site = site; this.persister = persister; this.languagesCache = languagesCache; this.descendantFinder = descendantFinder; }
public InstallationManager(ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, IPersister persister, ContentActivator activator) { this.connectionContext = connectionContext; this.importer = importer; this.webContext = webContext; this.persister = persister; this.activator = activator; }
public ItemMover(IPersister persister, Navigator navigator, IIntegrityManager integrity, IVersionManager versions, ContentVersionRepository versionRepository) { this.persister = persister; this.navigator = navigator; this.integrity = integrity; this.versions = versions; this.versionRepository = versionRepository; }
public UrlParser(IPersister persister, IWebContext webContext, IHost host, N2.Plugin.ConnectionMonitor connections, HostSection config) { if (host == null) { throw new ArgumentNullException("host"); } IsOnline = connections.IsConnected ?? true; connections.Online += (s, a) => IsOnline = true; connections.Offline += (s, a) => IsOnline = false; this.persister = persister; this.webContext = webContext; this.host = host; ignoreExistingFiles = config.Web.IgnoreExistingFiles; }
public EditManager(IDefinitionManager definitions, IPersister persister, IVersionManager versioner, ISecurityManager securityManager, IPluginFinder pluginFinder, IEditUrlManager urls, StateChanger changer, EditableHierarchyBuilder interfaceBuilder, EditSection config) { this.definitions = definitions; this.persister = persister; this.versioner = versioner; this.securityManager = securityManager; this.pluginFinder = pluginFinder; this.urls = urls; this.stateChanger = changer; this.interfaceBuilder = interfaceBuilder; EditTheme = config.EditTheme; EnableVersioning = config.Versions.Enabled; MaximumNumberOfVersions = config.Versions.MaximumPerItem; uploadFolders = new List <string>(config.UploadFolders.Folders); }
private TrashHandler CreateTrashHandler() { ContentActivator activator = new ContentActivator(null, null, null); IPersister persister = MockPersister(root, trash, item); Expect.Call(delegate { persister.Move(null, null); }).IgnoreArguments() .Do(new System.Action <ContentItem, ContentItem>(delegate(ContentItem source, ContentItem destination) { source.AddTo(destination); })).Repeat.Any(); mocks.ReplayAll(); return(new TrashHandler(persister, null, null, new ContainerRepository <TrashContainerItem>(persister, null, host, activator), new StateChanger()) { UseNavigationMode = true }); }
public MultipleSitesInitializer(IPersister persister, IHost host, ISitesProvider sitesProvider, HostSection config, IDefinitionManager ignored) { Debug.WriteLine("MultipleSitesInitializer"); if (config.MultipleSites && config.DynamicSites) { host.AddSites(sitesProvider.GetSites()); persister.ItemSaved += delegate(object sender, ItemEventArgs e) { if (e.AffectedItem is ISitesSource) { IList <Site> sites = Host.ExtractSites(config); sites = Host.Union(sites, sitesProvider.GetSites()); host.ReplaceSites(host.DefaultSite, sites); } }; } }
public LanguageGatewaySelector( IPersister persister, IHost host, StructureBoundDictionaryCache <int, LanguageInfo[]> languagesCache, DescendantItemFinder descendantFinder, ILanguageGateway languages, CacheWrapper cacheWrapper, EngineSection config) { this.persister = persister; this.host = host; this.languagesCache = languagesCache; this.descendantFinder = descendantFinder; this.languages = languages; this.cacheWrapper = cacheWrapper; Enabled = config.Globalization.Enabled; Cache = config.Globalization.Cache; LanguagesPerSite = config.Globalization.LanguagesPerSite; }
public HttpServer(IWebServer webServer, IPersister persister, interfaces.Logging.ILogger logger) { if (!HttpListener.IsSupported) { throw new NotSupportedException("The Http Listener is not supported."); } // save our persister _persister = persister ?? throw new ArgumentNullException(nameof(persister)); // the webserver config _webServer = webServer ?? throw new ArgumentNullException(nameof(webServer)); // the logger _logger = logger ?? throw new ArgumentNullException(nameof(logger)); // create our listener. _listener = new HttpListener(); }
public override void SetUp() { base.SetUp(); persister = engine.Persister; versions = engine.Resolve <IVersionManager>(); persister.Dispose(); CreateDatabaseSchema(); root = CreateOneItem <ThrowableItem>(0, "root", null); item = CreateOneItem <ThrowableItem>(0, "item", root); item2 = CreateOneItem <ThrowableItem>(0, "item2", root); trash = engine.Resolve <ITrashHandler>(); System.Threading.Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("admin", "test"), new string[] { "Administrators" }); }
public static ContentItem Publish(this IVersionManager versionManager, IPersister persister, ContentItem previewedItem) { if (previewedItem.VersionOf.HasValue) { previewedItem = versionManager.MakeMasterVersion(previewedItem); persister.Save(previewedItem); } if (previewedItem.State != ContentState.Published) { previewedItem.State = ContentState.Published; if (!previewedItem.Published.HasValue) { previewedItem.Published = Utility.CurrentTime(); } persister.Save(previewedItem); } return(previewedItem); }
/// <inheritdoc /> public void Prepare(IPersister persister, IConnectionFactory factory) { // no readonly event posible here. if (factory.IsReadOnly) { return; } // sanity check. Contract.Assert(Factory == null); Contract.Assert(_wordsHelper == null); Contract.Assert(_partsHelper == null); Contract.Assert(_partsSearchHelper == null); Factory = factory; _wordsHelper = new WordsHelper(factory, Tables.Words); _partsHelper = new PartsHelper(factory, Tables.Parts); _partsSearchHelper = new PartsSearchHelper(factory, Tables.PartsSearch); }
private void CreatePersister() { mocks.Record(); persister = mocks.DynamicMock <IPersister>(); persister.ItemMoving += null; moving = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemCopying += null; copying = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemDeleting += null; deleting = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemSaving += null; saving = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); mocks.Replay(persister); }
/// <inheritdoc /> public void Prepare(IPersister persister, IConnectionFactory factory) { // prepare the files Files.Prepare(persister, factory); // prepare the folder updates FolderUpdates.Prepare(persister, factory); // no readonly event posible here. if (factory.IsReadOnly) { return; } // sanity check. Contract.Assert(_foldersHelper == null); Contract.Assert(Factory == null); Factory = factory; _foldersHelper = new FoldersHelper(factory, Tables.Folders); }
public override void SetUp() { base.SetUp(); finder = new FakeTypeFinder(typeof(XmlableItem).Assembly, typeof(XmlableItem), typeof(XmlableItem2)); notifier = mocks.Stub <IItemNotifier>(); mocks.Replay(notifier); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, new InterceptingProxyFactory()); definitions = new DefinitionManager( new[] { new DefinitionProvider(new DefinitionBuilder(new DefinitionMap(), finder, new TransformerBase <IUniquelyNamed> [0], TestSupport.SetupEngineSection())) }, new ITemplateProvider[0], activator, new StateChanger()); definitions.Start(); parser = mocks.StrictMock <IUrlParser>(); Expect.On(parser) .Call(parser.BuildUrl(null)) .IgnoreArguments() .Do(new BuildUrl(delegate(ContentItem itemToBuild) { string url = "/" + itemToBuild.Name + ".aspx"; foreach (ContentItem parent in Find.EnumerateParents(itemToBuild, null)) { if (parent.Parent != null) { url = "/" + parent.Name + url; } } return(url); })) .Repeat.Any(); mocks.Replay(parser); persister = mocks.StrictMock <IPersister>(); persister.Save(null); LastCall.IgnoreArguments().Repeat.Any(); mocks.Replay(persister); }
public Animazione Retrieve(BinaryReader br) { // Animazione string nome = br.ReadString(); uint frameRate = br.ReadUInt32(); Animazione result = new Animazione(frameRate); result.Nome = nome; // Modello Modello modello = Documento.getInstance().ModelloRiferimento; int width = br.ReadInt32(); int height = br.ReadInt32(); if (width != modello.Size.Width || height != modello.Size.Height) { return(null); } // Frames byte[] frameAsArray; int nFrames = br.ReadInt32(); for (int i = 0; i < nFrames; i++) { int nCol = br.ReadInt32(); int len = br.ReadInt32(); frameAsArray = new byte[len]; br.Read(frameAsArray, 0, len); result.Frames.Add(new Frame(frameAsArray, nCol, width * height)); } // Informazione IPersister infoPersister = PersisterFactory.GetPersister(br.ReadString()); IInformazione infoAssociata = (IInformazione)infoPersister.Retrieve(br); // Out result.InformazioneAssociata = infoAssociata; return(result); }
public ItemBridge(ContentActivator activator, IPersister persister, ISecurityManager security, IHost host, EditSection config) { this.security = security; this.activator = activator; this.persister = persister; this.host = host; this.editorUsernames = ToArray(config.Editors.Users); this.administratorUsernames = ToArray(config.Administrators.Users); Type configuredUserType = Type.GetType(config.Membership.UserType); if (configuredUserType == null) { throw new ArgumentException("Couldn't create configured membership user type: " + config.Membership.UserType); } if (!typeof(User).IsAssignableFrom(configuredUserType)) { throw new ArgumentException("Configured membership user type '" + config.Membership.UserType + "' doesn't derive from '" + typeof(User).AssemblyQualifiedName + "'"); } this.userType = configuredUserType; }
public LanguageGateway( IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, IHost host, ISecurityManager security, IWebContext context, StructureBoundDictionaryCache <int, LanguageInfo[]> languagesCache, DescendantItemFinder descendantFinder, EngineSection config) { this.persister = persister; this.editUrlManager = editUrlManager; this.definitions = definitions; this.host = host; this.security = security; this.context = context; this.languagesCache = languagesCache; this.descendantFinder = descendantFinder; Enabled = config.Globalization.Enabled; }
private void ReadSingle(string fileName) { using (BinaryReader br = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read))) { IPersister persister = PersisterFactory.GetPersister(br.ReadString()); object result = persister.Retrieve(br); if (null != result as Sequenza) { _sequenze.Add((Sequenza)result); } else if (null != result as ProgrammazioneGiornaliera) { _progrGiornaliere.Add((ProgrammazioneGiornaliera)result); } else { InsideAggiungiElemento(new PersisterMapper <Elemento>((Elemento)result)); } } }
public void GetTestResult_evicts_the_entity_retrieves_it_and_compares_it([Frozen] IDataConnection session, IGetsTransaction tranFactory, [Frozen] ITransaction tran, IPersister persister, IQuery query, [Frozen, NoRecursion] SampleEntity entity, [NoAutoProperties] PersistenceTestSpec <SampleEntity> spec, object id) { var evicted = false; var sut = new PersistenceTester <SampleEntity>(spec); Mock.Get(spec.SessionProvider).Setup(x => x.GetConnection()).Returns(session); Mock.Get(session) .Setup(x => x.GetTransactionFactory()) .Returns(tranFactory); Mock.Get(tranFactory) .Setup(x => x.GetTransaction()) .Returns(tran); Mock.Get(session).Setup(x => x.GetPersister()).Returns(persister); Mock.Get(session).Setup(x => x.GetQuery()).Returns(query); Mock.Get(persister) .Setup(x => x.Add(entity, null)) .Returns(id); Mock.Get(session) .Setup(x => x.EvictFromCache(entity)) .Callback(() => evicted = true); var retrievedEntity = new SampleEntity(); Mock.Get(query) .Setup(x => x.Get <SampleEntity>(id)) .Returns(() => evicted? retrievedEntity : entity); sut.GetTestResult(); Mock.Get(spec.EqualityRule).Verify(x => x.GetEqualityResult(entity, retrievedEntity), Times.Once); }
public ReplicationManager( IPersister persister, IItemFinder finder, IReplicationStorage repstore, IFileSystemFactory fileSystemFactory, DatabaseSection dataBaseSection, ISecurityManager security, IIndexer indexer, // optional IFlushable flushable // optional ) { _repstore = repstore; _security = security; _persister = persister; _finder = finder; _indexer = indexer; _flushable = flushable; // detect sync direction from Database Type and double check via config string value = ConfigurationManager.AppSettings["XmlReplication"] ?? "false"; IsSlave = value.Equals("Slave", StringComparison.InvariantCultureIgnoreCase) & (dataBaseSection.Flavour == DatabaseFlavour.Xml); IsMaster = value.Equals("Master", StringComparison.InvariantCultureIgnoreCase) & !IsSlave; if (IsMaster || IsSlave) { // only initialize if replication is active var storageConfig = (FileSystemNamespace)Enum.Parse(typeof(FileSystemNamespace), ConfigurationManager.AppSettings["AzureReplicationStorageContainerName"] ?? "ReplicationStorageDebug"); _fileSystem = fileSystemFactory.Create(storageConfig); // constructing these dependencies to ensure same filesystem and simplify construction _replicationWriteLockManager = new ReplicationWriteLockManager(_fileSystem); _replicationReadLockManager = new ReplicationReadLockManager(_fileSystem); } _replicationLogPath = "/_Xml_Sync_Log"; }
public ReplicationStorageFileSystemN2(ContentActivator activator, IFileSystemFactory fsfactory, IDefinitionManager definitions, IPersister persister) { _activator = activator; _definitions = definitions; _persister = persister; string value = (ConfigurationManager.AppSettings["XmlReplication"] ?? "false").ToLowerInvariant(); if (value.Equals("slave") || value.Equals("master")) { // only initialize if replication is active var storageConfig = (FileSystemNamespace)Enum.Parse(typeof(FileSystemNamespace), ConfigurationManager.AppSettings["AzureReplicationStorageContainerName"] ?? "ReplicationStorageDebug"); _fs = fsfactory.Create(storageConfig); if (_fs.GetType().Name.Contains("Azure")) { _path = "/_Xml_Sync_"; // TODO maybe should add TablePrefix? } } }
public void ThrownItem_IsMoved_ToTrashcan() { var activator = new ContentActivator(null, null, null); IPersister persister = mocks.StrictMock <IPersister>(); Expect.Call(persister.Get(1)).Return(root).Repeat.Any(); Expect.Call(delegate { persister.Save(item); }).Repeat.Any(); mocks.ReplayAll(); TrashHandler th = new TrashHandler(persister, null, null, new ContainerRepository <TrashContainerItem>(persister, null, host, activator), new StateChanger()) { UseNavigationMode = true }; th.Throw(item); Assert.AreEqual(trash, item.Parent); mocks.VerifyAll(); }
public void TestFixtureSetUp() { var definitionProviders = TestSupport.SetupDefinitionProviders(new DefinitionMap(), typeof(NormalPage), typeof(NormalItem)); var proxies = new N2.Persistence.Proxying.InterceptingProxyFactory(); proxies.Initialize(definitionProviders.SelectMany(dp => dp.GetDefinitions())); itemRepository = new MongoContentItemRepository( databaseProvider = new MongoDatabaseProvider(TestSupport.CreateDependencyInjector(), proxies, new N2.Configuration.ConfigurationManagerWrapper("n2mongo"), definitionProviders, new AdaptiveContext())); persister = new ContentPersister(TestSupport.SetupContentSource(itemRepository), itemRepository); IRepository <ContentVersion> versionRepository = new MongoDbRepository <ContentVersion>(databaseProvider); repository = TestSupport.CreateVersionRepository( ref persister, ref activator, ref versionRepository, typeof(NormalPage), typeof(NormalItem)); drafts = new DraftRepository(repository, new FakeCacheWrapper()); }
public void ThrashHandler_Throw_CanBeCancelled() { var definitions = mocks.Stub <IDefinitionManager>(); IPersister persister = mocks.StrictMock <IPersister>(); Expect.Call(persister.Get(1)).Return(root).Repeat.Any(); Expect.Call(delegate { persister.Save(item); }).Repeat.Never(); mocks.ReplayAll(); var host = new Host(webContext, 1, 1); TrashHandler th = new TrashHandler(persister, null, null, new ContainerRepository <TrashContainerItem>(persister, null, host, null), new StateChanger()) { UseNavigationMode = true }; th.ItemThrowing += delegate(object sender, CancellableItemEventArgs args) { args.Cancel = true; }; th.Throw(item); mocks.VerifyAll(); }
public void Exit() { IPersister persister = _container.Get <IPersister>(); string characterName = ViewModelBase.FFACE?.Player?.Name; string characterJob = ViewModelBase.FFACE?.Player?.Job.ToString(); string fileName = $"{characterName}.eup"; if (!String.IsNullOrWhiteSpace(fileName)) { persister.Serialize(fileName, Config.Instance); } fileName = $"{characterName}-{characterJob}.eup"; if (!String.IsNullOrWhiteSpace(fileName)) { persister.Serialize(fileName, Config.Instance); } LogViewModel.Write("Application exiting"); }
private void CreatePersister() { mocks.Record(); persister = mocks.DynamicMock <IPersister>(); repository = new FakeContentItemRepository(); persister.Expect(p => p.Repository).Return(repository); persister.ItemMoving += null; moving = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemCopying += null; copying = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemDeleting += null; deleting = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); persister.ItemSaving += null; saving = LastCall.IgnoreArguments().Repeat.Any().GetEventRaiser(); mocks.Replay(persister); }
public MultipleSitesParser(IPersister persister, IWebContext webContext, IHost host, ISitesProvider sitesProvider, HostSection config) : base(persister, webContext, host, config) { if (config == null) { throw new ArgumentNullException("config"); } if (config.DynamicSites) { host.AddSites(sitesProvider.GetSites()); persister.ItemSaved += delegate(object sender, ItemEventArgs e) { if (e.AffectedItem is ISitesSource) { IList <Site> sites = Host.ExtractSites(config); sites = Host.Union(sites, sitesProvider.GetSites()); host.ReplaceSites(host.DefaultSite, sites); } }; } }
/// <summary> /// Used by PublishScheduledAction and the Publish Button in the Curtain /// </summary> /// <param name="versionManager"></param> /// <param name="persister"></param> /// <param name="previewedItem"></param> /// <returns></returns> public static ContentItem Publish(this IVersionManager versionManager, IPersister persister, ContentItem previewedItem) { //if (previewedItem.State == ContentState.Published) // return previewedItem; // nothing to do if (!previewedItem.IsPage) { throw new ArgumentException("Publish requires item to be a page"); } if (previewedItem.VersionOf.HasValue) { // is versioned previewedItem = versionManager.MakeMasterVersion(previewedItem); persister.Save(previewedItem); } var stateChanger = Context.Current.Resolve <StateChanger>(); stateChanger.ChangeTo(previewedItem, ContentState.Published); persister.Save(previewedItem); return(previewedItem); }
protected SystemEventsParser(IPersister persister, IDirectory directory, int eventsParserMs, int eventsMaxWaitTransactionMs, ILogger logger) { // the directories handler Directory = directory ?? throw new ArgumentNullException(nameof(directory)); if (eventsParserMs <= 0) { throw new ArgumentException($"The event timeout, ({eventsParserMs}), cannot be zero or negative."); } _eventsTimeOutInMs = eventsParserMs; if (eventsParserMs < 0) { throw new ArgumentException($"The event max wait for transaction, ({_eventsMaxWaitTransactionMs}), cannot be negative."); } _eventsMaxWaitTransactionMs = eventsMaxWaitTransactionMs; // save the logger Logger = logger ?? throw new ArgumentNullException(nameof(logger)); // save the database Persister = persister ?? throw new ArgumentNullException(nameof(persister)); }
public void Save(ImmagineFissa elem, BinaryWriter bw) { // Immagine bw.Write(elem.GetType().ToString()); bw.Write(elem.Nome); // Modello di riferimento Modello modello = Documento.getInstance().ModelloRiferimento; bw.Write(modello.Size.Width); bw.Write(modello.Size.Height); // Frame byte[] frameAsArray = elem.Frame.ToByteArray(); bw.Write(elem.Frame.Size.Width); bw.Write(frameAsArray.Length); bw.Write(frameAsArray); // Informazione IPersister infoPersister = PersisterFactory.GetPersister(elem.InformazioneAssociata.GetType()); infoPersister.Save(elem.InformazioneAssociata, bw); }
/// <summary> /// Instruments message <paramref name="message"/>. /// </summary> /// <param name="message"></param> private void InternalInstrument(IMessage message) { lock (syncRoot) { if (!IsInstrumentationEnabled) { return; } // // Resolving persister names. string[] persisterNames; persisterNames = ResolvePersisterNames(message); if (persisterNames == null || persisterNames.GetLength(0) == 0) { throw new InstrumentationException(string.Format( Strings.InstrumentationManager_InternalInstrument_UnableToResolvePersistersForMessage, message.GetType().FullName, message.Source, message.Severity)); } // // Persisting message. foreach (string persisterName in persisterNames) { if (!Persisters.ContainsKey(persisterName)) { throw new InstrumentationException(string.Format( Strings.InstrumentationManager_InternalInstrument_NoPersistersWithGivenNameRegistered, persisterName)); } IPersister persister = Persisters[persisterName]; persister.Persist(message); } // foreach } // lock }
public static ContentVersionRepository CreateVersionRepository(ref IPersister persister, ref ContentActivator activator, ref IRepository <ContentVersion> versionRepository, params Type[] definedTypes) { if (persister == null) { persister = SetupFakePersister(); } var definitions = SetupDefinitions(definedTypes); var parser = new UrlParser(persister, new ThreadContext(), new Host(new ThreadContext(), new HostSection()), new ConnectionMonitor(), new HostSection()); var proxyFactory = new InterceptingProxyFactory(); if (activator == null) { activator = new ContentActivator(new StateChanger(), new ItemNotifier(), proxyFactory); activator.Initialize(definitions.GetDefinitions()); } if (versionRepository == null) { versionRepository = new FakeRepository <ContentVersion>(); } var importer = new Importer(persister, new ItemXmlReader(definitions, activator, persister.Repository), new Fakes.FakeMemoryFileSystem()); var exporter = new Exporter( new ItemXmlWriter( definitions, parser, new FakeMemoryFileSystem())); return(new ContentVersionRepository( versionRepository, exporter, importer, parser, proxyFactory)); }