private string[] GetMimeTypes()
{
return(FileTypeChoices
.SelectMany(choice => choice.Value)
.Select(extension => MimeTypeService.GetFromExtension(extension))
.Distinct()
.ToArray());
}
private string[] GetMimeTypes()
{
if (FileTypeFilter.Contains("*"))
{
return(new[] { "*/*" });
}
return(FileTypeFilter
.Select(extension => MimeTypeService.GetFromExtension(extension))
.Distinct()
.ToArray());
}
public void MapFromFileNameWithDefault_WhenContentTypeNotFound_ReturnsDefault()
{
string fileName = "my-file.jpg";
string contentType = null;
var contentTypeProvider = new Mock <IContentTypeProvider>();
contentTypeProvider.Setup(p => p.TryGetContentType(fileName, out contentType)).Returns(false);
var service = new MimeTypeService(contentTypeProvider.Object);
var result = service.MapFromFileName(fileName, TEST_DEFAULT_MIME_TYPE);
Assert.Equal(TEST_DEFAULT_MIME_TYPE, result);
}
public void MapFromFileName_WhenContentTypeFound_ReturnsMatch()
{
string fileName = "my-file.jpg";
string contentType = JPEG_MIME_TYPE;
var contentTypeProvider = new Mock <IContentTypeProvider>();
contentTypeProvider.Setup(p => p.TryGetContentType(fileName, out contentType)).Returns(true);
var service = new MimeTypeService(contentTypeProvider.Object);
var result = service.MapFromFileName(fileName);
Assert.Equal(contentType, result);
}
public override Task Invoke(IOwinContext context)
{
Trace.WriteLine("Invoke DefaultMiddleware");
var path = FileSystem.MapPath(_options.BasePath, context.Request.Path.Value);
context.Response.StatusCode = 200;
context.Response.ContentType = MimeTypeService.GetMimeType(Path.GetExtension(path));
using (var inputStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
StreamHandler.CopyStream(context.Response.Body, inputStream);
}
return(Globals.CompletedTask);
}
private NativeFilePickerAcceptType[] BuildFileTypesMap()
{
var acceptTypes = new List <NativeFilePickerAcceptType>();
var mimeTypeGroups = FileTypeFilter
.Except(new[] { "*" })
.GroupBy(f => MimeTypeService.GetFromExtension(f))
.ToArray();
var allAccepts = new List <NativeFilePickerAcceptTypeItem>();
foreach (var mimeTypeGroup in mimeTypeGroups)
{
var extensions = mimeTypeGroup.ToArray();
var acceptType = new NativeFilePickerAcceptType();
acceptType.Description = extensions.Length > 1 ? string.Empty : extensions.First();
var acceptItem = new NativeFilePickerAcceptTypeItem()
{
MimeType = mimeTypeGroup.Key,
Extensions = extensions
};
allAccepts.Add(acceptItem);
acceptType.Accept = new[] { acceptItem };
acceptTypes.Add(acceptType);
}
if (allAccepts.Count > 1)
{
var fullAcceptType = new NativeFilePickerAcceptType()
{
Description = "All",
Accept = allAccepts.ToArray()
};
acceptTypes.Insert(0, fullAcceptType);
}
return(acceptTypes.ToArray());
}
public override Task Invoke(IOwinContext context)
{
var path = FileSystem.MapPath(_options.BasePath, context.Request.Path.Value);
var ext = Path.GetExtension(path);
if (ExtToHandle(ext))
{
Trace.WriteLine("Invoke SassMiddleware");
context.Response.StatusCode = 200;
context.Response.ContentType = MimeTypeService.GetMimeType(".css");
var compiler = new SassCompiler();
var compressed = compiler.CompileFile(path, OutputStyle.Compressed, false);
compressed = compressed.Replace(";}", "}").Replace(" {", "{");
context.Response.Write(compressed);
return(Globals.CompletedTask);
}
return(Next.Invoke(context));
}
private string[] GetMimeTypes()
{
if (FileTypeFilter.Contains("*"))
{
return(new[] { "*/*" });
}
List <string> mimeTypes = new List <string>();
using Android.Webkit.MimeTypeMap? mimeTypeMap = Android.Webkit.MimeTypeMap.Singleton;
if (mimeTypeMap is null)
{
// when map is unavailable (probably never happens, but Singleton returns nullable)
return(new[] { "*/*" });
}
foreach (string oneExtensionForLoop in FileTypeFilter)
{
bool unknownExtensionPresent = false;
string oneExtension = oneExtensionForLoop;
if (oneExtension.StartsWith("."))
{
// Supported format from UWP, e.g. ".jpg"
oneExtension = oneExtension.Substring(1);
}
if (!mimeTypeMap.HasExtension(oneExtension))
{
// when there is unknown extension, we should show all files
unknownExtensionPresent = true;
}
string?mimeType = mimeTypeMap.GetMimeTypeFromExtension(oneExtension);
if (string.IsNullOrEmpty(mimeType))
{
// second check for unknown extension...
unknownExtensionPresent = true;
}
else
{
#pragma warning disable CS8604 // Possible null reference argument.
// it cannot be null, as this is within "if", but still compiler complains about possible null reference
if (!mimeTypes.Contains(mimeType))
{
mimeTypes.Add(mimeType);
}
#pragma warning restore CS8604 // Possible null reference argument.
}
if (unknownExtensionPresent)
{
// it is some unknown extension
var mimeTypesFromUno = FileTypeFilter
.Select(extension => MimeTypeService.GetFromExtension(extension))
.Distinct();
if (mimeTypesFromUno is null || mimeTypesFromUno.Count() < 1)
{
return(new[] { "*/*" });
}
foreach (var oneUnoMimeType in mimeTypesFromUno)
{
if (!mimeTypes.Contains(oneUnoMimeType))
{
mimeTypes.Add(oneUnoMimeType);
}
}
}
}
return(mimeTypes.ToArray());
}
