public KDataStoreProject BuildDatabaseProject(KickstartWizardModel kickstartWizardModel, KProtoFile kProtoFile)
{
KDataStoreProject databaseProject = new KDataStoreProject {
CompanyName = kickstartWizardModel.CompanyName, ProjectName = kickstartWizardModel.ProjectName, KickstartCRUDStoredProcedures = false, Kickstart = kickstartWizardModel.CreateDatabaseProject
};
databaseProject.GenerateStoredProcAsEmbeddedQuery = kickstartWizardModel.GenerateStoredProcAsEmbeddedQuery;
databaseProject.ConvertToSnakeCase = kickstartWizardModel.ConvertToSnakeCase;
databaseProject.DataStoreType = kickstartWizardModel.DatabaseType;
if (kickstartWizardModel.MetadataSource == MetadataSource.Grpc && !kickstartWizardModel.HasSql())
{
databaseProject.InferSqlFromProto(kProtoFile);
}
else if (kickstartWizardModel.MetadataSource == MetadataSource.SqlScripts || kickstartWizardModel.HasSql())
{
databaseProject.SqlTableText = kickstartWizardModel.SqlTableText;
databaseProject.SqlTableTypeText = kickstartWizardModel.SqlTableTypeText;
databaseProject.SqlStoredProcedureText = kickstartWizardModel.SqlStoredProcText;
}
return(databaseProject);
}
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 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 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 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);
}
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 ConvertMockViewsToTables(KDataStoreProject mDatabaseProject)
{
foreach (var view in mDatabaseProject.MockView)
{
var table = _cViewToCTableConverter.Convert(view.GeneratedView);
mDatabaseProject.Table.Add(new KTable
{
Schema = new CSchema {
SchemaName = table.Schema.SchemaName
},
TableName = table.TableName,
GeneratedTable = table
});
}
mDatabaseProject.MockView.Clear();
}
private void AddDeleteStoredProcedures(KDataStoreProject mDatabaseProject)
{
var deleteStoredProcedures = new List <KStoredProcedure>();
foreach (var table in Enumerable.Reverse(mDatabaseProject.Table))
{
var storedProcedure = _cTableToSStoredProcedureDeleteConverter.Convert(table.GeneratedTable);
deleteStoredProcedures.Add(new KStoredProcedure
{
StoredProcedureName = storedProcedure.StoredProcedureName,
ParameterSetName = storedProcedure.ParameterSetName,
ResultSetName = storedProcedure.ResultSetName,
GeneratedStoredProcedure = storedProcedure
});
}
mDatabaseProject.StoredProcedure.AddRange(deleteStoredProcedures);
}
private void AddInsertUpdateStoredProcedures(KDataStoreProject mDatabaseProject)
{
//merge version of stored procs
//update stored procedures
var addUpdateStoredProcedures = new List <KStoredProcedure>();
foreach (var table in mDatabaseProject.Table)
{
var storedProcedure = _cTableToSqlServerStoredProcedureAddUpdateConverter.Convert(table.GeneratedTable);
addUpdateStoredProcedures.Add(new KStoredProcedure
{
StoredProcedureName = storedProcedure.StoredProcedureName,
ParameterSetName = storedProcedure.ParameterSetName,
ResultSetName = storedProcedure.ResultSetName,
GeneratedStoredProcedure = storedProcedure
});
}
mDatabaseProject.StoredProcedure.AddRange(addUpdateStoredProcedures);
}
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 KDataStoreProject BuildSqlMeta(string connectionString, string outputRootPath,
KDataStoreProject dataStoreProject)
{
dataStoreProject.ClearSqlMeta(); //clear what was generated during user config, going to regenerate
var stopWatch = Stopwatch.StartNew();
var connectionStringBuilder = new SqlConnectionStringBuilder(connectionString);
var timeString = DateTime.Now.ToString("yyyyMMddHHmmss");
var newDbName = $"WorkDb{timeString}";
connectionStringBuilder.InitialCatalog = "master";
connectionStringBuilder.IntegratedSecurity = true;
//connectionStringBuilder.UserID = "fillthisin";
//connectionStringBuilder.Password = "******";
connectionStringBuilder.ConnectTimeout = 60;
var scriptGen = new Sql120ScriptGenerator();
using (var sqlConnection = new SqlConnection(connectionStringBuilder.ConnectionString))
{
sqlConnection.Open();
var createDatabaseStatement =
new CreateDatabaseStatement {
DatabaseName = new Identifier {
Value = newDbName
}
};
string createDatabaseScriptOut;
scriptGen.GenerateScript(createDatabaseStatement, out createDatabaseScriptOut);
var sqlCommandCreateDatabase = new SqlCommand(createDatabaseScriptOut, sqlConnection);
sqlCommandCreateDatabase.ExecuteNonQuery();
sqlConnection.Close();
}
connectionStringBuilder.InitialCatalog = newDbName;
if (!string.IsNullOrEmpty(dataStoreProject.SqlTableText))
{
var tableNames = CreateSqlTablesInDb(dataStoreProject, connectionStringBuilder.ConnectionString,
dataStoreProject.SqlTableText);
foreach (var tablePair in tableNames)
{
_sqlServerTableReader.ConnectionString = connectionStringBuilder.ConnectionString;
var dataReader = _sqlServerTableReader.Read(tablePair.Schema.SchemaName, tablePair.TableName);
var foreignKeyData = _sqlServerTableReader.ReadForeignKeys(tablePair.Schema.SchemaName, tablePair.TableName);
var table2 = _sqlServerTableToCTableConverter.Convert(dataReader, foreignKeyData);
table2.TableText = tablePair.TableText;
table2.DatabaseType = dataStoreProject.DataStoreType;
table2.ConvertToSnakeCase = dataStoreProject.ConvertToSnakeCase;
tablePair.GeneratedTable = table2;
dataStoreProject.Table.Add(tablePair);
}
_sqlServerTableToCTableConverter.FixupForeignKeyTables(dataStoreProject.Table.Select(kt => kt.GeneratedTable));
foreach (var tablePair in tableNames)
{
tablePair.GeneratedTable.DerivedFrom = tablePair.DerivedFrom;
}
}
if (!string.IsNullOrEmpty(dataStoreProject.MockSqlViewText))
{
var mockViewNames = CreateMockSqlViewsInDb(connectionStringBuilder.ConnectionString,
dataStoreProject.MockSqlViewText);
foreach (var viewPair in mockViewNames)
{
var dataReader = _sqlServerViewReader.Read(connectionStringBuilder.ConnectionString, viewPair.ViewName, viewPair.ViewText);
var view2 = _sqlServerViewToCViewConverter.Convert(dataReader);
if (dataStoreProject.KickstartCreatedBy)
{
AddCreatedByToView(view2);
}
if (dataStoreProject.KickstartCreatedDateUtc)
{
AddCreatedDateUtcToView(view2);
}
if (dataStoreProject.KickstartModifiedBy)
{
AddModifiedByToView(view2);
}
if (dataStoreProject.KickstartModifiedDateUtc)
{
AddModifiedDateUtcToView(view2);
}
if (dataStoreProject.KickstartLoadDateUtc)
{
AddLoadDateUtcToView(view2);
}
if (dataStoreProject.KickstartEffectiveDateUtc)
{
AddEffectiveDateUtcToView(view2);
}
if (dataStoreProject.KickstartHashDiff)
{
AddHashDiffToView(view2);
}
viewPair.GeneratedView = view2;
dataStoreProject.MockView.Add(viewPair);
}
}
if (!string.IsNullOrEmpty(dataStoreProject.SqlTableTypeText))
{
var tableTypeNames = CreateTableTypesInDb(dataStoreProject, connectionStringBuilder.ConnectionString,
dataStoreProject.SqlTableTypeText);
foreach (var tableType in tableTypeNames)
{
_sqlServerTableTypeReader.ConnectionString = connectionStringBuilder.ConnectionString;
var tt = _sqlServerTableTypeReader.Read(tableType.Schema, tableType.TableTypeName, tableType.TableTypeText);
tt.DerivedFrom = tableType.DerivedFrom as CPart;
tt.DatabaseType = dataStoreProject.DataStoreType;
tt.ConvertToSnakeCase = dataStoreProject.ConvertToSnakeCase;
tableType.GeneratedTableType = tt;
dataStoreProject.TableType.Add(tableType);
}
}
if (!string.IsNullOrEmpty(dataStoreProject.SqlViewText))
{
var viewNames =
CreateSqlViewsInDb(connectionStringBuilder.ConnectionString, dataStoreProject.SqlViewText);
foreach (var viewPair in viewNames)
{
var dataReader = _sqlServerViewReader.Read(connectionStringBuilder.ConnectionString, viewPair.ViewName, viewPair.ViewText);
var view2 = _sqlServerViewToCViewConverter.Convert(dataReader);
view2.DatabaseType = dataStoreProject.DataStoreType;
view2.ConvertToSnakeCase = dataStoreProject.ConvertToSnakeCase;
view2.ViewText = viewPair.ViewText;
viewPair.GeneratedView = view2;
dataStoreProject.View.Add(viewPair);
}
}
if (!string.IsNullOrEmpty(dataStoreProject.SqlFunctionText))
{
var functionNames =
CreateSqlFunctionsInDb(dataStoreProject, connectionStringBuilder.ConnectionString, dataStoreProject.SqlFunctionText);
foreach (var functionPair in functionNames)
{
var function2 = _sqlServerFunctionReader.Read(connectionStringBuilder.ConnectionString, functionPair.Schema.SchemaName, functionPair.FunctionName, functionPair.FunctionText);
//var function2 = _sqlServerFunctionToCFunctionConverter.Convert(dataReader);
functionPair.DatabaseType = dataStoreProject.DataStoreType;
functionPair.ConvertToSnakeCase = dataStoreProject.ConvertToSnakeCase;
functionPair.FunctionText = functionPair.FunctionText;
functionPair.GeneratedFunction = functionPair;
dataStoreProject.Function.Add(functionPair);
}
}
if (!string.IsNullOrEmpty(dataStoreProject.SqlStoredProcedureText))
{
var storedProcedureNames = CreateSqlStoredProcsInDb(dataStoreProject, connectionStringBuilder.ConnectionString,
dataStoreProject.SqlStoredProcedureText);
foreach (var sp in storedProcedureNames)
{
var storedProceure = _sqlServerStoredProcedureReader.Read(connectionStringBuilder.ConnectionString, sp.Schema, sp.StoredProcedureName, sp.StoredProcedureText);
storedProceure.DatabaseType = dataStoreProject.DataStoreType;
storedProceure.DerivedFrom = sp.DerivedFrom as CPart;
storedProceure.ConvertToSnakeCase = dataStoreProject.ConvertToSnakeCase;
sp.GeneratedStoredProcedure = storedProceure;
sp.GeneratedStoredProcedure.StoredProcedureDescription = sp.StoredProcedureDescription;
sp.GeneratedStoredProcedure.GenerateAsEmbeddedQuery = dataStoreProject.GenerateStoredProcAsEmbeddedQuery;
dataStoreProject.StoredProcedure.Add(sp);
}
}
if (dataStoreProject.Query.Any())
{
foreach (var kQuery in dataStoreProject.Query)
{
var reader =
new SqlServerQueryReader
{
ConnectionString = connectionStringBuilder.ConnectionString
};
kQuery.GeneratedQuery = new CQuery();
//databaseProject.Query.Add()
/*
* var query = reader.Read(sp.Schema, sp.StoredProcedureName, sp.StoredProcedureText);
* sp.GeneratedStoredProcedure = storedProceure;
* sp.GeneratedStoredProcedure.StoredProcedureDescription = sp.StoredProcedureDescription;
* databaseProject.StoredProcedure.Add(sp);
*/
}
}
DropWorkDb(connectionStringBuilder, newDbName);
dataStoreProject.ConfigureMetaData();
dataStoreProject.AddSeedData();
ConvertMockViewsToTables(dataStoreProject);
var currentSPs = new List <KStoredProcedure>();
currentSPs.AddRange(dataStoreProject.StoredProcedure);
dataStoreProject.StoredProcedure.Clear();
if (dataStoreProject.KickstartCRUDStoredProcedures)
{
AddInsertUpdateStoredProcedures(dataStoreProject);
}
dataStoreProject.StoredProcedure.AddRange(currentSPs);
if (dataStoreProject.KickstartCRUDStoredProcedures)
{
AddDeleteStoredProcedures(dataStoreProject);
}
dataStoreProject.ConfigureMetaData2();
//todo; clean this up
foreach (var sp in dataStoreProject.StoredProcedure)
{
sp.GeneratedStoredProcedure.ParameterSetName = sp.ParameterSetName;
sp.GeneratedStoredProcedure.ResultSetName = sp.ResultSetName;
sp.GeneratedStoredProcedure.ReturnsMultipleRows = sp.ReturnsMultipleRows;
}
/*
* var protoRpcRefs = new List<SProtoRpcRef>();
* foreach (var protoRpcRef in mSolution.ProtoRpcRef)
* {
*
* protoRpcRefs.Add(protoRpcRef);
* }*/
return(dataStoreProject);
}
public override async Task <SplitDDLResponse> SplitDDL(SplitDDLRequest request, ServerCallContext context)
{
var dataStoreType = DataStoreTypes.Unknown;
if (request.DatabaseType == DatabaseTypes.SqlServer)
{
dataStoreType = DataStoreTypes.SqlServer;
}
else if (request.DatabaseType == DatabaseTypes.Postgres)
{
dataStoreType = DataStoreTypes.Postgres;
}
else
{
throw new NotImplementedException();
}
KDataStoreProject result = null;
if (request.DatabaseType == DatabaseTypes.SqlServer)
{
var query = new SplitSqlServerDDLQuery()
{
DataStoreType = DataStoreTypes.SqlServer,
UnSplitStoredProcedureDDL = request.UnSplitStoredProcedureDDL,
UnSplitTableDDL = request.UnSplitTableDDL,
UnSplitViewDDL = request.UnSplitViewDDL,
UnSplitFunctionDDL = request.UnSplitFunctionDDL,
UnSplitTableTypeDDL = request.UnSplitTableTypeDDL
};
result = await _executor.ExecuteAsync(query).ConfigureAwait(false);
}
else if (request.DatabaseType == DatabaseTypes.Postgres)
{
var query = new SplitPostgresDDLQuery()
{
DataStoreType = DataStoreTypes.Postgres,
UnSplitStoredProcedureDDL = request.UnSplitStoredProcedureDDL,
UnSplitTableDDL = request.UnSplitTableDDL,
UnSplitViewDDL = request.UnSplitViewDDL,
UnSplitFunctionDDL = request.UnSplitFunctionDDL,
UnSplitTableTypeDDL = request.UnSplitTableTypeDDL
};
result = await _executor.ExecuteAsync(query).ConfigureAwait(false);
}
else
{
throw new NotImplementedException();
}
var response = new SplitDDLResponse();
using (var memoryStream = new MemoryStream())
{
using (var zipFile = new ZipArchive(memoryStream, ZipArchiveMode.Create))
{
foreach (var table in result.Table)
{
var fileName = _flywayFileNameService.GetFlywayFileName(new CTable(dataStoreType)
{
Schema = new CSchema {
SchemaName = table.Schema.SchemaName
},
TableName = table.TableName
});
var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
using (var writer = new StreamWriter(newEntry.Open()))
{
writer.Write(table.TableText);
}
}
foreach (var tableType in result.TableType)
{
var fileName = _flywayFileNameService.GetFlywayFileName(new CTableType(dataStoreType)
{
Schema = new CSchema {
SchemaName = tableType.Schema
},
TableName = tableType.TableTypeName
});
var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
using (var writer = new StreamWriter(newEntry.Open()))
{
writer.Write(tableType.TableTypeText);
}
}
foreach (var view in result.View)
{
var fileName = _flywayFileNameService.GetFlywayFileName(new CView()
{
Schema = new CSchema {
SchemaName = view.Schema.SchemaName
},
ViewName = view.ViewName
});
var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
using (var writer = new StreamWriter(newEntry.Open()))
{
writer.Write(view.ViewText);
}
}
foreach (var function in result.Function)
{
var fileName = _flywayFileNameService.GetFlywayFileName(new CFunction(dataStoreType)
{
Schema = new CSchema {
SchemaName = function.Schema.SchemaName
},
FunctionName = function.FunctionName
});
var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
using (var writer = new StreamWriter(newEntry.Open()))
{
writer.Write(function.FunctionText);
}
}
foreach (var storedProc in result.StoredProcedure)
{
var spFullName = storedProc.StoredProcedureName;
var schemaName = storedProc.Schema;
var spName = storedProc.StoredProcedureName;
var fileName = _flywayFileNameService.GetFlywayFileName(new CStoredProcedure(dataStoreType)
{
Schema = new CSchema {
SchemaName = schemaName
},
StoredProcedureName = spName
});
var newEntry = zipFile.CreateEntry(Path.Combine("migrations", fileName));
using (var writer = new StreamWriter(newEntry.Open()))
{
writer.Write(storedProc.StoredProcedureText);
}
}
}
response.ZipAsBase64 = Convert.ToBase64String(memoryStream.ToArray());
}
return(response);
}
private List <KFunction> CreateSqlFunctionsInDb(KDataStoreProject kDataStoreProject, string connectionString, string sqlText)
{
var functions = new List <KFunction>();
var scriptGen = new Sql120ScriptGenerator(new SqlScriptGeneratorOptions {
IncludeSemicolons = true
});
using (var sqlConnection = new SqlConnection(connectionString))
{
sqlConnection.Open();
var parser = new TSql120Parser(false);
var script2 = parser.Parse(new StringReader(sqlText), out var errors) as TSqlScript;
if (errors.Count > 0)
{
var errorList = new StringBuilder();
foreach (var error in errors)
{
errorList.AppendLine($"{error.Message}<br/>");
}
throw new ApplicationException(errorList.ToString());
}
for (var batchNo = 0; batchNo < script2.Batches.Count; batchNo++)
{
var batch2 = script2.Batches[batchNo];
//get the doc above the stored proc
var betweenBatchStart = 0;
if (batchNo > 0)
{
betweenBatchStart = script2.Batches[batchNo - 1].StartOffset +
script2.Batches[batchNo - 1].FragmentLength;
}
var betweenBatchEnd = batch2.StartOffset - 1;
string batchText = null;
if (betweenBatchEnd > 0)
{
batchText = sqlText.Substring(betweenBatchStart, betweenBatchEnd - betweenBatchStart);
//clean up the doc
batchText = batchText.Replace("GO", "");
batchText = batchText.Replace(Environment.NewLine, "");
batchText = batchText.Replace("\r", "");
batchText = batchText.Replace("/*", "");
batchText = batchText.Replace("*/", "");
batchText = batchText.Trim();
}
foreach (var statement in batch2.Statements)
{
var createFunctionStatement = statement as CreateFunctionStatement;
if (createFunctionStatement == null)
{
continue;
}
var viewSchemaName = createFunctionStatement.Name.SchemaIdentifier.Value;
var createSchemaCommand = new SqlCommand(
$@" IF NOT EXISTS (SELECT name FROM sys.schemas WHERE name = N'{viewSchemaName}')
BEGIN
EXEC sp_executesql N'CREATE SCHEMA {viewSchemaName}'
END", sqlConnection);
createSchemaCommand.ExecuteNonQuery();
scriptGen.GenerateScript(statement, out var scriptOut, out var errors2);
//fixup CTE
//var tempScript = scriptOut.Replace(Environment.NewLine, " ").ToUpper();
//might insert extra ; it won't hurt anything
if (scriptOut.Contains(" WITH "))
{
scriptOut = scriptOut.Replace(" WITH ", "; WITH ");
}
else if (scriptOut.Contains(Environment.NewLine + "WITH "))
{
scriptOut = scriptOut.Replace(Environment.NewLine + "WITH ", ";" + Environment.NewLine + " WITH ");
}
var sqlCommand = new SqlCommand(scriptOut, sqlConnection);
sqlCommand.ExecuteNonQuery();
var function = new KFunction(DataStoreTypes.SqlServer)
{
Schema = new CSchema()
{
SchemaName =
createFunctionStatement.Name.SchemaIdentifier.Value
},
FunctionName =
createFunctionStatement.Name.BaseIdentifier.Value,
FunctionText = scriptOut,
//StoredProcedureDescription = batchText,
ResultSetName = createFunctionStatement.Name.BaseIdentifier.Value + "Dto"// "ResultSet"
};
/*
* var oldStoredProc = kDataStoreProject.OldStoredProcedure.FirstOrDefault(s => s.StoredProcedureName == function.FunctionName); //todo: compare schema
* if (oldStoredProc != null)
* {
* function.DerivedFrom = oldStoredProc.DerivedFrom;
* }
*/
functions.Add(function);
}
}
sqlConnection.Close();
}
return(functions);
}
public CClass BuildDataServiceTestClass(KDataStoreProject sqlKProject, KDataLayerProject dataLayerKProject, KDataStoreTestProject sqlTestKProject, CInterface dbProviderInterface)
{
var @class = new CClass("EventCaptureDataServiceTest")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}"
},
ClassAttribute = new List <CClassAttribute>()
{
new CClassAttribute()
{
AttributeName = "TestClass"
}
}
};
AddNamespaceRefs(@class, dbProviderInterface);
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
FieldType = $"TestDataService<{dbProviderInterface.InterfaceName}>",
FieldName = "_testDataService"
});
@class.Method.Add(new CMethod()
{
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "ClassInitialize"
}
},
AccessModifier = CAccessModifier.Public,
IsStatic = true,
ReturnType = "void",
MethodName = "ClassInitialize",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "TestContext", ParameterName = "context"
}
},
CodeSnippet = $@"var testDataServiceBuilder =
TestInitialization.ServiceProvider.GetService<ITestDataServiceBuilder<{dbProviderInterface.InterfaceName}>>();
_testDataService = testDataServiceBuilder.Create();
_testDataService.SeedAsync()
.GetAwaiter()
.GetResult();"
});
var service = new DataLayerServiceProjectServiceBase();
foreach (var kStoredProcedure in sqlKProject.StoredProcedure)
{
if (!string.IsNullOrEmpty(kStoredProcedure.ParameterSetName))
{
var @entityClass = service.BuildParameterEntityClass(kStoredProcedure.GeneratedStoredProcedure, kStoredProcedure.ParameterSetName);
int x = 1;
}
if (!string.IsNullOrWhiteSpace(kStoredProcedure.ResultSetName))
{
var @entityClass = service.BuildResultEntityClass(kStoredProcedure.GeneratedStoredProcedure, kStoredProcedure.ResultSetName, dataLayerKProject);
@class.Method.Add(new CMethod()
{
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "TestMethod"
}
},
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task",
MethodName = $"Test{kStoredProcedure.StoredProcedureName}",
CodeSnippet = $@"var result = await _testDataService.Query(new EmbeddedSqlQuery<{@entityClass.ClassName}>(""{kStoredProcedure.StoredProcedureName}""));"
});
}
}
return(@class);
}
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);
}
private KGrpcProject BuildGrpcProject(KickstartWizardModel kickstartWizardModel, KDataStoreProject databaseProject, KDataLayerProject dataLayerProject, KProtoFile kProtoFile)
{
var grpcProject = new KGrpcProject()
{
CompanyName = kickstartWizardModel.CompanyName, ProjectName = kickstartWizardModel.ProjectName, Kickstart = kickstartWizardModel.CreateGrpcServiceProject
};
if (kProtoFile != null)
{
grpcProject.ProtoFile.Add(kProtoFile);
}
grpcProject.DependsOnProject.Add(databaseProject);
grpcProject.DependsOnProject.Add(dataLayerProject);
return(grpcProject);
}
private KDataLayerProject BuildDataLayerProject(KickstartWizardModel kickstartWizardModel, KDataStoreProject databaseProject)
{
var dataLayerProject = new KDataLayerProject(kickstartWizardModel.DatabaseType)
{
CompanyName = kickstartWizardModel.CompanyName, ProjectName = kickstartWizardModel.ProjectName, KickstartBulkStore = false, Kickstart = kickstartWizardModel.CreateDataLayerProject
};
var allStoredProcedures = new List <CStoredProcedure>();
var dataProject = _dataLayerServiceFactory.Create(databaseProject.DataStoreType).BuildProject(databaseProject, dataLayerProject, allStoredProcedures,
databaseProject?.Table, databaseProject?.TableType, databaseProject?.View);
if (databaseProject != null)
{
dataLayerProject.DependsOnProject.Add(databaseProject);
}
return(dataLayerProject);
}
public CProject BuildProject(KDataStoreProject databaseKProject, KDataLayerProject dataLayerKProject, IEnumerable <CStoredProcedure> storedProceduresIn, IEnumerable <KTable> tables, IEnumerable <KTableType> tableTypes, IEnumerable <CView> views)
{
_dataStoreKProject = databaseKProject;
_dataLayerKProject = dataLayerKProject;
var dataProject = new CProject
{
ProjectName = $"{dataLayerKProject.ProjectFullName}.{dataLayerKProject.ConnectsToDatabaseType}",
ProjectShortName = dataLayerKProject.ProjectShortName,
ProjectFolder = $"{dataLayerKProject.ProjectFolder}.{dataLayerKProject.ConnectsToDatabaseType}",
ProjectType = CProjectType.CsProj,
ProjectIs = CProjectIs.DataAccess
};
dataProject.TemplateProjectPath =
@"templates\NetStandard20ClassLibrary.csproj";
var dbProviderInterface = BuildDbProviderInterface();
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Interface = dbProviderInterface,
File = new CFile {
Folder = "Providers", FileName = $"{dbProviderInterface.InterfaceName}.cs"
}
});
var dbProvider = BuildDbProviderClass(dbProviderInterface);
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Class = dbProvider,
File = new CFile {
Folder = "Providers", FileName = $"{dbProvider.ClassName}.cs"
}
});
var dataHealthCheckInterface = BuildDataHealthCheckInterface();
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Interface = dataHealthCheckInterface,
File = new CFile {
Folder = "DataServices", FileName = $"{dataHealthCheckInterface.InterfaceName}.cs"
}
});
var baseDataService = BuildBaseDataServiceClass(dbProviderInterface);
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Class = baseDataService,
File = new CFile {
Folder = "DataServices\\Base", FileName = $"{baseDataService.ClassName}.cs"
}
});
var dataHealthCheckClass = BuildDataHealthCheckClass(dataHealthCheckInterface, baseDataService, dbProviderInterface);
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Class = dataHealthCheckClass,
File = new CFile {
Folder = "DataServices", FileName = $"{dataHealthCheckClass.ClassName}.cs"
}
});
var storedProcedures = databaseKProject.StoredProcedure.Select(s => s.GeneratedStoredProcedure).ToList();
var dtoClassesAll = BuildEntityClasses(storedProcedures, tables, tableTypes, views, dataProject);
var dataServiceInterface = BuildDataServiceInterface(dtoClassesAll);
dataLayerKProject.DataServiceInterface.Add(dataServiceInterface);
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Interface = dataServiceInterface,
File = new CFile {
Folder = "DataServices", FileName = $"{dataServiceInterface.InterfaceName}.cs"
}
});
var dataService = BuildDataServiceClass(dataServiceInterface, dbProviderInterface, dtoClassesAll);
dataProject.ProjectContent.Add(new CProjectContent
{
BuildAction = CBuildAction.DoNotInclude,
Class = dataService,
File = new CFile {
Folder = "DataServices", FileName = $"{dataService.ClassName}.cs"
}
});
if (_dataLayerKProject.ConnectsToDatabaseType == DataStoreTypes.Kinesis)
{
dataProject.NuGetReference.Add(new CNuGet {
NuGetName = "AWSSDK.S3", Version = "3.3.18.4"
});
}
else
{
throw new NotImplementedException();
}
return(dataProject);
}
private List <KTableType> CreateTableTypesInDb(KDataStoreProject kDataStoreProject, string connectionString, string sqlText)
{
var tableTypes = new List <KTableType>();
var scriptGen = new Sql120ScriptGenerator();
using (var sqlConnection = new SqlConnection(connectionString))
{
sqlConnection.Open();
var parser = new TSql120Parser(false);
var script2 = parser.Parse(new StringReader(sqlText), out var errors) as TSqlScript;
if (errors.Count > 0)
{
var errorList = new StringBuilder();
foreach (var error in errors)
{
errorList.AppendLine($"{error.Message}<br/>");
}
throw new ApplicationException(errorList.ToString());
}
foreach (var batch2 in script2.Batches)
{
foreach (var statement in batch2.Statements)
{
var createTypeTableStatement = statement as CreateTypeTableStatement;
if (createTypeTableStatement == null)
{
continue;
}
var viewSchemaName = createTypeTableStatement.Name.SchemaIdentifier.Value;
var createSchemaCommand = new SqlCommand(
$@" IF NOT EXISTS (SELECT name FROM sys.schemas WHERE name = N'{viewSchemaName}')
BEGIN
EXEC sp_executesql N'CREATE SCHEMA {viewSchemaName}'
END", sqlConnection);
createSchemaCommand.ExecuteNonQuery();
scriptGen.GenerateScript(statement, out var scriptOut);
var sqlCommand = new SqlCommand(scriptOut, sqlConnection);
sqlCommand.ExecuteNonQuery();
var tableType = new KTableType
{
Schema =
createTypeTableStatement.Name.SchemaIdentifier.Value,
TableTypeName =
createTypeTableStatement.Name.BaseIdentifier.Value,
TableTypeText = scriptOut
};
var oldTableType = kDataStoreProject.OldTableType.FirstOrDefault(tt => tt.TableTypeName == tableType.TableTypeName); //todo: compare schema
if (oldTableType != null)
{
tableType.DerivedFrom = oldTableType.DerivedFrom;
}
tableTypes.Add(tableType);
}
}
sqlConnection.Close();
}
return(tableTypes);
}
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 IList <KProtoFile> Convert(KDataStoreProject databaseProject, KDataLayerProject dataLayerProject,
KGrpcProject grpcKProject)
{
var protoFiles = new List <KProtoFile>();
_databaseProject = databaseProject;
foreach (var dataLayerInter in dataLayerProject.DataServiceInterface)
{
//var messagesToAddToBulkRpc = new List<SProtoMessage>();
var kProtoFile = new KProtoFile {
ProtoFileName = grpcKProject.ProjectName
};
kProtoFile.GeneratedProtoFile = BuildProtoFile(grpcKProject, kProtoFile,
$@"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Proto.Types");
protoFiles.Add(kProtoFile);
foreach (var method in dataLayerInter.Method)
{
var protoFile = kProtoFile.GeneratedProtoFile;
var protoService = protoFile.ProtoService.FirstOrDefault();
var storedProcedure = method.DerivedFrom as CStoredProcedure;
var storedProcedureList = method.DerivedFrom as CStoredProcList;
if (storedProcedure != null)
{
if (!storedProcedure.KickstartApi)
{
continue;
}
/*
* if (!grpcKProject.KickstartCRUD)
* {
* //filter out anything that is CRUD
* if (storedProcedure.DataOperationIs.HasFlag(SOperationIs.CRUD))
* {
* continue;
* }
*
* }*/
var rpc = BuildRpcFromStoredProc(protoFile, protoService, method, storedProcedure);
//if using Proto first, Rpc may already exist
if (!protoService.Rpc.Any(r => r.RpcName == rpc.RpcName))
{
protoService.Rpc.Add(rpc);
}
}
else if (storedProcedureList != null && storedProcedureList.List.Any())
{
var rpc = BuildBulkRpcFromStoredProcList(protoFile, protoService, method, storedProcedureList);
protoService.Rpc.Add(rpc);
}
else if (method.MethodIs.HasFlag(COperationIs.Bulk))
{
// if (addBulkRpc)
if (false)
{
/*
* var rpc = new SProtoRpc(protoService)
* {
* RpcName = $"{method.MethodName}",
* OperationIs = SOperationIs.Bulk | SOperationIs.Add | SOperationIs.Update | SOperationIs.Delete
* };
*
* var request = new SProtoMessage
* {
* IsRequest = true,
* MessageName = $"{rpc.RpcName}Request"
*
* };
*
* rpc.Request = request;
* foreach (var message in messagesToAddToBulkRpc)
* {
* request.ProtoField.Add(new SProtoMessageField(null) { IsScalar = false, Repeated = true, MessageType = message.MessageName, FieldName = $"{message.MessageName}" });
* }
*
* var response = new SProtoMessage
* {
* IsResponse = true,
* MessageName = $"{rpc.RpcName}Response"
* };
* rpc.Response = response;
*
*
* protoService.Rpc.Add(rpc);*/
}
}
}
}
return(protoFiles);
}
private List <KTable> CreateSqlTablesInDb(KDataStoreProject kDataStoreProject, string connectionString, string sqlText)
{
var tablesNames = new List <KTable>();
var scriptGen = new Sql120ScriptGenerator();
using (var sqlConnection = new SqlConnection(connectionString))
{
sqlConnection.Open();
var parser = new TSql120Parser(false);
var script2 = parser.Parse(new StringReader(sqlText), out var errors) as TSqlScript;
if (errors.Count > 0)
{
var errorList = new StringBuilder();
foreach (var error in errors)
{
errorList.AppendLine($"{error.Message}<br/>");
}
throw new ApplicationException(errorList.ToString());
}
foreach (var batch2 in script2.Batches)
{
foreach (var statement in batch2.Statements)
{
var createTableStatement = statement as CreateTableStatement;
var alterTableStatement = statement as AlterTableStatement;
if (createTableStatement == null && alterTableStatement == null)
{
continue;
}
string viewSchemaName = string.Empty;
if (createTableStatement != null)
{
viewSchemaName = createTableStatement.SchemaObjectName.SchemaIdentifier.Value;
}
else if (alterTableStatement != null)
{
viewSchemaName = alterTableStatement.SchemaObjectName.SchemaIdentifier.Value;
}
var createSchemaCommand = new SqlCommand(
$@" IF NOT EXISTS (SELECT name FROM sys.schemas WHERE name = N'{viewSchemaName}')
BEGIN
EXEC sp_executesql N'CREATE SCHEMA [{viewSchemaName}]'
END", sqlConnection);
createSchemaCommand.ExecuteNonQuery();
scriptGen.GenerateScript(statement, out var scriptOut);
var sqlCommand = new SqlCommand(scriptOut, sqlConnection);
sqlCommand.ExecuteNonQuery();
if (createTableStatement != null)
{
var oldKTable = kDataStoreProject.OldTable.FirstOrDefault(t =>
t.Schema.SchemaName == createTableStatement.SchemaObjectName.SchemaIdentifier.Value &&
t.TableName == createTableStatement.SchemaObjectName.BaseIdentifier.Value);
//copy some attributes
var newKTable = new KTable
{
Schema =
new CSchema
{
SchemaName = createTableStatement.SchemaObjectName.SchemaIdentifier.Value
},
TableName =
createTableStatement.SchemaObjectName.BaseIdentifier.Value,
TableText = scriptOut
};
if (oldKTable != null)
{
newKTable.DerivedFrom = oldKTable.DerivedFrom;
}
tablesNames.Add(newKTable);
}
else if (alterTableStatement != null)
{
//assumes ALTER TABLE come before CREATE TABLE
var existingTable = tablesNames.Single(t =>
t.Schema.SchemaName == alterTableStatement.SchemaObjectName.SchemaIdentifier.Value &&
t.TableName == alterTableStatement.SchemaObjectName.BaseIdentifier.Value);
existingTable.TableText += Environment.NewLine + "GO" + Environment.NewLine + Environment.NewLine;
existingTable.TableText += scriptOut;
existingTable.TableText += Environment.NewLine + "GO" + Environment.NewLine + Environment.NewLine;
}
}
}
sqlConnection.Close();
}
return(tablesNames);
}
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 kSolution, KDataStoreProject dataStoreKProject)
{
return(new CProject {
Kickstart = false
});
}
