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));
}
