public override async Task <OperationResultEnum> Execute()
{
Validate(_arguments);
Binary binary = _generator.GenerateBinary(_arguments);
var resource = new ResourceWrapper(binary, FhirVersion.R4);
var serializer = new SerializationWrapper(FhirVersion.R4);
var serialized = serializer.Serialize(resource, _arguments.MimeType);
if (serialized == null)
{
_issues.Add(new Issue
{
Details = $"Failed to serialize binary from file\nLocation: '{_arguments.Path}'.",
Severity = IssueSeverityEnum.Error
});
return(OperationResultEnum.Failed);
}
await File.WriteAllTextAsync(@$ "{_arguments.OutPath}\binary-{_arguments.Id}.json", serialized);
_logger.LogInformation($"Successfully generated 'binary-{_arguments.Id}.json' to location: '{_arguments.OutPath}'.");
return(_issues.Any(issue => issue.Severity == IssueSeverityEnum.Error)
? OperationResultEnum.Failed
: OperationResultEnum.Succeeded);
}
private async IAsyncEnumerable <ResourceWrapper> ExpandInputFiles()
{
var serializer = new SerializationWrapper(_arguments.FhirVersion);
var content = await File.ReadAllTextAsync(_arguments.QuestionnairePath);
var resource = serializer.Parse(content, _arguments.MimeType);
if (resource == null)
{
_issues.Add(new Issue
{
Details = $"Failed to deserialize Questionnaire from file\nLocation: '{_arguments.QuestionnairePath}'.",
Severity = IssueSeverityEnum.Error,
});
yield break;
}
if (resource.ResourceType == ResourceTypeWrapper.Bundle)
{
var bundle = resource.CastToBundle();
foreach (var r in bundle.GetResources())
{
if (r.ResourceType != ResourceTypeWrapper.Questionnaire)
{
continue;
}
yield return(r);
}
}
else
{
yield return(resource);
}
}
private string GetContentAs(string content, FhirMimeType mimeType)
{
var serializer = new SerializationWrapper(_arguments.FhirVersion);
var resource = serializer.Parse(content);
return(serializer.Serialize(resource, mimeType));
}
private async Tasks.Task <BundleWrapper> CreateBundle(IEnumerable <string> batch, FhirVersion fhirVersion)
{
var serializer = new SerializationWrapper(fhirVersion);
var bundle = new BundleWrapper(fhirVersion);
foreach (var file in batch)
{
ResourceWrapper resource = null;
try
{
var content = await File.ReadAllTextAsync(file);
resource = serializer.Parse(content, _arguments.MimeType);
}
catch (Exception e)
{
_logger.LogError($"Could not read and parse {file}. Skipping: {e.Message}");
}
var entry = bundle.AddResourceEntry(resource, null);
var request = new RequestComponentWrapper(fhirVersion);
request.Method = HTTPVerbWrapper.PUT;
request.Url = $"/{resource.ResourceType}/{resource.Id}";
entry.Request = request;
_logger.LogInformation($" Added {request.Url} to bundle");
}
return(bundle);
}
public override string ToString()
{
var root = new SerializationWrapper
{
CostFunction = this,
};
return(JsonSerializer.Serialize(root));
}
/// <summary>
/// Converts a message to a byte array
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="message">The message.</param>
/// <param name="headers">the message headers</param>
/// <returns></returns>
public byte[] ConvertMessageToBytes <T>(T message, IReadOnlyDictionary <string, object> headers)
where T : class
{
Guard.NotNull(() => message, message);
var wrapper = new SerializationWrapper <T> {
Message = message
};
return(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(wrapper, _serializerSettings)));
}
public string Convert(string fromString)
{
var parser = new SerializationWrapper(FromVersion);
var serializer = new SerializationWrapper(ToVersion);
var fromObject = parser.Parse(fromString);
var converted = Convert <Base, Base>(fromObject.Resource);
return(serializer.Serialize(converted));
}
public Task SerializeAsync(Stream stream)
{
var root = new SerializationWrapper
{
CostFunction = this,
};
// Save to the writer
return(JsonSerializer.SerializeAsync(stream, root));
}
private static object InternalSerialize(string HandleName, bool Compress = false, string OutputFilePath = null)
{
HandleName = HandleNames.GetNameFrom(HandleName);
IStoredObject storedObj;
if (!m_ObjectStore.GetByName(HandleName, out storedObj))
{
throw new Exception($"No object named {HandleName} found");
}
bool WriteToFile = !String.IsNullOrWhiteSpace(OutputFilePath);
var obj = new SerializationWrapper {
ContainedObject = storedObj
};
var result = XmlSerialize <SerializationWrapper>(obj);
if (Compress)
{
var compressed = Zip(result);
XDocument doc = new XDocument(new XElement("CompressedData", new XAttribute("Algorithm", "gzip"), Convert.ToBase64String(compressed)));
if (WriteToFile)
{
OutputFilePath = Environment.ExpandEnvironmentVariables(OutputFilePath);
using (var fileWriter = new FileStream(OutputFilePath, FileMode.Create))
{
doc.Save(fileWriter);
}
return($"Written to '{OutputFilePath}' in compressed format.");
}
else
{
using (var stringWriter = new StringWriter())
{
doc.Save(stringWriter);
return(stringWriter.ToString());
}
}
}
else
{
if (WriteToFile)
{
File.WriteAllLines(OutputFilePath, new string[] { result });
return($"Written to '{OutputFilePath}' in uncompressed XML format.");
}
else
{
return(result);
}
}
}
//[InlineData(@"TestData\account.profile-r4.json")]
//[InlineData(@"TestData\activitydefinition.profile-r4.json")]
//[InlineData(@"TestData\adverseevent.profile-r4.json")]
//[InlineData(@"TestData\allergyintolerance.profile-r4.json")]
//[InlineData(@"TestData\appointment.profile-r4.json")]
//[InlineData(@"TestData\appointmentresponse.profile-r4.json")]
//[InlineData(@"TestData\consent.profile-r4.json")]
public async Task CanConvert_Questionnaire_FromR4ToR3_RoundTrip(string path)
{
var converterFromR4ToR3 = new FhirConverter(to: FhirVersion.R3, from: FhirVersion.R4);
var converterFromR3ToR4 = new FhirConverter(to: FhirVersion.R4, from: FhirVersion.R3);
var r4Serializer = new SerializationWrapper(FhirVersion.R4);
var r4Resource = r4Serializer.Parse(await File.ReadAllTextAsync(path));
var r3Resource = converterFromR4ToR3.Convert <Resource, Resource>(r4Resource.Resource);
var r4ResourceRoundTrip = converterFromR3ToR4.Convert <Resource, Resource>(r3Resource);
var r4ResourceContent = r4Serializer.Serialize(r4Resource);
var r4ResourceRoundTripContent = r4Serializer.Serialize(r4ResourceRoundTrip);
Assert.Equal(r4ResourceContent, r4ResourceRoundTripContent);
}
private async Task SerializeAndStore(BundleWrapper result, DirectoryInfo baseDir)
{
if (result == null)
{
return;
}
var serializer = new SerializationWrapper(result.FhirVersion);
var resources = result.GetResources();
_logger.LogInformation($" Fetched {resources.Count()} resources from server");
foreach (var resource in resources)
{
string serialized = serializer.Serialize(resource, _arguments.MimeType);
await Store(resource.Id, serialized, baseDir);
}
}
public override async Tasks.Task <OperationResultEnum> Execute()
{
Validate(_arguments);
TokenResponse tokenResponse = null;
if (!string.IsNullOrEmpty(_arguments.Credentials))
{
tokenResponse = await GetToken(_arguments.Environment?.AuthorizationUrl, _arguments.Credentials, _arguments.AuthorizationUrl);
}
var endpoint = _arguments.FhirBaseUrl?.Uri;
if (string.IsNullOrEmpty(endpoint))
{
endpoint = tokenResponse == null ? _arguments.Environment.FhirBaseUrl : _arguments.Environment.ProxyBaseUrl;
}
var client = new FhirClientWrapper(endpoint, _logger, _arguments.FhirVersion, tokenResponse?.AccessToken);
var batches = FindFiles().Batch(_arguments.BatchSize);
foreach (var batch in batches)
{
var bundle = await CreateBundle(batch, client.FhirVersion);
bundle.Type = BundleTypeWrapper.Transaction;
try
{
_logger.LogInformation($"Uploading batch with {batch.Count()} entries");
await client.TransactionAsync(bundle);
System.Threading.Thread.Sleep(_arguments.Sleep);
}
catch (Exception e)
{
_logger.LogError($"Failed to upload batch: {e.Message}");
_logger.LogError($"Response was: {client.LastBodyAsText}");
var bundleAsStr = new SerializationWrapper(client.FhirVersion).Serialize(bundle.ToBase());
await File.WriteAllTextAsync("debug-on-exception", bundleAsStr);
}
}
return(await Tasks.Task.FromResult(OperationResultEnum.Succeeded));
}
public override async Task <OperationResultEnum> Execute()
{
_logger.LogInformation($"Starting conversion of source file: '{_arguments.Source}' from format: '{_arguments.FromMimeType}' to format '{_arguments.ToMimeType}'.");
var serializer = new SerializationWrapper(_arguments.FhirVersion);
var resource = serializer.Parse(_arguments.SourceContent, _arguments.FromMimeType, true);
var outContent = serializer.Serialize(resource, _arguments.ToMimeType.GetValueOrDefault());
var fileName = Path.GetFileName(_arguments.Source);
var outPath = GetOutPath(_arguments.OutPath, fileName, _arguments.ToMimeType.GetValueOrDefault());
if (!string.IsNullOrWhiteSpace(outContent))
{
using var stream = File.Open(outPath, FileMode.OpenOrCreate, FileAccess.Write);
await stream.WriteAsync(Encoding.UTF8.GetBytes(outContent));
_logger.LogInformation($"Converted file stored at: '{outPath}'.");
}
return(await Task.FromResult(OperationResultEnum.Succeeded));
}
public override async Task <OperationResultEnum> Execute()
{
DocumentReference documentReference = _documentReferenceGenerator.GenerateDocumentReference(_arguments);
var resource = new ResourceWrapper(documentReference, FhirVersion.R4);
var serializer = new SerializationWrapper(FhirVersion.R4);
var serialized = serializer.Serialize(resource, _arguments.MimeType);
if (serialized == null)
{
_issues.Add(new Issue
{
Details = $"Failed to serialize documentreference for Id: '{_arguments.Id}'.",
Severity = IssueSeverityEnum.Error
});
return(OperationResultEnum.Failed);
}
await File.WriteAllTextAsync(@$ "{_arguments.OutPath}\documentreference-{_arguments.Id}.json", serialized);
public override async Tasks.Task <OperationResultEnum> Execute()
{
var serializer = new SerializationWrapper(_arguments.FhirVersion);
var lines = await File.ReadAllLinesAsync(_arguments.DumpFile.Path);
var linenr = 0;
var versionMap = new Dictionary <string, Data>();
foreach (var entry in lines)
{
linenr++;
try
{
var json = JObject.Parse(entry);
var versionPath = json["_id"].ToString();
json.Property("_id").Remove();
var id = $"{json["resourceType"]}/{json["id"]}";
if (_arguments.SkipIds.Contains(id))
{
_logger.LogInformation($"Skipping {id} as requested");
continue;
}
RemoveUnwantedMongoDbElements(json);
var dataEntry = new Data
{
Id = id,
JObject = json,
Line = linenr,
RawContent = entry,
VersionPath = versionPath
};
if (versionMap.TryGetValue(id, out Data other))
{
var version = GetVersion(json);
var otherVersion = GetVersion(other.JObject);
if (version > otherVersion)
{
versionMap.Remove(id);
versionMap.Add(id, dataEntry);
}
}
else
{
versionMap.Add(id, dataEntry);
}
}
catch (Exception e)
{
_logger.LogError($"line {linenr}: Not valid json{Environment.NewLine}{e.Message}");
if (_arguments.ShowOriginalJson)
{
_logger.LogInformation(entry);
}
continue;
}
}
foreach (var key in versionMap.Keys)
{
var data = versionMap[key];
try
{
var content = data.JObject.ToString();
var resource = serializer.Parse(content, permissiveParsing: _arguments.PermissiveParsing);
}
catch (Exception e)
{
_logger.LogError($"line {data.Line}: resource {key} is not a valid FHIR object (was {data.VersionPath}){Environment.NewLine}{e.Message}");
if (_arguments.ShowOriginalJson)
{
_logger.LogInformation(data.RawContent);
}
continue;
}
}
return(await Tasks.Task.FromResult(OperationResultEnum.Succeeded));
}
public MetadataTests(SerializationWrapper serializer, DeserializationWrapper deserializer)
{
Serializer = serializer;
Deserializer = deserializer;
}
/**
* Create a new wrapping StorageUtility
*
* @param name unique name for underlying StorageUtility
* @param wrapper serialization wrapper
* @param storageFactory factory to create underlying StorageUtility
*/
public WrappingStorageUtility(String name, SerializationWrapper wrapper, IStorageFactory storageFactory)
{
this.storage = storageFactory.newStorage(name, wrapper.GetType());
this.wrapper = wrapper;
}
