729 lines
27 KiB
C#
729 lines
27 KiB
C#
using LeanCloud.Storage.Internal;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Net;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace LeanCloud
|
||
{
|
||
/// <summary>
|
||
/// AVFile is a local representation of a file that is saved to the LeanCloud.
|
||
/// </summary>
|
||
/// <example>
|
||
/// The workflow is to construct a <see cref="AVFile"/> with data and a filename,
|
||
/// then save it and set it as a field on a AVObject:
|
||
///
|
||
/// <code>
|
||
/// var file = new AVFile("hello.txt",
|
||
/// new MemoryStream(Encoding.UTF8.GetBytes("hello")));
|
||
/// await file.SaveAsync();
|
||
/// var obj = new AVObject("TestObject");
|
||
/// obj["file"] = file;
|
||
/// await obj.SaveAsync();
|
||
/// </code>
|
||
/// </example>
|
||
public partial class AVFile : IJsonConvertible
|
||
{
|
||
internal static int objectCounter = 0;
|
||
internal static readonly object Mutex = new object();
|
||
private FileState state;
|
||
private readonly Stream dataStream;
|
||
private readonly TaskQueue taskQueue = new TaskQueue();
|
||
|
||
#region Constructor
|
||
/// <summary>
|
||
/// 通过文件名，数据流，文件类型，文件源信息构建一个 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">数据流</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
/// <param name="metaData">文件源信息</param>
|
||
public AVFile(string name, Stream data, string mimeType = null, IDictionary<string, object> metaData = null)
|
||
{
|
||
mimeType = mimeType == null ? GetMIMEType(name) : mimeType;
|
||
state = new FileState
|
||
{
|
||
Name = name,
|
||
MimeType = mimeType,
|
||
MetaData = metaData
|
||
};
|
||
this.dataStream = data;
|
||
lock (Mutex)
|
||
{
|
||
objectCounter++;
|
||
state.counter = objectCounter;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，文件 Byte 数组，以及文件类型构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件 Byte 数组</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
public AVFile(string name, byte[] data, string mimeType = null)
|
||
: this(name, new MemoryStream(data), mimeType) { }
|
||
|
||
/// <summary>
|
||
/// 根据文件名，文件流数据，文件类型构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件流数据</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
public AVFile(string name, Stream data, string mimeType = null)
|
||
: this(name, data, mimeType, new Dictionary<string, object>())
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据 byte 数组以及文件名创建文件
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件的 byte[] 数据</param>
|
||
public AVFile(string name, byte[] data)
|
||
: this(name, new MemoryStream(data), new Dictionary<string, object>())
|
||
{
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，数据 byte[] 数组以及元数据创建文件
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件的 byte[] 数据</param>
|
||
/// <param name="metaData">元数据</param>
|
||
public AVFile(string name, byte[] data, IDictionary<string, object> metaData)
|
||
: this(name, new MemoryStream(data), metaData)
|
||
{
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，数据流以及元数据创建文件
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件的数据流</param>
|
||
/// <param name="metaData">元数据</param>
|
||
public AVFile(string name, Stream data, IDictionary<string, object> metaData)
|
||
: this(name, data, GetMIMEType(name), metaData)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，数据流以及元数据创建文件
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="data">文件的数据流</param>
|
||
public AVFile(string name, Stream data)
|
||
: this(name, data, new Dictionary<string, object>())
|
||
{
|
||
|
||
}
|
||
|
||
#region created by url or uri
|
||
/// <summary>
|
||
/// 根据文件名，Uri，文件类型以及文件源信息
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="uri">文件Uri</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
/// <param name="metaData">文件源信息</param>
|
||
public AVFile(string name, Uri uri, string mimeType = null, IDictionary<string, object> metaData = null)
|
||
{
|
||
mimeType = mimeType == null ? GetMIMEType(name) : mimeType;
|
||
state = new FileState
|
||
{
|
||
Name = name,
|
||
Url = uri,
|
||
MetaData = metaData,
|
||
MimeType = mimeType
|
||
};
|
||
lock (Mutex)
|
||
{
|
||
objectCounter++;
|
||
state.counter = objectCounter;
|
||
}
|
||
this.isExternal = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，文件 Url，文件类型，文件源信息构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="url">文件 Url</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
/// <param name="metaData">文件源信息</param>
|
||
public AVFile(string name, string url, string mimeType = null, IDictionary<string, object> metaData = null)
|
||
: this(name, new Uri(url), mimeType, metaData)
|
||
{
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，文件 Url以及文件的源信息构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="url">文件 Url</param>
|
||
/// <param name="metaData">文件源信息</param>
|
||
public AVFile(string name, string url, IDictionary<string, object> metaData)
|
||
: this(name, url, null, metaData)
|
||
{
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名，文件 Uri，以及文件类型构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="uri">文件 Uri</param>
|
||
/// <param name="mimeType">文件类型</param>
|
||
public AVFile(string name, Uri uri, string mimeType = null)
|
||
: this(name, uri, mimeType, new Dictionary<string, object>())
|
||
{
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据文件名以及文件 Uri 构建 AVFile
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="uri">文件 Uri</param>
|
||
public AVFile(string name, Uri uri)
|
||
: this(name, uri, null, new Dictionary<string, object>())
|
||
{
|
||
|
||
}
|
||
/// <summary>
|
||
/// 根据文件名和 Url 创建文件
|
||
/// </summary>
|
||
/// <param name="name">文件名</param>
|
||
/// <param name="url">文件的 Url</param>
|
||
public AVFile(string name, string url)
|
||
: this(name, new Uri(url))
|
||
{
|
||
}
|
||
|
||
internal AVFile(FileState filestate)
|
||
{
|
||
this.state = filestate;
|
||
}
|
||
internal AVFile(string objectId)
|
||
: this(new FileState()
|
||
{
|
||
ObjectId = objectId
|
||
})
|
||
{
|
||
|
||
}
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#region Properties
|
||
|
||
/// <summary>
|
||
/// Gets whether the file still needs to be saved.
|
||
/// </summary>
|
||
public bool IsDirty
|
||
{
|
||
get
|
||
{
|
||
return state.Url == null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the name of the file. Before save is called, this is the filename given by
|
||
/// the user. After save is called, that name gets prefixed with a unique identifier.
|
||
/// </summary>
|
||
[AVFieldName("name")]
|
||
public string Name
|
||
{
|
||
get
|
||
{
|
||
return state.Name;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the MIME type of the file. This is either passed in to the constructor or
|
||
/// inferred from the file extension. "unknown/unknown" will be used if neither is
|
||
/// available.
|
||
/// </summary>
|
||
public string MimeType
|
||
{
|
||
get
|
||
{
|
||
return state.MimeType;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the url of the file. It is only available after you save the file or after
|
||
/// you get the file from a <see cref="AVObject"/>.
|
||
/// </summary>
|
||
[AVFieldName("url")]
|
||
public Uri Url
|
||
{
|
||
get
|
||
{
|
||
return state.Url;
|
||
}
|
||
}
|
||
|
||
internal static IAVFileController FileController
|
||
{
|
||
get
|
||
{
|
||
return AVPlugins.Instance.FileController;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
IDictionary<string, object> IJsonConvertible.ToJSON()
|
||
{
|
||
if (this.IsDirty)
|
||
{
|
||
throw new InvalidOperationException(
|
||
"AVFile must be saved before it can be serialized.");
|
||
}
|
||
return new Dictionary<string, object> {
|
||
{"__type", "File"},
|
||
{ "id", ObjectId },
|
||
{"name", Name},
|
||
{"url", Url.AbsoluteUri}
|
||
};
|
||
}
|
||
|
||
#region Save
|
||
|
||
/// <summary>
|
||
/// Saves the file to the LeanCloud cloud.
|
||
/// </summary>
|
||
public Task SaveAsync()
|
||
{
|
||
return SaveAsync(null, CancellationToken.None);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Saves the file to the LeanCloud cloud.
|
||
/// </summary>
|
||
/// <param name="cancellationToken">The cancellation token.</param>
|
||
public Task SaveAsync(CancellationToken cancellationToken)
|
||
{
|
||
return SaveAsync(null, cancellationToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Saves the file to the LeanCloud cloud.
|
||
/// </summary>
|
||
/// <param name="progress">The progress callback.</param>
|
||
public Task SaveAsync(IProgress<AVUploadProgressEventArgs> progress)
|
||
{
|
||
return SaveAsync(progress, CancellationToken.None);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Saves the file to the LeanCloud cloud.
|
||
/// </summary>
|
||
/// <param name="progress">The progress callback.</param>
|
||
/// <param name="cancellationToken">The cancellation token.</param>
|
||
public Task SaveAsync(IProgress<AVUploadProgressEventArgs> progress,
|
||
CancellationToken cancellationToken)
|
||
{
|
||
if (this.isExternal)
|
||
return this.SaveExternal();
|
||
|
||
return taskQueue.Enqueue(
|
||
toAwait => FileController.SaveAsync(state, dataStream, AVUser.CurrentSessionToken, progress, cancellationToken), cancellationToken)
|
||
.OnSuccess(t =>
|
||
{
|
||
state = t.Result;
|
||
});
|
||
}
|
||
|
||
internal Task SaveExternal()
|
||
{
|
||
Dictionary<string, object> strs = new Dictionary<string, object>()
|
||
{
|
||
{ "url", this.Url.ToString() },
|
||
{ "name",this.Name },
|
||
{ "mime_type",this.MimeType},
|
||
{ "metaData",this.MetaData}
|
||
};
|
||
AVCommand cmd = null;
|
||
|
||
if (!string.IsNullOrEmpty(this.ObjectId))
|
||
{
|
||
cmd = new AVCommand("files/" + this.ObjectId,
|
||
method: "PUT", sessionToken: AVUser.CurrentSessionToken, data: strs);
|
||
}
|
||
else
|
||
{
|
||
cmd = new AVCommand("files", method: "POST", sessionToken: AVUser.CurrentSessionToken, data: strs);
|
||
}
|
||
|
||
return AVPlugins.Instance.CommandRunner.RunCommandAsync(cmd).ContinueWith(t =>
|
||
{
|
||
var result = t.Result.Item2;
|
||
this.state.ObjectId = result["objectId"].ToString();
|
||
return AVClient.IsSuccessStatusCode(t.Result.Item1);
|
||
});
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Compatible
|
||
private readonly static Dictionary<string, string> MIMETypesDictionary;
|
||
private object mutex = new object();
|
||
private bool isExternal;
|
||
/// <summary>
|
||
/// 文件在 LeanCloud 的唯一Id 标识
|
||
/// </summary>
|
||
public string ObjectId
|
||
{
|
||
get
|
||
{
|
||
string str;
|
||
lock (this.mutex)
|
||
{
|
||
str = state.ObjectId;
|
||
}
|
||
return str;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 文件的元数据。
|
||
/// </summary>
|
||
public IDictionary<string, object> MetaData
|
||
{
|
||
get
|
||
{
|
||
return state.MetaData;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 文件是否为外链文件。
|
||
/// </summary>
|
||
/// <value>
|
||
/// </value>
|
||
public bool IsExternal
|
||
{
|
||
get
|
||
{
|
||
return isExternal;
|
||
}
|
||
}
|
||
|
||
static AVFile()
|
||
{
|
||
Dictionary<string, string> strs = new Dictionary<string, string>()
|
||
{
|
||
{ "ai", "application/postscript" },
|
||
{ "aif", "audio/x-aiff" },
|
||
{ "aifc", "audio/x-aiff" },
|
||
{ "aiff", "audio/x-aiff" },
|
||
{ "asc", "text/plain" },
|
||
{ "atom", "application/atom+xml" },
|
||
{ "au", "audio/basic" },
|
||
{ "avi", "video/x-msvideo" },
|
||
{ "bcpio", "application/x-bcpio" },
|
||
{ "bin", "application/octet-stream" },
|
||
{ "bmp", "image/bmp" },
|
||
{ "cdf", "application/x-netcdf" },
|
||
{ "cgm", "image/cgm" },
|
||
{ "class", "application/octet-stream" },
|
||
{ "cpio", "application/x-cpio" },
|
||
{ "cpt", "application/mac-compactpro" },
|
||
{ "csh", "application/x-csh" },
|
||
{ "css", "text/css" },
|
||
{ "dcr", "application/x-director" },
|
||
{ "dif", "video/x-dv" },
|
||
{ "dir", "application/x-director" },
|
||
{ "djv", "image/vnd.djvu" },
|
||
{ "djvu", "image/vnd.djvu" },
|
||
{ "dll", "application/octet-stream" },
|
||
{ "dmg", "application/octet-stream" },
|
||
{ "dms", "application/octet-stream" },
|
||
{ "doc", "application/msword" },
|
||
{ "docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
|
||
{ "dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
|
||
{ "docm", "application/vnd.ms-word.document.macroEnabled.12" },
|
||
{ "dotm", "application/vnd.ms-word.template.macroEnabled.12" },
|
||
{ "dtd", "application/xml-dtd" },
|
||
{ "dv", "video/x-dv" },
|
||
{ "dvi", "application/x-dvi" },
|
||
{ "dxr", "application/x-director" },
|
||
{ "eps", "application/postscript" },
|
||
{ "etx", "text/x-setext" },
|
||
{ "exe", "application/octet-stream" },
|
||
{ "ez", "application/andrew-inset" },
|
||
{ "gif", "image/gif" },
|
||
{ "gram", "application/srgs" },
|
||
{ "grxml", "application/srgs+xml" },
|
||
{ "gtar", "application/x-gtar" },
|
||
{ "hdf", "application/x-hdf" },
|
||
{ "hqx", "application/mac-binhex40" },
|
||
{ "htm", "text/html" },
|
||
{ "html", "text/html" },
|
||
{ "ice", "x-conference/x-cooltalk" },
|
||
{ "ico", "image/x-icon" },
|
||
{ "ics", "text/calendar" },
|
||
{ "ief", "image/ief" },
|
||
{ "ifb", "text/calendar" },
|
||
{ "iges", "model/iges" },
|
||
{ "igs", "model/iges" },
|
||
{ "jnlp", "application/x-java-jnlp-file" },
|
||
{ "jp2", "image/jp2" },
|
||
{ "jpe", "image/jpeg" },
|
||
{ "jpeg", "image/jpeg" },
|
||
{ "jpg", "image/jpeg" },
|
||
{ "js", "application/x-javascript" },
|
||
{ "kar", "audio/midi" },
|
||
{ "latex", "application/x-latex" },
|
||
{ "lha", "application/octet-stream" },
|
||
{ "lzh", "application/octet-stream" },
|
||
{ "m3u", "audio/x-mpegurl" },
|
||
{ "m4a", "audio/mp4a-latm" },
|
||
{ "m4b", "audio/mp4a-latm" },
|
||
{ "m4p", "audio/mp4a-latm" },
|
||
{ "m4u", "video/vnd.mpegurl" },
|
||
{ "m4v", "video/x-m4v" },
|
||
{ "mac", "image/x-macpaint" },
|
||
{ "man", "application/x-troff-man" },
|
||
{ "mathml", "application/mathml+xml" },
|
||
{ "me", "application/x-troff-me" },
|
||
{ "mesh", "model/mesh" },
|
||
{ "mid", "audio/midi" },
|
||
{ "midi", "audio/midi" },
|
||
{ "mif", "application/vnd.mif" },
|
||
{ "mov", "video/quicktime" },
|
||
{ "movie", "video/x-sgi-movie" },
|
||
{ "mp2", "audio/mpeg" },
|
||
{ "mp3", "audio/mpeg" },
|
||
{ "mp4", "video/mp4" },
|
||
{ "mpe", "video/mpeg" },
|
||
{ "mpeg", "video/mpeg" },
|
||
{ "mpg", "video/mpeg" },
|
||
{ "mpga", "audio/mpeg" },
|
||
{ "ms", "application/x-troff-ms" },
|
||
{ "msh", "model/mesh" },
|
||
{ "mxu", "video/vnd.mpegurl" },
|
||
{ "nc", "application/x-netcdf" },
|
||
{ "oda", "application/oda" },
|
||
{ "ogg", "application/ogg" },
|
||
{ "pbm", "image/x-portable-bitmap" },
|
||
{ "pct", "image/pict" },
|
||
{ "pdb", "chemical/x-pdb" },
|
||
{ "pdf", "application/pdf" },
|
||
{ "pgm", "image/x-portable-graymap" },
|
||
{ "pgn", "application/x-chess-pgn" },
|
||
{ "pic", "image/pict" },
|
||
{ "pict", "image/pict" },
|
||
{ "png", "image/png" },
|
||
{ "pnm", "image/x-portable-anymap" },
|
||
{ "pnt", "image/x-macpaint" },
|
||
{ "pntg", "image/x-macpaint" },
|
||
{ "ppm", "image/x-portable-pixmap" },
|
||
{ "ppt", "application/vnd.ms-powerpoint" },
|
||
{ "pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
|
||
{ "potx", "application/vnd.openxmlformats-officedocument.presentationml.template" },
|
||
{ "ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow" },
|
||
{ "ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12" },
|
||
{ "pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12" },
|
||
{ "potm", "application/vnd.ms-powerpoint.template.macroEnabled.12" },
|
||
{ "ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" },
|
||
{ "ps", "application/postscript" },
|
||
{ "qt", "video/quicktime" },
|
||
{ "qti", "image/x-quicktime" },
|
||
{ "qtif", "image/x-quicktime" },
|
||
{ "ra", "audio/x-pn-realaudio" },
|
||
{ "ram", "audio/x-pn-realaudio" },
|
||
{ "ras", "image/x-cmu-raster" },
|
||
{ "rdf", "application/rdf+xml" },
|
||
{ "rgb", "image/x-rgb" },
|
||
{ "rm", "application/vnd.rn-realmedia" },
|
||
{ "roff", "application/x-troff" },
|
||
{ "rtf", "text/rtf" },
|
||
{ "rtx", "text/richtext" },
|
||
{ "sgm", "text/sgml" },
|
||
{ "sgml", "text/sgml" },
|
||
{ "sh", "application/x-sh" },
|
||
{ "shar", "application/x-shar" },
|
||
{ "silo", "model/mesh" },
|
||
{ "sit", "application/x-stuffit" },
|
||
{ "skd", "application/x-koan" },
|
||
{ "skm", "application/x-koan" },
|
||
{ "skp", "application/x-koan" },
|
||
{ "skt", "application/x-koan" },
|
||
{ "smi", "application/smil" },
|
||
{ "smil", "application/smil" },
|
||
{ "snd", "audio/basic" },
|
||
{ "so", "application/octet-stream" },
|
||
{ "spl", "application/x-futuresplash" },
|
||
{ "src", "application/x-wais-Source" },
|
||
{ "sv4cpio", "application/x-sv4cpio" },
|
||
{ "sv4crc", "application/x-sv4crc" },
|
||
{ "svg", "image/svg+xml" },
|
||
{ "swf", "application/x-shockwave-flash" },
|
||
{ "t", "application/x-troff" },
|
||
{ "tar", "application/x-tar" },
|
||
{ "tcl", "application/x-tcl" },
|
||
{ "tex", "application/x-tex" },
|
||
{ "texi", "application/x-texinfo" },
|
||
{ "texinfo", "application/x-texinfo" },
|
||
{ "tif", "image/tiff" },
|
||
{ "tiff", "image/tiff" },
|
||
{ "tr", "application/x-troff" },
|
||
{ "tsv", "text/tab-separated-values" },
|
||
{ "txt", "text/plain" },
|
||
{ "ustar", "application/x-ustar" },
|
||
{ "vcd", "application/x-cdlink" },
|
||
{ "vrml", "model/vrml" },
|
||
{ "vxml", "application/voicexml+xml" },
|
||
{ "wav", "audio/x-wav" },
|
||
{ "wbmp", "image/vnd.wap.wbmp" },
|
||
{ "wbmxl", "application/vnd.wap.wbxml" },
|
||
{ "wml", "text/vnd.wap.wml" },
|
||
{ "wmlc", "application/vnd.wap.wmlc" },
|
||
{ "wmls", "text/vnd.wap.wmlscript" },
|
||
{ "wmlsc", "application/vnd.wap.wmlscriptc" },
|
||
{ "wrl", "model/vrml" },
|
||
{ "xbm", "image/x-xbitmap" },
|
||
{ "xht", "application/xhtml+xml" },
|
||
{ "xhtml", "application/xhtml+xml" },
|
||
{ "xls", "application/vnd.ms-excel" },
|
||
{ "xml", "application/xml" },
|
||
{ "xpm", "image/x-xpixmap" },
|
||
{ "xsl", "application/xml" },
|
||
{ "xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
|
||
{ "xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
|
||
{ "xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12" },
|
||
{ "xltm", "application/vnd.ms-excel.template.macroEnabled.12" },
|
||
{ "xlam", "application/vnd.ms-excel.addin.macroEnabled.12" },
|
||
{ "xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12" },
|
||
{ "xslt", "application/xslt+xml" },
|
||
{ "xul", "application/vnd.mozilla.xul+xml" },
|
||
{ "xwd", "image/x-xwindowdump" },
|
||
{ "xyz", "chemical/x-xyz" },
|
||
{ "zip", "application/zip" },
|
||
};
|
||
AVFile.MIMETypesDictionary = strs;
|
||
}
|
||
internal static string GetMIMEType(string fileName)
|
||
{
|
||
try
|
||
{
|
||
string str = Path.GetExtension(fileName).Remove(0, 1);
|
||
if (!AVFile.MIMETypesDictionary.ContainsKey(str))
|
||
{
|
||
return "unknown/unknown";
|
||
}
|
||
return AVFile.MIMETypesDictionary[str];
|
||
}
|
||
catch
|
||
{
|
||
return "unknown/unknown";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据 ObjectId 获取文件
|
||
/// </summary>
|
||
/// <remarks>获取之后并没有实际执行下载，只是加载了文件的元信息以及物理地址（Url）
|
||
/// </remarks>
|
||
public static Task<AVFile> GetFileWithObjectIdAsync(string objectId, CancellationToken cancellationToken)
|
||
{
|
||
string currentSessionToken = AVUser.CurrentSessionToken;
|
||
return FileController.GetAsync(objectId, currentSessionToken, cancellationToken).OnSuccess(_ =>
|
||
{
|
||
var filestate = _.Result;
|
||
return new AVFile(filestate);
|
||
});
|
||
}
|
||
|
||
public static AVFile CreateWithoutData(string objectId)
|
||
{
|
||
return new AVFile(objectId);
|
||
}
|
||
|
||
public static AVFile CreateWithState(FileState state)
|
||
{
|
||
return new AVFile(state);
|
||
}
|
||
|
||
public static AVFile CreateWithData(string objectId,string name, string url,IDictionary<string,object> metaData)
|
||
{
|
||
var fileState = new FileState();
|
||
fileState.Name = name;
|
||
fileState.ObjectId = objectId;
|
||
fileState.Url = new Uri(url);
|
||
fileState.MetaData = metaData;
|
||
return CreateWithState(fileState);
|
||
}
|
||
/// <summary>
|
||
/// 根据 ObjectId 获取文件
|
||
/// </summary>
|
||
/// <remarks>获取之后并没有实际执行下载，只是加载了文件的元信息以及物理地址（Url）
|
||
/// </remarks>
|
||
public static Task<AVFile> GetFileWithObjectIdAsync(string objectId)
|
||
{
|
||
return GetFileWithObjectIdAsync(objectId, CancellationToken.None);
|
||
}
|
||
|
||
internal void MergeFromJSON(IDictionary<string, object> jsonData)
|
||
{
|
||
lock (this.mutex)
|
||
{
|
||
state.ObjectId = jsonData["objectId"] as string;
|
||
state.Url = new Uri(jsonData["url"] as string, UriKind.Absolute);
|
||
if (jsonData.ContainsKey("name"))
|
||
{
|
||
state.Name = jsonData["name"] as string;
|
||
}
|
||
if (jsonData.ContainsKey("metaData"))
|
||
{
|
||
state.MetaData = jsonData["metaData"] as Dictionary<string, object>;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除文件
|
||
/// </summary>
|
||
/// <returns>Task</returns>
|
||
public Task DeleteAsync()
|
||
{
|
||
return DeleteAsync(CancellationToken.None);
|
||
}
|
||
internal Task DeleteAsync(CancellationToken cancellationToken)
|
||
{
|
||
return taskQueue.Enqueue(toAwait => DeleteAsync(toAwait, cancellationToken),
|
||
cancellationToken);
|
||
|
||
}
|
||
internal Task DeleteAsync(Task toAwait, CancellationToken cancellationToken)
|
||
{
|
||
if (ObjectId == null)
|
||
{
|
||
return Task.FromResult(0);
|
||
}
|
||
|
||
string sessionToken = AVUser.CurrentSessionToken;
|
||
|
||
return toAwait.OnSuccess(_ =>
|
||
{
|
||
return FileController.DeleteAsync(state, sessionToken, cancellationToken);
|
||
}).Unwrap().OnSuccess(_ => { });
|
||
}
|
||
#endregion
|
||
}
|
||
|
||
|
||
}
|