protected virtual void RunGraphBuildForMicroserviceServiceTemplate(ProjectBuildArgs projectArgs)
{
if (MicroserviceServiceTemplateBase.IsMicroserviceServiceTemplate(projectArgs.TemplateName))
{
CmdHelper.RunCmd("dotnet build /graphbuild", projectArgs.OutputFolder);
}
}
protected virtual void RunInstallLibsForWebTemplate(ProjectBuildArgs projectArgs)
{
if (AppTemplateBase.IsAppTemplate(projectArgs.TemplateName) ||
ModuleTemplateBase.IsModuleTemplate(projectArgs.TemplateName) ||
AppNoLayersTemplateBase.IsAppNoLayersTemplate(projectArgs.TemplateName) ||
MicroserviceServiceTemplateBase.IsMicroserviceTemplate(projectArgs.TemplateName))
{
CmdHelper.RunCmd("abp install-libs", projectArgs.OutputFolder);
}
}
protected void ConfigurePwaSupportForAngular(ProjectBuildArgs projectArgs)
{
var isAngular = projectArgs.UiFramework == UiFramework.Angular;
var isPwa = projectArgs.Pwa;
if (isAngular && isPwa)
{
Logger.LogInformation("Adding PWA Support to Angular app.");
AngularPwaSupportAdder.AddPwaSupport(projectArgs.OutputFolder);
}
}
public ProjectBuildContext(
[NotNull] TemplateInfo template,
[NotNull] TemplateFile templateFile,
[NotNull] ProjectBuildArgs buildArgs)
{
Template = Check.NotNull(template, nameof(template));
TemplateFile = Check.NotNull(templateFile, nameof(templateFile));
BuildArgs = Check.NotNull(buildArgs, nameof(buildArgs));
Result = new ProjectResult();
}
protected virtual async Task RunGraphBuildForMicroserviceServiceTemplate(ProjectBuildArgs projectArgs)
{
if (MicroserviceServiceTemplateBase.IsMicroserviceServiceTemplate(projectArgs.TemplateName))
{
await EventBus.PublishAsync(new ProjectCreationProgressEvent {
Message = "Building the microservice solution"
}, false);
CmdHelper.RunCmd("dotnet build /graphbuild", projectArgs.OutputFolder);
}
}
protected async Task RunInstallLibsForWebTemplateAsync(ProjectBuildArgs projectArgs)
{
if (AppTemplateBase.IsAppTemplate(projectArgs.TemplateName) ||
ModuleTemplateBase.IsModuleTemplate(projectArgs.TemplateName) ||
AppNoLayersTemplateBase.IsAppNoLayersTemplate(projectArgs.TemplateName) ||
MicroserviceServiceTemplateBase.IsMicroserviceTemplate(projectArgs.TemplateName))
{
Logger.LogInformation("Installing client-side packages...");
await InstallLibsService.InstallLibsAsync(projectArgs.OutputFolder);
}
}
private async Task <TemplateInfo> GetTemplateInfoAsync(ProjectBuildArgs args)
{
if (args.TemplateName.IsNullOrWhiteSpace())
{
return(await TemplateInfoProvider.GetDefaultAsync());
}
else
{
return(TemplateInfoProvider.Get(args.TemplateName));
}
}
public ProjectBuildContext([NotNull] TemplateInfo template,
[NotNull] TemplateFile templateFile,
[NotNull] ProjectBuildArgs buildArgs,
[NotNull] string version)
{
Template = Check.NotNull(template, nameof(template));
TemplateFile = Check.NotNull(templateFile, nameof(templateFile));
BuildArgs = Check.NotNull(buildArgs, nameof(buildArgs));
Version = Check.NotNullOrWhiteSpace(version, nameof(version));
Result = new ProjectResult();
}
protected void ConfigureNpmPackagesForTheme(ProjectBuildArgs projectArgs)
{
if (!projectArgs.Theme.HasValue)
{
return;
}
switch (projectArgs.Theme)
{
case Theme.Basic:
ConfigureNpmPackagesForBasicTheme(projectArgs);
break;
}
}
protected void OpenRelatedWebPage(ProjectBuildArgs projectArgs,
string template,
bool isTiered,
CommandLineArgs commandLineArgs)
{
if (AppTemplateBase.IsAppTemplate(template))
{
var isCommercial = template == AppProTemplate.TemplateName;
OpenThanksPage(projectArgs.UiFramework, projectArgs.DatabaseProvider, isTiered || commandLineArgs.Options.ContainsKey("separate-identity-server"), isCommercial);
}
else if (MicroserviceTemplateBase.IsMicroserviceTemplate(template))
{
OpenMicroserviceDocumentPage();
}
}
} //TODO: Fill the symbols, like "UI-Angular", "CMS-KIT"!
public ProjectBuildContext(
TemplateInfo template,
ModuleInfo module,
NugetPackageInfo package,
[NotNull] TemplateFile templateFile,
[NotNull] ProjectBuildArgs buildArgs)
{
Template = template;
Module = module;
Package = package;
TemplateFile = Check.NotNull(templateFile, nameof(templateFile));
BuildArgs = Check.NotNull(buildArgs, nameof(buildArgs));
Symbols = new List <string>();
Result = new ProjectResult();
}
private void ConfigureNpmPackagesForBasicTheme(ProjectBuildArgs projectArgs)
{
if (projectArgs.UiFramework is not UiFramework.None or UiFramework.Angular)
{
ThemePackageAdder.AddNpmPackage(projectArgs.OutputFolder, "@abp/aspnetcore.mvc.ui.theme.basic", projectArgs.Version);
}
if (projectArgs.UiFramework is UiFramework.BlazorServer)
{
ThemePackageAdder.AddNpmPackage(projectArgs.OutputFolder, "@abp/aspnetcore.components.server.basictheme", projectArgs.Version);
}
if (projectArgs.UiFramework is UiFramework.Angular)
{
ThemePackageAdder.AddAngularPackage(projectArgs.OutputFolder, "@abp/ng.theme.basic", projectArgs.Version);
}
}
protected async Task CreateInitialMigrationsAsync(ProjectBuildArgs projectArgs)
{
if (projectArgs.DatabaseProvider == DatabaseProvider.MongoDb)
{
return;
}
var efCoreProjectPath = string.Empty;
bool isLayeredTemplate;
switch (projectArgs.TemplateName)
{
case AppTemplate.TemplateName:
case AppProTemplate.TemplateName:
efCoreProjectPath = Directory.GetFiles(projectArgs.OutputFolder, "*EntityFrameworkCore.csproj", SearchOption.AllDirectories).FirstOrDefault();
isLayeredTemplate = true;
break;
case AppNoLayersTemplate.TemplateName:
case AppNoLayersProTemplate.TemplateName:
efCoreProjectPath = Directory.GetFiles(projectArgs.OutputFolder, "*.csproj", SearchOption.AllDirectories).FirstOrDefault();
isLayeredTemplate = false;
break;
default:
return;
}
if (string.IsNullOrWhiteSpace(efCoreProjectPath))
{
Logger.LogWarning("Couldn't find the project to create initial migrations!");
return;
}
await EventBus.PublishAsync(new ProjectCreationProgressEvent
{
Message = "Creating the initial DB migration"
}, false);
await InitialMigrationCreator.CreateAsync(Path.GetDirectoryName(efCoreProjectPath), isLayeredTemplate);
}
private static void NormalizeArgs(ProjectBuildArgs args, TemplateInfo templateInfo)
{
if (args.TemplateName.IsNullOrEmpty())
{
args.TemplateName = templateInfo.Name;
}
if (args.DatabaseProvider == DatabaseProvider.NotSpecified)
{
if (templateInfo.DefaultDatabaseProvider != DatabaseProvider.NotSpecified)
{
args.DatabaseProvider = templateInfo.DefaultDatabaseProvider;
}
}
if (args.UiFramework == UiFramework.NotSpecified)
{
if (templateInfo.DefaultUiFramework != UiFramework.NotSpecified)
{
args.UiFramework = templateInfo.DefaultUiFramework;
}
}
}
private async Task <ModuleInfo> GetModuleInfoAsync(ProjectBuildArgs args)
{
return(await ModuleInfoProvider.GetAsync(args.TemplateName));
}
private async Task <NugetPackageInfo> GetPackageInfoAsync(ProjectBuildArgs args)
{
return(await NugetPackageInfoProvider.GetAsync(args.TemplateName));
}
public async Task <ProjectBuildResult> BuildAsync(ProjectBuildArgs args)
{
var packageInfo = await GetPackageInfoAsync(args);
var templateFile = await SourceCodeStore.GetAsync(
args.TemplateName,
SourceCodeTypes.NugetPackage,
args.Version,
null,
args.ExtraProperties.ContainsKey(GetSourceCommand.Options.Preview.Long)
);
var apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
if (apiKeyResult?.ApiKey != null)
{
args.ExtraProperties["api-key"] = apiKeyResult.ApiKey;
}
if (apiKeyResult?.LicenseCode != null)
{
args.ExtraProperties["license-code"] = apiKeyResult.LicenseCode;
}
var context = new ProjectBuildContext(
null,
null,
packageInfo,
null,
templateFile,
args
);
NugetPackageProjectBuildPipelineBuilder.Build(context).Execute();
// Exclude unwanted or known options.
var options = args.ExtraProperties
.Where(x => !x.Key.Equals(CliConsts.Command, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.OutputFolder.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.OutputFolder.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Version.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.Version.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.TemplateSource.Short, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.TemplateSource.Long, StringComparison.InvariantCultureIgnoreCase))
.Select(x => x.Key).ToList();
await CliAnalyticsCollect.CollectAsync(new CliAnalyticsCollectInputDto
{
Tool = Options.ToolName,
Command = args.ExtraProperties.ContainsKey(CliConsts.Command) ? args.ExtraProperties[CliConsts.Command] : "",
DatabaseProvider = null,
IsTiered = null,
UiFramework = null,
Options = JsonSerializer.Serialize(options),
ProjectName = null,
TemplateName = args.TemplateName,
TemplateVersion = templateFile.Version
});
return(new ProjectBuildResult(context.Result.ZipContent, args.TemplateName));
}
public async Task <ProjectBuildResult> BuildAsync(ProjectBuildArgs args)
{
var templateInfo = await GetTemplateInfoAsync(args);
NormalizeArgs(args, templateInfo);
await EventBus.PublishAsync(new ProjectCreationProgressEvent {
Message = "Downloading the solution template"
}, false);
var templateFile = await SourceCodeStore.GetAsync(
args.TemplateName,
SourceCodeTypes.Template,
args.Version,
args.TemplateSource,
args.ExtraProperties.ContainsKey(NewCommand.Options.Preview.Long)
);
DeveloperApiKeyResult apiKeyResult = null;
#if DEBUG
try
{
var apiKeyResultSection = _configuration.GetSection("apiKeyResult");
if (apiKeyResultSection.Exists())
{
apiKeyResult = apiKeyResultSection.Get <DeveloperApiKeyResult>(); //you can use user secrets
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
if (apiKeyResult == null)
{
apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
}
#else
apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
#endif
if (apiKeyResult != null)
{
if (apiKeyResult.ApiKey != null)
{
args.ExtraProperties["api-key"] = apiKeyResult.ApiKey;
}
else if (templateInfo.Name == AppProTemplate.TemplateName)
{
throw new UserFriendlyException(apiKeyResult.ErrorMessage);
}
}
if (apiKeyResult?.LicenseCode != null)
{
args.ExtraProperties["license-code"] = apiKeyResult.LicenseCode;
}
var context = new ProjectBuildContext(
templateInfo,
null,
null,
null,
templateFile,
args
);
if (context.Template is AppTemplateBase appTemplateBase)
{
appTemplateBase.HasDbMigrations = SemanticVersion.Parse(templateFile.Version) < new SemanticVersion(4, 3, 99);
}
await EventBus.PublishAsync(new ProjectCreationProgressEvent {
Message = "Customizing the solution template"
}, false);
TemplateProjectBuildPipelineBuilder.Build(context).Execute();
if (!templateInfo.DocumentUrl.IsNullOrEmpty())
{
Logger.LogInformation("Check out the documents at " + templateInfo.DocumentUrl);
}
// Exclude unwanted or known options.
var options = args.ExtraProperties
.Where(x => !x.Key.Equals(CliConsts.Command, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Tiered.Long, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Preview.Long, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.DatabaseProvider.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.DatabaseProvider.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.OutputFolder.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.OutputFolder.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.UiFramework.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.UiFramework.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Mobile.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.Mobile.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Version.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.Version.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.TemplateSource.Short, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.TemplateSource.Long, StringComparison.InvariantCultureIgnoreCase))
.Select(x => x.Key).ToList();
await CliAnalyticsCollect.CollectAsync(new CliAnalyticsCollectInputDto
{
Tool = Options.ToolName,
Command = args.ExtraProperties.ContainsKey(CliConsts.Command) ? args.ExtraProperties[CliConsts.Command] : "",
DatabaseProvider = args.DatabaseProvider.ToProviderName(),
IsTiered = args.ExtraProperties.ContainsKey(NewCommand.Options.Tiered.Long),
UiFramework = args.UiFramework.ToFrameworkName(),
Options = JsonSerializer.Serialize(options),
ProjectName = args.SolutionName.FullName,
TemplateName = args.TemplateName,
TemplateVersion = templateFile.Version
});
return(new ProjectBuildResult(context.Result.ZipContent, args.SolutionName.ProjectName));
}
