public void BuildSqlMeta(string outputRootPath, string connectionString,
                          List <KSolutionGroup> solutionGroupList)
 {
     foreach (var solutionGroup in solutionGroupList)
     {
         foreach (var solution in solutionGroup.Solution)
         {
             foreach (var project in solution.Project
                      .OfType <KDataStoreProject>())
             {
                 _dbToKSolutionConverter.BuildSqlMeta(connectionString, outputRootPath, project);
             }
             if (solution is KApplicationSolution)
             {
                 var appSolution = solution as KApplicationSolution;
                 foreach (var childSolution in appSolution.ChildSolution)
                 {
                     foreach (var project in childSolution.Project
                              .OfType <KDataStoreProject>())
                     {
                         _dbToKSolutionConverter.BuildSqlMeta(connectionString, outputRootPath, project);
                     }
                 }
             }
         }
     }
 }
        public async Task <KDataStoreProject> Handle(SplitSqlServerDDLQuery query, CancellationToken cancellationToken)
        {
            var databaseProject = new KDataStoreProject()
            {
                KickstartCRUDStoredProcedures = false,
                ConvertToSnakeCase            = false,// query.ConvertToSnakeCase,
                DataStoreType          = Utility.DataStoreTypes.SqlServer,
                SqlTableText           = query.UnSplitTableDDL,
                SqlTableTypeText       = query.UnSplitTableTypeDDL,
                SqlViewText            = query.UnSplitViewDDL,
                SqlFunctionText        = query.UnSplitFunctionDDL,
                SqlStoredProcedureText = query.UnSplitStoredProcedureDDL
            };

            var connectionString = "Server=localhost;";
            var outputRootPath   = string.Empty;

            return(_dbToKSolutionConverter.BuildSqlMeta(connectionString, outputRootPath, databaseProject));
        }
