private static async Task GenerateClass(KernelInvocationContext context,
IFileReader fileReader,
IGeneratorConfiguration config)
{
var classGenerator = new ClassGenerator();
var className = Path.GetFileNameWithoutExtension(fileReader.FileName);
className = char.ToUpper(className[0]) + className.Substring(1);
context.Display($"Generating class {className}", new[] { "text/html" });
var source = classGenerator.GenerateFile(fileReader.FileMetaData, config);
var result = await context.HandlingKernel.SubmitCodeAsync(source);
result.KernelEvents.Subscribe((ev) => { }, (ex) =>
{
context.Display(ex.Message, new[] { "text/plain" });
});
result.KernelEvents.Subscribe((ev) =>
{
if (ev is ErrorProduced error)
{
context.Fail(context.Command, null, error.Message);
}
if (ev is CommandFailed failure)
{
context.Fail(context.Command, null, failure.Message);
}
});
}
public Task HandleAsync(SubmitCode command, KernelInvocationContext context)
{
var markdown = new MermaidMarkdown(command.Code);
context.Display(markdown);
return(Task.CompletedTask);
}
private async Task InitializeDbContextAsync(MsSqlConnectionOptions options, KernelInvocationContext context)
{
CSharpKernel csharpKernel = null;
context.HandlingKernel.VisitSubkernelsAndSelf(k =>
{
if (k is CSharpKernel csk)
{
csharpKernel = csk;
}
});
if (csharpKernel is null)
{
return;
}
context.Display($"Scaffolding a `DbContext` and initializing an instance of it called `{options.KernelName}` in the C# kernel.", "text/markdown");
var submission1 = @$ "
#r " "nuget:Microsoft.EntityFrameworkCore.Design,3.1.8" "
#r " "nuget:Microsoft.EntityFrameworkCore.SqlServer,3.1.8" "
using System;
using System.Reflection;
using System.Linq;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.EntityFrameworkCore.Scaffolding;
using Microsoft.Extensions.DependencyInjection;
var services = new ServiceCollection();
services.AddEntityFrameworkDesignTimeServices();
var providerAssembly = Assembly.Load(" "Microsoft.EntityFrameworkCore.SqlServer" ");
var providerServicesAttribute = providerAssembly.GetCustomAttribute<DesignTimeProviderServicesAttribute>();
var providerServicesType = providerAssembly.GetType(providerServicesAttribute.TypeName);
var providerServices = (IDesignTimeServices)Activator.CreateInstance(providerServicesType);
providerServices.ConfigureDesignTimeServices(services);
var serviceProvider = services.BuildServiceProvider();
var scaffolder = serviceProvider.GetService<IReverseEngineerScaffolder>();
var model = scaffolder.ScaffoldModel(
@" "{options.ConnectionString}" ",
new DatabaseModelFactoryOptions(),
new ModelReverseEngineerOptions(),
new ModelCodeGenerationOptions()
{{
ContextName = " "{options.KernelName}Context" ",
ModelNamespace = " "{options.KernelName}" "
}});
public virtual async Task HandleAsync(
SubmitCode submitCode,
KernelInvocationContext context)
{
await using var connection = OpenConnection();
if (connection.State != ConnectionState.Open)
{
await connection.OpenAsync();
}
await using var dbCommand = connection.CreateCommand();
dbCommand.CommandText = submitCode.Code;
var results = Execute(dbCommand);
context.Display(results);
}
private async Task LoadScriptExtensionFromDirectory(
DirectoryInfo directory,
Kernel kernel,
KernelInvocationContext context)
{
var extensionFile = new FileInfo(Path.Combine(directory.FullName, ExtensionScriptName));
if (extensionFile.Exists)
{
var logMessage = $"Loading extension script from `{extensionFile.FullName}`";
using var op = new ConfirmationLogger(
Log.Category,
message: logMessage,
logOnStart: true,
args: new object[] { extensionFile });
context.Display(logMessage, "text/markdown");
var scriptContents = File.ReadAllText(extensionFile.FullName, Encoding.UTF8);
await kernel.SubmitCodeAsync(scriptContents);
}
}
public async Task HandleAsync(SubmitCode command, KernelInvocationContext context)
{
if (!_connected)
{
return;
}
if (_queryCompletionHandler != null)
{
context.Display("Error: Another query is currently running. Please wait for that query to complete before re-running this cell.");
return;
}
var completion = new TaskCompletionSource <bool>();
_queryCompletionHandler = async queryParams =>
{
try
{
foreach (var batchSummary in queryParams.BatchSummaries)
{
foreach (var resultSummary in batchSummary.ResultSetSummaries)
{
if (completion.Task.IsCompleted)
{
return;
}
var subsetParams = new QueryExecuteSubsetParams()
{
OwnerUri = _tempFileUri.ToString(),
BatchIndex = batchSummary.Id,
ResultSetIndex = resultSummary.Id,
RowsStartIndex = 0,
RowsCount = Convert.ToInt32(resultSummary.RowCount)
};
var subsetResult = await _serviceClient.ExecuteQueryExecuteSubsetAsync(subsetParams);
if (subsetResult.Message != null)
{
context.Fail(message: subsetResult.Message);
}
else
{
var table = GetEnumerableTable(resultSummary.ColumnInfo, subsetResult.ResultSubset.Rows);
context.Display(table);
}
}
}
completion.SetResult(true);
}
catch (Exception e)
{
completion.SetException(e);
}
};
#pragma warning disable 1998
_queryMessageHandler = async messageParams =>
{
try
{
if (messageParams.Message.IsError)
{
context.Fail(message: messageParams.Message.Message);
completion.SetResult(true);
}
}
catch (Exception e)
{
completion.SetException(e);
}
};
#pragma warning restore 1998
try
{
await _serviceClient.ExecuteQueryStringAsync(_tempFileUri, command.Code);
await completion.Task;
}
finally
{
_queryCompletionHandler = null;
_queryMessageHandler = null;
}
}
private async Task LoadFromAssembly(
FileInfo assemblyFile,
Kernel kernel,
KernelInvocationContext context)
{
if (assemblyFile is null)
{
throw new ArgumentNullException(nameof(assemblyFile));
}
if (kernel is null)
{
throw new ArgumentNullException(nameof(kernel));
}
if (!assemblyFile.Exists)
{
throw new ArgumentException($"File {assemblyFile.FullName} doesn't exist", nameof(assemblyFile));
}
bool loadExtensions;
lock (_lock)
{
loadExtensions = _loadedAssemblies.Add(AssemblyName.GetAssemblyName(assemblyFile.FullName));
}
if (loadExtensions)
{
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyFile.FullName);
var extensionTypes = assembly
.ExportedTypes
.Where(t => t.CanBeInstantiated() && typeof(IKernelExtension).IsAssignableFrom(t))
.ToArray();
if (extensionTypes.Any())
{
context.Display($"Loading extensions from `{assemblyFile.Name}`", "text/markdown");
}
foreach (var extensionType in extensionTypes)
{
var extension = (IKernelExtension)Activator.CreateInstance(extensionType);
try
{
await extension.OnLoadAsync(kernel);
context.Publish(new KernelExtensionLoaded(extension, context.Command));
}
catch (Exception e)
{
context.Publish(new ErrorProduced(
$"Failed to load kernel extension \"{extensionType.Name}\" from assembly {assemblyFile.FullName}",
context.Command));
context.Fail(new KernelExtensionLoadException(e));
}
}
}
}
