public HandlebarsTemplateSet(string directoryPath)
{
HandlebarsDirectories = new HashSet <HandlebarsDirectory>();
HandlebarsDirectories.Add(new HandlebarsDirectory(directoryPath));
HandlebarsEmbeddedResources = new HandlebarsEmbeddedResources(Assembly.GetExecutingAssembly());
_renderer = new HandlebarsTemplateRenderer(HandlebarsEmbeddedResources, HandlebarsDirectories.ToArray());
}
private static void EnsureBaseType(string baseTypeName, string writeTo, HandlebarsTemplateRenderer renderer,
CommandLineDelegatedClassModel model, HashSet <FileInfo> codeFiles)
{
FileInfo baseTypeCodeFile = new FileInfo(Path.Combine(writeTo, $"{baseTypeName}.cs"));
string baseTypeCode = renderer.Render("ProviderBaseClass", model.ProviderBaseClass);
baseTypeCode.SafeWriteToFile(baseTypeCodeFile.FullName, true);
codeFiles.Add(baseTypeCodeFile);
}
private static void GenerateDelegator(string writeTo, DelegatorClassModel model,
HandlebarsTemplateRenderer renderer, HashSet <FileInfo> codeFiles)
{
FileInfo delegatorTypeCodeFile =
new FileInfo(Path.Combine(writeTo, $"{model.BaseTypeName}Delegator.cs"));
string delegatorCode = renderer.Render("Delegator", model);
delegatorCode.SafeWriteToFile(delegatorTypeCodeFile.FullName, true);
codeFiles.Add(delegatorTypeCodeFile);
}
public override void WriteSource(string writeSourceDir)
{
List <TypeModel> typeModels = new List <TypeModel>();
Parallel.ForEach(Types, type =>
{
TypeModel typeModel = new TypeModel {
Type = type, SchemaName = Config.SchemaName, ToNameSpace = Config.ToNameSpace
};
typeModels.Add(typeModel);
string code = HandlebarsTemplateRenderer.Render("GraphQLType", typeModel);
string writeToFile = Path.Combine(writeSourceDir, $"{type.Name}Graph.cs");
code.SafeWriteToFile(writeToFile, true);
});
SchemaModel schemaModel = new SchemaModel()
{
SchemaName = Config.SchemaName, DataTypes = typeModels.ToArray(),
UsingStatements = GetUsingStatements(typeModels.Select(t => t.Type)),
ToNameSpace = Config.ToNameSpace
};
string contextCode = HandlebarsTemplateRenderer.Render("GraphQLQueryContext", schemaModel);
contextCode.SafeWriteToFile(Path.Combine(writeSourceDir, $"{Config.SchemaName}.cs"), true);
}
public HandlebarsTemplateSet(Assembly embeddedResourceContainer)
{
HandlebarsDirectories = new HashSet <HandlebarsDirectory>();
HandlebarsEmbeddedResources = new HandlebarsEmbeddedResources(embeddedResourceContainer);
_renderer = new HandlebarsTemplateRenderer(HandlebarsEmbeddedResources, HandlebarsDirectories.ToArray());
}
public HandlebarsAppPageRenderer(AppContentResponder appContentResponder, ITemplateManager commonTemplateManager, IApplicationTemplateManager applicationTemplateManager) : base(appContentResponder, commonTemplateManager, applicationTemplateManager)
{
FileExtension = ".hbs";
TemplateRenderer = new HandlebarsTemplateRenderer(AppConf.HtmlDir);
}
public GraphQLTypeGenerator()
{
Types = new HashSet <Type>();
HandlebarsTemplateRenderer = new HandlebarsTemplateRenderer();
}
public override void Add(Action <string> output = null, Action <string> error = null)
{
try
{
HashSet <FileInfo> codeFiles = new HashSet <FileInfo>();
HandlebarsTemplateRenderer renderer = new HandlebarsTemplateRenderer(new HandlebarsEmbeddedResources(GetType().Assembly));
RoslynCompiler compiler = new RoslynCompiler();
ShellGenConfig config = GetConfig();
Type baseType = null;
if (!Arguments.Contains("generateBaseType"))
{
Message("Searching current AppDomain for specified base type ({0})", output, config.BaseTypeName);
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
baseType = FindType(assembly, config.BaseTypeNamespace, config.BaseTypeName);
if (baseType != null)
{
Message("Found base type ({0}) in assembly ({1})", output, config.BaseTypeName, assembly.FullName);
break;
}
}
}
CommandLineDelegatedClassModel model = CommandLineDelegatedClassModel.Create(config.ConcreteTypeName, config.BaseTypeName);
model.Namespace = config.Namespace;
SetConcreteModelProperties(model.ConcreteClass, config);
ShellDescriptor descriptor = new ShellDescriptor();
if (baseType != null)
{
descriptor = new ShellDescriptor(baseType);
model.SetMethods(baseType.GetMethods().Where(m => m.IsAbstract).Select(m => m.Name).ToArray());
}
else
{
model.SetMethods(GetArgument("methodNames",
"Please enter the method names to define on the base type (comma separated).")
.DelimitSplit(","));
compiler.AddAssemblyReference(typeof(IRegisterArguments));
EnsureBaseType(config.BaseTypeName, config.WriteTo, renderer, model, codeFiles);
}
model.SetBaseTypeName(config.BaseTypeName);
GenerateDelegator(config.WriteTo, model.DelegatorClass, renderer, codeFiles);
GenerateConcreteType(config.WriteTo, config.ConcreteTypeName, renderer, model.ConcreteClass, codeFiles);
byte[] delegatorAssembly = compiler.Compile(config.ConcreteTypeName, codeFiles.ToArray());
descriptor = ShellGenerationRepository.Save(descriptor);
ShellWrapperAssembly wrapperAssembly = new ShellWrapperAssembly {
ShellDescriptorKey = descriptor.Key(), Base64Assembly = delegatorAssembly.ToBase64()
};
ShellGenerationRepository.Save(wrapperAssembly);
}
catch (Exception ex)
{
error(ex.Message);
Exit(1);
}
}
private static void GenerateConcreteType(string writeTo, string concreteTypeName, HandlebarsTemplateRenderer renderer,
ConcreteClassModel model, HashSet <FileInfo> codeFiles)
{
FileInfo concreteTypeCodeFile = new FileInfo(Path.Combine(writeTo, $"{concreteTypeName}.cs"));
string concreteTypeCode = renderer.Render("ConcreteClass", model);
concreteTypeCode.SafeWriteToFile(concreteTypeCodeFile.FullName, true);
codeFiles.Add(concreteTypeCodeFile);
}
