Esempio n. 1
0
        public SynonymsRenderer(
            IIdentifierDefaults identifierDefaults,
            IHtmlFormatter formatter,
            IReadOnlyCollection <IDatabaseSynonym> synonyms,
            SynonymTargets synonymTargets,
            DirectoryInfo exportDirectory)
        {
            if (synonyms == null || synonyms.AnyNull())
            {
                throw new ArgumentNullException(nameof(synonyms));
            }

            Synonyms           = synonyms;
            IdentifierDefaults = identifierDefaults ?? throw new ArgumentNullException(nameof(identifierDefaults));
            Formatter          = formatter ?? throw new ArgumentNullException(nameof(formatter));
            SynonymTargets     = synonymTargets ?? throw new ArgumentNullException(nameof(synonymTargets));
            ExportDirectory    = exportDirectory ?? throw new ArgumentNullException(nameof(exportDirectory));
        }
Esempio n. 2
0
        private IEnumerable <ITemplateRenderer> GetRenderers(
            IReadOnlyCollection <IRelationalDatabaseTable> tables,
            IReadOnlyCollection <IDatabaseView> views,
            IReadOnlyCollection <IDatabaseSequence> sequences,
            IReadOnlyCollection <IDatabaseSynonym> synonyms,
            IReadOnlyCollection <IDatabaseRoutine> routines,
            IReadOnlyDictionary <Identifier, ulong> rowCounts,
            string databaseVersion
            )
        {
            if (tables == null || tables.AnyNull())
            {
                throw new ArgumentNullException(nameof(tables));
            }
            if (views == null || views.AnyNull())
            {
                throw new ArgumentNullException(nameof(views));
            }
            if (sequences == null || sequences.AnyNull())
            {
                throw new ArgumentNullException(nameof(sequences));
            }
            if (synonyms == null || synonyms.AnyNull())
            {
                throw new ArgumentNullException(nameof(synonyms));
            }
            if (routines == null || routines.AnyNull())
            {
                throw new ArgumentNullException(nameof(routines));
            }
            if (rowCounts == null)
            {
                throw new ArgumentNullException(nameof(rowCounts));
            }

            var ruleProvider   = new ReportingRuleProvider();
            var rules          = ruleProvider.GetRules(Connection, RuleLevel.Warning);
            var linter         = new RelationalDatabaseLinter(rules);
            var synonymTargets = new SynonymTargets(tables, views, sequences, synonyms, routines);

            var dependencyProvider      = Connection.Dialect.GetDependencyProvider();
            var referencedObjectTargets = new ReferencedObjectTargets(dependencyProvider, tables, views, sequences, synonyms, routines);

            return(new ITemplateRenderer[]
            {
                new ColumnsRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, views, ExportDirectory),
                new ConstraintsRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, ExportDirectory),
                new IndexesRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, ExportDirectory),
                new LintRenderer(linter, Database.IdentifierDefaults, TemplateFormatter, tables, views, sequences, synonyms, routines, ExportDirectory),
                new MainRenderer(Database, TemplateFormatter, tables, views, sequences, synonyms, routines, rowCounts, databaseVersion, ExportDirectory),
                new OrphansRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, rowCounts, ExportDirectory),
                new RelationshipsRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, rowCounts, ExportDirectory),
                new TableRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, rowCounts, ExportDirectory),
                new TriggerRenderer(TemplateFormatter, tables, ExportDirectory),
                new ViewRenderer(Database.IdentifierDefaults, TemplateFormatter, views, referencedObjectTargets, ExportDirectory),
                new SequenceRenderer(Database.IdentifierDefaults, TemplateFormatter, sequences, ExportDirectory),
                new SynonymRenderer(Database.IdentifierDefaults, TemplateFormatter, synonyms, synonymTargets, ExportDirectory),
                new RoutineRenderer(Database.IdentifierDefaults, TemplateFormatter, routines, ExportDirectory),
                new TablesRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, rowCounts, ExportDirectory),
                new TriggersRenderer(Database.IdentifierDefaults, TemplateFormatter, tables, ExportDirectory),
                new ViewsRenderer(Database.IdentifierDefaults, TemplateFormatter, views, ExportDirectory),
                new SequencesRenderer(Database.IdentifierDefaults, TemplateFormatter, sequences, ExportDirectory),
                new SynonymsRenderer(Database.IdentifierDefaults, TemplateFormatter, synonyms, synonymTargets, ExportDirectory),
                new RoutinesRenderer(Database.IdentifierDefaults, TemplateFormatter, routines, ExportDirectory),
                new TableOrderingRenderer(Connection.Dialect, tables, ExportDirectory),
                new DbmlRenderer(tables, ExportDirectory)
            });
        }