示例#3
0
        public override async Task <ConvertDDLResponse> ConvertDDL(ConvertDDLRequest request, ServerCallContext context)
        {
            var sw = Stopwatch.StartNew();

            GrpcEnvironment.Logger.Info($@"Processing ConvertDDL Request");

            var databaseProject = new KDataStoreProject()
            {
                KickstartCRUDStoredProcedures = false, ConvertToSnakeCase = request.ConvertToSnakeCase,
                DataStoreType          = Utility.DataStoreTypes.Postgres,
                SqlTableText           = request.UnconvertedTableDDL,
                SqlTableTypeText       = request.UnconvertedTableTypeDDL,
                SqlStoredProcedureText = request.UnconvertedStoredProcedureDDL
            };

            var connectionString = "Server=localhost;";
            var outputRootPath   = string.Empty;

            _dbToKSolutionConverter.BuildSqlMeta(connectionString, outputRootPath, databaseProject);

            var response = new ConvertDDLResponse();
            ICSchemaToSchemaConverter                   schemaConverter;
            ICTableToTableConverter                     tableConverter;
            ICTableTypeToTableTypeConverter             tableTypeConverter;
            ICStoredProcedureToStoredProcedureConverter storedProcConverter;

            if (request.DatabaseType == Types.DatabaseTypes.Postgres)
            {
                schemaConverter     = new CSchemaToPostgresSchemaConverter();
                tableConverter      = new CTableToPostgresTableConverter();
                tableTypeConverter  = new CTableTypeToPostgresTableTypeConverter();
                storedProcConverter = new CStoredProcedureToPostgresStoredProcedureConverter();
            }
            else if (request.DatabaseType == Types.DatabaseTypes.SqlServer)
            {
                schemaConverter     = new CSchemaToSqlServerSchemaConverter();
                tableConverter      = new CTableToSqlServerTableConverter();
                tableTypeConverter  = new CTableTypeToSqlServerTableTypeConverter();
                storedProcConverter = new CStoredProcedureToSSqlServerStoredProcedureConverter();
            }
            else
            {
                throw new NotImplementedException();
            }

            var codeWriter          = new CodeWriter();
            var codeWriterTableType = new CodeWriter();

            var codeWriterStoredProc = new CodeWriter();

            using (var memoryStream = new MemoryStream( ))
            {
                using (var zipFile = new ZipArchive(memoryStream, ZipArchiveMode.Create))
                {
                    foreach (var schema in databaseProject.GetAllGeneratedSchemas())
                    {
                        if (request.DatabaseType == Types.DatabaseTypes.SqlServer && schema.SchemaName.ToLower() == "dbo")
                        {
                            continue;// dbo already exists on Sql Server
                        }

                        var ddl = schemaConverter.Convert(schema);

                        var fileName = _flywayFileNameService.GetFlywayFileName(schema);
                        //fileWriter.WriteFile(fileName, ddl);
                        var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
                        using (var writer = new StreamWriter(newEntry.Open()))
                        {
                            writer.Write(ddl);
                        }
                    }
                    foreach (var table in databaseProject.Table)
                    {
                        var ddl = tableConverter.Convert(table.GeneratedTable);
                        codeWriter.WriteLine(ddl);
                        codeWriter.WriteLine();

                        var fileName = _flywayFileNameService.GetFlywayFileName(table.GeneratedTable);
                        //fileWriter.WriteFile(fileName, ddl);
                        var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
                        using (var writer = new StreamWriter(newEntry.Open()))
                        {
                            writer.Write(ddl);
                        }
                    }
                    {
                        var rules = new CRules();

                        foreach (var table in databaseProject.Table)
                        {
                            var rList = _cTableToDmsRuleConverter.Convert(table.GeneratedTable);
                            rules.Rule.AddRange(rList);
                        }

                        var json     = rules.ToJson();
                        var fileName = "DmsRules.json";
                        var newEntry = zipFile.CreateEntry(fileName);
                        using (var writer = new StreamWriter(newEntry.Open()))
                        {
                            writer.Write(json);
                        }
                        response.ConvertedDmsJson = json;
                    }


                    foreach (var tableType in databaseProject.TableType)
                    {
                        var ddl = tableTypeConverter.Convert(tableType.GeneratedTableType);
                        codeWriterTableType.WriteLine(ddl);
                        codeWriterTableType.WriteLine();

                        var fileName = _flywayFileNameService.GetFlywayFileName(tableType.GeneratedTableType);
                        //fileWriter.WriteFile(fileName, ddl);
                        var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
                        using (var writer = new StreamWriter(newEntry.Open()))
                        {
                            writer.Write(ddl);
                        }
                    }


                    foreach (var storedProc in databaseProject.StoredProcedure)
                    {
                        var ddl = storedProcConverter.Convert(storedProc.GeneratedStoredProcedure);
                        codeWriterStoredProc.WriteLine(ddl);
                        codeWriter.WriteLine();

                        var fileName = _flywayFileNameService.GetFlywayFileName(storedProc.GeneratedStoredProcedure);
                        //fileWriter.WriteFile(fileName, ddl);
                        var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
                        using (var writer = new StreamWriter(newEntry.Open()))
                        {
                            writer.Write(ddl);
                        }
                    }
                }
                response.ZipAsBase64 = Convert.ToBase64String(memoryStream.ToArray());
            }
            response.ConvertedTableDDL           = codeWriter.ToString();
            response.ConvertedTableTypeDDL       = codeWriterTableType.ToString();
            response.ConvertedStoredProcedureDDL = codeWriterStoredProc.ToString();

            sw.Stop();
            GrpcEnvironment.Logger.Info($"Processed request in {sw.ElapsedMilliseconds} ms");
            return(response);
        }
        public KSolution BuildSolution(KickstartWizardModel kickstartWizardModel)
        {
            var solution = new KSolution()
            {
                CompanyName = kickstartWizardModel.CompanyName, SolutionName = kickstartWizardModel.SolutionName
            };

            KProtoFile kProtoFile = null;

            if (kickstartWizardModel.MetadataSource == MetadataSource.Grpc)
            {
                kProtoFile = kickstartWizardModel.MetadataSource == MetadataSource.Grpc ? _protoToKProtoConverter.Convert("zzz", kickstartWizardModel.ProtoFileText) : null;

                //this will override whatever user typed on first standard VS dialog
                if (kickstartWizardModel.CurrentStep == KickstartWizardModel.Step.ProtoFile)
                {
                    kickstartWizardModel.SolutionName = InferSolutionName(kProtoFile);
                    kickstartWizardModel.ProjectName  = InferProjectName(kProtoFile);
                }
                else
                {
                }

                var databaseProject = BuildDatabaseProject(kickstartWizardModel, kProtoFile);
                solution.Project.Add(databaseProject);

                var databaseTestProject = BuildDatabaseTestProject(kickstartWizardModel, kProtoFile);
                solution.Project.Add(databaseTestProject);

                //_databaseSqlView.Bind(databaseProject);

                //if (_currentStep == Step.GenerationStart)
                {
                    var dataLayerProject = BuildDataLayerProject(kickstartWizardModel, databaseProject);
                    var grpcProject      = BuildGrpcProject(kickstartWizardModel, databaseProject, dataLayerProject, kProtoFile);
                    solution.Project.Add(grpcProject);

                    solution.Project.Add(dataLayerProject);
                }
            }
            else if (kickstartWizardModel.MetadataSource == MetadataSource.SqlScripts)
            {
                var databaseProjectStart = BuildDatabaseProject(kickstartWizardModel, null);

                var connectionString = "Server=localhost;";
                var outputRootPath   = string.Empty;

                var databaseProject = _dbToKSolutionConverter.BuildSqlMeta(connectionString, outputRootPath, databaseProjectStart);

                var dataLayerProject = BuildDataLayerProject(kickstartWizardModel, databaseProject);

                solution.Project.Add(databaseProject);
                solution.Project.Add(dataLayerProject);

                var grpcProject = BuildGrpcProject(kickstartWizardModel, databaseProject, dataLayerProject, null);
                grpcProject.CompanyName = kickstartWizardModel.CompanyName;
                solution.Project.Add(grpcProject);

                var protoFiles = _dataLayerProjectToKProtoFileConverter.Convert(databaseProject, dataLayerProject, grpcProject);
                foreach (var pf in protoFiles)
                {
                    grpcProject.ProtoFile.Add(pf);
                }
                //_databaseSqlStep.Bind(databaseProject);

                var pf3 = protoFiles.FirstOrDefault();
                if (pf3 != null)
                {
                    pf3.ProtoFileText = _protoFileToProtoFileConverter.Convert(pf3.GeneratedProtoFile);
                    // _protoFileView.Bind(pf3);
                }
            }


            if (kickstartWizardModel.CreateGrpcServiceTestClientProject)
            {
                solution.Project.Add(new KGrpcServiceClientTestProject {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }
            if (kickstartWizardModel.CreateDockerBuildProject)
            {
                solution.Project.Add(new KDockerBuildScriptProject {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }
            if (kickstartWizardModel.CreateGrpcUnitTestProject)
            {
                solution.Project.Add(new KGrpcServiceUnitTestProject {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }
            if (kickstartWizardModel.CreateIntegrationTestProject)
            {
                solution.Project.Add(new KGrpcServiceIntegrationTestProject {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }

            if (kickstartWizardModel.CreateWebAppProject)
            {
                solution.Project.Add(new KWebUIProject {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }

            if (kickstartWizardModel.CreateDockerComposeProject)
            {
                solution.Project.Add(new KDockerComposeProject()
                {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }

            if (kickstartWizardModel.CreateGrpcClientProject)
            {
                solution.Project.Add(new KGrpcClientProject()
                {
                    ProjectName = kickstartWizardModel.ProjectName
                });
            }
            return(solution);
        }