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