public async Task <bool> AddImageAsync(string publicKey, string url, string realEstateId, int sequence)
{
List <Domain.Image> images = new List <Domain.Image>();
if (string.IsNullOrEmpty(url) || string.IsNullOrEmpty(realEstateId) || string.IsNullOrEmpty(publicKey))
{
throw new ArgumentNullException(InvalidImageParamsMessage);
}
var image = new Domain.Image
{
Url = url,
RealEstateId = realEstateId,
Id = publicKey,
Sequence = sequence,
};
images.Add(image);
await this.context.Images.AddRangeAsync(images);
await this.context.SaveChangesAsync();
return(true);
}
public void Resize(Domain.Image image, IEnumerable <ImageSizeSpecification> sizeSpecs, Furniture furniture)
{
foreach (var sizeSpec in sizeSpecs)
{
ResizeAndSave(image, furniture, sizeSpec.Width, sizeSpec.Height);
}
}
private void ResizeAndSave(Domain.Image image, Furniture furniture, int width, int height)
{
using (System.Drawing.Image img = System.Drawing.Image.FromFile(GetVirtualPath(image.VirtualPath)))
{
using (Bitmap bitmap = new Bitmap(width, height))
{
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
graphics.DrawImage(img, new Rectangle(0, 0, width, height));
}
string resizedPath = furniture.PartNumber + "/" + width + "x" + height;
CreateDirectory(GetVirtualPath(resizedPath));
bitmap.Save(GetVirtualPath(resizedPath) + "/" + image.FileName);
Dependencies.ImageSizeRepository.Add(new ImageSize
{
FileName = image.FileName,
Path = UploadPath + resizedPath,
Height = height,
Width = width,
ImageId = image.ImageId
});
}
}
}
public void Execute(PostDto request)
{
if (Context.Posts.Any(p => p.Title == request.Title))
{
throw new EntityAlreadyExistsException();
}
if (request.Title == null)
{
throw new Exception();
}
var ext = Path.GetExtension(request.Image.FileName);
if (!FileUpload.AllowedExtensions.Contains(ext))
{
throw new Exception("File extension is not ok");
}
var newFileName = Guid.NewGuid().ToString() + "_" + request.Image.FileName;
var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "uploads", newFileName);
request.Image.CopyTo(new FileStream(filePath, FileMode.Create));
var image = new Domain.Image
{
Alt = request.Title,
Path = newFileName
};
Context.Images.Add(image);
var post = new Domain.Post
{
Title = request.Title,
Summary = request.Summary,
Text = request.Text,
CategoryId = request.CategoryId,
UserId = request.UserId,
Image = image
};
Context.Posts.Add(post);
if (request.AddTagsInPost != null)
{
foreach (var tag in request.AddTagsInPost)
{
Context.PostTags.Add(new Domain.PostTag
{
Post = post,
TagId = tag
});
}
}
Context.SaveChanges();
}
private static ImagePreviousVersionType ImagePreviousVersionTypeFromImage(Domain.Image i)
{
return(i.VersionType switch
{
ImageVersionType.Creation => ImagePreviousVersionType.Creation,
ImageVersionType.Changes => ImagePreviousVersionType.Changes,
_ => throw new NotImplementedException(),
});
private async Task <Domain.Image> BuildImageAsync(Guid originalFileId, Guid previewFileId)
{
var image = new Domain.Image();
image.Id = Guid.NewGuid();
image.OriginalFileId = originalFileId;
image.PreviewFileId = previewFileId;
await this.imagesRepository.AddAsync(image);
return(image);
}
public void Delete(Domain.Image image)
{
List <ImageSize> imageSizez = image.ImageSizes.ToList();
foreach (var imageSize in imageSizez)
{
File.Delete(GetVirtualPath(imageSize.VirtualPath));
Dependencies.ImageSizeRepository.Delete(imageSize);
}
File.Delete(GetVirtualPath(image.VirtualPath));
Dependencies.ImageRepository.Delete(image);
}
public static Windows.UI.Xaml.Controls.Image Control(this Domain.Image item)
{
var control = new Windows.UI.Xaml.Controls.Image
{
Width = item.Width,
Height = item.Height
};
if (!string.IsNullOrEmpty(item.Stretch))
{
control.Stretch = Helpers.ParseEnum <Stretch>(item.Stretch);
}
return(control);
}
public void SaveImage_ByPixels_ReturnsName()
{
var image = new Domain.Image
{
Pixels = new Color[, ]
{
{ Color.FromArgb(64, 64, 255), Color.FromArgb(64, 65, 255), Color.FromArgb(64, 64, 251) },
{ Color.FromArgb(63, 64, 255), Color.FromArgb(62, 63, 255), Color.FromArgb(64, 64, 240) },
{ Color.FromArgb(60, 64, 255), Color.FromArgb(11, 64, 255), Color.FromArgb(64, 64, 232) },
}
};
var actual = _service.SaveImage(image);
Assert.NotEmpty(actual);
}
public async Task <UploadImage.Response> Upload(UploadImage.Request request, CancellationToken cancellationToken)
{
if (request.Image.Length <= 0)
{
throw new ImageInvalidException("Изображение повреждено загрузка невозможна");
}
var imageType = request.Image.ContentType;
if (imageType != "image/jpg" &&
imageType != "image/jpeg" &&
imageType != "image/pjpeg" &&
imageType != "image/gif" &&
imageType != "image/x-png" &&
imageType != "image/png")
{
throw new ImageInvalidException("Недопустимый формат изображения");
}
var imageName = Guid.NewGuid() + request.Image.FileName;
await using var memoryStream = new MemoryStream();
await request.Image.CopyToAsync(memoryStream, cancellationToken);
var response = await _s3Service.UploadFile(memoryStream, imageName, cancellationToken);
if (!response)
{
throw new ImageInvalidException("При загрузке произошла ошибка!");
}
var image = new Domain.Image
{
Id = Guid.NewGuid().ToString(),
Name = imageName,
ImageBlob = memoryStream.ToArray(),
CreatedDate = DateTime.UtcNow
};
await _repository.Save(image, cancellationToken);
return(new UploadImage.Response
{
Id = image.Id
});
}
public async Task <Guid> RunAsync(Request request)
{
request.CheckValidity(localizer);
if (dbContext.Images.Where(image => EF.Functions.Like(image.Name, request.Name)).Any())
{
throw new RequestInputException(localizer["ImageAlreadyExists"] + $" '{request.Name}'");
}
var image = new Domain.Image();
image.Name = request.Name;
image.Description = request.Description;
image.Source = request.Source;
image.Owner = request.Owner;
image.VersionDescription = localizer["InitialImageVersionCreation"].Value;
image.VersionType = ImageVersionType.Creation;
image.InitialUploadUtcDate = DateTime.UtcNow;
image.LastChangeUtcDate = image.InitialUploadUtcDate;
image.OriginalContentType = request.ContentType;
image.OriginalSize = request.Blob.Length;
image.OriginalBlob = request.Blob;
using (var sourceStream = new MemoryStream(request.Blob))
{
using (var originalImage = GetBitmap(sourceStream, request.ContentType))
{
image.SmallBlob = ResizeImage(originalImage, 100);
image.SmallBlobSize = image.SmallBlob.Length;
image.MediumBlob = ResizeImage(originalImage, 600);
image.MediumBlobSize = image.MediumBlob.Length;
image.BigBlob = ResizeImage(originalImage, bigImageWidth);
image.BigBlobSize = image.BigBlob.Length;
dbContext.Images.Add(image);
await dbContext.SaveChangesAsync();
return(image.Id);
}
}
}
protected override async Task <ResultWithMetrologyProperties <Result> > DoRunAsync(Request request)
{
var owner = await DbContext.Users.SingleAsync(u => u.Id == request.Owner);
var image = new Domain.Image
{
Name = request.Name,
Description = request.Description,
Source = request.Source,
Owner = owner,
VersionDescription = Localized.Get("InitialImageVersionCreation"),
VersionType = ImageVersionType.Creation,
InitialUploadUtcDate = runDate ?? DateTime.UtcNow
};
image.LastChangeUtcDate = image.InitialUploadUtcDate;
image.OriginalContentType = request.ContentType;
image.OriginalSize = request.Blob.Length;
image.OriginalBlob = request.Blob;
using var sourceStream = new MemoryStream(request.Blob);
using var originalImage = GetBitmap(sourceStream, request.ContentType);
image.SmallBlob = ResizeImage(originalImage, 100);
image.SmallBlobSize = image.SmallBlob.Length;
image.MediumBlob = ResizeImage(originalImage, 600);
image.MediumBlobSize = image.MediumBlob.Length;
image.BigBlob = ResizeImage(originalImage, bigImageWidth);
image.BigBlobSize = image.BigBlob.Length;
DbContext.Images.Add(image);
await DbContext.SaveChangesAsync();
return(new ResultWithMetrologyProperties <Result>(new Result(),
("ImageName", request.Name.ToString()),
("DescriptionLength", request.Description.Length.ToString()),
("SourceFieldLength", request.Source.Length.ToString()),
("ContentType", request.ContentType),
("ImageSize", image.OriginalSize.ToString())
));
}
public byte[] Adapt()
{
var image = new Image <Rgba32>(_image.Width, _image.Height);
for (var y = 0; y < _image.Height; y++)
{
for (var x = 0; x < _image.Width; x++)
{
image[x, y] = new Rgba32((byte)_image[x, y].R,
(byte)_image[x, y].G,
(byte)_image[x, y].B);
}
}
using var memoryStream = new MemoryStream();
var imageEncoder = image.GetConfiguration()
.ImageFormatsManager
.FindEncoder(PngFormat.Instance);
image.Save(memoryStream, imageEncoder);
return(memoryStream.ToArray());
}
public Domain.Image Upload(HttpPostedFileBase file, Furniture furniture)
{
Condition.Requires(file).IsNotNull();
Condition.Requires(file.ContentLength).IsGreaterThan(0);
Condition.Requires(file.FileName).IsNotNullOrWhiteSpace();
Condition.Requires(furniture).IsNotNull();
Condition.Requires(furniture.PartNumber).IsNotNullOrWhiteSpace();
string path, fileName;
UploadImage(file, furniture, out path, out fileName);
Domain.Image image = Dependencies.ImageRepository.Add(
new Domain.Image()
{
Path = UploadPath + path,
FileName = fileName
}, furniture);
return(image);
}
public IActionResult UploadFile(IFormFile file)
{
if (file != null || file.Length != 0)
{
var number = Convert.ToInt32(HttpContext.Request.Form["realedit"]);
NewImageFolder(number);
var path = Path.Combine(
Directory.GetCurrentDirectory(), "wwwroot\\Images" + "\\" + number,
file.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
file.CopyTo(stream);
}
Domain.Image img = new Domain.Image();
img.RealEstateId = number;
img.Nazwapliku = file.FileName;
ImagesContext.AddToDatabase(img);
}
return(RedirectToAction("Index", "Home"));
}
public void Execute(GetPostDto request)
{
var post = Context.Posts.Find(request.Id);
if (post == null)
{
throw new NotFoundException();
}
if (request.Title != post.Title && Context.Posts.Any(p => p.Title == request.Title))
{
throw new EntityAlreadyExistsException();
}
post.Title = request.Title;
post.Summary = request.Summary;
post.Text = request.Text;
post.UserId = request.UserId;
post.CategoryId = request.CategoryId;
foreach (var p in Context.PostTags.Where(p => p.PostId == request.Id))
{
Context.PostTags.Remove(p);
}
foreach (var tag in request.TagsInPost)
{
Context.PostTags.Add(new Domain.PostTag
{
PostId = post.Id,
TagId = tag
});
}
if (request.ImageFile != null)
{
var ext = Path.GetExtension(request.ImageFile.FileName);
if (!FileUpload.AllowedExtensions.Contains(ext))
{
throw new Exception("File extension is not ok");
}
var newFileName = Guid.NewGuid().ToString() + "_" + request.ImageFile.FileName;
var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "uploads", newFileName);
request.ImageFile.CopyTo(new FileStream(filePath, FileMode.Create));
var image = new Domain.Image
{
Alt = request.Title,
Path = newFileName
};
Context.Images.Add(image);
post.Image = image;
Context.SaveChanges();
}
else
{
Context.SaveChanges();
}
}
public void Resize(Domain.Image image, ImageSizeSpecification sizeSpec, Furniture furniture)
{
ResizeAndSave(image, furniture, sizeSpec.Width, sizeSpec.Height);
}
private async Task <List <FileDto> > Store(params StoreFileDto[] inputs)
{
var filesDto = new List <FileDto>();
foreach (var input in inputs)
{
var physicalFile = await input.CreatePhysicalFile();
if (typeProvider.IsValidImageFile(input.File, physicalFile.Extension))
{
var img = SixLabors.ImageSharp.Image.Load(input.File);
var image = new Domain.Image
{
Date = DateTime.Now,
Path = physicalFile.Path,
UID = physicalFile.UID,
UserId = user.Id,
Description = input.Description,
IsPublic = input.IsPublic,
Filename = input.Filename,
Extension = physicalFile.Extension,
Size = input.File.Length,
MimeType = MimeTypeMap.GetMimeType(physicalFile.Extension),
Width = img.Width,
Height = img.Height
};
filesDto.Add(new FileDto
{
Filename = image.Filename,
UID = image.UID,
IsPublic = image.IsPublic,
IsImage = true
});
context.Add(image);
}
else
{
var file = new File()
{
Date = DateTime.Now,
Path = physicalFile.Path,
UID = physicalFile.UID,
UserId = user.Id,
Description = input.Description,
IsPublic = input.IsPublic,
Filename = input.Filename,
Extension = physicalFile.Extension,
Size = input.File.Length,
MimeType = MimeTypeMap.GetMimeType(physicalFile.Extension),
};
filesDto.Add(new FileDto
{
Filename = file.Filename,
UID = file.UID,
IsPublic = file.IsPublic,
IsImage = false
});
context.Add(file);
}
}
await context.SaveChangesAsync();
return(filesDto);
}
public ImageAdapter(Image image)
{
_image = image;
}
