public override Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
ValidateNameSpaceName(controllerGeneratorModel);
var outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
return(Task.CompletedTask);
}
protected virtual CommandLineGeneratorModel GetModel()
{
var model = new CommandLineGeneratorModel();
model.ControllerName = "TestController";
return(model);
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
Contract.Assert(!String.IsNullOrEmpty(controllerGeneratorModel.ModelClass));
ValidateNameSpaceName(controllerGeneratorModel);
string outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
_areaName = GetAreaName(ApplicationInfo.ApplicationBasePath, outputPath);
var modelTypeAndContextModel = await ModelMetadataUtilities.ValidateModelAndGetEFMetadata(
controllerGeneratorModel,
EntityFrameworkService,
ModelTypesLocator,
_areaName
);
if (string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
//Todo: Pluralize model name
controllerGeneratorModel.ControllerName = modelTypeAndContextModel.ModelType.Name + Constants.ControllerSuffix;
}
var namespaceName = string.IsNullOrEmpty(controllerGeneratorModel.ControllerNamespace)
? GetDefaultControllerNamespace(controllerGeneratorModel.RelativeFolderPath)
: controllerGeneratorModel.ControllerNamespace;
var templateModel = new ControllerWithContextTemplateModel(modelTypeAndContextModel.ModelType, modelTypeAndContextModel.DbContextFullName)
{
ControllerName = controllerGeneratorModel.ControllerName,
AreaName = _areaName,
UseAsync = controllerGeneratorModel.UseAsync, // This is no longer used for controllers with context.
ControllerNamespace = namespaceName,
ModelMetadata = modelTypeAndContextModel.ContextProcessingResult.ModelMetadata
};
await CodeGeneratorActionsService.AddFileFromTemplateAsync(
outputPath,
GetTemplateName(controllerGeneratorModel),
TemplateFolders,
templateModel
);
Logger.LogMessage("Added Controller : " + outputPath.Substring(ApplicationInfo.ApplicationBasePath.Length));
await GenerateViewsIfRequired(
controllerGeneratorModel,
modelTypeAndContextModel,
templateModel.ControllerRootName
);
if (modelTypeAndContextModel.ContextProcessingResult.ContextProcessingStatus
== ContextProcessingStatus.ContextAddedButRequiresConfig)
{
throw new Exception(string.Format("{0} {1}", MessageStrings.ScaffoldingSuccessful_unregistered,
MessageStrings.Scaffolding_additionalSteps));
}
}
private async Task GenerateControllerAndViews(CommandLineGeneratorModel cgModel)
{
try
{
// Generate Controller & 3-Views(Index, Details, Edit)
var generator = ActivatorUtilities.CreateInstance <ControllerWithContextGenerator>(
this._serviceProvider
);
await generator.Generate(cgModel);
}
catch (Exception ex)
{
this._logger.LogMessage(Xb.Util.GetErrorHighlighted(ex));
throw ex;
}
}
private async Task GenerateViewsIfRequired(
CommandLineGeneratorModel controllerGeneratorModel,
ModelTypeAndContextModel modelTypeAndContextModel,
string controllerRootName
)
{
if (!controllerGeneratorModel.IsRestController && !controllerGeneratorModel.NoViews)
{
var layoutDependencyInstaller = ActivatorUtilities.CreateInstance <MvcLayoutDependencyInstaller>(ServiceProvider);
var viewGenerator = ActivatorUtilities.CreateInstance <ModelBasedViewScaffolder>(ServiceProvider);
var areaPath = string.IsNullOrEmpty(_areaName) ? string.Empty : Path.Combine("Areas", _areaName);
var viewBaseOutputPath = Path.Combine(
ApplicationInfo.ApplicationBasePath,
areaPath,
Constants.ViewsFolderName,
controllerRootName);
await layoutDependencyInstaller.Execute();
var viewGeneratorModel = new ViewGeneratorModel()
{
UseDefaultLayout = controllerGeneratorModel.UseDefaultLayout,
PartialView = false,
LayoutPage = controllerGeneratorModel.LayoutPage,
Force = controllerGeneratorModel.Force,
RelativeFolderPath = viewBaseOutputPath,
ReferenceScriptLibraries = controllerGeneratorModel.ReferenceScriptLibraries
};
var viewAndTemplateNames = new Dictionary <string, string>();
foreach (var viewTemplate in _views)
{
var viewName = viewTemplate == "List" ? "Index" : viewTemplate;
viewAndTemplateNames.Add(viewName, viewTemplate);
}
await viewGenerator.GenerateViews(
viewAndTemplateNames,
viewGeneratorModel,
modelTypeAndContextModel,
viewBaseOutputPath
);
await layoutDependencyInstaller.InstallDependencies();
}
}
protected string ValidateAndGetOutputPath(CommandLineGeneratorModel commandLineModel, string outputFileName)
{
string outputFolder = String.IsNullOrEmpty(commandLineModel.RelativeFolderPath)
? ApplicationEnvironment.ApplicationBasePath
: Path.Combine(ApplicationEnvironment.ApplicationBasePath, commandLineModel.RelativeFolderPath);
var outputPath = Path.Combine(outputFolder, outputFileName);
if (File.Exists(outputPath) && !commandLineModel.Force)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
"The file {0} exists, use -f option to overwrite",
outputPath));
}
return(outputPath);
}
internal async Task Generate(CommandLineGeneratorModel model)
{
DocumentationViewModel viewModel = new DocumentationViewModel();
viewModel.Attributes = new List <AttributeInfo>();
viewModel.Interfaces = new List <InterfaceInfo>();
viewModel.BaseControllers = new List <BaseControllerInfo>();
viewModel.Models = new List <ModelInfo>();
ParseAttributes(viewModel);
ParseInterfaces(viewModel);
ParseBaseControllers(viewModel);
ParseModels(viewModel);
var viewOutputPath = Path.Combine(
ApplicationEnvironment.ApplicationBasePath,
"Views",
"Home",
"Documentation.cshtml");
await CodeGeneratorActionsService.AddFileFromTemplateAsync(viewOutputPath,
"StaticDocumentationBuilder.cshtml", TemplateFolders, viewModel);
}
public async Task GenerateCode(CommandLineGeneratorModel model)
{
var generator = ActivatorUtilities.CreateInstance <DocumentationGenerator>(ServiceProvider);
await generator.Generate(model);
}
public static void Main(string[] args)
{
var app = new CommandLineApplication(false)
{
Name = "Coalesce"
};
app.HelpOption("-h|--help");
var dataContextClass = app.Option("-dc|--dataContext", "Data Context containing the classes to scaffold", CommandOptionType.SingleValue);
var force = app.Option("-f|--force", "Use this option to overwrite existing files", CommandOptionType.SingleValue);
var relativeFolderPath = app.Option("-outDir|--relativeFolderPath", "Specify the relative output folder path from project where the file needs to be generated, if not specified, file will be generated in the project folder", CommandOptionType.SingleValue);
var onlyGenerateFiles = app.Option("-filesOnly|--onlyGenerateFiles", "Will only generate the file output and will not restore any of the packages", CommandOptionType.SingleValue);
var validateOnly = app.Option("-vo|--validateOnly", "Validates the model but does not generate the models", CommandOptionType.SingleValue);
var area = app.Option("-a|--area", "The area where the generated/scaffolded code should be placed", CommandOptionType.SingleValue);
var module = app.Option("-m|--module", "The prefix to apply to the module name of the generated typescript files", CommandOptionType.SingleValue);
var webProject = app.Option("-wp|--webproject", "Relative path to the web project; if empty will search up from current folder for first project.json", CommandOptionType.SingleValue);
var dataProject = app.Option("-dp|--dataproject", "Relative path to the data project", CommandOptionType.SingleValue);
var targetNamespace = app.Option("-ns|--namespace", "Target Namespace for the generated code", CommandOptionType.SingleValue);
app.OnExecute(async() =>
{
var model = new CommandLineGeneratorModel
{
DataContextClass = dataContextClass.Value() ?? "",
Force = force.Value() != null && force.Value().ToLower() == "true",
RelativeFolderPath = relativeFolderPath.Value() ?? "",
OnlyGenerateFiles = onlyGenerateFiles.Value() != null && onlyGenerateFiles.Value().ToLower() == "true",
ValidateOnly = validateOnly.Value() != null && validateOnly.Value().ToLower() == "true",
AreaLocation = area.Value() ?? "",
TypescriptModulePrefix = module.Value() ?? "",
TargetNamespace = targetNamespace.Value() ?? ""
};
// Find the web project
ProjectContext webContext = DependencyProvider.ProjectContext(webProject.Value());
if (webContext == null)
{
throw new ArgumentException("Web project or target namespace was not found.");
}
// Find the data project
ProjectContext dataContext = DependencyProvider.ProjectContext(dataProject.Value());
if (dataContext == null)
{
throw new ArgumentException("Data project was not found.");
}
Console.WriteLine("");
CommandLineGenerator generator = new CommandLineGenerator(webContext, dataContext);
await generator.GenerateCode(model);
return(0);
});
try
{
app.Execute(args);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
if (ex.InnerException != null)
{
Console.WriteLine(ex.InnerException.Message);
Console.WriteLine(ex.InnerException.StackTrace);
}
}
}
protected override string GetTemplateName(CommandLineGeneratorModel controllerGeneratorModel)
{
throw new NotImplementedException();
}
protected override string GetTemplateName(CommandLineGeneratorModel generatorModel)
{
return(generatorModel.IsRestController ? Constants.ApiControllerWithContextTemplate : Constants.MvcControllerWithContextTemplate);
}
/// <summary>
/// Exec code generation
/// </summary>
/// <param name="genModel"></param>
/// <returns></returns>
public async Task GenerateCode(XbCodeGeneratorModel genModel)
{
try
{
if (genModel == null)
{
throw new ArgumentNullException(nameof(genModel));
}
this._modelName = genModel.ModelName
?? throw new ArgumentException(MessageStrings.ModelNameRequired);
this._dbContextName = genModel.DbContextName
?? throw new ArgumentException(MessageStrings.DbContextNameRequired);
this._controllerName = genModel.ControllerName
?? throw new ArgumentException(MessageStrings.ControllerNameRequired);
this._areaName = genModel.AreaName;
// When multiple this NuGet packages are installed,
// depending on the situation, older versions may be used.
var version = this.GetType().GetTypeInfo().Assembly.GetName().Version.ToString();
this._logger.LogMessage($"Generator version: {version}");
if (!string.IsNullOrEmpty(genModel.ControllerName) &&
(Xb.Str.Right(genModel.ControllerName, 10).ToLower() == "controller"))
{
this._controllerName = genModel.ControllerName;
this._baseName = Xb.Str.SliceReverse(genModel.ControllerName, -10);
}
else
{
this._controllerName = genModel.ControllerName + "Controller";
this._baseName = genModel.ControllerName;
}
var cgModel = new CommandLineGeneratorModel()
{
ModelClass = this._modelName,
DataContextClass = this._dbContextName,
ControllerName = this._controllerName,
RelativeFolderPath = string.IsNullOrEmpty(this._areaName)
? "Controllers"
: Path.Combine("Areas", this._areaName, "Controllers")
};
this._modelTypeAndContextModel = await ModelMetadataUtilities.ValidateModelAndGetEFMetadata(
cgModel,
this._entityFrameworkService,
this._modelTypesLocator,
this._areaName
);
this._logger.LogMessage($"Model name: {this._modelName}");
this._logger.LogMessage($"DbContext name: {this._dbContextName}");
this._logger.LogMessage($"Controller name: {this._controllerName}"
+ ((this._controllerName == genModel.ControllerName)
? ""
: $" (passing: {genModel.ControllerName})"));
this._logger.LogMessage($"Area name: {this._areaName}");
await this.GenerateControllerAndViews(cgModel);
await this.GenerateStore();
await this.GenerateViewModel();
}
catch (Exception ex)
{
this._logger?.LogMessage(Xb.Util.GetErrorHighlighted(ex));
throw ex;
}
}
