public IActionResult Code(string org, string service)
{
List <AltinnCoreFile> altinnCoreFiles = _repository.GetImplementationFiles(org, service);
CodeCompilationResult compResult = _compilation.CreateServiceAssembly(org, service, false, null, false);
// Check to see if any of the files has compiliation errors or warnings
foreach (AltinnCoreFile coreFile in altinnCoreFiles)
{
if (compResult.CompilationInfo != null &&
compResult.CompilationInfo.Exists(c => c.FileName.ToLower().Equals(coreFile.FileName.ToLower()) && c.Severity.Equals("Error")))
{
coreFile.FileStatus = ServiceLibrary.Enums.AltinnCoreFileStatusType.Error;
}
else if (compResult.CompilationInfo != null &&
compResult.CompilationInfo.Exists(c => c.FileName.ToLower().Equals(coreFile.FileName.ToLower()) && c.Severity.Equals("Warning")))
{
coreFile.FileStatus = ServiceLibrary.Enums.AltinnCoreFileStatusType.Warning;
}
else
{
coreFile.FileStatus = ServiceLibrary.Enums.AltinnCoreFileStatusType.OK;
}
}
string filePath = _settings.GetModelPath(org, service, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext)) + _settings.ServiceModelFileName;
ViewBag.HasDataModel = System.IO.File.Exists(filePath);
ViewBag.CompilationResult = compResult;
return(View(altinnCoreFiles));
}
private static IEnumerable <ServiceStatusViewModel.UserMessage> CompilationUserMessages(
CodeCompilationResult compilation)
{
if (compilation == null)
{
yield return(ServiceStatusViewModel.UserMessage.Error("Kompileringsresultat mangler"));
yield break;
}
var errorFiles = NiceSeparatedFileList(compilation.CompilationInfo, c => c.IsError());
var warningFiles = NiceSeparatedFileList(compilation.CompilationInfo, c => c.IsWarning());
if (!compilation.Succeeded || !string.IsNullOrWhiteSpace(errorFiles))
{
var failed = ServiceStatusViewModel.UserMessage.Error("Tjenesten kompilerer ikke");
if (!string.IsNullOrWhiteSpace(errorFiles))
{
failed.Details.Add("Filer", errorFiles);
}
yield return(failed);
}
else if (!string.IsNullOrWhiteSpace(warningFiles))
{
var warning = ServiceStatusViewModel.UserMessage.Warning("Advarsler ved kompilering");
warning.Details.Add("Filer", warningFiles);
yield return(warning);
}
}
/// <summary>
/// Compiles the implementation files.
/// </summary>
/// <param name="org">The organization code for the requested service.</param>
/// <param name="service">The service short name for the requested service.</param>
/// <returns>A View with the result.</returns>
public IActionResult Compile(string org, string service)
{
CodeCompilationResult compResult = _compilation.CreateServiceAssembly(org, service, false, null, false);
ViewBag.CompilationResult = compResult;
return(PartialView("CompilationResult"));
}
public IActionResult Code(string org, string service)
{
List <AltinnCoreFile> altinnCoreFiles = _repository.GetImplementationFiles(org, service);
CodeCompilationResult compResult = _compilation.CreateServiceAssembly(org, service, null, false);
// Check to see if any of the files has compiliation errors or warnings
foreach (AltinnCoreFile coreFile in altinnCoreFiles)
{
if (compResult.CompilationInfo != null &&
compResult.CompilationInfo.Exists(c => c.FileName.ToLower().Equals(coreFile.FileName.ToLower()) && c.Severity.Equals("Error")))
{
coreFile.FileStatus = AltinnCore.ServiceLibrary.Enums.AltinnCoreFileStatusType.Error;
}
else if (compResult.CompilationInfo != null &&
compResult.CompilationInfo.Exists(c => c.FileName.ToLower().Equals(coreFile.FileName.ToLower()) && c.Severity.Equals("Warning")))
{
coreFile.FileStatus = AltinnCore.ServiceLibrary.Enums.AltinnCoreFileStatusType.Warning;
}
else
{
coreFile.FileStatus = AltinnCore.ServiceLibrary.Enums.AltinnCoreFileStatusType.OK;
}
}
ViewBag.CompilationResult = compResult;
return(View(altinnCoreFiles));
}
/// <summary>
/// The invokes the Component async.
/// </summary>
/// <param name="org"> The org. </param>
/// <param name="service"> The service. </param>
/// <param name="edition"> The edition. </param>
/// <param name="serviceMetadata"> The service Metadata. </param>
/// <param name="viewMetadatas">The view metadata list</param>
/// <param name="codeCompilationResult"> The code Compilation Result. </param>
/// <returns> The <see cref="Task"/>. </returns>
public async Task <IViewComponentResult> InvokeAsync(
string org,
string service,
string edition,
ServiceMetadata serviceMetadata = null,
IList <ViewMetadata> viewMetadata = null,
CodeCompilationResult codeCompilationResult = null)
{
ServiceEditionIdentifier serviceEdition = new ServiceEditionIdentifier {
Org = org, Service = service, Edition = edition
};
CodeCompilationResult compilation = null;
if (string.IsNullOrEmpty(_generalSettings.RuntimeMode) || !_generalSettings.RuntimeMode.Equals("ServiceContainer"))
{
compilation = codeCompilationResult ?? await Compile(serviceEdition);
var metadata = serviceMetadata ?? await GetServiceMetadata(serviceEdition);
EditionStatusViewModel model = CreateModel(serviceEdition, compilation, metadata);
return(View(model));
}
return(View(new EditionStatusViewModel()));
}
/// <summary>
/// Invokes the Component async.
/// </summary>
/// <param name="org">Unique identifier of the organisation responsible for the app.</param>
/// <param name="app">Application identifier which is unique within an organisation.</param>
/// <param name="serviceMetadata">The service metadata.</param>
/// <param name="codeCompilationResult">The code compilation result.</param>
/// <returns>The <see cref="Task"/>.</returns>
public async Task <IViewComponentResult> InvokeAsync(
string org,
string app,
ServiceMetadata serviceMetadata = null,
CodeCompilationResult codeCompilationResult = null)
{
var serviceIdentifier = new ServiceIdentifier {
Org = org, Service = app
};
var compilation = codeCompilationResult ?? await CompileHelper.CompileService(_compilation, serviceIdentifier);
var metadata = serviceMetadata ?? await GetServiceMetadata(serviceIdentifier);
var model = CreateModel(serviceIdentifier, compilation, metadata);
return(View(model));
}
private static IEnumerable <CompilationInfo> FilterCompilationInfos(CodeCompilationResult codeCompilationResult)
{
if (codeCompilationResult?.CompilationInfo == null || codeCompilationResult.CompilationInfo.Any() == false)
{
return(new CompilationInfo[0]);
}
var relevante =
codeCompilationResult.CompilationInfo.Where(RelevantCompilationInfo)
.GroupBy(c => c.Severity + c.FileName + c.Info)
.Select(c => c.First())
.OrderBy(c => c.Severity)
.ThenBy(c => c.FileName)
.ThenBy(c => c.Info);
return(relevante);
}
private ServiceStatusViewModel CreateModel(
ServiceIdentifier serviceIdentifier,
CodeCompilationResult compilationResult,
ServiceMetadata serviceMetadata)
{
var userMessages =
CompilationUserMessages(compilationResult)
.Union(ServiceMetadataMessages(serviceMetadata))
.ToList();
userMessages.Sort();
return(new ServiceStatusViewModel
{
ServiceIdentifier = serviceIdentifier,
CodeCompilationMessages = FilterCompilationInfos(compilationResult).ToList(),
UserMessages = userMessages,
});
}
private EditionStatusViewModel CreateModel(
ServiceEditionIdentifier serviceEditionIdentifier,
CodeCompilationResult compilationResult,
ServiceMetadata serviceMetadata,
IEnumerable <ViewMetadata> viewMetadatas)
{
var userMessages =
CompilationUserMessages(compilationResult)
.Union(ServiceMetadataMessages(serviceMetadata, viewMetadatas))
.ToList();
userMessages.Sort();
return(new EditionStatusViewModel
{
EditionIdentifier = serviceEditionIdentifier,
CodeCompilationMessages = FilterCompilationInfos(compilationResult).ToList(),
UserMessages = userMessages
});
}
/// <summary>
/// The invokes the Component async.
/// </summary>
/// <param name="org"> The org. </param>
/// <param name="service"> The service. </param>
/// <param name="edition"> The edition. </param>
/// <param name="serviceMetadata"> The service Metadata. </param>
/// <param name="viewMetadatas">The view metadata list</param>
/// <param name="codeCompilationResult"> The code Compilation Result. </param>
/// <returns> The <see cref="Task"/>. </returns>
public async Task <IViewComponentResult> InvokeAsync(
string org,
string service,
string edition,
ServiceMetadata serviceMetadata = null,
IList <ViewMetadata> viewMetadata = null,
CodeCompilationResult codeCompilationResult = null)
{
var serviceEdition = new ServiceEditionIdentifier {
Org = org, Service = service, Edition = edition
};
var compilation = codeCompilationResult ?? await Compile(serviceEdition);
var metadata = serviceMetadata ?? await GetServiceMetadata(serviceEdition);
var views = viewMetadata ?? await GetViewMetadata(serviceEdition);
var model = CreateModel(serviceEdition, compilation, metadata, views);
return(View(model));
}
public async Task <IActionResult> Compile(string org, string app)
{
if (string.IsNullOrWhiteSpace(org) || string.IsNullOrWhiteSpace(app))
{
return(BadRequest("Org or app not supplied"));
}
try
{
ServiceIdentifier serviceIdentifier = new ServiceIdentifier {
Org = org, Service = app
};
CodeCompilationResult compileResult = await CompileHelper.CompileService(_compilation, serviceIdentifier);
return(Ok(compileResult));
}
catch (Exception ex)
{
_logger.LogError($"Compiling services files for org: {org}, app: {app} failed with message: {ex.Message}");
return(StatusCode(500, ex.Message));
}
}
/// <summary>
/// Creates the service assembly for a service
/// </summary>
/// <param name="org">The Organization code for the service owner</param>
/// <param name="service">The service code for the current service</param>
/// <param name="edition">The edition code for the current service</param>
/// <param name="outputLocation">The directory where the resulting assembly should be saved</param>
/// <param name="loadAssemblyContext">Defines if assembly should be loaded in context</param>
/// <returns>The assembly name</returns>
public CodeCompilationResult CreateServiceAssembly(string org, string service, string edition, string outputLocation = null, bool loadAssemblyContext = true)
{
CodeCompilationResult compilationResult = new CodeCompilationResult()
{
CompileStarted = DateTime.Now
};
string assemblykey = org + "_" + service + "_" + edition;
List <AltinnCoreFile> implementationFiles = _repository.GetImplementationFiles(org, service, edition);
DateTime lastChanged = new DateTime(2000, 01, 01);
foreach (AltinnCoreFile file in implementationFiles)
{
if (file.LastChanged > lastChanged)
{
lastChanged = file.LastChanged;
}
}
if (_assemblyNames.ContainsKey(assemblykey) && _assemblyNames[assemblykey].CompileStarted > lastChanged && string.IsNullOrWhiteSpace(outputLocation))
{
compilationResult = _assemblyNames[assemblykey];
return(compilationResult);
}
SyntaxTree[] syntaxTrees = GetSyntaxTrees(org, service, edition);
List <MetadataReference> references = new List <MetadataReference>();
Assembly root = Assembly.GetEntryAssembly();
string assemblyName = Path.GetRandomFileName();
MetadataReferenceFeature referenceFeature = new MetadataReferenceFeature();
_partManager.PopulateFeature(referenceFeature);
CSharpCompilation compilation = CSharpCompilation.Create(
assemblyName,
syntaxTrees: syntaxTrees,
references: referenceFeature.MetadataReferences,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
using (var pdbMs = new MemoryStream())
using (var ms = new MemoryStream())
{
EmitResult result;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
if (!string.IsNullOrEmpty(outputLocation))
{
result = compilation.Emit(outputLocation + assemblyName + ".dll", outputLocation + assemblyName + ".pdb");
}
else
{
result = compilation.Emit(ms, pdbMs);
}
stopWatch.Stop();
compilationResult.TimeUsed = stopWatch.Elapsed;
compilationResult.CompilationInfo = new List <CompilationInfo>();
foreach (Diagnostic diag in result.Diagnostics)
{
// TODO: Decide how to handle this special CS1701 we get
if (!diag.Id.Equals("CS1701"))
{
var compInfo = new CompilationInfo
{
Info = diag.GetMessage(),
FilePath = diag.Location.SourceTree.FilePath,
FileName = System.IO.Path.GetFileName(diag.Location.SourceTree.FilePath),
Severity = diag.Severity.ToString(),
Code = diag.Id,
WarningLevel = diag.WarningLevel,
LineNumber = diag.Location.GetLineSpan().StartLinePosition.Line + 1
};
if (diag.Severity.Equals(DiagnosticSeverity.Warning))
{
compilationResult.Warnings++;
}
else if (diag.Severity.Equals(DiagnosticSeverity.Error))
{
compilationResult.Errors++;
}
compilationResult.CompilationInfo.Add(compInfo);
}
}
if (!result.Success)
{
LogEmitResult(result);
}
else
{
compilationResult.AssemblyName = compilation.AssemblyName;
compilationResult.Succeeded = true;
if (string.IsNullOrEmpty(outputLocation) && loadAssemblyContext)
{
ms.Seek(0, SeekOrigin.Begin);
pdbMs.Seek(0, SeekOrigin.Begin);
AssemblyLoadContext.Default.LoadFromStream(ms, pdbMs);
ms.Seek(0, SeekOrigin.Begin);
MetadataReference newReference = MetadataReference.CreateFromStream(ms);
if (_roslynCompilation.ServiceReferences.ContainsKey(assemblykey))
{
_roslynCompilation.ServiceReferences.Remove(assemblykey);
}
_roslynCompilation.ServiceReferences.Add(assemblykey, newReference);
if (_assemblyNames.ContainsKey(assemblykey))
{
_assemblyNames.Remove(assemblykey);
}
_assemblyNames.Add(assemblykey, compilationResult);
}
return(compilationResult);
}
}
return(compilationResult);
}
