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); } } }