public override void Serialize(BinaryWriter writer, IDefinitionManager definitionManager = null)
{
writer.Write(Issuer);
writer.Write(Property);
writer.Write(Value.Length);
writer.Write(Value);
}
public ControllerMapper(ITypeFinder typeFinder, IDefinitionManager definitionManager)
{
IList <ControlsAttribute> controllerDefinitions = FindControllers(typeFinder);
foreach (ItemDefinition id in definitionManager.GetDefinitions())
{
IAdapterDescriptor controllerDefinition = GetControllerFor(id, controllerDefinitions);
if (controllerDefinition != null)
{
ControllerMap[id.ItemType] = controllerDefinition.ControllerName;
// interacting with static context is tricky, here I made the assumtion that the last
// finder is the most relevat and takes the place of previous ones, this makes a few
// tests pass and doesn't seem to be called in production
foreach (var finder in PathDictionary.GetFinders(id.ItemType).Where(f => f is ActionResolver))
{
PathDictionary.RemoveFinder(id.ItemType, finder);
}
// Use MVC's ReflectedControllerDescriptor to find all actions on the Controller
var methods = new ReflectedControllerDescriptor(controllerDefinition.AdapterType)
.GetCanonicalActions()
.Select(m => m.ActionName).ToArray();
var actionResolver = new ActionResolver(this, methods);
_controllerActionMap[controllerDefinition.ControllerName] = methods;
PathDictionary.PrependFinder(id.ItemType, actionResolver);
}
}
}
public DirectUrlInjector(IHost host, IUrlParser parser, IContentItemRepository repository, IDefinitionManager definitions)
{
this.host = host;
this.parser = parser;
this.repository = repository;
this.definitions = definitions;
}
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator, IRepository<ContentItem> repository)
{
this.definitions = definitions;
this.activator = activator;
this.readers = DefaultReaders();
this.repository = repository;
}
public override void Deserialize(BinaryReader reader, IDefinitionManager definitionManager)
{
base.Deserialize(reader, definitionManager);
var count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
string name = reader.ReadString();
var definition = definitionManager.GetDefinitions().FirstOrDefault(d => d.GetType().FullName == name);
var amount = reader.ReadDecimal();
if (definition == null || !(definition is IInventoryableDefinition))
{
continue;
}
var slot = new InventorySlot()
{
Amount = amount,
Definition = (IInventoryableDefinition)definition,
};
Inventory.Add(slot);
}
}
public PopularityReordererScheduledAction(IDefinitionManager definitions, IPersister persister, IHost host, PopularityChildrenSorter sorter)
{
this.definitions = definitions;
this.persister = persister;
this.host = host;
this.sorter = sorter;
}
public ControllerMapper(ITypeFinder typeFinder, IDefinitionManager definitionManager)
{
IList<ControlsAttribute> controllerDefinitions = FindControllers(typeFinder);
foreach (ItemDefinition id in definitionManager.GetDefinitions())
{
IAdapterDescriptor controllerDefinition = GetControllerFor(id, controllerDefinitions);
if(controllerDefinition != null)
{
ControllerMap[id.ItemType] = controllerDefinition.ControllerName;
// interacting with static context is tricky, here I made the assumtion that the last
// finder is the most relevat and takes the place of previous ones, this makes a few
// tests pass and doesn't seem to be called in production
foreach (var finder in PathDictionary.GetFinders(id.ItemType).Where(f => f is ActionResolver))
PathDictionary.RemoveFinder(id.ItemType, finder);
// Use MVC's ReflectedControllerDescriptor to find all actions on the Controller
var methods = new ReflectedControllerDescriptor(controllerDefinition.AdapterType)
.GetCanonicalActions()
.Select(m => m.ActionName).ToArray();
var actionResolver = new ActionResolver(this, methods);
_controllerActionMap[controllerDefinition.ControllerName] = methods;
PathDictionary.PrependFinder(id.ItemType, actionResolver);
}
}
}
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator, IRepository <ContentItem> repository)
{
this.definitions = definitions;
this.activator = activator;
this.readers = DefaultReaders();
this.repository = repository;
}
/// <summary>Creates a new instance of the <see cref="ConfigurationBuilder"/>.</summary>
public ConfigurationBuilder(IDefinitionManager definitions, ClassMappingGenerator generator, IWebContext webContext, ConfigurationBuilderParticipator[] participators, DatabaseSection config, ConnectionStringsSection connectionStrings)
{
this.definitions = definitions;
this.generator = generator;
this.webContext = webContext;
this.participators = participators;
if (config == null)
{
config = new DatabaseSection();
}
if (!string.IsNullOrEmpty(config.HibernateMapping))
{
DefaultMapping = config.HibernateMapping;
}
SetupProperties(config, connectionStrings);
SetupMappings(config);
TryLocatingHbmResources = config.TryLocatingHbmResources;
tablePrefix = config.TablePrefix;
batchSize = config.BatchSize;
childrenLaziness = config.ChildrenLaziness;
}
protected virtual void OnItemCreating(ItemEventArgs e)
{
EventHandler <ItemEventArgs> handler = base.Events[EventItemCreating] as EventHandler <ItemEventArgs>;
if (handler != null)
{
handler.Invoke(this, e);
}
if (e.AffectedItem != null)
{
IDefinitionManager definitions = Engine.Definitions;
ISecurityManager security = Engine.SecurityManager;
ContentActivator activator = Engine.Resolve <ContentActivator>();
ItemDefinition parentDefinition = definitions.GetDefinition(parentItem);
if (parentDefinition.IsChildAllowed(definitions, parentItem, parentDefinition))
{
e.AffectedItem = Engine.Resolve <ContentActivator>().CreateInstance(parentItem.GetContentType(), parentItem);
return;
}
foreach (ItemDefinition definition in definitions.GetAllowedChildren(parentItem, null).WhereAuthorized(security, HttpContext.Current.User, parentItem))
{
e.AffectedItem = activator.CreateInstance(definition.ItemType, parentItem);
return;
}
throw new N2.Definitions.NoItemAllowedException(parentItem);
}
}
public DiagnosticController(IContentItemRepository repository, IHost host, IDefinitionManager definitions,
ILinkGenerator linkGenerator, IUrlParser parser, DatabaseSection config, IFlushable flushable, IReplicationStorage repstore,
IFileSystemFactory fileSystemFactory)
{
_repository = repository;
_host = host;
_definitions = definitions;
_linkGenerator = linkGenerator;
_parser = parser;
_flushable = flushable;
_tablePrefix = config.TablePrefix;
_repstore = repstore;
if (_forceWriteLockManager != null)
{
return;
}
// Create Force Write Lock Manager
var storageConfig = (FileSystemNamespace)Enum.Parse(typeof(FileSystemNamespace),
ConfigurationManager.AppSettings["AzureReplicationStorageContainerName"] ??
"ReplicationStorageDebug");
var fileSystem = fileSystemFactory.Create(storageConfig);
_forceWriteLockManager = new ReplicationForceWriteLockManager(fileSystem);
_writeLockManager = new ReplicationWriteLockManager(fileSystem);
}
public DirectUrlInjector(IHost host, IUrlParser parser, IContentItemRepository repository, IDefinitionManager definitions)
{
this.host = host;
this.parser = parser;
this.repository = repository;
this.definitions = definitions;
}
public void NonThrowableItem_IsNotMovedToTrashcan_LegacyAttribute()
{
IDefinitionManager definitions = mocks.Stub <IDefinitionManager>();
IPersister persister = mocks.Stub <IPersister>();
Expect.Call(persister.Get(1)).Return(root).Repeat.Any();
persister.ItemDeleting += null;
IEventRaiser invokeDelete = LastCall.IgnoreArguments().GetEventRaiser();
mocks.ReplayAll();
var host = new Host(webContext, 1, 1);
TrashHandler th = new TrashHandler(persister, null, null, new ContainerRepository <TrashContainerItem>(persister, null, host, null))
{
UseNavigationMode = true
};
DeleteInterceptor interceptor = new DeleteInterceptor(persister, th);
interceptor.Start();
CancellableItemEventArgs deleteArgs = new CancellableItemEventArgs(nonThrowable2);
invokeDelete.Raise(persister, deleteArgs);
Assert.That(deleteArgs.Cancel, Is.False);
Assert.That(trash.Children.Count, Is.EqualTo(0));
}
public virtual ItemDefinition GetDefinition(IDefinitionManager definitions)
{
foreach (ItemDefinition definition in definitions.GetDefinitions())
if (definition.Discriminator == ItemDiscriminator)
return definition;
return null;
}
public override void Populate(IDefinitionManager definitionManager, IPlanet planet, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
{
// Tree Definitions initialisieren
if (treeDefinitions == null)
{
treeDefinitions = definitionManager.GetDefinitions<ITreeDefinition>().OrderBy(d => d.Order).ToArray();
foreach (var treeDefinition in treeDefinitions)
treeDefinition.Init(definitionManager);
}
int salt = (column00.Index.X & 0xffff) + ((column00.Index.Y & 0xffff) << 16);
Random random = new Random(planet.Seed + salt);
Index3 sample = new Index3(column00.Index.X * Chunk.CHUNKSIZE_X, column00.Index.Y * Chunk.CHUNKSIZE_Y, column00.Heights[0, 0]);
foreach (var treeDefinition in treeDefinitions)
{
int density = treeDefinition.GetDensity(planet, sample);
if (density <= 0) continue;
for (int i = 0; i < density; i++)
{
int x = random.Next(Chunk.CHUNKSIZE_X / 2, Chunk.CHUNKSIZE_X * 3 / 2);
int y = random.Next(Chunk.CHUNKSIZE_Y / 2, Chunk.CHUNKSIZE_Y * 3 / 2);
int z = LocalBuilder.GetSurfaceHeight(column00, column10, column01, column11, x, y);
LocalBuilder builder = new LocalBuilder(x, y, z + 1, column00, column10, column01, column11);
treeDefinition.PlantTree(definitionManager, planet, new Index3(x, y, z), builder, random.Next(int.MaxValue));
}
}
}
public TrackerService(IDefinitionManager <IPageEventDefinition> pageEventDefinitionManager, IDefinitionManager <IOutcomeDefinition> outcomeDefinitionManager, IDefinitionManager <IGoalDefinition> goalDefinitionManager)
{
this.PageEventDefinitionManager = pageEventDefinitionManager;
this.OutcomeDefinitionManager = outcomeDefinitionManager;
this.GoalDefinitionManager = goalDefinitionManager;
this.ContactManager = Factory.CreateObject("tracking/contactManager", true) as ContactManager;
}
public LanguageInterceptor(IPersister persister, IDefinitionManager definitions, IWebContext context, ILanguageGateway gateway)
{
this.persister = persister;
this.definitions = definitions;
this.context = context;
this.gateway = gateway;
}
public PopularityReordererScheduledAction(IDefinitionManager definitions, IPersister persister, IHost host, PopularityChildrenSorter sorter)
{
this.definitions = definitions;
this.persister = persister;
this.host = host;
this.sorter = sorter;
}
public DiagnosticController(IContentItemRepository repository, IHost host, IDefinitionManager definitions,
ILinkGenerator linkGenerator, IUrlParser parser, DatabaseSection config, IFlushable flushable, IReplicationStorage repstore,
IFileSystemFactory fileSystemFactory)
{
_repository = repository;
_host = host;
_definitions = definitions;
_linkGenerator = linkGenerator;
_parser = parser;
_flushable = flushable;
_tablePrefix = config.TablePrefix;
_repstore = repstore;
if (_forceWriteLockManager != null) return;
// Create Force Write Lock Manager
var storageConfig = (FileSystemNamespace) Enum.Parse(typeof (FileSystemNamespace),
ConfigurationManager.AppSettings["AzureReplicationStorageContainerName"] ??
"ReplicationStorageDebug");
var fileSystem = fileSystemFactory.Create(storageConfig);
_forceWriteLockManager = new ReplicationForceWriteLockManager(fileSystem);
_writeLockManager = new ReplicationWriteLockManager(fileSystem);
}
public IChunkColumn GenerateColumn(Stream stream, IDefinitionManager definitionManager, int planetId, Index2 index)
{
IChunkColumn column = new ChunkColumn();
column.Deserialize(stream, definitionManager, planetId, index);
return(column);
}
public ContainerResourceManager(IUpdateHub updateHub, IExtensionResolver extensionResolver, IDefinitionManager definitionManager, ISettings settings)
{
UpdateHub = updateHub;
this.extensionResolver = extensionResolver;
this.definitionManager = definitionManager;
this.settings = settings;
}
private void TriggerGoal(SubscribeModel subscription)
{
var goalId = Guid.Empty;
IGoalDefinition goalDefinition = null;
if (Guid.TryParse(subscription.GoalId, out goalId))
{
using (new Sitecore.SecurityModel.SecurityDisabler())
{
IDefinitionManager <IGoalDefinition> goalDefinitionManager = ServiceLocator.ServiceProvider.GetDefinitionManagerFactory().GetDefinitionManager <Sitecore.Marketing.Definitions.Goals.IGoalDefinition>();
goalDefinition = goalDefinitionManager.Get(goalId, System.Globalization.CultureInfo.InvariantCulture);
if (goalDefinition != null)
{
//Trigger Goal on last page in the tracker. (May be incorrect if visitor is in multiple tabs)
var page = Tracker.Current.Interaction.PreviousPage;
page.RegisterGoal(goalDefinition);
}
else
{
Sitecore.Diagnostics.Log.Warn("Goal: [" + subscription.GoalId + "] Not Defined", this);
}
}
}
else
{
Sitecore.Diagnostics.Log.Warn("Goal: [" + subscription.GoalId + "] Can Not be Parsed", this);
}
}
public void Deserialize(BinaryReader reader, IDefinitionManager definitionManager)
{
foreach (var item in this)
{
item.Deserialize(reader, definitionManager);
}
}
public void Serialize(BinaryWriter writer, IDefinitionManager definitionManager)
{
foreach (var item in this)
{
item.Serialize(writer, definitionManager);
}
}
public override void Deserialize(BinaryReader reader, IDefinitionManager definitionManager)
{
base.Deserialize(reader, definitionManager);
Mass = reader.ReadSingle();
Radius = reader.ReadSingle();
Height = reader.ReadSingle();
}
public EditableItemMigration(IDefinitionManager definitions, IRepository <ContentItem> itemRepository)
{
this.definitions = definitions;
this.itemRepository = itemRepository;
Title = "Upgrade parts and pages using [EditableItem]";
Description = "This migration will change the name of sub-items and remove the reference from the containing page.";
}
public FixZoneNamePartsMigration(IContentItemRepository repository, IDefinitionManager definitions)
{
this.repository = repository;
this.definitions = definitions;
Title = "Fixes zone name on parts with null zone name";
Description = "In the database parts are defined by having a non-null ZoneName property. This migrations updates parts which have a null zone name and changes it to empty string.";
}
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 static IEnumerable<TemplateDefinition> AllowedBelow(this IEnumerable<TemplateDefinition> allTemplates, ItemDefinition parentDefinition, ContentItem parentItem, IDefinitionManager definitions)
{
foreach (var template in allTemplates)
{
if (IsAllowed(template.Definition, parentItem, parentDefinition, definitions))
yield return template;
}
}
public NetworkPersistenceManager(Client client, IDefinitionManager definitionManager)
{
this.client = client;
subscription = client.Subscribe(this);
packages = new Dictionary <uint, Awaiter>();
this.definitionManager = definitionManager;
}
public DirectUrlInjector(IHost host, IUrlParser parser, IContentItemRepository repository, IDefinitionManager definitions, Configuration.EngineSection config)
{
this.host = host;
this.parser = parser;
this.repository = repository;
this.definitions = definitions;
this.enabled = config.DirectUrlInjector.Enabled;
}
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, AjaxRequestDispatcher dispatcher, Navigator navigator)
: base(dispatcher)
{
this.persister = persister;
this.editUrlManager = editUrlManager;
this.definitions = definitions;
this.navigator = navigator;
}
public FixZoneNamePartsMigration(IContentItemRepository repository, IDefinitionManager definitions)
{
this.repository = repository;
this.definitions = definitions;
Title = "Fixes zone name on parts with null zone name";
Description = "In the database parts are defined by having a non-null ZoneName property. This migrations updates parts which have a null zone name and changes it to empty string.";
}
public IChunkColumn GenerateColumn(Stream stream, IDefinitionManager definitionManager, int planetId, Index2 index)
{
IChunkColumn column = new ChunkColumn();
using (var reader = new BinaryReader(stream))
column.Deserialize(reader, definitionManager);
return(column);
}
public static IEnumerable<ItemDefinition> AllowedBelow(this IEnumerable<ItemDefinition> allDefinitions, ItemDefinition parentDefinition, ContentItem parentItem, IDefinitionManager definitions)
{
foreach (var definition in allDefinitions)
{
if (IsAllowed(definition, parentItem, parentDefinition, definitions))
yield return definition;
}
}
protected PartsModifyingAjaxService(Navigator navigator, IIntegrityManager integrity, IVersionManager versions, ContentVersionRepository versionRepository, IDefinitionManager definitionManager)
{
this.navigator = navigator;
this.integrity = integrity;
this.versions = versions;
this.versionRepository = versionRepository;
this.definitionManager = definitionManager;
}
public override void Serialize(BinaryWriter writer, IDefinitionManager definitionManager)
{
base.Serialize(writer, definitionManager);
writer.Write(Mass);
writer.Write(Radius);
writer.Write(Height);
}
public static void Setup(out IDefinitionManager definitions, out ContentActivator activator, out IItemNotifier notifier, out FakeSessionProvider sessionProvider, out ItemFinder finder, out SchemaExport schemaCreator, out InterceptingProxyFactory proxyFactory, params Type[] itemTypes)
{
var participators = new ConfigurationBuilderParticipator[0];
FakeWebContextWrapper context = new Fakes.FakeWebContextWrapper();
DatabaseSection config = (DatabaseSection)ConfigurationManager.GetSection("n2/database");
Setup(out definitions, out activator, out notifier, out sessionProvider, out finder, out schemaCreator, out proxyFactory, context, config, participators, itemTypes);
}
public void SetUp()
{
parentDefinition = new ItemDefinition(typeof(DefinitionControllingParent)) { TemplateKey = "List" };
childDefinition = new ItemDefinition(typeof(DefinitionOppressedChild)) { TemplateKey = "Wide" };
definitions = MockRepository.GenerateStub<IDefinitionManager>();
definitions.Expect(d => d.GetDefinitions()).Return(new[] { parentDefinition, childDefinition }).Repeat.Any();
}
protected PartsModifyingAjaxService(Navigator navigator, IIntegrityManager integrity, IVersionManager versions, ContentVersionRepository versionRepository, IDefinitionManager definitionManager)
{
this.navigator = navigator;
this.integrity = integrity;
this.versions = versions;
this.versionRepository = versionRepository;
this.definitionManager = definitionManager;
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
Definitions = Engine.Definitions;
Edits = Engine.ManagementPaths;
Wizard = Engine.Resolve<LocationWizard>();
}
public override void Deserialize(BinaryReader reader, IDefinitionManager definitionManager)
{
Name = reader.ReadString();
ModelName = reader.ReadString();
TextureName = reader.ReadString();
BaseZRotation = reader.ReadSingle();
base.Deserialize(reader, definitionManager);
}
public override void Serialize(BinaryWriter writer, IDefinitionManager definitionManager)
{
writer.Write(Name);
writer.Write(ModelName);
writer.Write(TextureName);
writer.Write(BaseZRotation);
base.Serialize(writer, definitionManager);
}
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 NetworkUpdateManager(Client client, IUpdateHub updateHub, IDefinitionManager manager)
{
this.client = client;
this.updateHub = updateHub;
hubSubscription = updateHub.Subscribe(this, DefaultChannels.Network);
clientSubscription = client.Subscribe(this);
definitionManager = manager;
}
public EditableItemMigration(IDefinitionManager definitions, IRepository<ContentItem> itemRepository)
{
this.definitions = definitions;
this.itemRepository = itemRepository;
Title = "Upgrade parts and pages using [EditableItem]";
Description = "This migration will change the name of sub-items and remove the reference from the containing page.";
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
Definitions = Engine.Definitions;
Edits = Engine.ManagementPaths;
Wizard = Engine.Resolve <LocationWizard>();
}
public ItemXmlWriter(IDefinitionManager definitions, IUrlParser parser, IFileSystem fs)
{
if (definitions == null)
throw new ArgumentNullException("definitions");
this.definitions = definitions;
this.parser = parser;
this.fs = fs;
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
Definitions = Engine.Definitions;
Edits = Engine.EditManager;
Wizard = Engine.Resolve<LocationWizard>();
Templates = Engine.Resolve<IContentTemplateRepository>();
}
public ConvertEnumsMigration(IRepository<ContentItem> repository, InstallationManager installer, IDefinitionManager definitions)
{
this.repository = repository;
this.installer = installer;
this.definitions = definitions;
Title = "Convert enum detail types to new storage format";
Description = "Enums values are stored as string (+ integer) in this version of N2. To support querying, previously stored enums must be converted.";
}
public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator)
{
if (definitions == null)
throw new ArgumentNullException("definitions");
this.definitions = definitions;
this.activator = activator;
this.readers = DefaultReaders();
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
Definitions = Engine.Definitions;
Edits = Engine.ManagementPaths;
Wizard = Engine.Resolve<LocationWizard>();
Templates = Engine.Container.ResolveAll<ITemplateProvider>();
}
public override void Execute()
{
this.definitions = Engine.Resolve<IDefinitionManager>();
this.finder = Engine.Resolve<IItemFinder>();
foreach (var definition in definitions.GetDefinitions())
{
definition.NumberOfItems = finder.Where.Type.Eq(definition.ItemType).Count();
}
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
Security = Engine.SecurityManager;
Definitions = Engine.Definitions;
Versions = Engine.Resolve<IVersionManager>();
Commands = Engine.Resolve<CommandDispatcher>();
EditManager = Engine.EditManager;
ManagementPaths = Engine.ManagementPaths;
}
private static bool IsAllowed(ItemDefinition definition, ContentItem parentItem, ItemDefinition parentDefinition, IDefinitionManager definitions)
{
var ctx = new AllowedDefinitionQuery { Parent = parentItem, ParentDefinition = parentDefinition, ChildDefinition = definition, Definitions = definitions };
var filters = parentDefinition.AllowedChildFilters.Union(definition.AllowedParentFilters).ToList();
if (filters.Any(f => f.IsAllowed(ctx) == AllowedDefinitionResult.Allow))
return true;
else if (!filters.Any(f => f.IsAllowed(ctx) == AllowedDefinitionResult.Deny))
return true;
return false;
}
public InstallationManager(IHost host, IDefinitionManager definitions, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext)
{
this.host = host;
this.definitions = definitions;
this.importer = importer;
this.persister = persister;
this.sessionProvider = sessionProvider;
this.configurationBuilder = configurationBuilder;
this.webContext = webContext;
}
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 override void PlantTree(IDefinitionManager definitionManager, IPlanet planet, Index3 index, LocalBuilder builder, int seed)
{
ushort ground = builder.GetBlock(0, 0, -1);
if (ground == water) return;
Random rand = new Random(seed);
int height = rand.Next(2, 4);
for (int i = 0; i < height; i++)
builder.SetBlock(0, 0, i, cactus);
}
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 override void SetUp()
{
base.SetUp();
var changer = new StateChanger();
definitions = TestSupport.SetupDefinitions(typeof(StatefulPage), typeof(StatefulPart));
versions = new FakeVersionManager(repository, changer, typeof(StatefulPage), typeof(StatefulPart));
var editManager = new EditUrlManager(null, new EditSection());
var security = new SecurityManager(new FakeWebContextWrapper(), new EditSection());
commands = new CommandFactory(persister, security, versions, editManager, null, changer);
dispatcher = new CommandDispatcher(commands, persister);
item = CreateOneItem<StatefulPage>(1, "first", null);
child = CreateOneItem<StatefulPage>(2, "child", item);
}
