private async Task UpdateArticleContent(Article article, string articleContent) { var df = new DocumentFormatter(articleContent); // clean old images if (article.Id != 0) { await CleanArticleContentImage(article, df); } var imageSources = df.GetImageSources(); var images = imageSources.Select(imgSource => { var image = new Image { ArticleId = article.Id, Data = imgSource.Data, DataType = imgSource.DataType }; imgSource.BindEntity(image); return(image); }); await _db.Images.AddRangeAsync(images); await _db.SaveChangesAsync(); imageSources.ForEach(ic => ic.UpdateHtmlSource("api/article/image/")); article.Content = df.Html; _db.Articles.Update(article); await _db.SaveChangesAsync(); }
public override void Write(DocumentFormatter output, OutputContext context) { if (Overloads.Count == 0) { base.Write(output, context); return; } output.Header(1, SharedTitle); WriteInfoBox(output, context); WriteOverloadsSummary(output, context); output.Table(new[] { "Overload", "Description" }, Overloads, overload => overload.WriteLink(output, context), overload => overload.WriteSummaryLine(output, context) ); foreach (var overload in Overloads) { output.Header(2, overload.Name); overload.WriteSummary(output, context); var syntax = overload.GetSyntax(context.Language); if (!string.IsNullOrEmpty(syntax)) { output.Header(3, "Syntax"); output.Code(syntax, context.Language.Name); } overload.WriteDetails(3, output, context); } }
protected override void ToolExportClick(object sender, EventArgs e) { if (Procedure == null || Procedure.Data == null) { base.ToolExportClick(sender, e); } else { string fileName = Procedure.DataName.Replace(".", DateTime.Now.ToString("yyMMddHHmmss") + "."); using (var dialog = new SaveFileDialog() { InitialFileName = fileName }) { if (dialog.Run(ParentWindow)) { DocumentFormatter.Execute(Procedure, new ExecuteArgs() { Parameters = parameters, Result = Query }); System.Diagnostics.Process.Start(dialog.FileName); } } } }
public virtual void WriteParametersSection(int level, DocumentFormatter output, OutputContext context, IEnumerable <ParameterInfo> parameters) { if (parameters == null || !parameters.Any()) { return; } var doc = context.Document.Of(this); output.Header(level, "Parameters"); output.DefinitionList(parameters, parameter => { output.Text(parameter.Name, TextStyles.Teletype); output.Text(": "); if (parameter.ParameterType.IsGenericParameter) { output.Text(parameter.ParameterType.GetDisplayName(), TextStyles.Emphasize); } else { output.LinkCRef(parameter.ParameterType.GetCRef(), parameter.ParameterType.GetDisplayName()); } }, parameter => output.Section(() => doc?.Parameters.For(parameter.Name, output.Xml, name => Log.WarnMisisngParameterDoc(this, name)))); }
protected virtual void WriteThreadSafetySection(int level, DocumentFormatter output, IEnumerable <XmlThreadSafety> threadSafeties) { var threadSafety = threadSafeties?.FirstOrDefault(); if (threadSafety == null) { return; } output.Header(level, "Thread Safety"); if (threadSafety.Static && threadSafety.Instance) { output.Section("Any public member of this type, either static or instance, is thread-safe."); } else if (threadSafety.Static && !threadSafety.Instance) { output.Section("Any public static member of this type is thread-safe, but instance members are not guaranteed to be thread-safe."); } else if (!threadSafety.Static && threadSafety.Instance) { output.Section("Any public static member of this type is not guaranteed to be thread-safe, but instance members are thread-safe."); } else { output.Section("Neither public nor instance members of this type are guaranteed to be thread-safe."); } }
private static bool FormatDocument() { var documentFormatter = new DocumentFormatter( new ClauserUnitStrategy(new ClauserUnitChecker()), new AdverbUnitStrategy(), new TimerUnitStrategy(), new ModifierStrategy(new ModifierFormatter()), new PrenStrategy()); List <OpenXmlElement> shuffledXmlElements = new List <OpenXmlElement>(); try { using (var document = WordprocessingDocument.Open(wordPath, true)) { var docPart = document.MainDocumentPart; if (docPart?.Document != null) { shuffledXmlElements = documentFormatter.ProcessDocument(docPart); } CreateAndSaveShuffledDocument(shuffledXmlElements); } } catch (Exception ex) { DisplayException(ex); return(false); } return(true); }
public static Task <Document> RefactorAsync( Document document, InitializerExpressionSyntax initializer, CancellationToken cancellationToken) { return(DocumentFormatter.ToSingleLineAsync(document, initializer, cancellationToken)); }
private static List <OpenXmlElement> GetDocument(string documentName) { List <OpenXmlElement> elements; using (WordprocessingDocument document = DocumentContentHelper.GetMainDocumentPart(documentName)) { // arrange var documentFormatter = new DocumentFormatter( new ClauserUnitStrategy(new ClauserUnitChecker()), new AdverbUnitStrategy(), new TimerUnitStrategy(), new ModifierStrategy(new ModifierFormatter()), new PrenStrategy()); var docPart = document.MainDocumentPart; if (docPart?.Document == null) { throw new Exception(); } // act elements = documentFormatter.ProcessDocument(docPart); } return(elements); }
public static void ComputeRefactorings(RefactoringContext context, AccessorDeclarationSyntax accessor) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatAccessorBraces)) { BlockSyntax body = accessor.Body; if (body?.Span.Contains(context.Span) == true && !body.OpenBraceToken.IsMissing && !body.CloseBraceToken.IsMissing) { if (body.IsSingleLine()) { if (accessor.Parent?.IsMultiLine() == true) { context.RegisterRefactoring( "Format braces on separate lines", cancellationToken => DocumentFormatter.ToMultiLineAsync(context.Document, accessor, cancellationToken)); } } else { SyntaxList <StatementSyntax> statements = body.Statements; if (statements.Count == 1 && statements[0].IsSingleLine()) { context.RegisterRefactoring( "Format braces on a single line", cancellationToken => DocumentFormatter.ToSingleLineAsync(context.Document, accessor, cancellationToken)); } } } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessor) && context.SupportsCSharp6 && UseExpressionBodiedMemberRefactoring.CanRefactor(accessor)) { SyntaxNode node = accessor; if (accessor.Parent is AccessorListSyntax accessorList) { SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors; if (accessors.Count == 1 && accessors.First().IsKind(SyntaxKind.GetAccessorDeclaration) && (accessorList.Parent is MemberDeclarationSyntax parent)) { node = parent; } } context.RegisterRefactoring( "Use expression-bodied member", cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, node, cancellationToken)); } }
public virtual void WriteInfoBox(DocumentFormatter output, OutputContext context) { output.Quote(GetInfoBoxWriters(context), info => { output.Text(info.Label); output.Text(": "); info.Writer(output); }); }
protected void WriteTypesInCategory(DocumentFormatter output, OutputContext context, TypeCategory category, IEnumerable <ClrType> types) { output.Header(3, category.ToPluralString()); output.Table(new[] { category.ToString(), "Description" }, types, type => type.WriteLink(output, context), type => type.WriteSummaryLine(output, context) ); }
protected void WriteMembersInCategory(int level, DocumentFormatter output, OutputContext context, MemberCategory category, IEnumerable <ClrMember> members) { output.Header(level, category.ToPluralString()); output.Table(new[] { category.ToString(), "Description" }, members, member => member.WriteLink(output, context), member => member.WriteSummaryLine(output, context) ); }
public override void WriteMembers(int level, DocumentFormatter output, OutputContext context) { output.Header(level, "Members"); output.Table(new[] { "Name", "Value", "Description" }, Info.GetEnumValues().Cast <Enum>(), value => output.Text(Info.GetEnumName(value)), value => output.Text((value as IFormattable)?.ToString("D", CultureInfo.InvariantCulture)), value => context.Document.Members.For(value.GetCRef(), doc => output.Xml(doc.Summaries.FirstOrDefault())) ); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ConditionalExpressionSyntax conditionalExpression) { if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(conditionalExpression)) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatConditionalExpression)) { if (conditionalExpression.IsSingleLine()) { context.RegisterRefactoring( "Format ?: on separate lines", cancellationToken => { return(DocumentFormatter.ToMultiLineAsync( context.Document, conditionalExpression, cancellationToken)); }); } else { context.RegisterRefactoring( "Format ?: on a single line", cancellationToken => { return(DocumentFormatter.ToSingleLineAsync( context.Document, conditionalExpression, cancellationToken)); }); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceConditionalExpressionWithIfElse)) { await ReplaceConditionalExpressionWithIfElseRefactoring.ComputeRefactoringAsync(context, conditionalExpression).ConfigureAwait(false); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapExpressionsInConditionalExpression) && (context.Span.IsBetweenSpans(conditionalExpression) || context.Span.IsEmptyAndContainedInSpan(conditionalExpression.QuestionToken) || context.Span.IsEmptyAndContainedInSpan(conditionalExpression.ColonToken)) && SwapExpressionsInConditionalExpressionRefactoring.CanRefactor(conditionalExpression)) { context.RegisterRefactoring( "Swap expressions in ?:", cancellationToken => { return(SwapExpressionsInConditionalExpressionRefactoring.RefactorAsync( context.Document, conditionalExpression, cancellationToken)); }); } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, InitializerExpressionSyntax initializer) { if (initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) && initializer.IsParentKind(SyntaxKind.CollectionInitializerExpression)) { initializer = (InitializerExpressionSyntax)initializer.Parent; } if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer) || context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer.Expressions)) { SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions; if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatInitializer) && expressions.Any() && !initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) && initializer.IsParentKind( SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.ObjectCreationExpression, SyntaxKind.CollectionInitializerExpression)) { if (initializer.IsSingleLine(includeExteriorTrivia: false)) { context.RegisterRefactoring( "Format initializer on multiple lines", cancellationToken => DocumentFormatter.ToMultiLineAsync( context.Document, initializer, cancellationToken)); } else if (expressions.All(expression => expression.IsSingleLine())) { context.RegisterRefactoring( "Format initializer on a single line", cancellationToken => DocumentFormatter.ToSingleLineAsync( context.Document, initializer, cancellationToken)); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandInitializer)) { await ExpandInitializerRefactoring.ComputeRefactoringsAsync(context, initializer).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseCSharp6DictionaryInitializer) && context.SupportsCSharp6) { await UseCSharp6DictionaryInitializerRefactoring.ComputeRefactoringAsync(context, initializer).ConfigureAwait(false); } } }
public override void WriteDetails(int level, DocumentFormatter output, OutputContext context) { if (Info.IsIndexer()) { WriteParametersSection(level, output, context, Info.GetIndexParameters()); } WriteSection(output, level, "Property Value", context.Document.Of(this)?.PropertyValues); base.WriteDetails(level, output, context); }
public override void Write(DocumentFormatter output, OutputContext context) { output.Header(2, Title); WriteSummaryLine(output, context); foreach (var typeCategory in TypeCategories.OrderBy(group => group.Key)) { WriteTypesInCategory(output, context, typeCategory.Key, typeCategory); typeCategory.ForEach(context.Compose); } }
public override void WriteDetails(int level, DocumentFormatter output, OutputContext context) { if (Info.IsGenericMethod) { WriteTypeParametersSection(level + 1, output, context, Info.GetGenericArguments().Where(arg => arg.IsGenericMethodParameter)); } WriteParametersSection(level + 1, output, context, Info.GetParameters()); WriteReturnValueSection(level + 1, output, context, (Info as MethodInfo)?.ReturnType); base.WriteDetails(level, output, context); }
public virtual void WriteMembers(int level, DocumentFormatter output, OutputContext context) { foreach (var category in Members.Select(g => g.Key).OrderBy(c => c)) { var categoryMembers = Members[category]; if (categoryMembers.Any()) { WriteMembersInCategory(level, output, context, category, categoryMembers); categoryMembers.Where(m => m.HasOwnDocFile).ForEach(context.Compose); } } }
private async Task CleanArticleContentImage(Article article, DocumentFormatter df) { var articleImages = await _db.Images.Where(x => x.ArticleId == article.Id).ToListAsync(); var htmlImagesIdList = df.GetInDocumentImagesList("api/article/image/"); var needToDelete = articleImages.Except(htmlImagesIdList.Select(id => new Image { Id = id })) .ToList(); _db.Images.RemoveRange(needToDelete); await _db.SaveChangesAsync(); }
public override void WriteSummary(DocumentFormatter output, OutputContext context) { var summary = context.Document.Of(this)?.Summaries; if (summary != null && summary.Count != 0) { output.Section(() => output.Xml(summary)); } else { output.Section(() => WriteDefaultSummary(output, context)); } }
public override void WriteDetails(int level, DocumentFormatter output, OutputContext context) { if (Info.IsGenericType) { WriteTypeParametersSection(level + 1, output, context, Info.GetGenericArguments()); } WriteMembers(level, output, context); WriteThreadSafetySection(level, output, context.Document.Of(this)?.ThreadSafeties); base.WriteDetails(level, output, context); }
public override void WriteSummaryLine(DocumentFormatter output, OutputContext context) { var summary = context.Document.Of(this)?.Summaries.FirstOrDefault(); if (summary != null) { output.Xml(summary); } else { WriteDefaultSummary(output, context); } }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <ICRef> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.List(items, item => output.LinkCRef(item.CRef, (item as ClrItem)?.Title)); }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <XmlNode> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.Xml(items); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ArgumentListSyntax argumentList) { SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments; if (arguments.Count == 0) { return; } await AddOrRemoveParameterNameRefactoring.ComputeRefactoringsAsync(context, argumentList).ConfigureAwait(false); if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateArgument)) { var refactoring = new DuplicateArgumentRefactoring(argumentList); refactoring.ComputeRefactoring(context); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatArgumentList) && (context.Span.IsEmpty || context.Span.IsBetweenSpans(argumentList))) { if (argumentList.IsSingleLine()) { if (arguments.Count > 1) { context.RegisterRefactoring( "Format arguments on separate lines", cancellationToken => { return(DocumentFormatter.ToMultiLineAsync( context.Document, argumentList, cancellationToken)); }); } } else { context.RegisterRefactoring( "Format arguments on a single line", cancellationToken => { return(DocumentFormatter.ToSingleLineAsync( context.Document, argumentList, cancellationToken)); }); } } }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, string label, IEnumerable <XmlReferenceNode> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.Table(new[] { label, "Description" }, items, item => output.LinkCRef(item.CRef, Utils.FormatCRef(item.CRef)), item => output.Xml(item)); }
protected virtual void WriteOverloadsSummary(DocumentFormatter output, OutputContext context) { var doc = Overloads.Select(o => context.Document.Of(o)?.Overloads.FirstOrDefault()).FirstOrDefault(o => o != null); if (doc != null) { if (doc.Summaries.Any()) { output.Xml(doc.Summaries); } else { output.Section(() => output.Xml(doc)); } } }
public override void Write(DocumentFormatter output, OutputContext context) { output.Header(1, Title); WriteInfoBox(output, context); WriteSummary(output, context); var syntax = GetSyntax(context.Language); if (!string.IsNullOrEmpty(syntax)) { output.Header(2, "Syntax"); output.Code(syntax, context.Language.Name); } WriteDetails(2, output, context); }
static void Main(string[] args) { ReportPrinter test1 = new ReportPrinter(); test1.data = "Przykład"; test1.PrintReport(); test1.FormatDocument(); Report test2 = new Report(); ReportPrinterBetter printer = new ReportPrinterBetter(); DocumentFormatter format = new DocumentFormatter(); test2.data = "Drugi przykład"; format.FormatDocument(test2); printer.PrintReport(test2); }
public MasterControl() { InitializeComponent(); this.formatter = new DocumentFormatter(); this.ctrlPreview.Master = this; this.bIsAscending = Properties.Settings.Default.DEFAULT_IS_SORTDIRECTION_ASCENDING; }