private async Task RunBundleForBlazorAsync(string[] projectFiles, ModuleWithMastersInfo module)
{
var blazorProject = projectFiles.FirstOrDefault(f => f.EndsWith(".Blazor.csproj"));
if (blazorProject == null || !module.NugetPackages.Any(np => np.Target == NuGetPackageTarget.Blazor))
{
return;
}
// return if project is blazor-server
var document = new XmlDocument();
document.Load(blazorProject);
var sdk = document.DocumentElement.GetAttribute("Sdk");
if (sdk != BundlingConsts.SupportedWebAssemblyProjectType)
{
return;
}
await PublishEventAsync(10, $"Running bundle command for Blazor");
var args = new CommandLineArgs("bundle");
args.Options.Add(BundleCommand.Options.WorkingDirectory.Short, Path.GetDirectoryName(blazorProject));
args.Options.Add(BundleCommand.Options.ForceBuild.Short, string.Empty);
await BundleCommand.ExecuteAsync(args);
}
private void ChangeDomainTestReferenceToMongoDB(ModuleWithMastersInfo module, string moduleSolutionFile)
{
var testPath = Path.Combine(Path.GetDirectoryName(moduleSolutionFile), "test");
if (!Directory.Exists(testPath))
{
return;
}
var projectFolderPath = Directory.GetDirectories(testPath).FirstOrDefault(d => d.EndsWith("Domain.Tests"));
if (projectFolderPath == null)
{
return;
}
var csprojFile = Directory.GetFiles(projectFolderPath, "*.csproj", SearchOption.AllDirectories).FirstOrDefault();
var moduleFile = Directory.GetFiles(projectFolderPath, "*DomainTestModule.cs", SearchOption.AllDirectories).FirstOrDefault();
if (csprojFile == null || moduleFile == null)
{
return;
}
File.WriteAllText(csprojFile, File.ReadAllText(csprojFile).Replace("EntityFrameworkCore", "MongoDB"));
File.WriteAllText(moduleFile, File.ReadAllText(moduleFile)
.Replace(".EntityFrameworkCore;", ".MongoDB;")
.Replace("EntityFrameworkCoreTestModule", "MongoDbTestModule"));
}
private async Task CreateNewModuleAsync(ModuleWithMastersInfo module, string modulesFolderInSolution,
string version, bool newProTemplate = false)
{
var args = new CommandLineArgs("new", module.Name);
args.Options.Add("t", newProTemplate ? ModuleProTemplate.TemplateName : ModuleTemplate.TemplateName);
args.Options.Add("v", version);
args.Options.Add("o", Path.Combine(modulesFolderInSolution, module.Name));
await NewCommand.ExecuteAsync(args);
}
public async Task Convert(ModuleWithMastersInfo module, string solutionFile, string modulePrefix = "Volo.")
{
var nugetPackageList = GetNugetPackages(module);
var modulesFolder = Path.Combine(Path.GetDirectoryName(solutionFile), "modules");
var srcFolder = Path.Combine(Path.GetDirectoryName(solutionFile), "src");
var testFolder = Path.Combine(Path.GetDirectoryName(solutionFile), "test");
ConvertToLocalReference(modulesFolder, nugetPackageList, "..\\..\\..\\", "src", modulePrefix);
ConvertToLocalReference(srcFolder, nugetPackageList, "..\\..\\modules\\", "src", modulePrefix);
ConvertToLocalReference(testFolder, nugetPackageList, "..\\..\\modules\\", "test", modulePrefix);
}
private static bool SouldWebPackagesBeAddedToBlazorServerProject(ModuleWithMastersInfo module, string[] projectFiles)
{
var blazorProject = projectFiles.FirstOrDefault(p => p.EndsWith(".Blazor.csproj"));
if (blazorProject == null)
{
return(false);
}
var isBlazorServerProject = BlazorProjectTypeChecker.IsBlazorServerProject(blazorProject);
return(isBlazorServerProject && module.NugetPackages.All(np => np.Target != NuGetPackageTarget.BlazorServer && np.TieredTarget != NuGetPackageTarget.BlazorServer));
}
private async Task AddNugetAndNpmReferences(ModuleWithMastersInfo module, string[] projectFiles,
bool useDotnetCliToInstall)
{
var webPackagesWillBeAddedToBlazorServerProject = SouldWebPackagesBeAddedToBlazorServerProject(module, projectFiles);
foreach (var nugetPackage in module.NugetPackages)
{
var nugetTarget =
await IsProjectTiered(projectFiles) && nugetPackage.TieredTarget != NuGetPackageTarget.Undefined
? nugetPackage.TieredTarget
: nugetPackage.Target;
if (webPackagesWillBeAddedToBlazorServerProject && nugetTarget == NuGetPackageTarget.Web)
{
nugetTarget = NuGetPackageTarget.BlazorServer;
}
var targetProjectFile = ProjectFinder.FindNuGetTargetProjectFile(projectFiles, nugetTarget);
if (targetProjectFile == null)
{
Logger.LogDebug($"Target project is not available for this NuGet package '{nugetPackage.Name}'");
continue;
}
await ProjectNugetPackageAdder.AddAsync(null, targetProjectFile, nugetPackage, null, useDotnetCliToInstall);
}
var mvcNpmPackages = module.NpmPackages?.Where(p => p.ApplicationType.HasFlag(NpmApplicationType.Mvc))
.ToList();
if (!mvcNpmPackages.IsNullOrEmpty())
{
var targetProjects = ProjectFinder.FindNpmTargetProjectFile(projectFiles);
if (targetProjects.Any())
{
NpmGlobalPackagesChecker.Check();
foreach (var targetProject in targetProjects)
{
foreach (var npmPackage in mvcNpmPackages)
{
await ProjectNpmPackageAdder.AddMvcPackageAsync(Path.GetDirectoryName(targetProject), npmPackage);
}
}
}
else
{
Logger.LogDebug("Target project is not available for NPM packages.");
}
}
}
public List <NugetPackageInfoWithModuleName> GetNugetPackages(ModuleWithMastersInfo module)
{
var list = new List <NugetPackageInfoWithModuleName>();
list.AddRange(module.NugetPackages.Select(n => new NugetPackageInfoWithModuleName
{
ModuleName = module.Name,
NugetPackage = n
}));
if (module.MasterModuleInfos != null)
{
foreach (var masterModule in module.MasterModuleInfos)
{
list.AddRange(GetNugetPackages(masterModule));
}
}
return(list);
}
private async Task AddAngularPackages(string solutionFilePath, ModuleWithMastersInfo module)
{
var angularPath = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(solutionFilePath)), "angular");
if (!Directory.Exists(angularPath))
{
return;
}
var angularPackages = module.NpmPackages?.Where(p => p.ApplicationType.HasFlag(NpmApplicationType.Angular))
.ToList();
if (!angularPackages.IsNullOrEmpty())
{
foreach (var npmPackage in angularPackages)
{
await ProjectNpmPackageAdder.AddAngularPackageAsync(angularPath, npmPackage);
}
}
}
private async Task <List <string> > FindProjectsToRemoveByTarget(ModuleWithMastersInfo module,
NuGetPackageTarget target, bool isTieredProject)
{
var projectsToRemove = new List <string>();
var packages = module.NugetPackages.Where(n =>
(isTieredProject && n.TieredTarget != NuGetPackageTarget.Undefined
? n.TieredTarget
: n.Target) == target
).ToList();
foreach (var package in packages)
{
if (target == NuGetPackageTarget.Web && package.Name.StartsWith("Volo.Abp.Account"))
{
continue;
}
projectsToRemove.Add(package.Name);
}
return(projectsToRemove);
}
private async Task DownloadSourceCodesToSolutionFolder(ModuleWithMastersInfo module,
string modulesFolderInSolution, string version = null, bool newTemplate = false,
bool newProTemplate = false)
{
var targetModuleFolder = Path.Combine(modulesFolderInSolution, module.Name);
if (newTemplate || newProTemplate)
{
await CreateNewModuleAsync(module, modulesFolderInSolution, version, newProTemplate);
}
else
{
await SourceCodeDownloadService.DownloadModuleAsync(
module.Name,
targetModuleFolder,
version,
null,
null,
null
);
}
await DeleteRedundantHostProjects(targetModuleFolder, "app");
await DeleteRedundantHostProjects(targetModuleFolder, "demo");
await DeleteRedundantHostProjects(targetModuleFolder, "host");
if (module.MasterModuleInfos == null)
{
return;
}
foreach (var masterModule in module.MasterModuleInfos)
{
await DownloadSourceCodesToSolutionFolder(masterModule, modulesFolderInSolution, version);
}
}
private ModuleWithMastersInfo GetEmptyModuleProjectInfo(string moduleName,
bool newProTemplate = false)
{
var module = new ModuleWithMastersInfo
{
Name = moduleName,
DisplayName = moduleName,
MasterModuleInfos = new List <ModuleWithMastersInfo>()
};
var moduleProjectName = module.Name.Split('.').Last();
module.EfCoreConfigureMethodName = $"{module.Name}.EntityFrameworkCore:Configure{moduleProjectName}";
module.NugetPackages = new List <NugetPackageInfo>
{
new NugetPackageInfo
{
Name = $"{module.Name}.Application",
ModuleClass = $"{module.Name}.{moduleProjectName}ApplicationModule",
Target = NuGetPackageTarget.Application
},
new NugetPackageInfo
{
Name = $"{module.Name}.Application.Contracts",
ModuleClass = $"{module.Name}.{moduleProjectName}ApplicationContractsModule",
Target = NuGetPackageTarget.ApplicationContracts
},
new NugetPackageInfo
{
Name = $"{module.Name}.Blazor.WebAssembly",
ModuleClass = $"{module.Name}.Blazor.WebAssembly.{moduleProjectName}BlazorWebAssemblyModule",
Target = NuGetPackageTarget.BlazorWebAssembly
},
new NugetPackageInfo
{
Name = $"{module.Name}.Blazor.Server",
ModuleClass = $"{module.Name}.Blazor.Server.{moduleProjectName}BlazorServerModule",
Target = NuGetPackageTarget.BlazorServer
},
new NugetPackageInfo
{
Name = $"{module.Name}.Domain",
ModuleClass = $"{module.Name}.{moduleProjectName}DomainModule",
Target = NuGetPackageTarget.Domain
},
new NugetPackageInfo
{
Name = $"{module.Name}.Domain.Shared",
ModuleClass = $"{module.Name}.{moduleProjectName}DomainSharedModule",
Target = NuGetPackageTarget.DomainShared
},
new NugetPackageInfo
{
Name = $"{module.Name}.EntityFrameworkCore",
ModuleClass = $"{module.Name}.EntityFrameworkCore.{moduleProjectName}EntityFrameworkCoreModule",
Target = NuGetPackageTarget.EntityFrameworkCore
},
new NugetPackageInfo
{
Name = $"{module.Name}.HttpApi",
ModuleClass = $"{module.Name}.{moduleProjectName}HttpApiModule",
Target = NuGetPackageTarget.HttpApi
},
new NugetPackageInfo
{
Name = $"{module.Name}.HttpApi.Client",
ModuleClass = $"{module.Name}.{moduleProjectName}HttpApiClientModule",
Target = NuGetPackageTarget.HttpApiClient
},
new NugetPackageInfo
{
Name = $"{module.Name}.MongoDB",
ModuleClass = $"{module.Name}.MongoDB.{moduleProjectName}MongoDbModule",
Target = NuGetPackageTarget.MongoDB
},
new NugetPackageInfo
{
Name = $"{module.Name}.Web",
ModuleClass = $"{module.Name}.Web.{moduleProjectName}WebModule",
Target = NuGetPackageTarget.Web
},
};
module.NpmPackages = new List <NpmPackageInfo>();
return(module);
}
private async Task RemoveUnnecessaryProjectsAsync(string solutionDirectory, ModuleWithMastersInfo module,
string[] projectFiles)
{
var projectsToRemove = new List <string>();
var moduleDirectory = Path.Combine(solutionDirectory, "modules", module.Name);
var moduleSolutionFile = Directory.GetFiles(moduleDirectory, "*.sln", SearchOption.TopDirectoryOnly).First();
var isProjectTiered = await IsProjectTiered(projectFiles);
var webPackagesWillBeAddedToBlazorServerProject = false;
var blazorProject = projectFiles.FirstOrDefault(p => p.EndsWith(".Blazor.csproj"));
if (blazorProject == null)
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.Blazor, isProjectTiered));
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.BlazorServer, isProjectTiered));
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.BlazorWebAssembly, isProjectTiered));
projectsToRemove.AddRange(await FindProjectsToRemoveByPostFix(moduleDirectory, "src", ".Blazor"));
}
else
{
var isBlazorServer = BlazorProjectTypeChecker.IsBlazorServerProject(blazorProject);
if (isBlazorServer)
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.BlazorWebAssembly, isProjectTiered));
webPackagesWillBeAddedToBlazorServerProject = module.NugetPackages.All(np => np.Target != NuGetPackageTarget.BlazorServer && np.TieredTarget != NuGetPackageTarget.BlazorServer);
}
else
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.BlazorServer, isProjectTiered));
}
}
if (!projectFiles.Any(p => p.EndsWith(".Web.csproj")) && !webPackagesWillBeAddedToBlazorServerProject)
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.Web, isProjectTiered));
}
if (!projectFiles.Any(p => p.EndsWith(".MongoDB.csproj")))
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.MongoDB, isProjectTiered));
projectsToRemove.AddRange(await FindProjectsToRemoveByPostFix(moduleDirectory, "test", ".MongoDB.Tests"));
}
if (!projectFiles.Any(p => p.EndsWith(".EntityFrameworkCore.csproj")))
{
projectsToRemove.AddRange(await FindProjectsToRemoveByTarget(module, NuGetPackageTarget.EntityFrameworkCore, isProjectTiered));
projectsToRemove.AddRange(await FindProjectsToRemoveByPostFix(moduleDirectory, "test", ".EntityFrameworkCore.Tests"));
projectsToRemove.AddRange(await FindProjectsToRemoveByPostFix(moduleDirectory, "test", ".Application.Tests"));
ChangeDomainTestReferenceToMongoDB(module, moduleSolutionFile);
}
foreach (var projectToRemove in projectsToRemove)
{
if (IsReferencedByAnotherProject(solutionDirectory, projectsToRemove, projectToRemove))
{
continue;
}
RemoveProjectFromSolutionAsync(moduleSolutionFile, projectToRemove);
}
}
private ModuleWithMastersInfo RemoveIncompatiblePackages(ModuleWithMastersInfo module, string version)
{
module.NugetPackages.RemoveAll(np => IsPackageInCompatible(np.MinVersion, np.MaxVersion, version));
module.NpmPackages.RemoveAll(np => IsPackageInCompatible(np.MinVersion, np.MaxVersion, version));
return(module);
}
public async Task AddModuleToSolutionFileAsync(ModuleWithMastersInfo module, string solutionFile)
{
await AddModuleAsync(module, solutionFile);
}
private async Task AddModuleAsync(ModuleWithMastersInfo module, string solutionFile)
{
var srcModuleFolderId = await AddNewFolderAndGetIdOrGetExistingIdAsync(solutionFile, module.Name,
await AddNewFolderAndGetIdOrGetExistingIdAsync(solutionFile, "modules"));
var testModuleFolderId = await AddNewFolderAndGetIdOrGetExistingIdAsync(solutionFile, module.Name + ".Tests",
await AddNewFolderAndGetIdOrGetExistingIdAsync(solutionFile, "test"));
var file = File.ReadAllText(solutionFile);
var lines = file.Split(Environment.NewLine).ToList();
var projectsUnderModule = Directory.GetFiles(
Path.Combine(Path.GetDirectoryName(solutionFile), "modules", module.Name),
"*.csproj",
SearchOption.AllDirectories);
var projectsUnderTest = new List <string>();
if (Directory.Exists(Path.Combine(Path.GetDirectoryName(solutionFile), "modules", module.Name, "test")))
{
projectsUnderTest = Directory.GetFiles(
Path.Combine(Path.GetDirectoryName(solutionFile), "modules", module.Name, "test"),
"*.csproj",
SearchOption.AllDirectories).ToList();
}
foreach (var projectPath in projectsUnderModule)
{
var parentFolderId = projectsUnderTest.Contains(projectPath) ? testModuleFolderId : srcModuleFolderId;
var projectId = Path.GetFileName(projectPath).Replace(".csproj", "");
var projectParentFolderInModule = projectsUnderTest.Contains(projectPath) ? "test" : "src";
if (lines.Any(l => l.Contains($"\"{projectId}\"")))
{
continue;
}
var projectGuid = Guid.NewGuid().ToString();
var newProjectLine = "Project(\"{9A19103F-16F7-4668-BE54-9A1E7A4F7556}\") = \"" + projectId + "\"," +
" \"modules\\" + module.Name + "\\" + projectParentFolderInModule + "\\" +
projectId + "\\" + projectId + ".csproj\", \"{" + projectGuid + "}\""
+ Environment.NewLine + "EndProject";
lines.InsertAfter(l => l.Trim().Equals("EndProject"), newProjectLine);
var newPostSolutionLine =
" {"+ projectGuid + "}.Debug|Any CPU.ActiveCfg = Debug|Any CPU" + Environment.NewLine +
" {"+ projectGuid + "}.Debug|Any CPU.Build.0 = Debug|Any CPU" + Environment.NewLine +
" {"+ projectGuid + "}.Release|Any CPU.ActiveCfg = Release|Any CPU" + Environment.NewLine +
" {"+ projectGuid + "}.Release|Any CPU.Build.0 = Release|Any CPU";
lines.InsertAfter(l => l.Contains("GlobalSection") && l.Contains("ProjectConfigurationPlatforms"),
newPostSolutionLine);
var newPreSolutionLine =
" {"+ projectGuid + "} = {" + parentFolderId + "}";
lines.InsertAfter(l => l.Contains("GlobalSection") && l.Contains("NestedProjects"), newPreSolutionLine);
}
File.WriteAllText(solutionFile, string.Join(Environment.NewLine, lines));
if (module.MasterModuleInfos != null)
{
foreach (var masterModule in module.MasterModuleInfos)
{
await AddModuleAsync(masterModule, solutionFile);
}
}
}
