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 override void SetUp() { base.SetUp(); activator = new ContentActivator(stateChanger = new N2.Edit.Workflow.StateChanger(), notifier = new ItemNotifier(), new InterceptingProxyFactory()); activator.Initialize(new[] { new ItemDefinition(typeof(Definitions.PersistableItem)), new ItemDefinition(typeof(Definitions.PersistableItem1b)) }); }
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 void SetUp() { var changer = new N2.Edit.Workflow.StateChanger(); var activator = new ContentActivator(changer, MockRepository.GenerateStrictMock<IItemNotifier>(), new EmptyProxyFactory()); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), new Fakes.FakeTypeFinder(typeof(RestrictsChildWithCardinality), typeof(ChildWithCardinality)), new TransformerBase<IUniquelyNamed>[0], new EngineSection { Definitions = new DefinitionCollection { DefineUnattributedTypes = true } }); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ITemplateProvider[0], activator, changer); }
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 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 LanguageInterceptor(IPersister persister, ContentActivator activator, IWebContext context, ILanguageGateway gateway) { this.persister = persister; this.activator = activator; this.context = context; this.gateway = gateway; }
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator, IRepository<ContentItem> repository) { this.definitions = definitions; this.activator = activator; this.readers = DefaultReaders(); this.repository = repository; }
public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext) { this.webContext = webContext; this.persister = persister; this.security = security; this.activator = activator; this.urlParser = urlParser; }
public override void SetUp() { base.SetUp(); persister = null; activator = null; repository = TestSupport.CreateVersionRepository(ref persister, ref activator, typeof(Items.NormalPage), typeof(Items.NormalItem)); drafts = new DraftRepository(repository, new FakeCacheWrapper()); }
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 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 SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext, Configuration.HostSection config) { this.webContext = webContext; this.persister = persister; this.security = security; this.activator = activator; this.urlParser = urlParser; this.permissionDeniedHttpCode = config.Web.PermissionDeniedHttpCode; }
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator) { if (definitions == null) throw new ArgumentNullException("definitions"); this.definitions = definitions; this.activator = activator; this.readers = DefaultReaders(); }
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ITemplateProvider[] templates, ContentActivator activator, AjaxRequestDispatcher dispatcher, Navigator navigator) : base(dispatcher) { this.persister = persister; this.managementPaths = editUrlManager; this.definitions = definitions; this.templates = templates; this.activator = activator; this.navigator = navigator; }
public InstallationManager(IHost host, IDefinitionManager definitions, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext) { this.host = host; this.definitions = definitions; this.activator = activator; this.importer = importer; this.persister = persister; this.sessionProvider = sessionProvider; this.configurationBuilder = configurationBuilder; this.webContext = webContext; }
public ViewTemplateProvider(ViewTemplateRegistrator registrator, ViewTemplateAnalyzer analyzer, ContentActivator activator, DefinitionBuilder builder, IProvider<HttpContextBase> httpContextProvider, IProvider<VirtualPathProvider> vppProvider) { this.registrator = registrator; this.analyzer = analyzer; this.activator = activator; this.builder = builder; this.httpContextProvider = httpContextProvider; this.vppProvider = vppProvider; registrator.RegistrationAdded += (s, a) => rebuild = true; }
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ITemplateAggregator templates, ContentActivator activator, Navigator navigator, IVersionManager versions, ContentVersionRepository versionRepository) { this.persister = persister; this.managementPaths = editUrlManager; this.definitions = definitions; this.templates = templates; this.activator = activator; this.navigator = navigator; this.versions = versions; this.versionRepository = versionRepository; }
public InstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext) { this.host = host; this.map = map; this.activator = activator; this.importer = importer; this.persister = persister; this.sessionProvider = sessionProvider; this.configurationBuilder = configurationBuilder; this.webContext = webContext; this.connectionContext = connectionContext; }
public InstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext, DatabaseSection config) { this.host = host; this.map = map; this.activator = activator; this.importer = importer; this.persister = persister; this.sessionProvider = sessionProvider; this.configurationBuilder = configurationBuilder; this.webContext = webContext; this.connectionContext = connectionContext; this.isDatabaseFileSystemEnbled = config.Files.StorageLocation == FileStoreLocation.Database; }
public override void SetUp() { CreateDatabaseSchema(); base.SetUp(); persister = engine.Resolve<IPersister>(); activator = engine.Resolve<ContentActivator>(); editManager = engine.Resolve<IEditManager>(); versionManager = engine.Resolve<IVersionManager>(); editors = new Dictionary<string, Control>(); editors["Title"] = new TextBox { Text = "New title" }; }
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); SetUserType(configuredUserType); }
public override void SetUp() { base.SetUp(); user = CreatePrincipal("SomeSchmuck"); map = new DefinitionMap(); DefinitionBuilder builder = new DefinitionBuilder(map, typeFinder, new TransformerBase<IUniquelyNamed>[0], new EngineSection()); IItemNotifier notifier = mocks.DynamicMock<IItemNotifier>(); mocks.Replay(notifier); var changer = new N2.Edit.Workflow.StateChanger(); activator = new ContentActivator(changer, notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ITemplateProvider[0], activator, changer); }
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 ContentPartTemplateProvider( ContentActivator activator, DefinitionBuilder builder, IProvider<HttpContextBase> httpContextProvider, //IProvider<VirtualPathProvider> vppProvider, //IRepository<ContentItem> repository, ConnectionMonitor connection, IHost host) { _activator = activator; _builder = builder; _httpContextProvider = httpContextProvider; _connection = connection; //_vpp = vppProvider.Get(); //_repository = repository; _host = host; }
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 override void SetUp() { base.SetUp(); CreatePersister(); parser = mocks.StrictMock<IUrlParser>(); ITypeFinder typeFinder = CreateTypeFinder(); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase<IUniquelyNamed>[0], TestSupport.SetupEngineSection()); IItemNotifier notifier = mocks.DynamicMock<IItemNotifier>(); mocks.Replay(notifier); var changer = new N2.Edit.Workflow.StateChanger(); activator = new ContentActivator(changer, notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ITemplateProvider[0], activator, changer, new DefinitionMap()); finder = new FakeItemFinder(() => Enumerable.Empty<ContentItem>()); integrityManger = new IntegrityManager(definitions, finder, parser); IntegrityEnforcer enforcer = new IntegrityEnforcer(persister, integrityManger, activator); enforcer.Start(); }
protected override void OnInit(EventArgs e) { base.OnInit(e); repository = Engine.Resolve<IContentItemRepository>(); activator = Engine.Resolve<ContentActivator>(); if (!Page.IsPostBack) { LoadSelectableTypes(); LoadSelectableItems(); LoadSelectableEditors(); } else { ie.EditableNameFilter = Request[EditableNameFilter.UniqueID].Split(','); } ie.ParentPath = Selection.SelectedItem.Path; }
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( finder, new EngineSection())) }, activator); 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 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 override void SetUp() { base.SetUp(); CreatePersister(); parser = mocks.StrictMock <IUrlParser>(); ITypeFinder typeFinder = CreateTypeFinder(); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase <IUniquelyNamed> [0], TestSupport.SetupEngineSection()); IItemNotifier notifier = mocks.DynamicMock <IItemNotifier>(); mocks.Replay(notifier); var changer = new N2.Edit.Workflow.StateChanger(); activator = new ContentActivator(changer, notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, activator, changer, new DefinitionMap()); integrityManger = new IntegrityManager(definitions, persister.Repository, parser); IntegrityEnforcer enforcer = new IntegrityEnforcer(persister, integrityManger, activator); enforcer.Start(); }
public ItemBridge(ContentActivator activator, IItemFinder finder, IPersister persister, ISecurityManager security, IHost host, EditSection config) { this.security = security; this.activator = activator; this.finder = finder; 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 FakeEngine(params Type[] types) { AddComponentInstance <ITypeFinder>(new FakeTypeFinder(types)); var definitionManager = TestSupport.SetupDefinitions(types.Where(t => typeof(ContentItem).IsAssignableFrom(t)).ToArray()); AddComponentInstance <IDefinitionManager>(definitionManager); var adapterProvider = new ContentAdapterProvider(this, Resolve <ITypeFinder>()); AddComponentInstance <IContentAdapterProvider>(adapterProvider); var itemRepository = new FakeContentItemRepository(); AddComponentInstance <IRepository <ContentItem> >(itemRepository); AddComponentInstance <IContentItemRepository>(itemRepository); var webContext = new ThreadContext(); AddComponentInstance <IWebContext>(webContext); var host = new Host(webContext, 1, 1); AddComponentInstance <IHost>(host); var security = new FakeSecurityManager(); AddComponentInstance <ISecurityManager>(security); var source = new ContentSource(security, new [] { new DatabaseSource(host, itemRepository) }); AddComponentInstance(source); AddComponentInstance <IPersister>(new ContentPersister(source, itemRepository)); AddComponentInstance <IWebContext>(webContext); var proxyFactory = new InterceptingProxyFactory(); AddComponentInstance <IProxyFactory>(proxyFactory); var activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), new ItemNotifier(), proxyFactory); AddComponentInstance <ContentActivator>(activator); activator.Initialize(definitionManager.GetDefinitions()); var editSection = new EditSection(); AddComponentInstance <EditSection>(editSection); }
public override void SetUp() { base.SetUp(); CreatePersister(); parser = mocks.StrictMock <IUrlParser>(); ITypeFinder typeFinder = CreateTypeFinder(); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection()); IItemNotifier notifier = mocks.DynamicMock <IItemNotifier>(); mocks.Replay(notifier); var changer = new N2.Edit.Workflow.StateChanger(); activator = new ContentActivator(changer, notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ITemplateProvider[0], activator, changer); finder = new FakeItemFinder(() => Enumerable.Empty <ContentItem>()); integrityManger = new IntegrityManager(definitions, finder, parser); IntegrityEnforcer enforcer = new IntegrityEnforcer(persister, integrityManger, activator); enforcer.Start(); }
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)); }
public void ThrashHandler_Throw_WillInvokeEvents() { 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(); var host = new Host(webContext, 1, 1); TrashHandler th = new TrashHandler(persister, null, null, new ContainerRepository<TrashContainerItem>(persister, null, host, activator)) { UseNavigationMode = true }; bool throwingWasInvoked = false; bool throwedWasInvoked = false; th.ItemThrowing += delegate { throwingWasInvoked = true; }; th.ItemThrowed += delegate { throwedWasInvoked = true; }; th.Throw(item); Assert.That(throwingWasInvoked); Assert.That(throwedWasInvoked); mocks.VerifyAll(); }
/// <summary>Stores dependencies</summary> /// <param name="finder"></param> /// <param name="persister"></param> /// <param name="activator"></param> public ContainerRepository(IPersister persister, IItemFinder finder, IHost host, ContentActivator activator) { this.finder = finder; this.persister = persister; this.host = host; this.activator = activator; }
public LanguageInterceptor(IPersister persister, ContentActivator activator, IWebContext context, ILanguageGateway gateway, EngineSection config) : this(persister, activator, context, gateway) { enabled = config.Globalization.Enabled; autoDeleteTranslations = config.Globalization.AutoDeleteTranslations; }
public TestPageController(IDefinitionManager definitions, ContentActivator activator) { this.definitions = definitions; this.activator = activator; }
public TemplateProvider(ContentActivator activator, DefinitionMap map) { this.activator = activator; this.map = map; }
public static void Setup(out IDefinitionProvider[] definitionProviders, out IDefinitionManager definitions, out ContentActivator activator, out IItemNotifier notifier, out InterceptingProxyFactory proxyFactory, params Type[] itemTypes) { ITypeFinder typeFinder = new Fakes.FakeTypeFinder(itemTypes[0].Assembly, itemTypes); DefinitionBuilder definitionBuilder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase <IUniquelyNamed> [0], SetupEngineSection()); notifier = new ItemNotifier(); proxyFactory = new InterceptingProxyFactory(); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, proxyFactory); definitionProviders = new IDefinitionProvider[] { new DefinitionProvider(definitionBuilder) }; definitions = new DefinitionManager(definitionProviders, new ITemplateProvider[0], activator, new StateChanger()); ((DefinitionManager)definitions).Start(); }
public ViewTemplateProvider(ViewTemplateRegistrator registrator, ViewTemplateAnalyzer analyzer, ContentActivator activator, DefinitionBuilder builder, IProvider <HttpContextBase> httpContextProvider, IProvider <VirtualPathProvider> vppProvider) { SortOrder = -1000; this.registrator = registrator; this.analyzer = analyzer; this.activator = activator; this.builder = builder; this.httpContextProvider = httpContextProvider; this.vppProvider = vppProvider; registrator.RegistrationAdded += (s, a) => rebuild = true; }
public static ContentVersionRepository CreateVersionRepository(ref IPersister persister, ref ContentActivator activator, ref IRepository <ContentVersion> versionRepository, params Type[] definedTypes) { InterceptingProxyFactory proxyFactory; var definitions = SetupDefinitions(out activator, out proxyFactory, definedTypes); if (persister == null) { persister = SetupFakePersister(proxyFactory); } var parser = new UrlParser(persister, new ThreadContext(), new Host(new ThreadContext(), new HostSection()), new ConnectionMonitor(), new HostSection()); if (versionRepository == null) { versionRepository = new FakeRepository <ContentVersion>(proxyFactory); } var importer = new Importer(persister, new ItemXmlReader(definitions, activator), new Fakes.FakeMemoryFileSystem(), null, null); var exporter = new Exporter( new ItemXmlWriter( definitions, new FakeMemoryFileSystem())); return(new ContentVersionRepository( versionRepository, exporter, importer, parser, proxyFactory)); }
public static void Setup(out IDefinitionProvider[] definitionProviders, out IDefinitionManager definitions, out ContentActivator activator, out IItemNotifier notifier, out InterceptingProxyFactory proxyFactory, params Type[] itemTypes) { var map = new DefinitionMap(); definitionProviders = SetupDefinitionProviders(map, itemTypes); notifier = new ItemNotifier(); proxyFactory = new InterceptingProxyFactory(); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, proxyFactory); definitions = new DefinitionManager(definitionProviders, activator, new StateChanger(), new DefinitionMap()); ((DefinitionManager)definitions).Start(); activator.Initialize(definitions.GetDefinitions()); }
public static N2.Edit.Versioning.DraftRepository CreateDraftRepository(ref IPersister persister, params Type[] definedTypes) { ContentActivator activator = null; return(new DraftRepository(CreateVersionRepository(ref persister, ref activator, definedTypes), new CacheWrapper(persister, new ThreadContext(), new DatabaseSection()))); }
public TestContentGeneratorController(IDefinitionManager definitions, ContentActivator activator, ISecurityManager security) { this.definitions = definitions; this.activator = activator; this.security = security; }
public DefinitionManager(IDefinitionProvider[] definitionProviders, ITemplateProvider[] providers, ContentActivator activator, StateChanger changer) { this.definitionProviders = definitionProviders; this.providers = providers; this.activator = activator; this.stateChanger = changer; }
public static void Setup(out IDefinitionManager definitions, out ITemplateAggregator templates, out ContentActivator activator, params Type[] itemTypes) { var map = new DefinitionMap(); var definitionProviders = SetupDefinitionProviders(map, itemTypes); var notifier = new ItemNotifier(); var proxyFactory = new InterceptingProxyFactory(); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, proxyFactory); definitions = new DefinitionManager(definitionProviders, activator, new StateChanger(), new DefinitionMap()); templates = new TemplateAggregator(definitions, new[] { new TemplateProvider(activator, map) }); ((IAutoStart)definitions).Start(); ((IAutoStart)templates).Start(); }
public static N2.Edit.Versioning.ContentVersionRepository CreateVersionRepository(ref IPersister persister, ref ContentActivator activator, params Type[] definedTypes) { IRepository <ContentVersion> versionRepository = null; return(CreateVersionRepository(ref persister, ref activator, ref versionRepository, definedTypes)); }
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator) : this(definitions, activator, DefaultReaders()) { }
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ContentActivator activator, AjaxRequestDispatcher dispatcher, Navigator navigator) : base(dispatcher) { this.persister = persister; this.managementPaths = editUrlManager; this.definitions = definitions; this.activator = activator; this.navigator = navigator; }
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator, IDictionary <string, IXmlReader> readers) { this.definitions = definitions; this.activator = activator; this.readers = readers; }
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 }; }