private void AddSchemas(CProject dataProject, KSolution mSolution, KDataStoreProject sqlKProject)
{
/*
* foreach (var mockView in sqlKProject.MockView)
* {
* AddSchema(dataProject, mockView.Schema.SchemaName);
* if (sqlKProject.KickstartAuditTables)
* AddSchema(dataProject, $"{mockView.Schema.SchemaName}");
*
* AddSchema(dataProject, $"{mockView.Schema.SchemaName}Api");
* }*/
foreach (var table in sqlKProject.Table)
{
AddSchema(dataProject, $"{table.GeneratedTable.Schema.SchemaName}");
}
foreach (var view in sqlKProject.View)
{
AddSchema(dataProject, $"{view.GeneratedView.Schema.SchemaName}");
}
foreach (var storeProcedure in sqlKProject.StoredProcedure)
{
AddSchema(dataProject, $"{storeProcedure.GeneratedStoredProcedure.Schema.SchemaName}");
}
}
public bool GenerateCSolution(KSolution solution)
{
if (solution.GeneratedSolution != null)
{
return(false);
;
}
var allGenerated = true;
foreach (var project in solution.Project
.OfType <KGrpcIntegrationProject>())
{
foreach (var rpcRef in project.ProtoRef)
{
if (rpcRef.RefSolution.GeneratedSolution == null)
{
allGenerated = false;
break;
}
}
}
if (!allGenerated)
{
return(false);
}
_solutionToCSolutionConverter.Convert(solution);
return(true);
}
public CProject BuildProject(KSolution kSolution, KDataStoreProject dataStoreKProject)
{
_dataStoreKProject = dataStoreKProject;
var kinesisProject = new CProject
{
ProjectName = dataStoreKProject.ProjectFullName,
ProjectShortName = dataStoreKProject.ProjectName,
ProjectFolder = dataStoreKProject.ProjectFolder,
ProjectType = CProjectType.FlywayProj
};
kinesisProject.TemplateProjectPath =
@"templates\NetStandard20ClassLibrary.csproj";
kinesisProject.ProjectIs = CProjectIs.DatabaseFlyway;
/*
* addFlyway(kinesisProject);
*
* AddSchemas(kinesisProject, kSolution, dataStoreKProject);
*
* var tables2 = dataStoreKProject.Table.Select(t => t.GeneratedTable).ToList();
* AddTables(kinesisProject, tables2);
*
* AddTableTypes(kinesisProject, dataStoreKProject.TableType.Select(tt=> tt.GeneratedTableType).ToList());
*
* if (true) //todo: add separate setting for CRUD vs GET
* AddGetStoredProcedures(kinesisProject, dataStoreKProject.StoredProcedure.Select(s=>s.GeneratedStoredProcedure).ToList());
*
*
* AddDmsRules(kinesisProject, tables2);
*/
return(kinesisProject);
}
public CProject BuildProject(KSolution kSolution, KDataStoreProject sqlKProject)
{
_sqlKProject = sqlKProject;
var dbProject = new CProject
{
ProjectName = sqlKProject.ProjectFullName,
ProjectShortName = sqlKProject.ProjectName,
ProjectFolder = sqlKProject.ProjectFolder,
ProjectType = CProjectType.FlywayProj
};
dbProject.TemplateProjectPath =
@"templates\NetStandard20ClassLibrary.csproj";
dbProject.ProjectIs = CProjectIs.DatabaseFlyway;
addFlyway(dbProject);
AddSchemas(dbProject, kSolution, sqlKProject);
var tables2 = sqlKProject.Table.Select(t => t.GeneratedTable).ToList();
AddTables(dbProject, tables2);
AddTableTypes(dbProject, sqlKProject.TableType.Select(tt => tt.GeneratedTableType).ToList());
if (true) //todo: add separate setting for CRUD vs GET
{
AddGetStoredProcedures(dbProject, sqlKProject.StoredProcedure.Select(s => s.GeneratedStoredProcedure).ToList());
}
AddDmsRules(dbProject, tables2);
return(dbProject);
}
public void Bind(KSolution templateSolution)
{
_templateSolution = templateSolution;
_textBoxSolutionName.Text = templateSolution.SolutionName;
_textBoxCompanyName.Text = templateSolution.CompanyName;
if (!string.IsNullOrEmpty(templateSolution.ProtoFileText))
{
_comboBoxSourceOfMetadata.SelectedIndex = 1;
}
else
{
_comboBoxSourceOfMetadata.SelectedIndex = 2;
}
foreach (var templateProject in _templateSolution.Project)
{
var projectControl = new ProjectOptionsControl();
var tabPage = new TabPage();
tabPage.Text = templateProject.ProjectShortName;
_tabControlProjects.TabPages.Add(tabPage);
tabPage.Controls.Add(projectControl);
projectControl.Dock = DockStyle.Fill;
projectControl.Bind(templateProject);
}
}
private CProject BuildGrpcProject(KSolution kSolution, KDataStoreProject databaseKProject,
KDataLayerProject dataLayerKProject, KGrpcProject grpcKProjectIn, CSolution solution, CProject sqlProject,
CProject dataProject)
{
var grpcProject = _grpcServiceProjectService.BuildProject(kSolution, databaseKProject, dataLayerKProject,
grpcKProjectIn, sqlProject, dataProject);
return(grpcProject);
}
public override CProject BuildProject(KSolution kSolution, KDataStoreProject databaseKProject,
KDataLayerProject dataLayerKProject, KGrpcProject grpcKProject, CProject sqlProject, CProject dataProject)
{
var project = base.BuildProject(kSolution, databaseKProject, dataLayerKProject, grpcKProject, sqlProject,
dataProject);
project.ProjectIs = CProjectIs.Grpc | CProjectIs.Service;
return(project);
}
private CProject BuildDataStoreProject(KSolution kSolution, KDataStoreProject dataStoreKProject)
{
var service = _dataStoreServiceFactory.Create(dataStoreKProject.DataStoreType);
if (service == null)
{
return(null);
}
return(service.BuildProject(kSolution, dataStoreKProject));
}
private void addTabPage(KSolution templateSolution)
{
var tabPage = new TabPage();
tabPage.Text = $"{templateSolution.SolutionName}";
var control = new SolutionOptionsControl();
tabPage.Controls.Add(control);
control.Dock = DockStyle.Fill;
control.Bind(templateSolution);
_tabControl.TabPages.Add(tabPage);
}
public KProtoFile BuildProtoFileFromKSolution(KSolution solution)
{
if (string.IsNullOrWhiteSpace(solution.ProtoFileText))
{
return(null);
}
try
{
var kProtoFile = Convert(solution.ProtoFileName, solution.ProtoFileText);
return(kProtoFile);
}
catch (ProtoCompileException)
{
return(null);
}
}
public CProject BuildSolutionFilesProject(KSolution mSolution)
{
var project = new CProject
{
ProjectName = "SolutionFiles",
ProjectShortName = "SolutionFiles",
ProjectFolder = string.Empty,
ProjectType = CProjectType.CsProj,
ProjectIs = CProjectIs.SolutionFiles
};
AddGitIgnoreFile(project);
AddNugetConfig(project);
AddRulesetFile(mSolution, project);
return(project);
}
public CProject BuildProject(KSolution kSolution, KGrpcClientProject grpcClientKProject)
{
_grpcClientKProject = grpcClientKProject;
var project = new CProject
{
ProjectName = grpcClientKProject.ProjectFullName,
ProjectShortName = grpcClientKProject.ProjectShortName,
ProjectFolder = grpcClientKProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = grpcClientKProject.ProjectIs
};
project.TemplateProjectPath = @"templates\NetStandard20ClassLibrary.csproj";
return(project);
}
private void AddRulesetFile(KSolution mSolution, CProject project)
{
var nuGetConfigFile = ReadResourceFile($".ruleset");
nuGetConfigFile = nuGetConfigFile.Replace("##CompanyName##", mSolution.CompanyName);
nuGetConfigFile = nuGetConfigFile.Replace("##SolutionName##", mSolution.SolutionName);
project.ProjectContent.Add(new CProjectContent
{
Content = new CText {
Text = nuGetConfigFile
},
BuildAction = CBuildAction.None,
File = new CFile
{
Folder = $@"",
FileName = $"{mSolution.CompanyName}.{mSolution.SolutionName}.ruleset",
Encoding = Encoding.ASCII
}
});
}
public CProject BuildProject(KSolution kSolution, KDataStoreProject dataStoreKProject, KDataStoreTestProject sqlTestKProject,
KDataLayerProject dataLayerKProject,
CProject dataStoreProject, CInterface dbProviderInterface, CClass dbProviderClass)
{
_dataStoreKProject = dataStoreKProject;
_sqlTestKProject = sqlTestKProject;
_dataLayerKProject = dataLayerKProject;
_dataStoreProject = dataStoreProject;
_dbProviderInterface = dbProviderInterface;
_dbProviderClass = dbProviderClass;
var dbTestProject = new CProject
{
ProjectName = sqlTestKProject.ProjectFullName,
ProjectShortName = sqlTestKProject.ProjectName,
ProjectFolder = sqlTestKProject.ProjectFolder,
ProjectType = CProjectType.CsProj
};
dbTestProject.ProjectReference.Add(dataStoreProject);
dbTestProject.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
AddTestInitializationClass(dbTestProject);
AddStartupContainerClass(dbTestProject);
AddTestDataServiceClass(dbTestProject);
AddTestDataServiceBuilderInterface(dbTestProject);
AddTestDataServiceBuilderClass(dbTestProject);
AddReadSqlScriptClass(dbTestProject);
AddSqlScriptInterface(dbTestProject);
AddSqlScriptClass(dbTestProject);
AddEmbeddedSqlCommandClass(dbTestProject);
AddEmbeddedSqlQueryClass(dbTestProject);
AddAssemblyExtensionClass(dbTestProject);
AddAppSettingsJson(dbTestProject);
AddDataServiceTestClass(dbTestProject);
AddNuGetRefs(dbTestProject);
return(dbTestProject);
}
public CProject BuildProject(KSolution kSolution, KDockerComposeProject dockerComposeKProject)
{
_dockerComposeKProject = dockerComposeKProject;
var project = new CProject
{
ProjectName = dockerComposeKProject.ProjectFullName,
ProjectShortName = dockerComposeKProject.ProjectShortName,
ProjectFolder = dockerComposeKProject.ProjectFolder,
ProjectType = CProjectType.DockerProj,
ProjectIs = dockerComposeKProject.ProjectIs
};
project.TemplateProjectPath = @"templates\Docker\docker-compose.dcproj";
var dockerComposeFile = new DockerComposeFileService().Build();
project.ProjectContent.Add(new CProjectContent {
Content = dockerComposeFile, File = new CFile {
FileName = "docker-compose.yml"
}, BuildAction = CBuildAction.None
});
return(project);
}
public CProject BuildProject(KSolution kSolution, KDataStoreProject dataStoreKProject)
{
return(new CProject {
Kickstart = false
});
}
private List <KSolutionGroup> GetSolutionGroups()
{
var solutionGroupList = new List <KSolutionGroup>();
_sl.SelectWorksheet("Solutions");
var colSolutionGroup = GetColumnIndex("SolutionGroupName");
var colSolutionName = GetColumnIndex("SolutionName");
var colCompanyName = GetColumnIndex("CompanyName");
var colDefaultSchemaName = GetColumnIndex("DefaultSchemaName");
var colKickstartdatabaseProject = GetColumnIndex("KickstartdatabaseProject");
var colKickstartDataProject = GetColumnIndex("KickstartDataProject");
var colKickstartAuditTables = GetColumnIndex("KickstartAuditTables");
var colKickstartCRUDStoredProcedures = GetColumnIndex("KickstartCRUDStoredProcedures");
var colKickstartTableSeedScripts = GetColumnIndex("KickstartTableSeedScripts");
var colKickstartGrpcProjectFlag = GetColumnIndex("KickstartGrpcProjectFlag");
var colKickstartGrpcIntegrationProjectFlag = GetColumnIndex("KickstartGrpcIntegrationProjectFlag");
var colSqlViewFile = GetColumnIndex("SqlViewFile");
/*
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
* var col = GetColumnIndex("");
*/
var currentRow = 2;
var solutionGroup =
new KSolutionGroup {
SolutionGroupName = _sl.GetCellValueAsString(currentRow, colSolutionGroup)
};
solutionGroupList.Add(solutionGroup);
while (!string.IsNullOrEmpty(_sl.GetCellValueAsString(currentRow, colSolutionGroup)))
{
if (solutionGroup.SolutionGroupName != _sl.GetCellValueAsString(currentRow, colSolutionGroup))
{
solutionGroup = new KSolutionGroup
{
SolutionGroupName = _sl.GetCellValueAsString(currentRow, colSolutionGroup)
};
solutionGroupList.Add(solutionGroup);
}
var solution = new KSolution
{
SolutionName = _sl.GetCellValueAsString(currentRow, colSolutionName),
CompanyName = _sl.GetCellValueAsString(currentRow, colCompanyName)
/*
* DefaultSchemaName = _sl.GetCellValueAsString(currentRow, colDefaultSchemaName),
* KickstartdatabaseProject = _sl.GetCellValueAsBoolean(currentRow, colKickstartdatabaseProject),
* KickstartDataProject = _sl.GetCellValueAsBoolean(currentRow, colKickstartDataProject),
* KickstartAuditTables = _sl.GetCellValueAsBoolean(currentRow, colKickstartAuditTables),
* KickstartCRUDStoredProcedures = _sl.GetCellValueAsBoolean(currentRow, colKickstartCRUDStoredProcedures),
* KickstartTableSeedScripts = _sl.GetCellValueAsBoolean(currentRow, colKickstartTableSeedScripts),
*
* KickstartGrpcProjectFlag = _sl.GetCellValueAsBoolean(currentRow, colKickstartGrpcProjectFlag),
* KickstartGrpcIntegrationProjectFlag = _sl.GetCellValueAsBoolean(currentRow, colKickstartGrpcIntegrationProjectFlag),
*/
};
var databaseProject = new KDataStoreProject();
databaseProject.SqlViewFile = _sl.GetCellValueAsString(currentRow, colSqlViewFile);
solution.Project.Add(databaseProject);
solution.GeneratedSolution = new CSolution {
SolutionName = solution.SolutionName
};
solutionGroup.Solution.Add(solution);
currentRow++;
}
return(solutionGroupList);
}
public CProject BuildProject(KSolution mSolution, KDataStoreProject sqlKProject)
{
var dbProject = new CProject
{
ProjectName = sqlKProject.ProjectFullName, //$"{CompanyName}.{ProjectName}.{ProjectSuffix}",
ProjectShortName = sqlKProject.ProjectName, // $@"{ProjectName}.{ProjectSuffix}",
ProjectFolder = sqlKProject.ProjectFolder,
ProjectType = CProjectType.SqlProj
};
dbProject.TemplateProjectPath =
@"templates\SqlServer2014DbProject.sqlproj";
dbProject.ProjectIs = CProjectIs.DataBase;
var schemaConverter = new CSchemaToSqlServerSchemaConverter();
//create schema
AddSchemas(dbProject, mSolution, sqlKProject);
var tables2 = sqlKProject.Table.Select(t => t.GeneratedTable).ToList();
AddTables(dbProject, tables2);
var tables = GetTables(sqlKProject.MockView, false);
AddTables(dbProject, tables);
if (sqlKProject.KickstartAuditTables)
{
var auditTables = GetTables(sqlKProject.MockView, true);
//fixup the FK's
FixupAuditFKs(auditTables);
AddIsDeleteColumn(auditTables);
AddTables(dbProject, auditTables);
}
AddTableTypes(dbProject, sqlKProject.TableType);
AddViews(dbProject, sqlKProject.View);
var allTables = new List <CTable>();
allTables.AddRange(tables);
allTables.AddRange(tables2);
/*
* if (sqlKProject.KickstartCRUDStoredProcedures)
* {
* //AddInsertStoredProcedures(dataProject, tables);
* //AddUpdateStoredProcedures(dataProject, tables);
*
* AddInsertUpdateStoredProcedures(dbProject, allTables);
* //AddInsertUpdateStoredProcedures(dbProject, tables2);
*
* }*/
if (true) //todo: add separate setting for CRUD vs GET
{
AddGetStoredProcedures(dbProject, sqlKProject.StoredProcedure);
}
/*
* if (sqlMProject.KickstartCRUDStoredProcedures)
* {
* //delete stored procedures
* AddDeleteStoredProcedures(dbProject, allTables);
* //AddDeleteStoredProcedures(dbProject, tables2);
* }
*/
if (sqlKProject.KickstartTableSeedScripts)
{
AddSeedScripts(dbProject, allTables);
}
return(dbProject);
}
public CProject BuildProject(KSolution kSolution, KGrpcProject mGrpcProject,
KGrpcServiceClientTestProject grpcMServiceClientTestProject, CProject grpcProject, bool addProtoRef = false)
{
_kSolution = kSolution;
_mGrpcProject = mGrpcProject;
_grpcMServiceClientTestProject = grpcMServiceClientTestProject;
var project = new CProject
{
ProjectName = grpcMServiceClientTestProject.ProjectFullName,
ProjectShortName = grpcMServiceClientTestProject.ProjectShortName,
ProjectFolder = grpcMServiceClientTestProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = CProjectIs.Test | CProjectIs.Client,
StartupObject =
$"{grpcMServiceClientTestProject.CompanyName}.{grpcMServiceClientTestProject.ProjectName}{grpcMServiceClientTestProject.NamespaceSuffix}.{grpcMServiceClientTestProject.ProjectSuffix}.Program"
};
project.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
project.NuGetReference.Add(new CNuGet {
NuGetName = "Microsoft.NET.Test.Sdk", Version = "15.3.0"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "Moq", Version = "4.7.99"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestAdapter", Version = "1.1.18"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestFramework", Version = "1.1.18"
});
var testClasses = new List <CClass>();
foreach (var protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
{
var testClass = BuildTestClass(protoService);
testClasses.Add(testClass);
project.ProjectContent.Add(new CProjectContent
{
Content = testClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{testClass.ClassName}.cs"
}
});
}
if (addProtoRef)
{
AddProtoRpcRef(project, protoFile.GeneratedProtoFile);
}
}
AddProgramClass(project, grpcProject, testClasses);
AddProtoBatchFile(project);
project.ProjectReference.Add(grpcProject);
return(project);
}
public void AddAllProjectsToMasterSln(KSolution solution, string outputRootPath, string solutionName)
{
AddAllProjectsToMasterSln(solution.GeneratedSolution, outputRootPath, solutionName);
}
public CProject BuildProject(KSolution mSolution, KGrpcIntegrationProject grpcKIntegrationProject,
IList <KProtoRef> protoRpcRefs)
{
_kSolution = mSolution;
_grpcKProject = grpcKIntegrationProject;
var project = new CProject
{
ProjectName = grpcKIntegrationProject.ProjectFullName,
ProjectShortName = grpcKIntegrationProject.ProjectShortName,
ProjectFolder = grpcKIntegrationProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = CProjectIs.Grpc | CProjectIs.Integration | CProjectIs.Service,
TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj"
};
//AddLoggerClass(project);
//AddGitIgnoreFile(project);
AddProtoRpcRefs(project, protoRpcRefs);
//AddProtoBatchFile(project);
if (protoRpcRefs.Count > 0)
{
AddProtoRefBatchFile(project);
}
AddAppClass(project);
//AddLogEvents(project);
if (_grpcKProject is KGrpcIntegrationProject)
{
AddApiHosts(project);
AddLimitsSettings(project);
}
AddServiceSettings(project);
AddVersionTxt(project);
var containerClass = _containerClassBuilder.AddContainerClass(_grpcKProject, DataStoreTypes.Unknown, project, null, null, null, null);
AddStartupAppServices(project, null, null);
// var mediatorInterface = AddIMediatorInterface(project);
//AddMediatorClass(project, mediatorInterface);
AddDockerFile(project);
AddNugetRefs(project);
AddAppSettingsJson(project, grpcKIntegrationProject.ProtoFile.FirstOrDefault()?.GeneratedProtoFile);
foreach (var protoFile in grpcKIntegrationProject.ProtoFile)
{
AddProtoFile(project, protoFile.GeneratedProtoFile);
//AddProtoFileRefs(project, protoFileRefs);
AddQuery(project, null, protoFile.GeneratedProtoFile);
AddHandlers(project, null, null, grpcKIntegrationProject, protoFile.GeneratedProtoFile);
foreach (var service in protoFile.GeneratedProtoFile.ProtoService)
{
var protoNamespace = protoFile.GeneratedProtoFile.CSharpNamespace; //
if (string.IsNullOrEmpty(protoNamespace))
{
protoNamespace =
$@"{grpcKIntegrationProject.CompanyName}.{grpcKIntegrationProject.ProjectName}.{
grpcKIntegrationProject.ProjectSuffix
}.Proto.Types";
}
var implClass = _serviceImplClassBuilder.BuildServiceImplClass(_grpcKProject, service, protoFile.CSharpNamespace);
project.ProjectContent.Add(new CProjectContent
{
Content = implClass,
BuildAction = _grpcKProject.DotNetType == DotNetType.Framework ? CBuildAction.Compile : CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"Implementation", FileName = $"{implClass.ClassName}.cs"
}
});
}
}
AddStartupGrpcClass(project, grpcKIntegrationProject.ProtoFile);
AddProgramClass(project, containerClass);
return(project);
}
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);
}
public void Convert(KSolution kSolution)
{
var solution = new CSolution {
SolutionName = $"{kSolution.CompanyName}.{kSolution.SolutionName}"
};
var integrationTestSolution = new CSolution
{
SolutionName = $"{kSolution.CompanyName}.{kSolution.SolutionName}.IntegrationTests"
};
bool generatedSomething = true;
while (generatedSomething)
{
generatedSomething = false;
foreach (var kProject in kSolution.Project)
{
_logger.LogInformation("Generating projects for KProject: {project}", kProject.ProjectName);
bool dependenciesAllGenerated = !kProject.DependsOnProject.Any(p => p.GeneratedProject == null);
if (dependenciesAllGenerated)
{
if (kProject.GeneratedProject != null)
{
continue;
}
if (kProject is KWebUIProject)
{
var webAppProject = kProject as KWebUIProject;
var webAppService =
new WebAppProjectService {
};
var webAppCProject = webAppService.BuildProject(webAppProject);
kProject.GeneratedProject = webAppCProject;
if (webAppProject.Kickstart)
{
solution.Project.Add(webAppCProject);
}
}
if (kProject is KDockerComposeProject)
{
var dockerComposeKProject = kProject as KDockerComposeProject;
var dockerComposeProjectService = new DockerComposeProjectService();
var dockerComposeCProject = dockerComposeProjectService.BuildProject(kSolution, dockerComposeKProject);
kProject.GeneratedProject = dockerComposeCProject;
if (dockerComposeCProject.Kickstart)
{
solution.Project.Add(dockerComposeCProject);
}
}
if (kProject is KGrpcClientProject)
{
var kGrpcClientProject = kProject as KGrpcClientProject;
var grpcClientProjectService = new GrpcClientProjectService();
var grpcClientCProject = grpcClientProjectService.BuildProject(kSolution, kGrpcClientProject);
kProject.GeneratedProject = grpcClientCProject;
if (grpcClientCProject.Kickstart)
{
solution.Project.Add(grpcClientCProject);
}
}
if (kProject is KDataStoreProject)
{
var dataStoreKProject = kProject as KDataStoreProject;
CProject dataStoreProject = BuildDataStoreProject(kSolution, dataStoreKProject);
if (dataStoreProject != null)
{
kProject.GeneratedProject = dataStoreProject;
if (dataStoreKProject.Kickstart && dataStoreProject.Kickstart)
{
solution.Project.Add(dataStoreProject);
}
_logger.LogInformation("Generated data store project {project}", dataStoreProject.ProjectName);
generatedSomething = true;
}
else
{
kProject.GeneratedProject = new CNullProject();
_logger.LogInformation("Kipped data store project {project}", kProject.ProjectName);
generatedSomething = true; //tell a white lie
}
}
else if (kProject is KDataLayerProject)
{
CProject dataProject = null;
var sqlKProject = kProject.DependsOnProject.FirstOrDefault(k => k is KDataStoreProject) as KDataStoreProject;
var sqlProject = sqlKProject?.GeneratedProject;
var allStoredProcedures = new List <CStoredProcedure>();
if (sqlProject != null)
{
foreach (var pc in sqlProject.ProjectContent)
{
if (pc.Content is CStoredProcedure)
{
allStoredProcedures.Add(pc.Content as CStoredProcedure);
}
}
}
var dataLayerKProject = kProject as KDataLayerProject;
dataProject = _dataLayerServiceFactory.Create(dataLayerKProject.ConnectsToDatabaseType).BuildProject(sqlKProject, dataLayerKProject, allStoredProcedures,
sqlKProject?.Table, sqlKProject?.TableType, sqlKProject?.View);
kProject.GeneratedProject = dataProject;
if (dataLayerKProject.Kickstart)
{
solution.Project.Add(dataProject);
}
generatedSomething = true;
foreach (var dbTest in kSolution.Project
.OfType <KDataStoreTestProject>())
{
var dataStoreProject = sqlKProject.GeneratedProject;
var kDataStoreTestProject = dbTest as KDataStoreTestProject;
var service = _dataStoreTestServiceFactory.Create(kDataStoreTestProject.DataStoreType);
if (service != null)
{
var dbProviderInterface = dataProject.Interface.First(i =>
i.InheritsFrom?.InterfaceName == "IDbProvider");
var dbProviderClass = dataProject.Class.First(c =>
c.Implements.Exists(i => i.InterfaceName == dbProviderInterface.InterfaceName));
if (kDataStoreTestProject.Kickstart && kDataStoreTestProject.Kickstart)
{
solution.Project.Add(service.BuildProject(kSolution, sqlKProject,
kDataStoreTestProject, dataLayerKProject, dataStoreProject,
dbProviderInterface, dbProviderClass));
}
// kDataStoreTestProject, dataStoreProject));
}
}
}
else if (kProject is KGrpcIntegrationProject)
{
var sqlKProject = kProject.DependsOnProject.FirstOrDefault(k => k is KDataStoreProject) as KDataStoreProject;
var dataLayerKProject = kProject.DependsOnProject.FirstOrDefault(k => k is KDataLayerProject) as KDataLayerProject;
var kGrpcProject = kProject.DependsOnProject.FirstOrDefault(k => k is KGrpcProject) as KGrpcProject;
if (sqlKProject != null && dataLayerKProject != null)
{
var sqlProject = sqlKProject.GeneratedProject;
var dataLayerProject = dataLayerKProject.GeneratedProject;
var grpcIntegrationProject = BuildGrpcProject(kSolution, sqlKProject, dataLayerKProject, kGrpcProject,
solution, sqlProject, dataLayerProject);
kProject.GeneratedProject = grpcIntegrationProject;
solution.Project.Add(grpcIntegrationProject);
}
else
{
var grpcKIntegrationProject = kProject as KGrpcIntegrationProject;
var grpcIntegrationProject = _grpcIntegrationServiceProjectService.BuildProject(kSolution,
grpcKIntegrationProject, grpcKIntegrationProject.ProtoRef);
kProject.GeneratedProject = grpcIntegrationProject;
solution.Project.Add(grpcIntegrationProject);
}
generatedSomething = true;
}
else if (kProject is KGrpcProject)
{
var sqlKProject = kProject.DependsOnProject.FirstOrDefault(k => k is KDataStoreProject) as KDataStoreProject;
var sqlProject = sqlKProject?.GeneratedProject;
var dataLayerKProject = kProject.DependsOnProject.FirstOrDefault(k => k is KDataLayerProject) as KDataLayerProject;
var dataLayerProject = dataLayerKProject?.GeneratedProject;
var kGrpcProject = kProject as KGrpcProject;//.DependsOnProject.First(k => k is KGrpcProject) as KGrpcProject;
var grpcProject = BuildGrpcProject(kSolution, sqlKProject, dataLayerKProject, kGrpcProject,
solution, sqlProject, dataLayerProject);
kProject.GeneratedProject = grpcProject;
if (kGrpcProject.Kickstart)
{
solution.Project.Add(grpcProject);
}
foreach (var grpcUnitTestProject in kSolution.Project.OfType <KGrpcServiceUnitTestProject>())
{
solution.Project.Add(_grpcServiceUnitTestProjectService.BuildProject(kGrpcProject,
grpcUnitTestProject, grpcProject));
}
foreach (var grpcClientTestProject in kSolution.Project
.OfType <KGrpcServiceClientTestProject>())
{
solution.Project.Add(_grpcServiceClientTestProjectService.BuildProject(kSolution, kGrpcProject,
grpcClientTestProject, grpcProject));
}
foreach (var grpcIntegrationBusinessTestProject in kSolution.Project
.OfType <KGrpcIntegrationBusinessTestProject>())
{
var grpcIntegrationTestBusinessProject =
_grpcServiceIntegrationBusinessTestProjectService.BuildProject(
grpcIntegrationBusinessTestProject, grpcProject, kGrpcProject.ProtoFile, false);
integrationTestSolution.Project.Add(grpcIntegrationTestBusinessProject);
foreach (var grpcIntegrationTestProject in kSolution.Project
.OfType <KGrpcServiceIntegrationTestProject>())
{
integrationTestSolution.Project.Add(
_grpcServiceIntegrationTestProjectService.BuildProject(kGrpcProject,
grpcIntegrationTestProject, grpcIntegrationTestBusinessProject, false));
}
}
generatedSomething = true;
}
}
}
}
foreach (var mDockerBuildScriptProject in kSolution.Project
.OfType <KDockerBuildScriptProject>())
{
solution.Project.Add(_buildScriptService.Execute(kSolution.SolutionName, mDockerBuildScriptProject));
}
solution.Project.Add(_solutionFileService.BuildSolutionFilesProject(kSolution));
kSolution.GeneratedSolution = solution;
kSolution.GeneratedTestSolution = integrationTestSolution;
int x = 1;
}
public void ConvertOld(KSolution kSolution)
{
var solution = new CSolution {
SolutionName = $"{kSolution.CompanyName}.{kSolution.SolutionName}"
};
var integrationTestSolution = new CSolution
{
SolutionName = $"{kSolution.CompanyName}.{kSolution.SolutionName}.IntegrationTests"
};
foreach (var sqlKProject in kSolution.Project
.OfType <KDataStoreProject>())
{
var sqlProject = _dataStoreServiceFactory.Create(sqlKProject.DataStoreType).BuildProject(kSolution, sqlKProject);
if (sqlKProject.Kickstart)
{
solution.Project.Add(sqlProject);
}
var allStoredProcedures = new List <CStoredProcedure>();
foreach (var pc in sqlProject.ProjectContent)
{
if (pc.Content is CStoredProcedure)
{
allStoredProcedures.Add(pc.Content as CStoredProcedure);
}
}
foreach (var dataLayerProject in kSolution.Project
.OfType <KDataLayerProject>())
{
CProject dataProject = _dataLayerServiceFactory.Create(dataLayerProject.ConnectsToDatabaseType).BuildProject(sqlKProject, dataLayerProject, allStoredProcedures, sqlKProject.Table,
sqlKProject.TableType, sqlKProject.View);
solution.Project.Add(dataProject);
foreach (var grpcServiceIntegrationTestDbProject in kSolution.Project
.OfType <KGrpcServiceIntegrationTestDbProject>())
{
var dataIntegrationService = new GrpcServiceIntegrationTestDbProjectService();
var dataIntegrationTestProject =
dataIntegrationService.BuildProject(grpcServiceIntegrationTestDbProject);
integrationTestSolution.Project.Add(dataIntegrationTestProject);
}
foreach (var kGrpcProject in kSolution.Project
.OfType <KGrpcProject>())
{
var grpcProject = BuildGrpcProject(kSolution, sqlKProject, dataLayerProject, kGrpcProject,
solution, sqlProject, dataProject);
solution.Project.Add(grpcProject);
foreach (var grpcUnitTestProject in kSolution.Project.OfType <KGrpcServiceUnitTestProject>())
{
var grpcServiceUnitTestProjectService = new GrpcServiceUnitTestProjectService();
solution.Project.Add(grpcServiceUnitTestProjectService.BuildProject(kGrpcProject,
grpcUnitTestProject, grpcProject));
}
foreach (var grpcClientTestProject in kSolution.Project
.OfType <KGrpcServiceClientTestProject>())
{
solution.Project.Add(_grpcServiceClientTestProjectService.BuildProject(kSolution, kGrpcProject,
grpcClientTestProject, grpcProject));
}
foreach (var grpcIntegrationBusinessTestProject in kSolution.Project
.OfType <KGrpcIntegrationBusinessTestProject>())
{
var grpcIntegrationTestBusinessProject =
_grpcServiceIntegrationBusinessTestProjectService.BuildProject(
grpcIntegrationBusinessTestProject, grpcProject, kGrpcProject.ProtoFile, false);
integrationTestSolution.Project.Add(grpcIntegrationTestBusinessProject);
foreach (var grpcIntegrationTestProject in kSolution.Project
.OfType <KGrpcServiceIntegrationTestProject>())
{
integrationTestSolution.Project.Add(
_grpcServiceIntegrationTestProjectService.BuildProject(kGrpcProject,
grpcIntegrationTestProject, grpcIntegrationTestBusinessProject, false));
}
}
}
}
}
foreach (var grpcMIntegrationProject in kSolution.Project
.OfType <KGrpcIntegrationProject>())
{
var grpcIntegrationProject = _grpcIntegrationServiceProjectService.BuildProject(kSolution,
grpcMIntegrationProject, grpcMIntegrationProject.ProtoRef);
solution.Project.Add(grpcIntegrationProject);
foreach (var grpcUnitTestProject in kSolution.Project
.OfType <KGrpcServiceUnitTestProject>())
{
solution.Project.Add(_grpcServiceUnitTestProjectService.BuildProject(grpcMIntegrationProject,
grpcUnitTestProject, grpcIntegrationProject));
}
foreach (var grpcIntegrationBusinessTestProject in kSolution.Project
.OfType <KGrpcIntegrationBusinessTestProject>())
{
var project = _grpcServiceIntegrationBusinessTestProjectService.BuildProject(
grpcIntegrationBusinessTestProject, grpcIntegrationProject, grpcMIntegrationProject.ProtoFile,
true);
project.ProjectIs = CProjectIs.Integration | CProjectIs.Test | CProjectIs.Client;
integrationTestSolution.Project.Add(project);
}
foreach (var grpcClientTestProject in kSolution.Project
.OfType <KGrpcServiceClientTestProject>())
{
solution.Project.Add(_grpcServiceClientTestProjectService.BuildProject(kSolution, grpcMIntegrationProject,
grpcClientTestProject, grpcIntegrationProject));
}
}
foreach (var mDockerBuildScriptProject in kSolution.Project
.OfType <KDockerBuildScriptProject>())
{
solution.Project.Add(_buildScriptService.Execute(kSolution.SolutionName, mDockerBuildScriptProject));
}
solution.Project.Add(_solutionFileService.BuildSolutionFilesProject(kSolution));
kSolution.GeneratedSolution = solution;
kSolution.GeneratedTestSolution = integrationTestSolution;
//return solution;
}
