public Composition(ICompositionContainer container, IAMTimeline timeline, IAMTimelineComp timelineComposition, string name, int priority) : base(timeline, name, priority) { _container = container; _timelineComposition = timelineComposition; }
public static MarkdownValidatorBuilder Create(ICompositionContainer container, string baseDir, string templateDir) { var builder = new MarkdownValidatorBuilder(container); LoadValidatorConfig(baseDir, templateDir, builder); return(builder); }
/// <summary> /// Gets all meta data containers ordered. If none exists in the system, a default is created /// </summary> /// <returns></returns> public static List <KeyValuePair <Guid, string> > GetAllMetaDataContainers() { List <KeyValuePair <Guid, string> > containers; using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope()) { bool anyExists = DataFacade.GetData <ICompositionContainer>().Any(); if (anyExists == false) { ICompositionContainer defaultContainer = DataFacade.BuildNew <ICompositionContainer>(); defaultContainer.Id = DefaultCompositionContainerId; defaultContainer.Label = "${Composite.Management, DataCompositionVisabilityFacade.DefaultContainerLabel}"; DataFacade.AddNew <ICompositionContainer>(defaultContainer); } containers = DataFacade.GetData <ICompositionContainer>(). OrderBy(f => f.Label). Select(f => new KeyValuePair <Guid, string>(f.Id, f.Label)). ToList(); transactionScope.Complete(); } return(containers); }
public MarkdigMarkdownService( MarkdownServiceParameters parameters, ICompositionContainer container = null) { _parameters = parameters; _mvb = MarkdownValidatorBuilder.Create(parameters, container); }
public SchemaDrivenDocumentProcessor( DocumentSchema schema, ICompositionContainer container, MarkdigMarkdownService markdigMarkdownService, FolderRedirectionManager folderRedirectionManager) { if (string.IsNullOrWhiteSpace(schema.Title)) { throw new ArgumentException("Title for schema must not be empty"); } _schemaName = schema.Title; _schema = schema; SchemaValidator = schema.Validator; _allowOverwrite = schema.AllowOverwrite; _serializerPool = new ResourcePoolManager <JsonSerializer>(GetSerializer, 0x10); _markdigMarkdownService = markdigMarkdownService ?? throw new ArgumentNullException(nameof(MarkdigMarkdownService)); _folderRedirectionManager = folderRedirectionManager; if (container != null) { var commonSteps = container.GetExports <IDocumentBuildStep>(nameof(SchemaDrivenDocumentProcessor)); var schemaSpecificSteps = container.GetExports <IDocumentBuildStep>($"{nameof(SchemaDrivenDocumentProcessor)}.{_schemaName}"); BuildSteps = commonSteps.Union(schemaSpecificSteps).ToList(); } }
public DfmService( DfmServiceProvider provider, string baseDir, string templateDir, ICompositionContainer container, ImmutableDictionary <string, string> tokens, IReadOnlyList <string> fallbackFolders, IReadOnlyDictionary <string, object> parameters) { var options = DocfxFlavoredMarked.CreateDefaultOptions(); options.LegacyMode = provider.LegacyMode; options.ShouldFixId = provider.ShouldFixId; options.ShouldExportSourceInfo = true; _builder = new DfmEngineBuilder( options, baseDir, templateDir, fallbackFolders, container); _builder.TokenTreeValidator = MarkdownTokenTreeValidatorFactory.Combine(provider.TokenTreeValidator); _tokens = tokens; _renderer = CustomizedRendererCreator.CreateRenderer(new DfmRenderer { Tokens = _tokens }, provider.DfmRendererPartProviders, parameters); foreach (var c in provider.DfmEngineCustomizers) { c.Customize(_builder, parameters); } _incrementalContextHash = ComputeIncrementalContextHash(baseDir, templateDir, provider.TokenTreeValidator, parameters); }
public Composition(ICompositionContainer container, IAMTimeline timeline, IAMTimelineComp timelineComposition, string name, int priority) : base(timeline, name, priority) { _container = container; TimelineComposition = timelineComposition; }
public void Compose(ICompositionContainer parentContainer) { //TODO: not support child containers yet Container = parentContainer.CreateChildContainer(); RegisterGlobalServices(Container); RegisterModuleServices(Container); Initialize(); }
public override void Load(ICompositionContainer moduleContainer) { base.Load(moduleContainer); AddGlobalServices(moduleContainer.Parent.Services); AddModuleServices(moduleContainer.Services); RegisterSiteMapInformation(moduleContainer.Services.Get<ISiteMapBuilderService>(true)); }
public void GetGroupContainer() { using (ITimeline timeline = new DefaultTimeline()) { IGroup group = timeline.AddAudioGroup(); ICompositionContainer container = group.Container; } }
private void OnPageInitComplete(object sender, EventArgs e) { Page page = (Page)sender; page.InitComplete -= new EventHandler(OnPageInitComplete); ICompositionContainer moduleContainer = GetModuleContainer(new HttpContext(System.Web.HttpContext.Current)); BuildControls(moduleContainer, page.Controls); }
public static ICompositionContainer Compose(ICompositionContainer parentContainer, IList <Type> modules) { foreach (var module in modules.Select(type => Activator.CreateInstance(type) as CompositionModule)) { module.Compose(parentContainer); //__modules.Add(module.Name, module); Modules.Add(Guid.NewGuid().ToString(), module); } return(parentContainer); }
public override void Load(ICompositionContainer container) { base.Load(container); AddModuleServices(container.Services); // TODO // RegisterRequiredPermissions(container.Services.Get<IPermissionsCatalog>(true)); // RegisterSiteMapInformation(container.Services.Get<ISiteMapBuilderService>(true)); RegisterPageFlows(); }
private static IMarkdownTokenRewriter InitMarkdownStyle(ICompositionContainer container, string baseDir, string templateDir) { try { return(MarkdownValidatorBuilder.Create(container, baseDir, templateDir).CreateRewriter()); } catch (Exception ex) { Logger.LogWarning($"Fail to init markdown style, details:{Environment.NewLine}{ex.ToString()}"); } return(null); }
public MarkdigMarkdownService( MarkdownServiceParameters parameters, ICompositionContainer container = null) { _parameters = parameters; _mvb = MarkdownValidatorBuilder.Create(parameters, container); _context = new MarkdownContext( key => _parameters.Tokens.TryGetValue(key, out var value) ? value : null, (code, message, origin, line) => Logger.LogWarning(message, null, InclusionContext.File.ToString(), line?.ToString(), code), (code, message, origin, line) => Logger.LogError(message, null, InclusionContext.File.ToString(), line?.ToString(), code), ReadFile); }
public void RegisterExport(ICompositionContainer compositionContainer) { compositionContainer.RegisterExport <WorkItemApiService>(); compositionContainer.RegisterExport <AutofillService>(); compositionContainer.RegisterExport <UserIdProvider, ICurrentUsernameProvider>(); //compositionContainer.RegisterInstance<IHubConnectionContext<dynamic>>(); compositionContainer.RegisterExport <SignalrClientsProvider>(); compositionContainer.RegisterExport <SignalrNotificator, IRealtimeNotificationService>(); compositionContainer.RegisterExport <SignalrNotificator, EventNotificator>(); compositionContainer.RegisterExport <DataGenerator>(); //var notificationService = new SignalrNotificator(GlobalHost.ConnectionManager.GetHubContext<NotificationHub>().Clients); //compositionContainer.RegisterInstance(notificationService); }
public void RootPathContainsCustomModulesAndIncorrectPrefixIsUsed_CustomModulesAreImported() { var rootPath = GetCurrentDirectory(); ICompositionContainer <ICustomModule> compositionContainer = CreateCompositionContainer <ICustomModule>(rootPath, new[] { "Incorrect" }); compositionContainer.Compose(); var modules = compositionContainer.Modules; var modulesCount = modules.Count(); Assert.AreEqual(0, modulesCount); }
public MarkdigMarkdownService( MarkdownServiceParameters parameters, ICompositionContainer container = null) { _parameters = parameters; _mvb = MarkdownValidatorBuilder.Create(parameters, container); _context = new MarkdownContext( _parameters.Tokens, (code, message, file, line) => Logger.LogWarning(message, null, file, line.ToString(), code), (code, message, file, line) => Logger.LogError(message, null, file, line.ToString(), code), ReadFile, GetLink); }
public void RootPathContainsCustomModulesAndNoPrefixIsUsed_CustomModulesAreImported() { var rootPath = GetCurrentDirectory(); ICompositionContainer <ICustomModule> compositionContainer = CreateCompositionContainer <ICustomModule>(rootPath); compositionContainer.Compose(); var modules = compositionContainer.Modules; var modulesCount = modules.Count(); modulesCount.Should().Be(2); }
public void RootPathContainsOtherModules_OtherModulesAreImported() { var rootPath = GetCurrentDirectory(); ICompositionContainer <IAnotherModule> compositionContainer = CreateCompositionContainer <IAnotherModule>(rootPath); compositionContainer.Compose(); var modules = compositionContainer.Modules; var modulesCount = modules.Count(); modulesCount.Should().Be(1); }
public void RootPathContainsCustomModules_CustomModulesAreImported() { var rootPath = GetCurrentDirectory(); ICompositionContainer <ICustomModule> compositionContainer = CreateCompositionContainer <ICustomModule>(rootPath); compositionContainer.Compose(); var modules = compositionContainer.Modules; var modulesCount = modules.Count(); Assert.AreEqual(2, modulesCount); }
public static ICompositionContainer Compose(IList <Type> modules) { if (Container != null) { return(Container); } Container = new CompositionContainer(); Container.Register <ICompositionContainer>(Container); Compose(Container, modules); return(Container); }
private void BuildControls(ICompositionContainer moduleContainer, ControlCollection controls) { foreach (Control currentControl in controls) { if (currentControl is UserControl) { CompositionContainer.BuildItem(PageBuilder, moduleContainer.Locator, currentControl); BuildControls(moduleContainer, currentControl.Controls); } else { BuildControls(moduleContainer, currentControl.Controls); } } }
/// <summary> /// Creates composable parts from an array of attributed objects and composes them in the specified composition container. /// </summary> /// <param name="container">The composition container to perform composition in.</param> /// <param name="attributedParts">An array of attributed objects to compose.</param> public static void ComposeParts(this ICompositionContainer container, params object[] attributedParts) { Requires.NotNull(container, nameof(container)); Requires.NotNull(attributedParts, nameof(attributedParts)); ComposablePart[] parts = new ComposablePart[attributedParts.Length]; for (int i = 0; i < parts.Length; i++) { parts[i] = AttributedModelServices.CreatePart(attributedParts[i]); } CompositionBatch batch = new CompositionBatch(parts, Enumerable.Empty <ComposablePart>()); container.Compose(batch); }
/// <summary> /// Creates a des composition, wraps it into an IComposition, adds it to a collecton /// and returns the new IComposition wrapper. /// </summary> /// <param name="timeline"></param> /// <param name="desComposition"></param> /// <param name="compositions"></param> /// <param name="name"></param> /// <param name="priority"></param> /// <returns></returns> internal static IComposition AddCompositionToCollection(ICompositionContainer container, IAMTimeline timeline, IAMTimelineComp desComposition, AddOnlyList <IComposition> compositions, string name, int priority) { priority = ReorderPriorities(compositions, priority); IComposition composition = new Composition(container, timeline, CreateComposition(timeline, desComposition, name, priority), name, priority); compositions.Add(composition); return(composition); }
public SchemaDrivenDocumentProcessor(DocumentSchema schema, ICompositionContainer container) { if (string.IsNullOrWhiteSpace(schema.Title)) { throw new ArgumentException("Title for schema must not be empty"); } _schemaName = schema.Title; _schema = schema; _serializerPool = new ResourcePoolManager <JsonSerializer>(GetSerializer, 0x10); if (container != null) { var commonSteps = container.GetExports <IDocumentBuildStep>(nameof(SchemaDrivenDocumentProcessor)); var schemaSpecificSteps = container.GetExports <IDocumentBuildStep>($"{nameof(SchemaDrivenDocumentProcessor)}.{_schemaName}"); BuildSteps = commonSteps.Union(schemaSpecificSteps).ToList(); } }
public static MarkdownValidatorBuilder Create( MarkdownServiceParameters parameters, ICompositionContainer container) { var builder = new MarkdownValidatorBuilder(container); if (parameters != null) { LoadValidatorConfig(parameters.BasePath, parameters.TemplateDir, builder); } if (container != null) { builder.LoadEnabledRulesProvider(); } return(builder); }
public void RegisterExport(ICompositionContainer compositionContainer) { compositionContainer.RegisterExportInRequestScope <ApplicationContext, ApplicationContext>(); compositionContainer.RegisterExport <WorkItemRepository, IWorkItemRepository>(); compositionContainer.RegisterExport <WorkItemRepository, ITreeRepository>(); compositionContainer.RegisterExport <UserRepository, IUserRepository>(); compositionContainer.RegisterExport <EventRepository, IEventRepository>(); compositionContainer.RegisterExport <UserPermissionsRepository, IUserPermissionsRepository>(); compositionContainer.RegisterExport <SettingRepository, ISettingRepository>(); compositionContainer.RegisterExport <SettingRepository, ISettingsValueProvider>(); compositionContainer.RegisterExport <UserSettingsRepository, IUserSettingsRepository>(); compositionContainer.RegisterExport <CommentRepository, ICommentRepository>(); compositionContainer.RegisterExport <AutofillRepository, IAutofillRepository>(); compositionContainer.RegisterExport <LocalFileSystemManager, IFileSystemManager>(); compositionContainer.RegisterExport <FileSystemManagerProvider>(); compositionContainer.RegisterExport <UsersService, IUsersService>(); compositionContainer.RegisterExport <UsersService, ICurrentUserProvider>(); compositionContainer.RegisterExport <WorkItemService>(); compositionContainer.RegisterExport <EventService, IEventService>(); compositionContainer.RegisterExport <SettingsService>(); compositionContainer.RegisterExport <SettingsService, ISettingsService>(); compositionContainer.RegisterExport <CommentsService>(); compositionContainer.RegisterExport <AttachingFileService>(); #region Event describers compositionContainer.RegisterExport <ItemAddedEventDescriber, EventDescriber>(); compositionContainer.RegisterExport <ItemAppointedEventDescriber, EventDescriber>(); compositionContainer.RegisterExport <ItemDeletedEventDescriber, EventDescriber>(); compositionContainer.RegisterExport <ItemDisappointedEventDescriber, EventDescriber>(); compositionContainer.RegisterExport <ItemChangedEventDecriber, EventDescriber>(); compositionContainer.RegisterExport <StateChangedEventDescriber, EventDescriber>(); #endregion compositionContainer.RegisterExport <EventNotificatorsUsersProvider, IEventNotificatorsUsersProvider>(); compositionContainer.RegisterExport <NotificationService, INotificationService>(); compositionContainer.RegisterExport <DatabaseEventNotificator, EventNotificator>(); compositionContainer.RegisterExport <DataUpdater>(); }
public WindowFactory(ICompositionContainer compositionContainer) { _compositionContainer = compositionContainer; }
public DfmEngineBuilder(Options options, string baseDir, string templateDir, IReadOnlyList <string> fallbackFolders, ICompositionContainer container) : base(options) { _baseDir = baseDir ?? string.Empty; _fallbackFolders = fallbackFolders ?? new List <string>(); var inlineRules = InlineRules.ToList(); // xref auto link must be before MarkdownAutoLinkInlineRule var index = inlineRules.FindIndex(s => s is MarkdownAutoLinkInlineRule); if (index < 0) { throw new ArgumentException("MarkdownAutoLinkInlineRule should exist!"); } inlineRules.Insert(index, new DfmXrefAutoLinkInlineRule()); index = inlineRules.FindLastIndex(s => s is MarkdownLinkInlineRule); if (index < 0) { throw new ArgumentException("MarkdownLinkInlineRule should exist!"); } inlineRules.Insert(index + 1, new DfmXrefShortcutInlineRule()); inlineRules.Insert(index + 1, new DfmEmailInlineRule()); inlineRules.Insert(index + 1, new DfmFencesInlineRule()); // xref link inline rule must be before MarkdownLinkInlineRule inlineRules.Insert(index, new DfmIncludeInlineRule()); Replace <MarkdownTextInlineRule, DfmTextInlineRule>(inlineRules); var blockRules = BlockRules.ToList(); index = blockRules.FindLastIndex(s => s is MarkdownCodeBlockRule); if (index < 0) { throw new ArgumentException("MarkdownNewLineBlockRule should exist!"); } blockRules.InsertRange( index + 1, new IMarkdownRule[] { new DfmIncludeBlockRule(), new DfmVideoBlockRule(), new DfmYamlHeaderBlockRule(), new DfmSectionBlockRule(), new DfmFencesBlockRule(), new DfmNoteBlockRule() }); Replace <MarkdownBlockquoteBlockRule, DfmBlockquoteBlockRule>(blockRules); Replace <MarkdownTableBlockRule, DfmTableBlockRule>(blockRules); Replace <MarkdownNpTableBlockRule, DfmNpTableBlockRule>(blockRules); InlineRules = inlineRules.ToImmutableList(); BlockRules = blockRules.ToImmutableList(); Rewriter = InitMarkdownStyle(container, baseDir, templateDir); TokenAggregator = new TabGroupAggregator(); }
public MarkdownRewriterContext(ICompositionContainer container, ImmutableList <MarkdownTagValidationRule> validators) { Container = container; Validators = validators; }
public MarkdownValidatorBuilder(ICompositionContainer container) { Container = container; }