Esempio n. 3
0
        public async Task RenderAsync(CancellationToken cancellationToken = default)
        {
            var mapper = new MainModelMapper();

            var columns         = 0U;
            var constraints     = 0U;
            var indexesCount    = 0U;
            var tableViewModels = new List <Main.Table>();

            foreach (var table in Tables)
            {
                if (!RowCounts.TryGetValue(table.Name, out var rowCount))
                {
                    rowCount = 0;
                }

                var renderTable = mapper.Map(table, rowCount);

                var uniqueKeyLookup = table.GetUniqueKeyLookup();
                var uniqueKeyCount  = uniqueKeyLookup.UCount();

                var checksLookup = table.GetCheckLookup();
                var checksCount  = checksLookup.UCount();

                var indexesLookup = table.GetIndexLookup();
                var indexCount    = indexesLookup.UCount();
                indexesCount += indexCount;

                await table.PrimaryKey.IfSomeAsync(_ => constraints++).ConfigureAwait(false);

                constraints += uniqueKeyCount;
                constraints += renderTable.ParentsCount;
                constraints += checksCount;

                columns += renderTable.ColumnCount;

                tableViewModels.Add(renderTable);
            }

            var viewViewModels = Views.Select(mapper.Map).ToList();

            columns += (uint)viewViewModels.Sum(v => v.ColumnCount);

            var sequenceViewModels = Sequences.Select(mapper.Map).ToList();

            var synonymTargets    = new SynonymTargets(Tables, Views, Sequences, Synonyms, Routines);
            var synonymViewModels = Synonyms.Select(s => mapper.Map(s, synonymTargets)).ToList();

            var routineViewModels = Routines.Select(mapper.Map).ToList();

            var schemas = Tables.Select(t => t.Name)
                          .Union(Views.Select(v => v.Name))
                          .Union(Sequences.Select(s => s.Name))
                          .Union(Synonyms.Select(s => s.Name))
                          .Union(Routines.Select(r => r.Name))
                          .Select(n => n.Schema)
                          .Where(n => n != null)
                          .Distinct()
                          .Where(s => s != null)
                          .Select(s => s !)
                          .OrderBy(n => n)
                          .ToList();

            var templateParameter = new Main(
                Database.IdentifierDefaults.Database,
                DatabaseDisplayVersion ?? string.Empty,
                columns,
                constraints,
                indexesCount,
                schemas,
                tableViewModels,
                viewViewModels,
                sequenceViewModels,
                synonymViewModels,
                routineViewModels
                );

            var renderedMain = await Formatter.RenderTemplateAsync(templateParameter, cancellationToken).ConfigureAwait(false);

            var databaseName = !Database.IdentifierDefaults.Database.IsNullOrWhiteSpace()
                ? Database.IdentifierDefaults.Database + " Database"
                : "Database";
            var pageTitle     = "Home · " + databaseName;
            var mainContainer = new Container(renderedMain, pageTitle, string.Empty);
            var renderedPage  = await Formatter.RenderTemplateAsync(mainContainer, cancellationToken).ConfigureAwait(false);

            if (!ExportDirectory.Exists)
            {
                ExportDirectory.Create();
            }
            var outputPath = Path.Combine(ExportDirectory.FullName, "index.html");

            using var writer = File.CreateText(outputPath);
            await writer.WriteAsync(renderedPage.AsMemory(), cancellationToken).ConfigureAwait(false);

            await writer.FlushAsync().ConfigureAwait(false);
        }