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; }