public async Task <StatusCodeResult> AddMediaAsync(string id, string url, EMediaType mediaType)
{
var residentObjectId = await CanWriteDataToResidentAsync(id);
await((IResidentsService)DataService).AddMediaAsync(residentObjectId, url, mediaType);
return(StatusCode((int)HttpStatusCode.Created));
}
public MediaBinding(EMediaType mediaType, string localMimeType, string remoteMimeType, string ext)
{
MediaType = mediaType;
LocalMimeType = localMimeType;
RemoteMimeType = remoteMimeType;
FileExtension = ext;
}
public async Task RemoveMediaAsync(string id, string mediaId, EMediaType mediaType)
{
var mediaObjectId = mediaId.ToObjectId();
var residentObjectId = await CanWriteDataToResidentAsync(id);
await((IResidentsService)DataService).RemoveMediaAsync(residentObjectId, mediaObjectId, mediaType);
}
public async Task RemoveMediaAsync(ObjectId residentId, ObjectId mediaId, EMediaType mediaType)
{
Resident resident;
bool containsMedia;
switch (mediaType)
{
case EMediaType.Audio:
resident = await RemoveMediaAsync(residentId, x => x.Music, mediaId, mediaType);
containsMedia = resident.Music.Any(x => x.Id == mediaId);
break;
case EMediaType.Video:
resident = await RemoveMediaAsync(residentId, x => x.Videos, mediaId, mediaType);
containsMedia = resident.Videos.Any(x => x.Id == mediaId);
break;
case EMediaType.Image:
resident = await RemoveMediaAsync(residentId, x => x.Images, mediaId, mediaType);
containsMedia = resident.Images.Any(x => x.Id == mediaId);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mediaType), mediaType, null);
}
if (!containsMedia)
{
throw new ElementNotFoundException <Resident>(mediaType.ToString(), "media");
}
}
public async Task AddMediaAsync(ObjectId residentId, string url, EMediaType mediaType)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
await AddMediaAsync(residentId, new MediaUrl { Id = ObjectId.GenerateNewId(), Url = url }, mediaType);
}
private void UpdateMediaType()
{
if (!string.IsNullOrEmpty(m_FilePath))
{
m_MediaType = MediaSettings.GetMediaFromPath(m_FilePath);
}
else
{
m_MediaType = EMediaType.UNKNOWN;
}
}
protected virtual void BaseHeader(EMediaType eMediaType, HttpClient client)
{
client.DefaultRequestHeaders.Accept.Clear();
if (Token.Any())
{
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(Token.FirstOrDefault().Key, Token.FirstOrDefault().Value);
}
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(eMediaType.ObterAtributoDescricao()));
client.BaseAddress = new Uri(UrlWs);
}
private void UpdateMediaType()
{
if (m_UploadAsset != null)
{
var assetPath = AssetDatabase.GetAssetPath(m_UploadAsset);
m_MediaType = MediaSettings.GetMediaFromPath(assetPath);
}
else
{
m_MediaType = EMediaType.UNKNOWN;
}
}
/// local mime (for upload)
public static string GetLocalMimeFromMedia(EMediaType type)
{
if (LocalMediaToMime.ContainsKey(type))
{
return(LocalMediaToMime[type]);
}
else
{
throw new System.NotSupportedException(
string.Format("unknown EMediaType : {0}", type));
}
}
public static string GetExtensionFromMedia(EMediaType type)
{
if (MediaToExt.ContainsKey(type))
{
return(MediaToExt[type]);
}
else
{
throw new System.NotSupportedException(
string.Format("unknown EMediaType : {0}", type));
}
}
public async Task <(List <Media> medias, int count)> GetMediasAsync(EMediaType mediaType, int pageNumber, int pageSize)
{
int skip = (pageNumber - 1) * pageSize;
int take = pageSize;
var q = _entities.Where(m => m.MediaType == mediaType);
var medias = await q.OrderByDescending(m => m.UploadedOn)
.Skip(skip)
.Take(take)
.ToListAsync();
var count = await q.CountAsync();
return(medias : medias, count : count);
}
private Tuple <Stream, string> GetConvertedMedia(MultiPartFile data, EMediaType mediaType, int maxFileSize)
{
Stream stream;
string extension;
switch (mediaType)
{
case EMediaType.Video:
var contentType = data.File.ContentType;
switch (contentType)
{
case "video/ogg":
case "video/mp4":
case "video/webm":
stream = data.File.OpenReadStream();
extension = GetExtensionFromContentType(contentType);
break;
default:
if (!CanConvert)
{
throw new BadMediaException($"Videos with the type {contentType} are not allowed");
}
else
{
var video = new Video(data.File.OpenReadStream());
stream = _videoConverter.ConvertToWebm(video).Stream;
extension = "webm";
}
break;
}
break;
default:
stream = data.File.OpenReadStream();
extension = GetExtensionFromContentType(data.File.ContentType);
break;
}
return(new Tuple <Stream, string>(stream, extension));
}
/// <summary>
/// ファイルをアップロードします
/// </summary>
public static string UploadFile(EMediaType type, string uploadName, string filePath)
{
DriveService drive = OpenDrive();
/////////////////////////////// UPLOAD FILE /////////////////////////////////////
File body = new File();
body.Name = uploadName;
body.Description = "test upload";
body.MimeType = MediaSettings.GetLocalMimeFromMedia(type);
body.Parents = new List <string>
{
};
string fileId;
UploadFile(drive, type, body, filePath, out fileId);
return(fileId);
}
private static void UploadFile(DriveService service, EMediaType type, File body, string filePath, out string fileId)
{
// File's content.
byte[] byteArray = System.IO.File.ReadAllBytes(filePath);
MemoryStream stream = new MemoryStream(byteArray);
try
{
var request = service.Files.Create(body, stream, MediaSettings.GetLocalMimeFromMedia(type)); // https://developers.google.com/drive/api/v3/mime-types
request.Upload();
File file = request.ResponseBody;
Debug.Log(file.Id);
fileId = file.Id;
}
catch (Exception e)
{
Debug.LogError("An error occurred: " + e.Message);
fileId = "";
}
}
private async Task AddMediaAsync(ObjectId residentId, MediaUrl mediaUrl, EMediaType mediaType)
{
switch (mediaType)
{
case EMediaType.Audio:
await AddMediaAsync(residentId, x => x.Music, mediaUrl);
break;
case EMediaType.Video:
await AddMediaAsync(residentId, x => x.Videos, mediaUrl);
break;
case EMediaType.Image:
await AddMediaAsync(residentId, x => x.Images, mediaUrl);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mediaType), mediaType, null);
}
}
private async Task <Resident> RemoveMediaAsync(ObjectId residentId,
Expression <Func <Resident, IEnumerable <MediaUrl> > > selector, ObjectId mediaId, EMediaType mediaType)
{
try
{
await _mediaService.RemoveAsync(mediaId);
}
catch (NotFoundException)
{
// IGNORED
}
var updater = Builders <Resident> .Update.PullFilter(selector, x => x.Id == mediaId);
var resident = await MongoCollection.FindOneAndUpdateAsync(x => x.Id == residentId, updater);
if (resident == null)
{
throw new NotFoundException <Resident>(nameof(IModelWithID.Id), residentId.ToString());
}
return(resident);
}
public async Task <StatusCodeResult> AddMediaAsync(string id, MultiPartFile data, EMediaType mediaType,
int maxFileSize = int.MaxValue)
{
if (data?.File == null)
{
throw new ArgumentNullException(nameof(data));
}
var residentObjectId = await CanWriteDataToResidentAsync(id);
var convertedMedia = GetConvertedMedia(data, mediaType, maxFileSize);
var title = data.File.FileName;
using (var stream = convertedMedia.Item1)
{
await((IResidentsService)DataService)
.AddMediaAsync(residentObjectId, title, stream, mediaType, convertedMedia.Item2);
}
return(StatusCode((int)HttpStatusCode.Created));
}
/// <summary>
/// Returns a list of <see cref="Media"/> based on media type page number and page size,
/// or empty list if no records found; and total count of medias for this media type.
/// </summary>
/// <param name="mediaType"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public async Task <(List <Media> medias, int count)> GetMediasAsync(EMediaType mediaType,
int pageNumber, int pageSize) =>
static MediaQuery Consume_MediaQuery(DataConsumer <CssToken> Stream = null)
{/* Docs: https://drafts.csswg.org/mediaqueries-4/#mq-syntax */
if (Stream is null)
{
throw new CssParserException(CssErrors.STREAM_IS_NULL);
}
if (Stream.Next.Type != ECssTokenType.Ident)
{
throw new CssSyntaxErrorException(CssErrors.EXPECTING_IDENT, Stream);
}
EMediaQueryModifier modifier = 0x0;
EMediaType mediaType = 0x0;
LinkedList <IMediaCondition> conditionList = new LinkedList <IMediaCondition>();
/* First check for media modifier */
if (Stream.Next.Type != ECssTokenType.Ident)
{
throw new CssSyntaxErrorException(CssErrors.EXPECTING_IDENT, Stream);
}
if (Lookup.TryEnum((Stream.Next as IdentToken).Value, out EMediaQueryModifier mod))
{
Stream.Consume();// consume this token
modifier = mod;
}
/* Skip 'and' keyword if present */
if (ParserCommon.Is_Combinator(Stream.Next))
{
Stream.Consume();
}
/* Set the media type */
if (Stream.Next.Type != ECssTokenType.Ident)
{
throw new CssSyntaxErrorException(CssErrors.EXPECTING_IDENT, Stream);
}
if (!Lookup.TryEnum((Stream.Next as IdentToken).Value, out EMediaType type))
{
throw new CssParserException(String.Format(CultureInfo.InvariantCulture, CssErrors.INVALID_MEDIA_TYPE, (Stream.Next as IdentToken).Value), Stream);
}
else
{
Stream.Consume();
}
/* Skip thew first combinator keyword if present */
Consume_All_Whitespace(Stream);
if (ParserCommon.Is_Combinator(Stream.Next))
{
Stream.Consume();
}
/* Now consume media conditions until we cant anymore */
do
{
Consume_All_Whitespace(Stream);
if (Stream.Next.Type != ECssTokenType.Parenth_Open)
{/* This isn't invalid, it just signals that we have no more features to consume */
break;
}
var condition = Consume_Media_Condition(Stream);
conditionList.AddLast(condition);
}while (Stream.Next.Type != ECssTokenType.EOF);
return(new MediaQuery(modifier, mediaType, conditionList));
}
public async Task AddMediaAsync(ObjectId residentId, string title, Stream data, EMediaType mediaType,
string extension = null)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var mediaId = await _mediaService.CreateAsync(data, title);
await AddMediaAsync(
residentId,
new MediaUrl { Id = mediaId, Title = title, Extension = extension },
mediaType);
}
public DMediaItem(EMediaType type_, String path_, IMediaItem referred_ = null)
{
type = type_;
path = path_;
referred = referred_;
}
/// <summary>
/// Returns a list of <see cref="Media"/> based on media type page number and page size,
/// or empty list if no records found; and total count of medias for this media type.
/// </summary>
/// <param name="mediaType"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public async Task <(List <Media> medias, int count)> GetMediasAsync(EMediaType mediaType, int pageNumber, int pageSize)
{
return(await _mediaRepo.GetMediasAsync(mediaType, pageNumber, pageSize));
}
public MediaQuery(EMediaQueryModifier modifier, EMediaType mediaType, LinkedList <IMediaCondition> conditions)
{
Modifier = modifier;
MediaType = mediaType;
Conditions = conditions;
}
