private static void runCab(int id)
{
// single iter
// get first
CSolution sol = new CSolution();
sol.orders.Add(DataContainer.getWhereId(id));
DataContainer.orders.Remove(DataContainer.getWhereId(id));
List<Order> avalible = GetAvalible(DataContainer.getWhereId(id).start, DataContainer.getWhereId(id).departTime);
sol.orders.Add(avalible[0]);
if (DataContainer.routes[sol.orders[1].start, sol.orders[0].finish] >
DataContainer.routes[sol.orders[1].start, sol.orders[1].finish])
{
sol.orders.Add(sol.orders[1]);
sol.orders.Add(sol.orders[0]);
}
else
{
sol.orders.Add(sol.orders[0]);
sol.orders.Add(sol.orders[1]);
}
File.WriteAllText("answer.txt", sol.ToString());
//while(avalible.Count > 0)
//{
//}
}
public void ShouldCreateSolutionWithMetaRepoProjectManualVerify()
{
//Arrange
var metaRepo = new MetaRepoBuilder().BuildSampleMetaRepo();
var project = new CProject()
{
ProjectName = "meta-repo", ProjectIs = CProjectIs.MetaRepo, ProjectType = CProjectType.MetaRepoProj
};
project.ProjectContent.Add(new CProjectContent {
Content = metaRepo, File = new CFile {
FileName = "metaproject.cmd", Encoding = Encoding.ASCII
}, BuildAction = CBuildAction.None
});
var solution = new CSolution()
{
SolutionName = "MetaSolution"
};
solution.Project.Add(project);
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IVisualStudioSolutionWriter, VisualStudioSolutionWriter>();
var serviceProvider = serviceCollection.BuildServiceProvider();
var writer = serviceProvider.GetRequiredService <IVisualStudioSolutionWriter>();
//Act
writer.Write(@"c:\temp\meta1\", solution);
//Assert
//todo: manual verification
}
CSolution GetActiveStdVerification(CSolution parent)
{
if (lstSolution.Exists(c => c.Type_sol == 3 && c.Solution_status == true && c.Parentid == parent.Id))
{
return(lstSolution.First(c => c.Type_sol == 3 && c.Solution_status == true && c.Parentid == parent.Id));
}
return(null);
}
public void AddAllProjectsToMasterSln(CSolution solution, string outputRootPath, string solutionName)
{
var masterSolutionPath = Path.Combine(outputRootPath, $"{solutionName}.sln");
CommandProcessor.ExecuteCommand($"dotnet new sln --name {solutionName}", outputRootPath);
foreach (var project in solution.Project)
{
AddProjectToSln(outputRootPath, solutionName, masterSolutionPath, project);
}
}
/// <summary>
/// Populate business objects from the data reader
/// </summary>
/// <param name="dataReader">data reader</param>
/// <returns>list of CSolution</returns>
internal List <CSolution> PopulateObjectsFromReader(IDataReader dataReader)
{
List <CSolution> list = new List <CSolution>();
while (dataReader.Read())
{
CSolution businessObject = new CSolution();
PopulateBusinessObjectFromReader(businessObject, dataReader);
list.Add(businessObject);
}
return(list);
}
public CSolution Convert(string slnPath)
{
var solution = new CSolution();
solution.SolutionName = Path.GetFileName(slnPath);
var rawSolution = SolutionParser.Parse(slnPath);
solution.SolutionPath = slnPath;
foreach (var rawProject in rawSolution.Projects)
{
//skip "folders"
if (rawProject.TypeGuid == Guid.Parse("{2150e333-8fdc-42a3-9474-1a3956d46de8}"))
{
continue;
}
var fullPath = Path.Combine(Path.GetDirectoryName(slnPath), rawProject.Path);
if (!File.Exists(fullPath))
{
continue;
}
var projectText = File.ReadAllText(fullPath);
if (IgnoreTestProjects && projectText.Contains("{3AC096D0-A1C2-E12C-1390-A8335801FDAB}"))
{
//test project
continue;
}
if (IgnoreTestProjects && rawProject.Name.Contains("Test"))
{
//test project
continue;
}
var project = new CProject {
};
project.ProjectGuid = rawProject.Guid;
project.ProjectShortName = rawProject.Name;
project.ProjectName = rawProject.Name;
project.Path = Path.Combine(Path.GetDirectoryName(slnPath), rawProject.Path);
project.HasDockerFile = HasDockerFile(project.Path);
var projectExtension = Path.GetExtension(project.Path).ToLower();
if (projectExtension == ".sqlproj")
{
project.ProjectType = CProjectType.SqlProj;
project.ProjectIs = CProjectIs.DataBase;
}
solution.Project.Add(project);
}
return(solution);
}
public void Visit(IVisitor visitor, CSolution solution)
{
_currentSolution = solution;
Directory.CreateDirectory(_fileWriter.RootPath);
solution.SolutionPath = Path.Combine(_fileWriter.RootPath, $"{solution.SolutionName}.sln");
CommandProcessor.ExecuteCommand($"dotnet new sln --name {solution.SolutionName} ", _fileWriter.RootPath);
foreach (var project in solution.Project)
{
if (string.IsNullOrEmpty(project.ProjectFolder))
{
_fileWriter.CurrentPath = _fileWriter.RootPath;
}
project.Accept(visitor);
}
}
public void Write(string outputRootPath, CSolution solution)
{
_fileWriter.RootPath = outputRootPath;
/*
* var visitor = new CVisualStudioVisitor(_logger, codeWriter,
* new FastSolutionVisitor(new CodeWriter(), fileWriter),
* new CProjectVisitor(_logger, new CodeWriter(), fileWriter),
* new CProjectFileVisitor(_logger, fileWriter, codeWriter), new CSharpCInterfaceVisitor(codeWriter),
* new CSharpCClassVisitor(codeWriter), new CSharpCMethodVisitor(codeWriter),
* new CSharpCPropertyVisitor(codeWriter),
* new CSharpCParameterVisitor(codeWriter),
* new CSharpCFieldVisitor(codeWriter),
* new CSharpCConstructorVisitor(codeWriter),
* null,
* new CSharpCClassAttributeVisitor(codeWriter),
* new CSharpCMethodAttributeVisitor(codeWriter));
*/
solution.Accept(_visualStudioVisitor);
//now that the .proto files and .cmd have been written to disk
//execute the .cmd to generate the .cs files
foreach (var project in solution.Project)
{
foreach (var pc in project.ProjectContent)
{
if (pc.Content is CBatchFile)
{
var batchFile = pc.Content as CBatchFile;
if (!batchFile.ExecutePostKickstart)
{
continue;
}
//todo: this probably won't run in Docker / Linux
var processStartInfo = new ProcessStartInfo();
processStartInfo.FileName = pc.File.FileName;
processStartInfo.WorkingDirectory = pc.File.WrittenToPath;
processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
processStartInfo.UseShellExecute = true;
Process.Start(processStartInfo);
//todo: verify success
}
}
}
}
void AddSecondSolution()
{
if (!lstSolution.Exists(c => c.Idsolution == 0 && c.Solution_status == true && c.Type_sol == 2))
{
CSolution firstSolution = GetActiveFirstSolution();
// --- añadir dentro de una solución intermedia 1
lstSolution.Add(
new CSolution
{
Idsolution = 0,
Id = GetMaxCorrelativeNode() + 1,
Parentid = firstSolution.Id,
Cod_solution = "Nueva solución intermedia 2", //modSolution.GetCorrelative(ModSolution.Correlative.SolucionIntermedia),
Date_begin = DateTime.Now,
Date_end = DateTime.Now.AddMonths(new CSettings().GetNumMonthSolInterm()),
Idelement = group_solution.Idelement,
Lote = "",
Observation = "",
Prepared_by = Comun.User_system.Iduser,
Purity = 0,
Solution_name = "",
Solution_status = true,
Type_sol = 2,
Volumen = 0,
Concentration = template_method_aa.Std_concentration_sol2,
Aliquot = 0,
Idreactive_medium = group_solution.Idreactive_medium,
Idreactive_modif = group_solution.Idreactive_modif,
Reactive_medium_value = GetMedium(2),
Image_index = 0
});
treeSolInterm.DataSource = new BindingList <CSolution>(lstSolution);
treeSolInterm.ExpandAll();
SetButtonsInProcess();
}
else
{
new FormMessage("Agregar solución", "No es posible agregar. Existe una solución intermedia 2 en proceso", true, false).ShowDialog();
}
}
public static CProtoFileRef GetProtoFileRef(this CSolution solution, string serviceName)
{
foreach (var project in solution.Project)
{
foreach (var pc in project.ProjectContent)
{
if (pc.Content is CProtoFileRef)
{
var protoFileRef = pc.Content as CProtoFileRef;
if (protoFileRef.ProtoFile.ProtoService.Exists(s => s.ServiceName == serviceName))
{
return(protoFileRef);
}
}
}
}
return(null);
}
/// <summary>
/// Select by primary key
/// </summary>
/// <param name="keys">primary keys</param>
/// <returns>CSolution business object</returns>
public CSolution SelectByPrimaryKey(CSolutionKeys keys)
{
NpgsqlCommand sqlCommand = new NpgsqlCommand();
sqlCommand.CommandText = "public.sp_solution_SelectByPrimaryKey";
sqlCommand.CommandType = CommandType.StoredProcedure;
// Use connection object of base class
sqlCommand.Connection = MainConnection;
try
{
sqlCommand.Parameters.Add(new NpgsqlParameter("p_idsolution", NpgsqlDbType.Integer, 4, "", ParameterDirection.Input, false, 0, 0, DataRowVersion.Proposed, keys.Idsolution));
MainConnection.Open();
NpgsqlDataReader dataReader = sqlCommand.ExecuteReader();
if (dataReader.Read())
{
CSolution businessObject = new CSolution();
PopulateBusinessObjectFromReader(businessObject, dataReader);
return(businessObject);
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw new Exception("CSolution::SelectByPrimaryKey::Error occured.", ex);
}
finally
{
MainConnection.Close();
sqlCommand.Dispose();
}
}
private List <CRepo> GetBlahRepos( )
{
var repos = new List <CRepo>();
var marketPlaceData = new CRepo {
Name = "sample-repo", Url = companyGit
};
var marketPlaceDataSolution1 = new CSolution
{
SolutionName = "Company.SampleService.SyncServices",
SolutionPath = @"Code\SyncServices"
};
marketPlaceDataSolution1.Project.Add(new CProject
{
ProjectName = "SampleService",
ProjectShortName = "SampleService",
Path = "Company.SampleService.SyncServices.csproj",
ProjectIs = CProjectIs.Grpc
});
marketPlaceData.RepoSolution.Add(marketPlaceDataSolution1);
repos.Add(marketPlaceData);
repos.Add(new CRepo {
Name = "news-svc", Url = companyGit
});
repos.Add(new CRepo {
Name = "weather-report-svc", Url = companyGit
});
repos.Add(new CRepo {
Name = "dockerize"
});
return(repos);
}
public void ShouldCreateSolutionWithDockerComposeProjectManualVerify()
{
//Arrange
var metaRepo = new MetaRepoBuilder().BuildSampleMetaRepo();
var dockerComposeFile = new DockerComposeFileService().Build(metaRepo);
var project = new CProject()
{
ProjectName = "docker-compose", ProjectIs = CProjectIs.DockerCompose, ProjectType = CProjectType.DockerProj, TemplateProjectPath = @"templates\Docker\docker-compose.dcproj"
};
project.ProjectContent.Add(new CProjectContent {
Content = dockerComposeFile, File = new CFile {
FileName = "docker-compose.yml"
}, BuildAction = CBuildAction.None
});
var solution = new CSolution()
{
SolutionName = "MetaSolution"
};
solution.Project.Add(project);
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IVisualStudioSolutionWriter, VisualStudioSolutionWriter>();
var serviceProvider = serviceCollection.BuildServiceProvider();
var writer = serviceProvider.GetRequiredService <IVisualStudioSolutionWriter>();
//Act
writer.Write(@"c:\temp\", solution);
//Assert
//todo: manual verification
}
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;
}
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 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;
}
/// <summary>
/// insert new row in the table
/// </summary>
/// <param name="businessObject">business object</param>
/// <returns>true of successfully insert</returns>
public bool Insert(CSolution businessObject)
{
NpgsqlCommand sqlCommand = new NpgsqlCommand();
sqlCommand.CommandText = "public.sp_solution_Insert";
sqlCommand.CommandType = CommandType.StoredProcedure;
// Use connection object of base class
sqlCommand.Connection = MainConnection;
try
{
sqlCommand.Parameters.AddWithValue("p_idsolution", businessObject.Idsolution);
sqlCommand.Parameters["p_idsolution"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters["p_idsolution"].Direction = ParameterDirection.InputOutput;
sqlCommand.Parameters.AddWithValue("p_id", businessObject.Id);
sqlCommand.Parameters["p_id"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_parentid", businessObject.Parentid);
sqlCommand.Parameters["p_parentid"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_idgroup_solution", businessObject.Idgroup_solution);
sqlCommand.Parameters["p_idgroup_solution"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_idelement", businessObject.Idelement);
sqlCommand.Parameters["p_idelement"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_cod_solution", businessObject.Cod_solution);
sqlCommand.Parameters["p_cod_solution"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_type_sol", businessObject.Type_sol);
sqlCommand.Parameters["p_type_sol"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_solution_name", businessObject.Solution_name);
sqlCommand.Parameters["p_solution_name"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_purity", businessObject.Purity);
sqlCommand.Parameters["p_purity"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_concentration", businessObject.Concentration);
sqlCommand.Parameters["p_concentration"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_aliquot", businessObject.Aliquot);
sqlCommand.Parameters["p_aliquot"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_volumen", businessObject.Volumen);
sqlCommand.Parameters["p_volumen"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_date_begin", businessObject.Date_begin);
sqlCommand.Parameters["p_date_begin"].NpgsqlDbType = NpgsqlDbType.Date;
sqlCommand.Parameters.AddWithValue("p_date_end", businessObject.Date_end);
sqlCommand.Parameters["p_date_end"].NpgsqlDbType = NpgsqlDbType.Date;
sqlCommand.Parameters.AddWithValue("p_num_months", businessObject.Num_months);
sqlCommand.Parameters["p_num_months"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_prepared_by", businessObject.Prepared_by);
sqlCommand.Parameters["p_prepared_by"].NpgsqlDbType = NpgsqlDbType.Smallint;
sqlCommand.Parameters.AddWithValue("p_observation", businessObject.Observation);
sqlCommand.Parameters["p_observation"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_lote", businessObject.Lote);
sqlCommand.Parameters["p_lote"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_solution_status", businessObject.Solution_status);
sqlCommand.Parameters["p_solution_status"].NpgsqlDbType = NpgsqlDbType.Boolean;
sqlCommand.Parameters.AddWithValue("p_idreactive_medium", businessObject.Idreactive_medium);
sqlCommand.Parameters["p_idreactive_medium"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_reactive_medium_value", businessObject.Reactive_medium_value);
sqlCommand.Parameters["p_reactive_medium_value"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_idreactive_modif", businessObject.Idreactive_modif);
sqlCommand.Parameters["p_idreactive_modif"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_reactive_modif_value", businessObject.Reactive_modif_value);
sqlCommand.Parameters["p_reactive_modif_value"].NpgsqlDbType = NpgsqlDbType.Numeric;
sqlCommand.Parameters.AddWithValue("p_concat_cod_methods", businessObject.Concat_cod_methods);
sqlCommand.Parameters["p_concat_cod_methods"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_image_index", businessObject.Image_index);
sqlCommand.Parameters["p_image_index"].NpgsqlDbType = NpgsqlDbType.Integer;
sqlCommand.Parameters.AddWithValue("p_usernew", businessObject.Usernew);
sqlCommand.Parameters["p_usernew"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_datenew", businessObject.Datenew);
sqlCommand.Parameters["p_datenew"].NpgsqlDbType = NpgsqlDbType.Date;
sqlCommand.Parameters.AddWithValue("p_useredit", businessObject.Useredit);
sqlCommand.Parameters["p_useredit"].NpgsqlDbType = NpgsqlDbType.Varchar;
sqlCommand.Parameters.AddWithValue("p_dateedit", businessObject.Dateedit);
sqlCommand.Parameters["p_dateedit"].NpgsqlDbType = NpgsqlDbType.Date;
sqlCommand.Parameters.AddWithValue("p_status", businessObject.Status);
sqlCommand.Parameters["p_status"].NpgsqlDbType = NpgsqlDbType.Boolean;
MainConnection.Open();
sqlCommand.ExecuteNonQuery();
businessObject.Idsolution = Convert.ToInt32(sqlCommand.Parameters["p_idsolution"].Value);
return(true);
}
catch (Exception ex)
{
throw new Exception("CSolution::Insert::Error occured.", ex);
}
finally
{
MainConnection.Close();
sqlCommand.Dispose();
}
}
CSolution GetActiveStdVerification(CSolution parent)
{
if (lstSolution.Exists(c => c.Type_sol == 3 && c.Solution_status == true && c.Parentid == parent.Id))
{
return lstSolution.First(c => c.Type_sol == 3 && c.Solution_status == true && c.Parentid == parent.Id);
}
return null;
}
/// <summary>
/// Estados para los botones:
/// -------------------------
/// - si no existe una solución o esta desactivada entonces se habilita el estado de activación del boton
/// - si existe una solución activa entonces se desactiva el botón y se puede preguntar por los botones
/// siguientes.
/// </summary>
void ShowStatusButtons()
{
AllowAddSolInterm1 = false;
AllowAddSolInterm2 = false;
AllowAddStdVerif = false;
CSolution firstSolution = null;
CSolution SecondSolution = null;
if (!FlagSolutionInProcess)
{
// Solución intermedia 1
if (Convert.ToBoolean(template_method_aa.Std_flag_sol_intermedia1))
{
if ((firstSolution = GetActiveFirstSolution()) == null)
{
// no existe o está deshabilitado la solución intermedia 1, entonces habilitar agregación
AllowAddSolInterm1 = true;
}
else
{
// ya existe una solución intermedia 1
AllowAddSolInterm1 = false;
AllowAddSolInterm2 = false;
AllowAddStdVerif = false;
//if (GetActiveStdVerification(firstSolution) == null)
if (GetActiveStdVerification1() == null)
{
AllowAddStdVerif = true;
}
else
{
// ya existe un estandar de verificación
AllowAddStdVerif = false;
}
}
}
// Solución intermedia 2
if (Convert.ToBoolean(template_method_aa.Std_flag_sol_intermedia2))
{
if (GetActiveFirstSolution() == null)
{
AllowAddSolInterm1 = true;
AllowAddSolInterm2 = false;
AllowAddStdVerif = false;
}
else
{
// ya existe la solución intermedia 1 deshabilitar agregación
AllowAddSolInterm1 = false;
AllowAddStdVerif = false;
// si solución intermedia dos no existe o está desactivada habilitar agregación
if ((SecondSolution = GetActiveSecondSolution()) == null)
{
AllowAddSolInterm2 = true;
}
else
{
// ya existe solución intermedia 2
AllowAddSolInterm2 = false;
AllowAddStdVerif = false;
//if (GetActiveStdVerification(SecondSolution) == null)
if (GetActiveStdVerification2() == null)
{
AllowAddStdVerif = true;
}
else
{
// ya existe un estandar de verificación
AllowAddStdVerif = false;
}
}
}
}
btSolInterm1.Enabled = AllowAddSolInterm1;
btSolInterm2.Enabled = AllowAddSolInterm2;
btStdVerif.Enabled = AllowAddStdVerif;
}
else
{
btSolInterm1.Enabled = AllowAddSolInterm1;
btSolInterm2.Enabled = AllowAddSolInterm2;
btStdVerif.Enabled = AllowAddStdVerif;
}
}
/// <summary>
/// Populate business object from data reader
/// </summary>
/// <param name="businessObject">business object</param>
/// <param name="dataReader">data reader</param>
internal void PopulateBusinessObjectFromReader(CSolution businessObject, IDataReader dataReader)
{
businessObject.Idsolution = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Idsolution.ToString()));
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Id.ToString())))
{
businessObject.Id = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Id.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Parentid.ToString())))
{
businessObject.Parentid = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Parentid.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Idgroup_solution.ToString())))
{
businessObject.Idgroup_solution = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Idgroup_solution.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Idelement.ToString())))
{
businessObject.Idelement = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Idelement.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Cod_solution.ToString())))
{
businessObject.Cod_solution = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Cod_solution.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Type_sol.ToString())))
{
businessObject.Type_sol = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Type_sol.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Solution_name.ToString())))
{
businessObject.Solution_name = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Solution_name.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Purity.ToString())))
{
businessObject.Purity = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Purity.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Concentration.ToString())))
{
businessObject.Concentration = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Concentration.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Aliquot.ToString())))
{
businessObject.Aliquot = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Aliquot.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Volumen.ToString())))
{
businessObject.Volumen = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Volumen.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Date_begin.ToString())))
{
businessObject.Date_begin = dataReader.GetDateTime(dataReader.GetOrdinal(CSolution.CSolutionFields.Date_begin.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Date_end.ToString())))
{
businessObject.Date_end = dataReader.GetDateTime(dataReader.GetOrdinal(CSolution.CSolutionFields.Date_end.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Num_months.ToString())))
{
businessObject.Num_months = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Num_months.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Prepared_by.ToString())))
{
businessObject.Prepared_by = (short?)dataReader.GetInt16(dataReader.GetOrdinal(CSolution.CSolutionFields.Prepared_by.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Observation.ToString())))
{
businessObject.Observation = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Observation.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Lote.ToString())))
{
businessObject.Lote = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Lote.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Solution_status.ToString())))
{
businessObject.Solution_status = dataReader.GetBoolean(dataReader.GetOrdinal(CSolution.CSolutionFields.Solution_status.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Idreactive_medium.ToString())))
{
businessObject.Idreactive_medium = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Idreactive_medium.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Reactive_medium_value.ToString())))
{
businessObject.Reactive_medium_value = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Reactive_medium_value.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Idreactive_modif.ToString())))
{
businessObject.Idreactive_modif = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Idreactive_modif.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Reactive_modif_value.ToString())))
{
businessObject.Reactive_modif_value = dataReader.GetDecimal(dataReader.GetOrdinal(CSolution.CSolutionFields.Reactive_modif_value.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Concat_cod_methods.ToString())))
{
businessObject.Concat_cod_methods = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Concat_cod_methods.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Image_index.ToString())))
{
businessObject.Image_index = dataReader.GetInt32(dataReader.GetOrdinal(CSolution.CSolutionFields.Image_index.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Usernew.ToString())))
{
businessObject.Usernew = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Usernew.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Datenew.ToString())))
{
businessObject.Datenew = dataReader.GetDateTime(dataReader.GetOrdinal(CSolution.CSolutionFields.Datenew.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Useredit.ToString())))
{
businessObject.Useredit = dataReader.GetString(dataReader.GetOrdinal(CSolution.CSolutionFields.Useredit.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Dateedit.ToString())))
{
businessObject.Dateedit = dataReader.GetDateTime(dataReader.GetOrdinal(CSolution.CSolutionFields.Dateedit.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CSolution.CSolutionFields.Status.ToString())))
{
businessObject.Status = dataReader.GetBoolean(dataReader.GetOrdinal(CSolution.CSolutionFields.Status.ToString()));
}
}
public void Visit(CSolution solution)
{
_logger.LogInformation($"Visiting {GetType()}");
_solutionVisitor.Visit(this, solution);
_logger.LogInformation($"Visited {GetType()}");
}
public void BuildSellersMegaSolution()
{
var tempPath = OutputDir;
var codeWriter = new CodeWriter();
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IVisualStudioSolutionWriter, VisualStudioSolutionWriter>();
serviceCollection.AddTransient <ICSolutionVisitor, FastSolutionVisitor>();
var fileWriter = new FileWriter();
fileWriter.RootPath = tempPath;
serviceCollection.AddSingleton <IFileWriter>(fileWriter);
serviceCollection.AddSingleton <ILogger <CVisualStudioVisitorBase> >(new Logger <CVisualStudioVisitorBase>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CMetaRepoVisitor> >(new Logger <CMetaRepoVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CRepoVisitor> >(new Logger <CRepoVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <VisualStudioSolutionWriter> >(new Logger <VisualStudioSolutionWriter>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CProjectVisitor> >(new Logger <CProjectVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CProjectFileVisitor> >(new Logger <CProjectFileVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CProjectContentVisitor> >(new Logger <CProjectContentVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CDockerComposeFileVisitor> >(new Logger <CDockerComposeFileVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ILogger <CDockerFileServiceVisitor> >(new Logger <CDockerFileServiceVisitor>(new NullLoggerFactory()));
serviceCollection.AddSingleton <ICodeWriter>(codeWriter);
serviceCollection.AddTransient <ICVisualStudioVisitorBase, CVisualStudioVisitorBase>();
serviceCollection.AddTransient <IFastSolutionVisitor, FastSolutionVisitor>();
//serviceCollection.AddTransient<ICVisualStudioVisitor, CVisualStudioVisitor>();
serviceCollection.AddTransient <ICMetaRepoVisitor, CMetaRepoVisitor>();
serviceCollection.AddTransient <ICRepoVisitor, CRepoVisitor>();
serviceCollection.AddTransient <ICVisualStudioVisitor, CVisualStudioVisitor>();
//var serviceProvider = serviceCollection.BuildServiceProvider();
var container = new Container();
container.Configure(config =>
{
config.Scan(scanner =>
{
scanner.AssemblyContainingType <ILogger>();
scanner.AssemblyContainingType <IKickstartService>();
scanner.SingleImplementationsOfInterface();
});
config.Populate(serviceCollection);
});
var serviceProvider = container.GetInstance <IServiceProvider>();
var metaRepo = new MetaRepoBuilder().BuildSampleMetaRepo();
var visitor = serviceProvider.GetRequiredService <ICVisualStudioVisitorBase>(); // new CVisualStudioVisitor(new Mock<ILogger>().Object, codeWriter);
metaRepo.Accept(visitor as IVisitor);
Directory.CreateDirectory(tempPath);
//http://thesoftwarecondition.com/blog/2014/06/08/nuget-issues-with-nested-solutions-branches/
//get code from repos
CommandProcessor.ExecuteCommandWindow(codeWriter.ToString(), tempPath, true);
UpdateLibraryPaths(tempPath);
var compositeSolution = new CSolution()
{
SolutionName = metaRepo.MetaRepoName
};
compositeSolution.SolutionPath = Path.Combine(tempPath, $"{compositeSolution.SolutionName}.sln");
var compositeRepo = new CRepo();
compositeRepo.RepoSolution.Add(compositeSolution);
metaRepo.CompositeRepo = compositeRepo;
//todo: dockerize Asp.Net apps
//set docker-compose to looking in the Publish folder otherwise there's way too many files
//add docker file to project
//set dockerfile to copy when Publish
//find all the solutions in repos
foreach (var repo in metaRepo.Repos)
{
var repoPath = Path.Combine(tempPath, repo.Name);
var solutionPaths = new VisualStudioScanner().ScanForSolutions(repoPath);
var solutions = new SlnToCSolutionConverter().Convert(solutionPaths);
repo.RepoSolution.Clear();//remove any existing
foreach (var solution in solutions)
{
if (repo.SolutionWhiteList.Count > 0 && !repo.SolutionWhiteList.Contains(solution.SolutionName))
{
continue;
}
repo.RepoSolution.Add(solution);
}
}
var dockerComposeFile = new DockerComposeFileService().Build(metaRepo);
var dockerComposeProject = new CProject()
{
ProjectName = "docker-compose", ProjectIs = CProjectIs.DockerCompose, ProjectType = CProjectType.DockerProj, TemplateProjectPath = @"templates\Docker\docker-compose.dcproj"
};
dockerComposeProject.ProjectContent.Add(new CProjectContent {
Content = dockerComposeFile, File = new CFile {
FileName = "docker-compose.yml", Encoding = Encoding.ASCII
}, BuildAction = CBuildAction.None
});
compositeSolution.Project.Add(dockerComposeProject);
var writer = serviceProvider.GetRequiredService <IVisualStudioSolutionWriter>();
writer.Write(tempPath, compositeSolution);
//add all the projects to the composite solution
var fastSolutionVisitor = serviceProvider.GetRequiredService <IFastSolutionVisitor>(); // new FastSolutionVisitor(codeWriter, new Mock<IFileWriter>().Object);
foreach (var repo in metaRepo.Repos)
{
foreach (var solution in repo.RepoSolution)
{
fastSolutionVisitor.AddAllProjectsToMasterSln(solution, tempPath, compositeSolution.SolutionName);
}
}
//generate batch script to do "Nuget Restore"
//todo: move into library
var batchWriter = new CodeWriter();
foreach (var repo in metaRepo.Repos)
{
foreach (var solution in repo.RepoSolution)
{
System.Uri uri1 = new Uri(tempPath);
System.Uri uri2 = new Uri(Path.GetDirectoryName(solution.SolutionPath));
Uri relativeUri = uri1.MakeRelativeUri(uri2);
var relativePath = relativeUri.ToString().Replace("%20", " ");
batchWriter.WriteLine($@"copy nuget.exe ""{relativePath}/nuget.exe"" /Y");
batchWriter.WriteLine($"cd {relativePath}");
batchWriter.WriteLine($@"Nuget Restore ""{solution.SolutionPath}""");
batchWriter.WriteLine($@"del nuget.exe");
batchWriter.WriteLine("cd /D %~dp0"); //go back to where batch was run
}
}
File.WriteAllText(Path.Combine(tempPath, "NugetRestore.cmd"), batchWriter.ToString());
}
