public CClass ReadSqlScriptClass(KDataStoreTestProject sqlTestKProject, KDataLayerProject dataLayerKProject)
{
var @class = new CClass("ReadSqlScript")
{
IsStatic = true,
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
}
};
AddNamespaceRefs(sqlTestKProject, @class);
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Internal,
IsStatic = true,
ReturnType = "string",
MethodName = "FromEmbeddedResource",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "string", ParameterName = "scriptName"
}
},
CodeSnippet = $@"var sourceName = $""{dataLayerKProject.ProjectFullName}.EmbeddedSql.{{scriptName}}.esql"";
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.Contains("".Data.SqlServer""));
var dataAssembly = assemblies.First();
return dataAssembly.ReadToEndEmbeddedResource(sourceName);"
});
return(@class);
}
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 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(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);
}
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);
}
public CClass BuildResultEntityClass(CStoredProcedure storedProcedure, string resultSetName, KDataLayerProject dataLayerKProject)
{
if (string.IsNullOrEmpty(resultSetName))
{
return(null);
}
var converter = new CStoredProcedureToCClassConverter();
var @class = converter.ConvertByResultSet(storedProcedure);
//overrite the default namespace logic
@class.Namespace = new CNamespace
{
NamespaceName =
$"{dataLayerKProject.CompanyName}.{dataLayerKProject.ProjectName}{dataLayerKProject.NamespaceSuffix}.Data.Entities"
};
return(@class);
}
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);
}
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);
}
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);
}
