internal static Result<CodeNamespace> Process(string xsdFile, string targetNamespace,
GenerationLanguage language,
CollectionType collectionType, bool enableDataBinding,
bool hidePrivate,
bool enableSummaryComment, List<NamespaceParam> customUsings,
string collectionBase, bool includeSerializeMethod,
string serializeMethodName, string deserializeMethodName,
string saveToFileMethodName, string loadFromFileMethodName,
bool generateCloneMethod, TargetFramework targetFramework)
{
var generatorParams = new GeneratorParams
{
CollectionObjectType = collectionType,
EnableDataBinding = enableDataBinding,
Language = language,
CustomUsings = customUsings,
CollectionBase = collectionBase,
GenerateCloneMethod = generateCloneMethod,
TargetFramework = targetFramework
};
generatorParams.Miscellaneous.HidePrivateFieldInIde = hidePrivate;
generatorParams.Miscellaneous.EnableSummaryComment = enableSummaryComment;
generatorParams.Serialization.Enabled = includeSerializeMethod;
generatorParams.Serialization.SerializeMethodName = serializeMethodName;
generatorParams.Serialization.DeserializeMethodName = deserializeMethodName;
generatorParams.Serialization.SaveToFileMethodName = saveToFileMethodName;
generatorParams.Serialization.LoadFromFileMethodName = loadFromFileMethodName;
return Process(generatorParams);
}
internal static Result <CodeNamespace> Process(string xsdFile, string targetNamespace,
GenerationLanguage language,
CollectionType collectionType, bool enableDataBinding,
bool hidePrivate,
bool enableSummaryComment, List <NamespaceParam> customUsings,
string collectionBase, bool includeSerializeMethod,
string serializeMethodName, string deserializeMethodName,
string saveToFileMethodName, string loadFromFileMethodName,
bool generateCloneMethod, TargetFramework targetFramework)
{
var generatorParams = new GeneratorParams
{
CollectionObjectType = collectionType,
EnableDataBinding = enableDataBinding,
Language = language,
CustomUsings = customUsings,
CollectionBase = collectionBase,
GenerateCloneMethod = generateCloneMethod,
TargetFramework = targetFramework
};
generatorParams.Miscellaneous.HidePrivateFieldInIde = hidePrivate;
generatorParams.Miscellaneous.EnableSummaryComment = enableSummaryComment;
generatorParams.Serialization.Enabled = includeSerializeMethod;
generatorParams.Serialization.SerializeMethodName = serializeMethodName;
generatorParams.Serialization.DeserializeMethodName = deserializeMethodName;
generatorParams.Serialization.SaveToFileMethodName = saveToFileMethodName;
generatorParams.Serialization.LoadFromFileMethodName = loadFromFileMethodName;
return(Process(generatorParams));
}
/// <summary>
/// Get Code DOM provider
/// </summary>
/// <returns></returns>
public static CodeDomProvider GetProvider(GenerationLanguage language)
{
switch (language)
{
case GenerationLanguage.CSharp:
return(new CSharpCodeProvider());
case GenerationLanguage.VisualBasic:
return(new VBCodeProvider());
default:
throw new NotImplementedException(string.Format("Code provider for language {0} is not supported", Utility.GetEnumDescription(language)));
}
}
/// <summary>
/// Get Code DOM provider
/// </summary>
/// <returns></returns>
public static CodeDomProvider GetProvider(GenerationLanguage language)
{
switch (language)
{
case GenerationLanguage.CSharp:
return new CSharpCodeProvider();
case GenerationLanguage.VisualBasic:
return new VBCodeProvider();
default:
throw new NotImplementedException(string.Format("Code provider for language {0} is not supported", Utility.GetEnumDescription(language)));
}
}
/// <summary>
/// Get Code DOM provider
/// </summary>
/// <param name="language">The language.</param>
/// <returns>CodeDom provider according language.</returns>
public static CodeDomProvider GetProvider(GenerationLanguage language)
{
switch (language)
{
case GenerationLanguage.CSharp:
return new CSharpCodeProvider();
case GenerationLanguage.VisualBasic:
return new VBCodeProvider();
default:
throw new NotImplementedException(
string.Format(Properties.Resources.UnsupportedLanguageCodeDomProvider, Utility.GetEnumDescription(language)));
}
}
/// <summary>
/// Get Code DOM provider
/// </summary>
/// <param name="language">The language.</param>
/// <returns>CodeDom provider according language.</returns>
public static CodeDomProvider GetProvider(GenerationLanguage language)
{
switch (language)
{
case GenerationLanguage.CSharp:
return(new CSharpCodeProvider());
case GenerationLanguage.VisualBasic:
return(new VBCodeProvider());
default:
throw new NotImplementedException(
string.Format(Properties.Resources.UnsupportedLanguageCodeDomProvider, Utility.GetEnumDescription(language)));
}
}
public async Task GeneratesResponseWithMultipleReturnFormats(GenerationLanguage language, bool backingStore)
{
var logger = LoggerFactory.Create((builder) => {
}).CreateLogger <KiotaBuilder>();
var backingStoreSuffix = backingStore ? "BackingStore" : string.Empty;
var configuration = new GenerationConfiguration
{
Language = language,
OpenAPIFilePath = "ResponseWithMultipleReturnFormats.yaml",
OutputPath = $".\\Generated\\ResponseWithMultipleReturnFormats\\{language}{backingStoreSuffix}",
UsesBackingStore = backingStore,
};
await new KiotaBuilder(logger, configuration).GenerateSDK(new());
}
public async Task GeneratesTodo(GenerationLanguage language, bool backingStore)
{
var logger = LoggerFactory.Create((builder) => {
}).CreateLogger <KiotaBuilder>();
var backingStoreSuffix = backingStore ? string.Empty : "BackingStore";
var configuration = new GenerationConfiguration
{
Language = language,
OpenAPIFilePath = "ToDoApi.yaml",
OutputPath = $".\\Generated\\Todo\\{language}{backingStoreSuffix}",
UsesBackingStore = backingStore,
};
await new KiotaBuilder(logger, configuration).GenerateSDK(new());
}
/// <summary>
/// Get output file path
/// </summary>
/// <param name="xsdFilePath">Input file path</param>
/// <param name="language">Generation language</param>
/// <returns>Generated file output path</returns>
public static string GetOutputFilePath(string xsdFilePath, GenerationLanguage language)
{
return(GetOutputFilePath(xsdFilePath, CodeDomProviderFactory.GetProvider(language)));
/* DCM REMOVED CodeDom Provider has FileExtension
* switch (language)
* {
* case GenerationLanguage.VisualBasic:
* return Path.ChangeExtension(xsdFilePath, ".Designer.vb");
* case GenerationLanguage.VisualCpp:
* return Path.ChangeExtension(xsdFilePath, ".Designer.cpp");
* default:
* return Path.ChangeExtension(xsdFilePath, ".Designer.cs");
* }
*/
}
public GeneratorFacade(string inputFile,
string nameSpace,
GenerationLanguage language,
CollectionType collectionType,
bool enableDataBinding, bool hidePrivate, bool enableSummaryComment,
List<NamespaceParam> customUsings, string collectionBase, bool includeSerializeMethod,
string serializeMethodName, string deserializeMethodName, string saveToFileMethodName,
string loadFromFileMethodName, bool disableDebug, bool implementCloneMethod,
TargetFramework targetFramework)
{
var provider = CodeDomProviderFactory.GetProvider(language);
this.Init(inputFile, nameSpace, provider, collectionType, enableDataBinding, hidePrivate,
enableSummaryComment, customUsings, collectionBase, includeSerializeMethod, serializeMethodName,
deserializeMethodName, saveToFileMethodName, loadFromFileMethodName, disableDebug,
implementCloneMethod, targetFramework);
}
/// <summary>
/// Creates a new CodeBuilder.
/// </summary>
/// <param name="xmlPath">The path to the DTML file</param>
/// <param name="lang">The language to generate with.</param>
/// <returns></returns>
public static ClassGenerator CreateBuilder(string xmlPath, string ns, GenerationLanguage lang)
{
var args = new ClassGeneratorArgs()
{
DtmlPath = xmlPath,
Namespace = ns,
};
switch (lang)
{
case GenerationLanguage.VB:
args.Provider = new VBCodeProvider();
break;
case GenerationLanguage.CSharp:
default:
args.Provider = new CSharpCodeProvider();
break;
}
return new ClassGenerator(args);
}
/// <summary>
/// Creates a new CodeBuilder.
/// </summary>
/// <param name="xmlPath">The path to the DTML file</param>
/// <param name="lang">The language to generate with.</param>
/// <returns></returns>
public static ClassGenerator CreateBuilder(string xmlPath, string ns, GenerationLanguage lang)
{
var args = new ClassGeneratorArgs()
{
DtmlPath = xmlPath,
Namespace = ns,
};
switch (lang)
{
case GenerationLanguage.VB:
args.Provider = new VBCodeProvider();
break;
case GenerationLanguage.CSharp:
default:
args.Provider = new CSharpCodeProvider();
break;
}
return(new ClassGenerator(args));
}
public static ClassGenerator CreateBuilder(string ns, GenerationLanguage lang, XDocument dtml, bool isInterface, bool interfaceInheritance)
{
var args = new ClassGeneratorArgs()
{
Dtml = dtml,
Namespace = ns,
IsInterface = isInterface,
GenerateInterfaceInheritance = interfaceInheritance
};
switch (lang)
{
case GenerationLanguage.VB:
args.Provider = new VBCodeProvider();
break;
case GenerationLanguage.CSharp:
default:
args.Provider = new CSharpCodeProvider();
break;
}
return new ClassGenerator(args);
}
public static ClassGenerator CreateBuilder(string ns, GenerationLanguage lang, XDocument dtml, bool isInterface, bool interfaceInheritance)
{
var args = new ClassGeneratorArgs()
{
Dtml = dtml,
Namespace = ns,
IsInterface = isInterface,
GenerateInterfaceInheritance = interfaceInheritance
};
switch (lang)
{
case GenerationLanguage.VB:
args.Provider = new VBCodeProvider();
break;
case GenerationLanguage.CSharp:
default:
args.Provider = new CSharpCodeProvider();
break;
}
return(new ClassGenerator(args));
}
public async Task <int> InvokeAsync(InvocationContext context)
{
string output = context.ParseResult.GetValueForOption(OutputOption);
GenerationLanguage language = context.ParseResult.GetValueForOption(LanguageOption);
string openapi = context.ParseResult.GetValueForOption(DescriptionOption);
bool backingStore = context.ParseResult.GetValueForOption(BackingStoreOption);
string className = context.ParseResult.GetValueForOption(ClassOption);
LogLevel logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
string namespaceName = context.ParseResult.GetValueForOption(NamespaceOption);
List <string> serializer = context.ParseResult.GetValueForOption(SerializerOption);
List <string> deserializer = context.ParseResult.GetValueForOption(DeserializerOption);
bool cleanOutput = context.ParseResult.GetValueForOption(CleanOutputOption);
List <string> structuredMimeTypes = context.ParseResult.GetValueForOption(StructuredMimeTypesOption);
CancellationToken cancellationToken = (CancellationToken)context.BindingContext.GetService(typeof(CancellationToken));
AssignIfNotNullOrEmpty(output, (c, s) => c.OutputPath = s);
AssignIfNotNullOrEmpty(openapi, (c, s) => c.OpenAPIFilePath = s);
AssignIfNotNullOrEmpty(className, (c, s) => c.ClientClassName = s);
AssignIfNotNullOrEmpty(namespaceName, (c, s) => c.ClientNamespaceName = s);
Configuration.UsesBackingStore = backingStore;
Configuration.Language = language;
if (serializer?.Any() ?? false)
{
Configuration.Serializers = serializer.Select(x => x.TrimQuotes()).ToHashSet(StringComparer.OrdinalIgnoreCase);
}
if (deserializer?.Any() ?? false)
{
Configuration.Deserializers = deserializer.Select(x => x.TrimQuotes()).ToHashSet(StringComparer.OrdinalIgnoreCase);
}
if (structuredMimeTypes?.Any() ?? false)
{
Configuration.StructuredMimeTypes = structuredMimeTypes.SelectMany(x => x.Split(new char[] { ' ' }))
.Select(x => x.TrimQuotes())
.ToHashSet(StringComparer.OrdinalIgnoreCase);
}
#if DEBUG
logLevel = logLevel > LogLevel.Debug ? LogLevel.Debug : logLevel;
#endif
Configuration.OpenAPIFilePath = GetAbsolutePath(Configuration.OpenAPIFilePath);
Configuration.OutputPath = GetAbsolutePath(Configuration.OutputPath);
Configuration.CleanOutput = cleanOutput;
using var loggerFactory = LoggerFactory.Create((builder) => {
builder
.AddConsole()
#if DEBUG
.AddDebug()
#endif
.SetMinimumLevel(logLevel);
});
var logger = loggerFactory.CreateLogger <KiotaBuilder>();
logger.LogTrace("configuration: {configuration}", JsonSerializer.Serialize(Configuration));
try {
await new KiotaBuilder(logger, Configuration).GenerateSDK(cancellationToken);
return(0);
} catch (Exception ex) {
#if DEBUG
logger.LogCritical(ex, "error generating the SDK: {exceptionMessage}", ex.Message);
throw; // so debug tools go straight to the source of the exception when attached
#else
logger.LogCritical("error generating the SDK: {exceptionMessage}", ex.Message);
return(1);
#endif
}
}
/// <summary>
/// Gets the language extension based on the Passed language.
/// </summary>
/// <param name="language">The language.</param>
/// <returns></returns>
public static string GetLanguageExtension(GenerationLanguage language)
{
return(CodeDomProviderFactory.GetProvider(language).FileExtension);
}
