public async Task<ValidationResult> Execute(MediaInfo mediaInfo, Int32 x, Int32 y, Int32 width, Int32 height)
{
if (x < 0 || y < 0 || width <= 0 || height <= 0)
{
return new ValidationResult("サイズの指定が不正です。");
}
var mediaContent = await _mediaRepository.Get(mediaInfo);
if (mediaContent == null)
{
return new ValidationResult("指定されたメディアが見つかりませんでした。");
}
var data = await mediaContent.GetContentAsync();
var imageInfo = new MagickImageInfo(data);
if (imageInfo.Width < (x + width) || imageInfo.Height < (y + height))
{
return new ValidationResult("指定されたサイズは画像のサイズを超えています。");
}
// リサイズするよ!
using (var image = new MagickImage(data))
{
image.Crop(new MagickGeometry(x, y, width, height));
image.Page = new MagickGeometry(0, 0, width, height);
// そして更新
await _mediaRepository.Update(mediaInfo, image.ToByteArray());
}
return ValidationResult.Success;
}
public static void ReadBasicImageInformation()
{
// Read from file
MagickImageInfo info = new MagickImageInfo(SampleFiles.SnakewarePng);
// Read from stream
using (MemoryStream memStream = LoadMemoryStreamImage())
{
info = new MagickImageInfo(memStream);
}
// Read from byte array
byte[] data = LoadImageBytes();
info = new MagickImageInfo(data);
info = new MagickImageInfo();
info.Read(SampleFiles.SnakewarePng);
using (MemoryStream memStream = LoadMemoryStreamImage())
{
info.Read(memStream);
}
info.Read(data);
Console.WriteLine(info.Width);
Console.WriteLine(info.Height);
Console.WriteLine(info.ColorSpace);
Console.WriteLine(info.Format);
Console.WriteLine(info.ResolutionX);
Console.WriteLine(info.ResolutionY);
}
/// <summary>
/// アップロードされたデータの検証を行います。
/// </summary>
/// <param name="userId">ユーザーのID</param>
/// <param name="stream">画像データ</param>
/// <param name="length">画像データの長さ</param>
/// <returns></returns>
public ValidationResult Validate(String userId, Stream stream, Int64 length)
{
if (length > 1024 * 1024 * 10)
{
return new ValidationResult("10MBを超える画像のアップロードは許可されていません");
}
// 画像の種類をとるよ
var imageInfo = new MagickImageInfo(stream);
var contentType = (imageInfo.Format == MagickFormat.Png)
? "image/png"
: (imageInfo.Format == MagickFormat.Jpeg)
? "image/jpeg"
: (imageInfo.Format == MagickFormat.Gif)
? "image/gif"
: null;
stream.Position = 0; // 巻き戻しておく
if (String.IsNullOrWhiteSpace(contentType))
{
return new ValidationResult("アップロードできる画像はPNG/JPEG/GIF形式のみです");
}
if (imageInfo.Width >= 10000 || imageInfo.Height >= 10000 || imageInfo.Width * imageInfo.Height * 4 > (45 * 1024 * 1024))
{
return new ValidationResult("やめてくださいしんでしまいます^o^");
}
return ValidationResult.Success;
}
private static MagickFormatInfo GetFormatInformation(FileInfo file)
{
MagickFormatInfo info = MagickNET.GetFormatInformation(file);
if (info != null)
return info;
MagickImageInfo imageInfo = new MagickImageInfo(file);
return MagickNET.GetFormatInformation(imageInfo.Format);
}
public void Test_Dimensions()
{
using (MagickImage image = new MagickImage())
{
MagickReadSettings settings = new MagickReadSettings();
settings.Width = 100;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(100, image.Width);
Assert.AreEqual(48, image.Height);
settings.Width = null;
settings.Height = 200;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(415, image.Width);
Assert.AreEqual(200, image.Height);
settings.Width = 300;
settings.Height = 300;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(300, image.Width);
Assert.AreEqual(144, image.Height);
image.Ping(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(300, image.Width);
Assert.AreEqual(144, image.Height);
using (FileStream fs = File.OpenRead(Files.Logos.MagickNETSVG))
{
fs.Seek(55, SeekOrigin.Begin);
ExceptionAssert.Throws<MagickMissingDelegateErrorException>(() =>
{
new MagickImageInfo(fs, settings);
});
fs.Seek(55, SeekOrigin.Begin);
settings.Format = MagickFormat.Svg;
MagickImageInfo info = new MagickImageInfo(fs, settings);
Assert.AreEqual(300, info.Width);
Assert.AreEqual(144, info.Height);
}
}
}
public static MagickReadSettings GetSettings(Stream stream)
{
var info = new MagickImageInfo(stream);
var settings = new MagickReadSettings
{
Format = info.Format,
ColorSpace = info.ColorSpace,
Height = info.Height,
Width = info.Width,
};
stream.Position = 0;
return(settings);
}
public void Test_Read()
{
MagickImageInfo imageInfo = new MagickImageInfo();
ExceptionAssert.Throws <ArgumentException>(delegate()
{
imageInfo.Read(new byte[0]);
});
ExceptionAssert.Throws <ArgumentNullException>(delegate()
{
imageInfo.Read((byte[])null);
});
ExceptionAssert.Throws <ArgumentNullException>(delegate()
{
imageInfo.Read((Stream)null);
});
ExceptionAssert.Throws <ArgumentNullException>(delegate()
{
imageInfo.Read((string)null);
});
ExceptionAssert.Throws <ArgumentException>(delegate()
{
imageInfo.Read(Files.Missing);
});
imageInfo.Read(File.ReadAllBytes(Files.SnakewarePNG));
using (FileStream fs = File.OpenRead(Files.SnakewarePNG))
{
imageInfo.Read(fs);
}
imageInfo.Read(Files.ImageMagickJPG);
Assert.AreEqual(ColorSpace.RGB, imageInfo.ColorSpace);
Assert.AreEqual(MagickFormat.Jpeg, imageInfo.Format);
Assert.AreEqual(123, imageInfo.Width);
Assert.AreEqual(118, imageInfo.Height);
Assert.AreEqual(72, imageInfo.ResolutionX);
Assert.AreEqual(72, imageInfo.ResolutionY);
Assert.AreEqual(Resolution.PixelsPerInch, imageInfo.ResolutionUnits);
}
public void ShouldResultInSmallerFileWHenQualityIsSetTo40()
{
using (var tempFile = new TemporaryFile(Files.ImageMagickJPG))
{
var optimizer = new JpegOptimizer();
optimizer.Compress(tempFile.FileInfo);
var info = new MagickImageInfo(tempFile.FileInfo);
Assert.Equal(85, info.Quality);
FileHelper.Copy(Files.ImageMagickJPG, tempFile.FullName);
optimizer.Compress(tempFile.FileInfo, 40);
info = new MagickImageInfo(tempFile.FileInfo);
Assert.Equal(40, info.Quality);
}
}
public void Compress_WithQualitySetTo40_FileIsSmallerThanNormalCompression()
{
using (TemporaryFile tempFile = new TemporaryFile(Files.ImageMagickJPG))
{
JpegOptimizer optimizer = new JpegOptimizer();
optimizer.Compress(tempFile);
IMagickImageInfo info = new MagickImageInfo(tempFile);
Assert.AreEqual(85, info.Quality);
File.Copy(Files.ImageMagickJPG, tempFile.FullName, true);
optimizer.Compress(tempFile, 40);
info = new MagickImageInfo(tempFile);
Assert.AreEqual(40, info.Quality);
}
}
public void ShouldResultInSmallerFileWHenQualityIsSetTo40()
{
using (TemporaryFile tempFile = new TemporaryFile(Files.ImageMagickJPG))
{
JpegOptimizer optimizer = new JpegOptimizer();
optimizer.Compress(tempFile);
IMagickImageInfo info = new MagickImageInfo(tempFile);
Assert.AreEqual(85, info.Quality);
File.Copy(Files.ImageMagickJPG, tempFile.FullName, true);
optimizer.Compress(tempFile, 40);
info = new MagickImageInfo(tempFile);
Assert.AreEqual(40, info.Quality);
}
}
public async Task <ImageProcessResult> GetImage(byte[] bytes, int width, int quality = 80, bool asProgressiveJpeg = false)
{
byte[] output;
string mimeType = string.Empty;
try
{
var info = new MagickImageInfo(bytes);
switch (info.Format)
{
case MagickFormat.Svg:
output = bytes;
break;
case MagickFormat.Gif:
output = ProcessGif(bytes, width, quality);
if (output.Length > bytes.Length)
{
output = bytes;
}
break;
default:
var result = ProcessImage(bytes, width, quality, asProgressiveJpeg);
output = result.Bytes;
mimeType = result.MimeType;
break;
}
}
catch (MagickException)
{
return(new ImageProcessResult {
Bytes = bytes, IsImage = false, Size = bytes.Length
});
}
var newImageInfo = new MagickImageInfo(output);
var task = Task.Run(() => new ImageProcessResult {
Bytes = output, IsImage = true, Width = newImageInfo.Width, Height = newImageInfo.Height, Size = output.Length, MimeType = mimeType
});
return(await task);
}
public MainForm()
{
InitializeComponent();
// initializing variables
info_before = null;
image_before = null;
image_after = null;
// creating empty profile
profile = new ConverterProfile();
// initializing form values
LoadProfileSettings();
// other visual setup
bOrderUp.Text = ((char)0x2191).ToString();
bOrderDown.Text = ((char)0x2193).ToString();
}
public IActionResult ReadPhotoInfo()
{
var filePath = hostingEnv.WebRootPath + $@"\Files\Pictures\Dishes\hongshaorou.JPG";
MagickImageInfo info = new MagickImageInfo(filePath);
using (MagickImage image = new MagickImage(filePath))
{
ExifProfile profile = image.GetExifProfile();
if (profile == null)
{
Console.WriteLine("Image does not contain exif information.");
}
else
{
// Write all values to the console
foreach (ExifValue value in profile.Values)
{
Console.WriteLine("{0}({1}): {2}", value.Tag, value.DataType, value.ToString());
string sstr = string.Format("{0}({1}): {2}", value.Tag, value.DataType, value.ToString());
}
//var filePathOutputThubnail = hostingEnv.WebRootPath + $@"\Files\Pictures\Dishes\outputimgThubnail.JPG";
//profile.CreateThumbnail().Write(filePathOutputThubnail);
}
//image.Scale(new Percentage(60));
if (image.Width > 1080)
{
var filePathOutput1080 = hostingEnv.WebRootPath + $@"\Files\Pictures\Dishes\outputimg1080.JPG";
var filePathOutput768 = hostingEnv.WebRootPath + $@"\Files\Pictures\Dishes\outputimg768.JPG";
//image.Scale(768, (image.Height / image.Height) * 768);
//image.Sample(768, (image.Height / image.Height) * 768);
//image.Resize(768, (image.Height / image.Height) * 768);
//image.Scale(1080, (image.Height / image.Height) * 1080);
}
var filePathOutput = hostingEnv.WebRootPath + $@"\Files\Pictures\Dishes\outputimgSample.JPG";
image.Write(filePathOutput);
}
return(View());
}
public IActionResult UploadFilesManagerValidation(Microsoft.AspNetCore.Http.IFormFile file)
{
string fileRoute = "wwwroot/";
var fileMimeType = file.ContentType;
string[] ImageMimeTypes = new string[] { "image/gif", "image/jpeg", "audio/mpeg", "image/png", "image/webp" };
if (!ImageMimeTypes.Contains(fileMimeType.ToString()))
{
return(Json(new Exception("Invalid contentType. It must be Image")));
}
Func <string, string, bool> validationFunction = (filePath, mimeType) => {
long size = new System.IO.FileInfo(filePath).Length;
if (size > 10 * 1024 * 1024)
{
return(false);
}
MagickImageInfo info = new MagickImageInfo(filePath);
if (info.Width != info.Height)
{
return(false);
}
return(true);
};
FroalaEditor.FileOptions options = new FroalaEditor.FileOptions
{
Fieldname = "file",
Validation = new FroalaEditor.FileValidation(validationFunction)
};
try
{
return(Json(FroalaEditor.Image.Upload(HttpContext, fileRoute, options)));
}
catch (Exception e)
{
return(Json(e));
}
}
private bool IsSupportedImage(string path)
{
try {
// I don't know the difference between Jpg and Jpeg.
// A lot of .jpg extention files are recognized as Jpeg.
MagickFormat format = new MagickImageInfo(path).Format;
if (format == MagickFormat.Jpg || format == MagickFormat.Jpeg || format == MagickFormat.Png || format == MagickFormat.Gif || format == MagickFormat.WebP)
{
return(true);
}
else
{
Console.WriteLine(format);
return(false);
}
} catch {
Console.WriteLine(path);
return(false);
}
}
public ActionResult UploadFilesManagerValidation()
{
string fileRoute = "/Public/";
var fileMimeType = System.Web.HttpContext.Current.Request.Files.Get("myImage").ContentType;
string[] ImageMimeTypes = new string[] { "image/gif", "image/jpeg", "audio/mpeg", "image/png", "image/webp" };
if (!ImageMimeTypes.Contains(fileMimeType.ToString()))
{
return(Json(new Exception("Invalid contentType. It must be Image")));
}
Func <string, string, bool> validationFunction = (filePath, mimeType) => {
MagickImageInfo info = new MagickImageInfo(filePath);
if (info.Width != info.Height)
{
return(false);
}
long size = new System.IO.FileInfo(filePath).Length;
if (size > 10 * 1024 * 1024)
{
return(false);
}
return(true);
};
FroalaEditor.FilesManagerOptions options = new FroalaEditor.FilesManagerOptions
{
Fieldname = "myImage",
Validation = new FroalaEditor.FilesManagerValidation(validationFunction)
};
try
{
return(Json(FroalaEditor.FilesManager.Upload(System.Web.HttpContext.Current, fileRoute, options)));
}
catch (Exception e)
{
return(Json(e));
}
}
public ActionResult SaveImage(int albumId)
{
try
{
var files = this.Request.Files;
if (files != null && files.Count > 0)
{
for (var i = 0; i < files.Count; i++)
{
var path = SaveFileToDisk(files[i]);
var name = Path.GetFileNameWithoutExtension(files[i].FileName);
var fileName = Path.GetFileName(path);
var photoThumbnail = ResizeImage(path, 400, 300, PhotoTypeEnum.Thumbnail);
var photoMedium = ResizeImage(path, 800, 1000, PhotoTypeEnum.Medium);
MagickImageInfo info = new MagickImageInfo(path);
var photoOriginal = CreatePhotoVersion(path, PhotoTypeEnum.Original, info.Width, info.Height);
var photoId = SaveFileToDatabase(albumId, name);
SavePhotoVersionToDatabase(photoId, photoThumbnail);
SavePhotoVersionToDatabase(photoId, photoMedium);
SavePhotoVersionToDatabase(photoId, photoOriginal);
}
}
}
catch (Exception ex) { return(Json("Error While Saving. " + ex.Message)); }
return(Index(albumId));
}
public IActionResult UploadImageValidation()
{
Func <string, string, bool> validationFunction = (filePath, mimeType) => {
var info = new MagickImageInfo(filePath);
return(info.Width == info.Height);
};
var options = new FroalaEditor.ImageOptions
{
Fieldname = "myImage",
Validation = new FroalaEditor.ImageValidation(validationFunction)
};
try
{
return(Json(FroalaEditor.Image.Upload(HttpContext, _uploadPath, options)));
}
catch (Exception e)
{
return(Json(e));
}
}
private async Task <Result <ImageDto> > GetRawImageFromMongoDBAsync(string hostName, string id)
{
var mongoDBImageProvider = _serviceProvider.GetService <MongoDBImageProvider>();
var imageResult = await mongoDBImageProvider.GetImageAsync(hostName, id);
if (!imageResult.Success)
{
return(Result.FromError <ImageDto>(imageResult.Message));
}
var imageBytes = imageResult.Data;
var imageInfo = new MagickImageInfo(imageBytes);
var imageDto = new ImageDto {
FileName = id, Imagebytes = imageBytes
};
if (imageInfo.Format == MagickFormat.Gif || imageInfo.Format == MagickFormat.Gif87)
{
imageDto.Mime = "image/gif";
}
else
{
using (var magickImage = new MagickImage(imageBytes))
{
if (magickImage.HasAlpha)
{
imageDto.Mime = "image/png";
}
else
{
imageDto.Mime = "image/jpeg";
}
}
}
return(Result.FromData(imageDto));
}
internal static Size?GetImageSize(string path)
{
var ori = GetOrientationFromExif(path);
try
{
var info = new MagickImageInfo(path);
if (ori == OrientationType.RightTop || ori == OrientationType.LeftBotom)
{
return new Size {
Width = info.Height, Height = info.Width
}
}
;
return(new Size {
Width = info.Width, Height = info.Height
});
}
catch (MagickException)
{
return(null);
}
}
private PhotoVersion ResizeImage(string fileName, int typeWidth, int typeHeight, PhotoTypeEnum type)
{
using (MagickImage image = new MagickImage(fileName)) //Nu stiu exact daca merge asa direct din HttpPostedFileBase
{
MagickImageInfo info = new MagickImageInfo(fileName);
//fit in dimensiunile respective
MagickGeometry size = new MagickGeometry(typeWidth, typeHeight);
if (info.Width > info.Height)
{
//image.Resize(0, typeHeight);
image.Resize(size);
}
else
{
//image.Resize(typeWidth, 0);
image.Resize(size);
}
return(saveImageToDisk(image, type, fileName));
}
}
public void Test_Compress_Quality()
{
FileInfo tempFile = CreateTemporaryFile(Files.ImageMagickJPG);
try
{
JpegOptimizer optimizer = new JpegOptimizer();
optimizer.Compress(tempFile);
IMagickImageInfo info = new MagickImageInfo(tempFile);
Assert.AreEqual(85, info.Quality);
File.Copy(Files.ImageMagickJPG, tempFile.FullName, true);
optimizer.Compress(tempFile, 40);
info = new MagickImageInfo(tempFile);
Assert.AreEqual(40, info.Quality);
}
finally
{
tempFile.Delete();
}
}
public void CopyFiles(bool preview)
{
int counter = 0;
try
{
_filenames.Clear();
OnProgressChange("Copying files");
foreach (FileItem fileItem in Files)
{
OnProgressChange("Copying file " + fileItem.Name);
string source = preview ? fileItem.LargeThumb : fileItem.FileName;
MagickImageInfo info = new MagickImageInfo();
info.Read(source);
string format = info.Format.ToString();
if (format == "Jpeg")
{
string randomFile = Path.Combine(_tempdir, "image_" + counter.ToString("0000") + ".jpg");
AutoExportPluginHelper.ExecuteTransformPlugins(fileItem, PluginSetting.AutoExportPluginConfig, source, randomFile);
_filenames.Add(randomFile);
counter++;
}
if (format == "Tiff")
{
string randomFile = Path.Combine(_tempdir, "image_" + counter.ToString("0000") + ".tif");
using (MagickImage image = new MagickImage(source))
{
image.Format = MagickFormat.Tiff;
image.Write(randomFile);
}
_filenames.Add(randomFile);
counter++;
}
if (format != "Jpeg" && format != "Tiff")
{
OnProgressChange(fileItem.Name + "has invalid format, will not be copied");
}
if (_shouldStop)
{
OnActionDone();
return;
}
}
}
catch (Exception exception)
{
OnProgressChange("Error copy files " + exception.Message);
Log.Error("Error copy files ", exception);
_shouldStop = true;
}
}
private void GetFileItemFormat()
{
foreach (FileItem fileItem in Files)
{
string source = fileItem.FileName;
MagickImageInfo info = new MagickImageInfo();
info.Read(source);
string format = info.Format.ToString();
string format2 = info.CompressionMethod.ToString();
OnProgressChange(fileItem.Name + " format is: " + format + "____" + format2);
}
}
public void Test_Read()
{
MagickImageInfo imageInfo = new MagickImageInfo();
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
imageInfo.Read(new byte[0]);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
imageInfo.Read((byte[])null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
imageInfo.Read((FileInfo)null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
imageInfo.Read((Stream)null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
imageInfo.Read((string)null);
});
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
imageInfo.Read(Files.Missing);
});
imageInfo.Read(File.ReadAllBytes(Files.SnakewarePNG));
using (FileStream fs = File.OpenRead(Files.SnakewarePNG))
{
imageInfo.Read(fs);
}
imageInfo.Read(Files.ImageMagickJPG);
Assert.AreEqual(ColorSpace.sRGB, imageInfo.ColorSpace);
Assert.AreEqual(MagickFormat.Jpeg, imageInfo.Format);
Assert.AreEqual(123, imageInfo.Width);
Assert.AreEqual(118, imageInfo.Height);
Assert.AreEqual(72, imageInfo.ResolutionX);
Assert.AreEqual(72, imageInfo.ResolutionY);
Assert.AreEqual(Resolution.PixelsPerInch, imageInfo.ResolutionUnits);
}
public void CopyFiles(bool preview)
{
int counter = 0;
try
{
_filenames.Clear();
OnProgressChange("Copying files");
WriteLog("Copying files");
WriteShortLog("Copying files");
foreach (FileItem fileItem in Files)
{
string source = preview ? fileItem.LargeThumb : fileItem.FileName;
MagickImageInfo info = new MagickImageInfo();
info.Read(source);
string format = info.Format.ToString();
OnProgressChange(fileItem.Name + " format is: " + format);
WriteLog(fileItem.Name + " format is: " + format);
WriteShortLog(fileItem.Name + " format is: " + format);
if (format == "Jpeg")
{
OnProgressChange("Copying file " + fileItem.Name);
WriteLog("Copying file " + fileItem.Name);
WriteShortLog("Copying file " + fileItem.Name);
string randomFile = Path.Combine(ProjetFolder, "image_" + counter.ToString("0000") + ".jpg");
AutoExportPluginHelper.ExecuteTransformPlugins(fileItem, PluginSetting.AutoExportPluginConfig, source, randomFile);
_filenames.Add(randomFile);
counter++;
}
if (format == "Tiff")
{
OnProgressChange("Converting file " + fileItem.Name);
WriteLog("Converting file " + fileItem.Name);
WriteShortLog("Converting file " + fileItem.Name);
string randomFile = Path.Combine(ProjetFolder, "image_" + counter.ToString("0000") + ".jpg");
try
{
using (MagickImage image = new MagickImage(source))
{
image.Format = MagickFormat.Jpeg;
image.Write(randomFile);
}
_filenames.Add(randomFile);
counter++;
}
catch (Exception exception)
{
Log.Error("Error converting Tiff file", exception);
}
}
if (format == "Nef" || format == "Cr2" || format == "Crw")
{
OnProgressChange("Converting file " + fileItem.Name);
WriteLog("Converting file " + fileItem.Name);
WriteShortLog("Converting file " + fileItem.Name);
string randomFile = Path.Combine(ProjetFolder, "image_" + counter.ToString("0000") + ".jpg");
try
{
string dcraw_exe = Path.Combine(Settings.ApplicationFolder, "dcraw.exe");
if (File.Exists(dcraw_exe))
{
PhotoUtils.RunAndWait(dcraw_exe,
string.Format(" -e -O \"{0}\" \"{1}\"", randomFile, source));
_filenames.Add(randomFile);
counter++;
}
}
catch (Exception exception)
{
Log.Error("Error converting Raw file", exception);
}
}
if (format != "Jpeg" && format != "Tiff" && format != "Nef" && format != "Cr2" && format != "Crw")
{
OnProgressChange(fileItem.Name + " has invalid format, will not be copied");
WriteLog(fileItem.Name + " has invalid format, will not be copied");
WriteShortLog(fileItem.Name + " has invalid format, will not be copied");
}
if (_shouldStop)
{
OnActionDone();
return;
}
}
}
catch (Exception exception)
{
OnProgressChange("Error copy files " + exception.Message);
WriteLog("Error copy files " + exception.Message);
WriteShortLog("Error copy files " + exception.Message);
Log.Error("Error copy files ", exception);
_shouldStop = true;
}
}
/// <summary>
/// アップロードを実行します。
/// </summary>
/// <param name="userId">ユーザーのID</param>
/// <param name="stream">画像データ</param>
/// <param name="length">画像データの長さ</param>
/// <returns></returns>
public async Task<MediaInfo> Execute(String userId, Stream stream, Int64 length)
{
// チェックしますよ
//var result = Validate(userId, stream, length);
//if (result != ValidationResult.Success)
//{
// throw new InvalidOperationException(result.ErrorMessage);
//}
// 読み込みますよ
var data = new Byte[length];
stream.Position = 0; // 一応巻き戻しますよ
stream.Read(data, 0, data.Length);
// 画像の種類をとるよ
var imageInfo = new MagickImageInfo(data);
var contentType = (imageInfo.Format == MagickFormat.Png)
? "image/png"
: (imageInfo.Format == MagickFormat.Jpeg)
? "image/jpeg"
: (imageInfo.Format == MagickFormat.Gif)
? "image/gif"
: null;
var mediaInfo = new MediaInfo() { UserId = userId, ContentType = contentType, MediaId = Guid.NewGuid(), CreatedAt = DateTime.UtcNow };
// 画像アップロードに失敗したときに情報だけは残るように(画像だけ上がってしまうのは絶対に防ぐ)
await _uploadedInfoRepository.Create(mediaInfo);
await _mediaRepository.Create(mediaInfo, data);
return mediaInfo;
}
