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 void Configuration_CanAdd_Editable_ToDefinition() { DefinitionElement definitionElement = new DefinitionElement { Name = "DefinitionTextPage" }; definitionElement.Containers.Add(new ContainableElement { Name = "X", Type = typeof(EditableCheckBoxAttribute).AssemblyQualifiedName }); var definitionCollection = new DefinitionCollection(); definitionCollection.Add(definitionElement); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinition = definitions .Single(d => d.ItemType == typeof(DefinitionTextPage)); var textEditors = textPageDefinition.Editables .Where(e => e.GetType() == typeof(EditableCheckBoxAttribute)); Assert.That(textEditors.Count(), Is.EqualTo(1)); }
public void GivenIHaveCreatedALinkedFixtureForFootballWithTheFollowingBaseVariables(Table table) { var baseVariables = table.CreateInstance <BaseVariables>(); // // var tradingRulesBuilder = new TradingRulesBuilder(); // var tradingRules = tradingRulesBuilder.ForSport(RestRelations.FootballOdds) // .WithDefaultRules() // .Build(); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); // var createdTradingRules = connectClient.CreateTradingRules(tradingRules); var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(RestRelations.FootballOdds) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinition = connectClient.CreateDefinition(definition); var fixture = new FixtureBuilder().ForSport(RestRelations.FootballOdds) .ForPublicFixture() .Build(); // fixture.Participants[0].Name = "Priya1"; // fixture.Participants[1].Name = "Priya2"; var publicCe = connectClient.CreatePublicFixture(fixture); var linkedCe = connectClient.CreateLinkedFixture(publicCe, createdDefinition); ScenarioContext.Current.Add(Constants.KeyLinkedCe, linkedCe); }
public void Configuration_CanChange_Editable_OnExistingDefinition() { var definitionCollection = new DefinitionCollection(); definitionCollection.Add(new DefinitionElement { Name = "DefinitionTextPage", Editables = new ContainableCollection { new ContainableElement { Name = "Title", Title = "Page title in navigation", Type = typeof(EditableTextAttribute).AssemblyQualifiedName } } }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textDefinition = definitions.Single(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textDefinition.Editables.Any(e => e.Title == "Page title in navigation" && e.GetType() == typeof(EditableTextAttribute))); Assert.That(textDefinition.Editables.Any(e => e.Title == "Title" || e.GetType() == typeof(WithEditableTitleAttribute)), Is.False); }
public void GivenIHaveCreatedAPrematchLinkedFixtureForWithTheFollowingBaseVariables(string sport, Table table) { var prematchBaseVariables = new GTP.Domain.Sports.Cricket.PreMatchBaseVariables(); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); var definitionBuilder = new DefinitionBuilder().ForSport(RestRelations.CricketOdds) .WithBaseVariables(new GTP.Domain.Sports.Cricket.BaseVariables()) .WithPreMatchBaseVariables(prematchBaseVariables) .WithDefaultTradingRules() .WithDefaultLadder(); var definition = definitionBuilder.Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); var fixture = new FixtureBuilder().ForSport(RestRelations.CricketOdds) .ForPublicFixture() .Build(); var publicFixtureResource = connectClient.CreatePublicFixture(fixture); var linkedFixtureResource = connectClient.CreateLinkedFixture(publicFixtureResource.Fixture, createdDefinitionResource.Definition); ScenarioContext.Current.Add(Constants.KeyLinkedCe, linkedFixtureResource); }
public void Configuration_CanRemove_Editable_FromDefinition() { DefinitionElement definitionElement = new DefinitionElement { Name = "DefinitionTextPage" }; definitionElement.Containers.Remove(new ContainableElement { Name = "Text" }); var definitionCollection = new DefinitionCollection(); definitionCollection.Add(definitionElement); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinition = definitions .Single(d => d.ItemType == typeof(DefinitionTextPage)); var textEditors = textPageDefinition.Editables .Where(e => e.GetType() == typeof(EditableFreeTextAreaAttribute)); Assert.That(textEditors.Count(), Is.EqualTo(0)); }
public void GivenIHaveCreatedADefinitionWithNewTwoRunnerLadderForSportWithFollowingBaseVariables(string ladderName, string sport, Table table) { var baseVariables = SharedStepsMarketDefinitions.CreateBaseVariables(sport, table); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); //Create a Two Runner Ladder with the specified name var ladderBuilder = new LadderBuilder(); var ladder = ladderBuilder.WithName(ladderName).WithDefaultTwoRunnerSteps().Build(); var ladderResource = connectClient.CreateLadder(ladder); var twoRunnerLadders = new List <Ladder>(); twoRunnerLadders.Add(ladderResource.Ladder); //Create a definition with the two runner ladder created above var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithTwoRunnerLadders(twoRunnerLadders) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); ScenarioContext.Current.Add(Constants.KeyDefinition, createdDefinitionResource); AddToCurrentScenarioContext(Constants.KeyLadder, ladderResource); }
public DefinitionBuilder GetDefinitionBuilder() { if (_definitionBuilder == null) { var enabledLanguages = _settings.EnabledLanguages; if (enabledLanguages == null) { enabledLanguages = new string[] {} } ; _definitionBuilder = new DefinitionBuilder( _settings.RootPath, Environment.CurrentDirectory, _settings.DefaultLanguage, enabledLanguages, () => { return(GetDefaultHandlers() .Select(x => new BuiltInCommand(x.Command, x.Usage))); }, (path) => PluginLocator().LocateAllFor(path)); } return(_definitionBuilder); }
public void Configuration_CanAdd_Editable_ToExistingDefinition() { var definitionCollection = new DefinitionCollection { DefineUnattributedTypes = true }; definitionCollection.Add(new DefinitionElement { Name = "DefinitionTextPage", Editables = new ContainableCollection { new ContainableElement { Name = "MetaTitle", Title = "Page title", Type = typeof(N2.Details.EditableTextAttribute).AssemblyQualifiedName } } }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase <IUniquelyNamed> [0], new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textDefinition = definitions.Single(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textDefinition.Editables.Any(e => e.Name == "MetaTitle")); }
public void GivenIHaveCreatedALinkedFixtureForAmericanFootballWithTheFollowingBaseVariables(string sport, Table table) { var baseVariables = CreateBaseVariables(sport, table); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); var fixture = new FixtureBuilder().ForSport(Sports.ToRestRelation[sport]) .ForPublicFixture() .Build(); var publicFixtureResource = connectClient.CreatePublicFixture(fixture); var linkedFixtureResource = connectClient.CreateLinkedFixture(publicFixtureResource.Fixture, createdDefinitionResource.Definition); ScenarioContext.Current.Add(Constants.KeyLinkedCe, linkedFixtureResource); }
public override void SetUp() { base.SetUp(); 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(); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ContentActivator(changer, notifier, new EmptyProxyFactory()), changer, new DefinitionMap()); versioner = mocks.StrictMock <IVersionManager>(); var urls = new FakeEditUrlManager(); editManager = new EditManager(definitions, persister, versioner, null, null, null, urls, changer, new EditableHierarchyBuilder(new SecurityManager(new ThreadContext(), new EditSection()), TestSupport.SetupEngineSection()), new EditSection()); editManager.EnableVersioning = true; var engine = new FakeEngine(); engine.Container.AddComponentInstance("editManager", typeof(IEditManager), editManager); engine.Container.AddComponentInstance("editSection", typeof(EditSection), new EditSection()); Context.Replace(engine); }
public static string GenerateMapping(IList <IDev2Definition> defs, enDev2ArgumentType typeOf) { var b = new DefinitionBuilder { ArgumentType = typeOf, Definitions = defs }; return(b.Generate()); }
public static IDefinitionProvider[] SetupDefinitionProviders(DefinitionMap map, params Type[] itemTypes) { IDefinitionProvider[] definitionProviders; ITypeFinder typeFinder = new Fakes.FakeTypeFinder(itemTypes.Select(t => t.Assembly).FirstOrDefault() ?? Assembly.GetExecutingAssembly(), itemTypes); var definitionBuilder = new DefinitionBuilder(map, typeFinder, new TransformerBase <IUniquelyNamed> [0], SetupEngineSection()); definitionProviders = new IDefinitionProvider[] { new DefinitionProvider(definitionBuilder) }; return(definitionProviders); }
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 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 void Configuration_CanAdd_Definition() { var definitionCollection = new DefinitionCollection(); definitionCollection.Add(new DefinitionElement { Name = "DefinitionUndefined", Type = typeof(DefinitionUndefined).AssemblyQualifiedName }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var undefinedDefinition = definitions .Single(d => d.ItemType == typeof(DefinitionUndefined)); Assert.That(undefinedDefinition.IsDefined, Is.True); }
public void Configuration_CanRemove_Definition() { var definitionCollection = new DefinitionCollection { DefineUnattributedTypes = true }; definitionCollection.Remove(new DefinitionElement { Name = "DefinitionTextPage" }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase<IUniquelyNamed>[0], new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinitions = definitions .Where(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textPageDefinitions.Count(), Is.EqualTo(0)); }
public void Configuration_CanRemove_Definition() { var definitionCollection = new DefinitionCollection(); definitionCollection.Remove(new DefinitionElement { Name = "DefinitionTextPage" }); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinitions = definitions .Where(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textPageDefinitions.Count(), Is.EqualTo(0)); }
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) }, activator, changer, new DefinitionMap()); }
public static void Setup(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(typeFinder, new EngineSection()); notifier = new ItemNotifier(); proxyFactory = new InterceptingProxyFactory(); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, proxyFactory); definitions = new DefinitionManager(new [] { new DefinitionProvider(definitionBuilder) }, activator); ((DefinitionManager)definitions).Start(); }
public override void SetUp() { base.SetUp(); user = CreatePrincipal("SomeSchmuck"); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection()); IItemNotifier notifier = mocks.DynamicMock <IItemNotifier>(); mocks.Replay(notifier); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new [] { new DefinitionProvider(builder) }, activator); }
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 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); }
protected override void CreateText(Dictionary <uint, NuGenTokenBase> allTokens) { base.CreateText(allTokens); ReadSignature(); NuGenHelperFunctions.SetSignatureItemToken(allTokens, signatureReader.ReturnType); NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly; DefinitionBuilder.Length = 0; if ((Flags & CorPropertyAttr.prSpecialName) == CorPropertyAttr.prSpecialName) { DefinitionBuilder.Append("specialname "); } CorPropertyAttr reservedFlags = Flags & CorPropertyAttr.prReservedMask; if ((reservedFlags & CorPropertyAttr.prRTSpecialName) == CorPropertyAttr.prRTSpecialName) { DefinitionBuilder.Append("rtsspecialname "); } if ((signatureReader.CallingConvention & CorCallingConvention.IMAGE_CEE_CS_CALLCONV_HASTHIS) == CorCallingConvention.IMAGE_CEE_CS_CALLCONV_HASTHIS) { DefinitionBuilder.Append("instance "); } DefinitionBuilder.Append(signatureReader.ReturnType); DefinitionBuilder.Append(" "); DefinitionBuilder.Append(Name); DefinitionBuilder.Append("("); if (signatureReader.Parameters != null) { for (int parametersIndex = 0; parametersIndex < signatureReader.Parameters.Count; parametersIndex++) { NuGenBaseSignatureItem parameter = signatureReader.Parameters[parametersIndex]; NuGenHelperFunctions.SetSignatureItemToken(allTokens, parameter); DefinitionBuilder.Append(parameter); if (parametersIndex < signatureReader.Parameters.Count - 1) { DefinitionBuilder.Append(", "); } } } DefinitionBuilder.Append(")"); Definition = DefinitionBuilder.ToString(); }
public void GivenICreateAMarketDefinitionWithBaseVariablesThatHaveTheProperties(string sport, Table table) { var baseVariables = SharedStepsMarketDefinitions.CreateBaseVariables(sport, table); var definition = new DefinitionBuilder().ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); var createdDefinitionResource = connectClient.CreateDefinition(definition); ScenarioContext.Current.Add(Constants.KeyDefinition, createdDefinitionResource); }
public static async Task WriteToFile(Options options, DefinitionBuilder builder, IEnumerable source) { var filename = Path.Combine(options.OutputDirectory, builder.Name + ".csv"); var directory = new DirectoryInfo(options.OutputDirectory); if (!directory.Exists && directory.Parent != null) { directory.Create(); } var dbLoader = new BulkLoader(builder.Name, source); await dbLoader.ExportToFile(filename); Console.WriteLine($"Exported {builder.Name} to CSV"); }
public void GivenIHaveCreatedANewMarketDefinitionForWithTheFollowingBaseVariables(string sport, Table table) { var baseVariables = CreateBaseVariables(sport, table); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); ScenarioContext.Current.Add(Constants.KeyDefinition, createdDefinitionResource); }
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 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 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 static string GenerateSerializableDefsFromDataList(string datalist, enDev2ColumnArgumentDirection direction) { DefinitionBuilder db = new DefinitionBuilder(); if (direction == enDev2ColumnArgumentDirection.Input) { db.ArgumentType = enDev2ArgumentType.Input; } else if (direction == enDev2ColumnArgumentDirection.Output) { db.ArgumentType = enDev2ArgumentType.Output; } db.Definitions = GenerateDefsFromDataList(datalist, direction); return(db.Generate()); }
public void Configuration_CanRemove_Definition() { var definitionCollection = new DefinitionCollection(); definitionCollection.Remove(new DefinitionElement { Name = "DefinitionTextPage" }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinitions = definitions .Where(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textPageDefinitions.Count(), Is.EqualTo(0)); }
public void Configuration_CanAdd_Editable_ToExistingDefinition() { var definitionCollection = new DefinitionCollection(); definitionCollection.Add(new DefinitionElement { Name = "DefinitionTextPage", Editables = new ContainableCollection { new ContainableElement { Name = "MetaTitle", Title = "Page title", Type = typeof(N2.Details.EditableTextAttribute).AssemblyQualifiedName } } }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textDefinition = definitions.Single(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textDefinition.Editables.Any(e => e.Name == "MetaTitle")); }
public void Configuration_CanRemove_Editable_FromDefinition() { DefinitionElement definitionElement = new DefinitionElement { Name = "DefinitionTextPage" }; definitionElement.Containers.Remove(new ContainableElement { Name = "Text" }); var definitionCollection = new DefinitionCollection(); definitionCollection.Add(definitionElement); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textPageDefinition = definitions .Single(d => d.ItemType == typeof(DefinitionTextPage)); var textEditors = textPageDefinition.Editables .Where(e => e.GetType() == typeof(EditableFreeTextAreaAttribute)); Assert.That(textEditors.Count(), Is.EqualTo(0)); }
private static async Task Run(Options options) { options.Validate(); var dbdProvider = new GithubDBDProvider(); var dbcProvider = new LocalDBCProvider(options.Directory); var dbs = Utils.GetFiles(options.Directory, "*.db2|*.dbc") .ToDictionary(Path.GetFileNameWithoutExtension); foreach (var db in dbs) { var dbcStream = await dbcProvider.StreamForTableName(db.Key); var dbdStream = await dbdProvider.StreamForTableName(db.Key); var dbReader = new DBReader(dbcStream); var builder = new DefinitionBuilder(db.Key, options.Build); var definition = builder.Generate(dbReader, dbdStream, dbs); var storage = dbReader.GetRecords(definition); if (storage.Count == 0) { Console.WriteLine($"Skipping {db.Key} - empty"); continue; } if (options.ExportType.HasFlag(ExportType.SQL)) { await DBObjectWriter.WriteToServer(options, builder, storage.Values); } if (options.ExportType.HasFlag(ExportType.CSV)) { await CSVObjectWriter.WriteToFile(options, builder, storage.Values); } } // append foreign keys to the database if (options.ExportType.HasFlag(ExportType.SQL) && options.ExportForeignKeys) { Console.WriteLine("Generating foreign keys"); await DBObjectWriter.WriteForeignKeys(options); } }
public void Configuration_CanChange_Editable_OnExistingDefinition() { var definitionCollection = new DefinitionCollection { DefineUnattributedTypes = true }; definitionCollection.Add(new DefinitionElement { Name = "DefinitionTextPage", Editables = new ContainableCollection { new ContainableElement { Name = "Title", Title = "Page title in navigation", Type = typeof(EditableTextAttribute).AssemblyQualifiedName } } }); DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase<IUniquelyNamed>[0], new EngineSection { Definitions = definitionCollection }); var definitions = builder.GetDefinitions(); var textDefinition = definitions.Single(d => d.ItemType == typeof(DefinitionTextPage)); Assert.That(textDefinition.Editables.Any(e => e.Title == "Page title in navigation" && e.GetType() == typeof(EditableTextAttribute))); Assert.That(textDefinition.Editables.Any(e => e.Title == "Title" || e.GetType() == typeof(WithEditableTitleAttribute)), Is.False); }
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(); }
public void GivenIHaveCreatedANewFixtureSetupInModeForWithFollowingBaseVariables(string tradeModeStr, string sport, Table table) { // Parse var tradeMode = (TradeMode)Enum.Parse(typeof(TradeMode), tradeModeStr); var baseVariables = CreateBaseVariables(sport, table); //Get Client var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); //Create Definition var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); //Create public Fixture var fixture = new FixtureBuilder().ForSport(Sports.ToRestRelation[sport]) .ForPublicFixture() .Build(); var publicFixtureResource = connectClient.CreatePublicFixture(fixture); var linkedFixtureResource = connectClient.CreateLinkedFixture(publicFixtureResource.Fixture, createdDefinitionResource.Definition); // Update trade mode if (linkedFixtureResource.Fixture.TradeMode != tradeMode) { linkedFixtureResource.Fixture.TradeMode = tradeMode; linkedFixtureResource = connectClient.UpdateFixture(linkedFixtureResource); } ScenarioContext.Current.Add(Constants.KeyLinkedCe, linkedFixtureResource); }
public override void SetUp() { base.SetUp(); 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(); definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ContentActivator(changer, notifier, new EmptyProxyFactory()), changer, new DefinitionMap()); versioner = mocks.StrictMock<IVersionManager>(); var urls = new FakeEditUrlManager(); editManager = new EditManager(definitions, persister, versioner, null, null, urls, changer, new EditableHierarchyBuilder(new SecurityManager(new ThreadContext(), new EditSection()), TestSupport.SetupEngineSection()), new EditSection()); editManager.EnableVersioning = true; var engine = new FakeEngine(); engine.Container.AddComponentInstance("editManager", typeof(IEditManager), editManager); engine.Container.AddComponentInstance("editSection", typeof(EditSection), new EditSection()); Context.Replace(engine); }
public void GivenIHaveCreatedNewTwoRunnerDefaultLadderWithTheNameAndANewDefinitionAsForWithDefaultBaseVariables(string ladderName, string definitionName, string sport) { var baseVariables = SharedStepsMarketDefinitions.CreateDefaultBaseVariables(sport); var connectClient = ScenarioContext.Current.Get <ConnectClient>(Constants.KeyConnectClient); var definitionBuilder = new DefinitionBuilder(); var definition = definitionBuilder.ForSport(Sports.ToRestRelation[sport]) .WithBaseVariables(baseVariables) .WithDefaultLadder() .WithDefaultTradingRules() .Build(); var createdDefinitionResource = connectClient.CreateDefinition(definition); var ladderBuilder = new LadderBuilder(); var ladder = ladderBuilder.WithName(ladderName).WithDefaultTwoRunnerSteps().Build(); var ladderResource = connectClient.CreateLadder(ladder); ScenarioContext.Current.Add(Constants.KeyDefinition, createdDefinitionResource); AddToCurrentScenarioContext(Constants.KeyLadder, ladderResource); }
public override void SetUp() { base.SetUp(); var urls = new FakeEditUrlManager(); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection(), urls); IItemNotifier notifier = mocks.DynamicMock<IItemNotifier>(); mocks.Replay(notifier); var changer = new N2.Edit.Workflow.StateChanger(); DefinitionManager definitions = new DefinitionManager(builder, changer, notifier, new EmptyProxyFactory()); versioner = mocks.StrictMock<IVersionManager>(); editManager = new EditManager(definitions, persister, versioner, null, null, null, urls, changer, new EditSection()); editManager.EnableVersioning = true; var engine = new FakeEngine(); engine.AddComponentInstance("editManager", typeof(IEditManager), editManager); engine.AddComponentInstance("editSection", typeof(EditSection), new EditSection()); Context.Replace(engine); }
public override void SetUp() { base.SetUp(); CreatePersister(); parser = mocks.StrictMock <IUrlParser>(); ITypeFinder typeFinder = CreateTypeFinder(); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection()); IItemNotifier notifier = mocks.DynamicMock <IItemNotifier>(); mocks.Replay(notifier); activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, new EmptyProxyFactory()); definitions = new DefinitionManager(new [] { new DefinitionProvider(builder) }, activator); finder = new FakeItemFinder(definitions, () => Enumerable.Empty <ContentItem>()); integrityManger = new IntegrityManager(definitions, finder, parser); IntegrityEnforcer enforcer = new IntegrityEnforcer(persister, integrityManger, activator); enforcer.Start(); }
public DefinitionProvider(DefinitionBuilder definitionBuilder) { this.definitions = definitionBuilder.GetDefinitions().ToArray(); }
public override void SetUp() { base.SetUp(); builder = new DefinitionBuilder(typeFinder, new EngineSection()); }
public ViewTemplateAnalyzer(IProvider<ViewEngineCollection> viewEnginesProvider, DefinitionMap map, DefinitionBuilder builder) { this.viewEnginesProvider = viewEnginesProvider; this.map = map; this.builder = builder; }
public ContentTemplateProvider(ContentTemplateRepository repository, DefinitionBuilder definitionBuilder) { this.repository = repository; this.definitionBuilder = definitionBuilder; }
public override void SetUp() { base.SetUp(); CreatePersister(); parser = mocks.StrictMock<IUrlParser>(); ITypeFinder typeFinder = CreateTypeFinder(); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection(), new FakeEditUrlManager()); IItemNotifier notifier = mocks.DynamicMock<IItemNotifier>(); mocks.Replay(notifier); definitions = new DefinitionManager(builder, new N2.Edit.Workflow.StateChanger(), notifier, new EmptyProxyFactory()); finder = new FakeItemFinder(definitions, () => Enumerable.Empty<ContentItem>()); integrityManger = new IntegrityManager(definitions, finder, parser); IntegrityEnforcer enforcer = new IntegrityEnforcer(persister, integrityManger, definitions); enforcer.Start(); }
public override void SetUp() { base.SetUp(); user = CreatePrincipal("SomeSchmuck"); DefinitionBuilder builder = new DefinitionBuilder(typeFinder, new EngineSection(), new FakeEditUrlManager()); IItemNotifier notifier = mocks.DynamicMock<IItemNotifier>(); mocks.Replay(notifier); definitions = new DefinitionManager(builder, new N2.Edit.Workflow.StateChanger(), notifier, new EmptyProxyFactory()); }
public DefinitionProvider(DefinitionBuilder definitionBuilder) { this.definitionBuilder = definitionBuilder; }
public override void SetUp() { base.SetUp(); builder = new DefinitionBuilder(new DefinitionMap(), typeFinder, new TransformerBase<IUniquelyNamed>[0], TestSupport.SetupEngineSection()); }