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 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 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 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 DefinitionManager(IDefinitionProvider[] definitionProviders, ITemplateProvider[] providers, ContentActivator activator, StateChanger changer)
{
this.definitionProviders = definitionProviders;
this.providers = providers;
this.activator = activator;
this.stateChanger = changer;
}
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 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 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 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 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 };
}
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;
}
