Example #1
0
        public async Task ExecuteAsync(RecipeExecutionContext context)
        {
            if (!String.Equals(context.Name, "media", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            var model = context.Step.ToObject <MediaStepModel>();

            foreach (JObject item in model.Files)
            {
                var file = item.ToObject <MediaStepFile>();
                using (var stream = new MemoryStream(Convert.FromBase64String(file.Base64)))
                {
                    await _mediaFileStore.TrySaveStreamAsync(file.Path, stream);
                }
            }
        }
Example #2
0
        private async Task <XRpcStruct> MetaWeblogNewMediaObjectAsync(string userName, string password, XRpcStruct file)
        {
            var user = await ValidateUserAsync(userName, password);

            var name = file.Optional <string>("name");
            var bits = file.Optional <byte[]>("bits");

            string directoryName = Path.GetDirectoryName(name);
            string filePath      = _mediaFileStore.Combine(directoryName, Path.GetFileName(name));
            bool   saved         = await _mediaFileStore.TrySaveStreamAsync(filePath, new MemoryStream(bits));

            string publicUrl = _mediaFileStore.GetPublicUrl(filePath);

            return(new XRpcStruct() // Some clients require all optional attributes to be declared Wordpress responds in this way as well.
                   .Set("file", publicUrl)
                   .Set("url", publicUrl)
                   .Set("type", file.Optional <string>("type")));
        }
        public async Task <ActionResult> Upload(
            string path,
            string contentType,
            ICollection <IFormFile> files)
        {
            if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia))
            {
                return(Unauthorized());
            }

            if (string.IsNullOrEmpty(path))
            {
                path = "";
            }

            var result = new List <object>();

            // TODO: Validate file extensions

            // Loop through each file in the request
            foreach (var file in files)
            {
                // TODO: support clipboard

                try
                {
                    var mediaFilePath = _mediaFileStore.Combine(path, file.FileName);

                    using (var stream = file.OpenReadStream())
                    {
                        if (!await _mediaFileStore.TrySaveStreamAsync(mediaFilePath, stream))
                        {
                            result.Add(new
                            {
                                name   = file.FileName,
                                size   = file.Length,
                                folder = path,
                                error  = "Couldn't copy the file in the media store"
                            });
                        }
                    }

                    var mediaFile = await _mediaFileStore.GetFileAsync(mediaFilePath);

                    result.Add(CreateFileResult(mediaFile));
                }
                catch (Exception ex)
                {
                    _logger.LogError("An error occured while uploading a media: " + ex.Message);

                    result.Add(new
                    {
                        name   = file.FileName,
                        size   = file.Length,
                        folder = path,
                        error  = ex.Message
                    });
                }
            }

            return(Json(new { files = result.ToArray() }));
        }