private async Task TransformFile(string file, string outPath)
{
var content = await File.ReadAllTextAsync(file);
var currentMimeType = MimeTypeUtils.ProbeFhirMimeType(content);
if (!currentMimeType.HasValue)
{
_logger.LogWarning("Can't determine mime-type of {0} -- Skipping", file);
return;
}
string result = null;
var newFile = _arguments.OutputIsDirectory ? Path.Combine(outPath, Path.GetFileName(file)) : outPath;
_logger.LogInformation("Transform {0} --> {1}", file, newFile);
if (_arguments.XslTransform != null)
{
result = TransformXslt(content, currentMimeType.Value);
}
else if (_arguments.JustTransform != null)
{
result = TransformJust(content, currentMimeType.Value);
}
result = GetContentAs(result, currentMimeType.Value);
await File.WriteAllTextAsync(newFile, result);
}
public void ParseMimeType()
{
var s = "audio/*";
var mimeType = MimeTypeUtils.ParseMimeType(s);
Assert.Equal("audio", mimeType.Type);
Assert.Equal("*", mimeType.Subtype);
}
private void TestWithQuotedParameters(params string[] mimeTypes)
{
var s = string.Join(",", mimeTypes);
var actual = MimeTypeUtils.ParseMimeTypes(s);
Assert.Equal(mimeTypes.Length, actual.Count);
for (var i = 0; i < mimeTypes.Length; i++)
{
Assert.Equal(mimeTypes[i], actual[i].ToString());
}
}
public void ParseMimeTypes()
{
var s = "text/plain, text/html, text/x-dvi, text/x-c";
var mimeTypes = MimeTypeUtils.ParseMimeTypes(s);
Assert.NotNull(mimeTypes);
Assert.Equal(4, mimeTypes.Count);
mimeTypes = MimeTypeUtils.ParseMimeTypes(null);
Assert.NotNull(mimeTypes);
Assert.Empty(mimeTypes);
}
public static HttpResponse ReturnFile(string filePath)
{
if (filePath.IsEmpty())
{
return(new HttpResponse(ResponseCode.BadRequest));
}
if (filePath.Contains("/"))
{
filePath = filePath.Replace("/", @"\");
}
if (filePath.StartsWith(@"\"))
{
filePath = filePath.Substring(1);
}
var rootPath = Path.GetFullPath(@"..\..\public\");
var resultPath = Path.Combine(rootPath, filePath);
if (!resultPath.Contains(rootPath) || !File.Exists(resultPath))
{
return(new HttpResponse(ResponseCode.NotFound));
}
var extension = Path.GetExtension(resultPath);
if (extension.IsEmpty())
{
return(new HttpResponse(ResponseCode.NotFound));
}
var mimeType = MimeTypeUtils.GetMimeType(extension);
var content = File.ReadAllBytes(resultPath);
return(new HttpResponse(ResponseCode.Ok, mimeType, content));
}
public ResourceWrapper Parse(string content, FhirMimeType?type = null, bool permissiveParsing = false)
{
if (!type.HasValue)
{
type = MimeTypeUtils.ProbeFhirMimeType(content);
}
if (!type.HasValue)
{
return(null);
}
switch (Version)
{
case FhirVersion.R3:
var settingsR3 = new ParserSettings {
PermissiveParsing = permissiveParsing
};
var resourceR3 = type == FhirMimeType.Json
? new R3Serialization.FhirJsonParser(settingsR3).Parse <Resource>(content)
: new R3Serialization.FhirXmlParser(settingsR3).Parse <Resource>(content);
return(new ResourceWrapper(resourceR3, FhirVersion.R3));
case FhirVersion.R4:
var settingsR4 = new ParserSettings {
PermissiveParsing = permissiveParsing
};
var resourceR4 = type == FhirMimeType.Json
? new R4Serialization.FhirJsonParser(settingsR4).Parse <Resource>(content)
: new R4Serialization.FhirXmlParser(settingsR4).Parse <Resource>(content);
return(new ResourceWrapper(resourceR4, FhirVersion.R4));
default:
return(default);
}
}
protected AbstractContentTypeInterceptor(string contentType)
{
_mimeType = MimeTypeUtils.ParseMimeType(contentType);
}
public void ParseMimeTypeEmptyParameterValue()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("audio/*;attr="));
}
public void ParseMimeTypeWithSpacesAroundEqualsAndQuotedValue()
{
var mimeType = MimeTypeUtils.ParseMimeType("text/plain; foo = \" bar \" ");
Assert.Equal("\" bar \"", mimeType.GetParameter("foo"));
}
public void ParseMimeTypeIllegalQuotedParameterValue()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("audio/*;attr=\""));
}
public void ParseMimeTypeSingleQuotedParameterValue()
{
var mimeType = MimeTypeUtils.ParseMimeType("audio/*;attr='v>alue'");
Assert.Equal("'v>alue'", mimeType.GetParameter("attr"));
}
public void ParseMimeTypeWithSpacesAroundEquals()
{
var mimeType = MimeTypeUtils.ParseMimeType("multipart/x-mixed-replace;boundary = --myboundary");
Assert.Equal("--myboundary", mimeType.GetParameter("boundary"));
}
public void ParseMimeTypeIllegalCharset()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("text/html; charset=foo-bar"));
}
public void ParseMimeTypeQuotedParameterValue()
{
var mimeType = MimeTypeUtils.ParseMimeType("audio/*;attr=\"v>alue\"");
Assert.Equal("\"v>alue\"", mimeType.GetParameter("attr"));
}
public void ParseMimeTypeIllegalParameterAttribute()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("audio/*;attr<=value"));
}
public void ParseMimeTypeNoSubtypeSlash()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("audio/"));
}
public void ParseMimeTypeMissingTypeAndSubtype()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType(" ;a=b"));
}
public void ParseMimeTypeIllegalSubtype()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("audio/basic)"));
}
public void ParseMimeTypeTypeRange()
{
Assert.Throws <ArgumentException>(() => MimeTypeUtils.ParseMimeType("*/json"));
}
