private string CreateName(ImageDto image, int number)
{
var collectionItem = _collectionItemRepository.Get(image.CollectionItemId).Format("{code} - {GENUS} {taxon}");
var date = image.DateAdded.ToString("yyyy-mm-dd");
var strNumber = number.ToString().PadLeft(2, '0');
return($"{collectionItem} {date} ({strNumber}).jpg");
}
public ImageDomain(ImageDto dto)
{
Id = dto.Id;
ImageId = dto.ImageId;
Source = dto.Source;
Width = dto.Width;
Height = dto.Height;
}
private void AddImage(ImageDto dto)
{
var imageDomain = new ImageDomain(dto);
Images.Add(imageDomain);
Root.AddIntegratedEvent(ProductEventType.IMAGE_ADDED, dto.Id);
Modify();
}
private ImageDto CreateLinksForImage(ImageDto image)
{
image.Links.Add(new LinkDto(this.urlHelper.Link("GetImage", new { id = image.Id }), "self", "GET"));
image.Links.Add(new LinkDto(this.urlHelper.Link("DeleteImage", new { id = image.Id }), "delete_image", "DELETE"));
image.Links.Add(new LinkDto(this.urlHelper.Link("UpdateImage", new { id = image.Id }), "update_image", "PUT"));
image.Links.Add(new LinkDto(this.urlHelper.Link("UpdateImageExtension", new { id = image.Id }), "update_image_extension", "PUT"));
return(image);
}
public int SaveImage(IFormFile file, ImageDto image)
{
var imageEntity = _mapper.Map <Image>(image);
_unitOfWork.ImageRepository.Add(imageEntity);
return(_unitOfWork.Save());
}
public ActionResult UploadAvatar(ImageDto dto)
{
IAccountRepository repo = new AccountRepository();
dto.ImageId = User.Identity.Name;
repo.UploadImage(dto);
return(RedirectToAction("Manage"));
}
public ImageDto Update(ImageDto image)
{
PostImage postImage = _mapper.Map <PostImage>(image);
_repository.Update(postImage);
_dal.Save();
return(_mapper.Map <ImageDto>(postImage));
}
private OperationResult <ImageDto> CreateImage(ImageDto image)
{
var domain = Mapper.Map <Image>(image);
var result = _repository.Create(domain);
_repository.Save();
return(OperationResult.Success(Mapper.Map <ImageDto>(result)));
}
public async Task <IActionResult> Save(ImageDto imageDto)
{
var imageFolder = _mapper.Map <ImageFolder>(imageDto);
imageFolder.UserId = Guid.Parse("1db506b5-3fa5-451a-9a4b-68edf7b4c2d7");
await _service.AddAsync(imageFolder);
return(NoContent());
}
private static async Task SaveImageToDirectoryAsync(ImageDto image)
{
await using var stream = new MemoryStream(image.ByteImage);
await using var fs = File.Create(image.ImageUri);
await stream.CopyToAsync(fs);
fs.Close();
stream.Close();
}
private OperationResult <ImageDto> UpdateImage(Image domain, ImageDto image)
{
domain = Mapper.Map(image, domain);
var result = _repository.Update(domain);
_repository.Save();
return(OperationResult.Success(Mapper.Map <ImageDto>(result)));
}
public async Task <ImageDto> GetImageAsync(string providerName, string imageId)
{
var key = ImageDto.CalculateCacheKey(providerName, imageId);
return(await ImageCache.GetOrAddAsync(
key,
() => GetImageFromProvidersAsync(providerName, imageId)
));
}
public ImageDto MoveToPersistentLocation(ImageDto dto)
{
return(new ImageDto()
{
Original = MoveToPersistentLocation(dto.Original),
Title = dto.Title
// Cropped = MoveToPersistentLocation(dto.Cropped)
});
}
public List <PostDto> PostDto()
{
var posts = _repository.Include(x => x.Comments, x => x.Images, x => x.Category).ToList();
if (posts.Count() > 0)
{
var postList = new List <PostDto>();
foreach (var post in posts)
{
var images = new List <ImageDto>();
foreach (var image in post.Images)
{
var imageDto = new ImageDto
{
ID = image.ID,
ImageUrl = image.ImageUrl,
Description = image.Description
};
images.Add(imageDto);
}
var comments = new List <CommentDto>();
foreach (var comment in post.Comments)
{
var commentDto = new CommentDto
{
ID = comment.ID,
FullName = comment.FullName,
Email = comment.Email,
CreatedDate = comment.CreatedDate
};
comments.Add(commentDto);
}
var result = new PostDto
{
ID = post.ID,
Title = post.Title,
Description = post.Description,
CategoryName = post.Category.Title,
CreatedDate = post.CreatedDate,
Comments = comments,
Images = images
};
postList.Add(result);
}
return(postList);
}
else
{
return(null);
}
}
private void ImageProcessorOnStreamChanged(object sender, ImageDto image)
{
Width = image.Width;
Height = image.Height;
if (image.ImageData.Length > 0)
{
LiveViewImageStream = image.ImageData;
_cameraStreamSynchronize.Set();
}
}
private static ImageDto CreateImage(string imageName, Guid newGuid)
{
var image = new ImageDto
{
ImageName = imageName,
ImageId = newGuid
};
return(image);
}
public ImageDto Remove(ImageDto postImage)
{
var temp = _repository.Remove(postImage.Id);
_dal.Save();
ImageDto ImageDto = _mapper.Map <ImageDto>(temp);
return(ImageDto);
}
public int addImage(ImageDto dto)
{
Image im = new Image();
im.HouseId = dto.HouseId;
im.source = dto.source;
_unitOfWork.ImageRepository.Add(im);
_unitOfWork.SaveChanges();
return(im.Id);
}
public async Task SetProfileImageAsync(int userId, ImageDto imageDto)
{
var user = await _userManager.FindByIdAsync(userId.ToString());
var image = _mapper.Map <ImageEntity>(imageDto);
user.ProfileImage = image;
await _userManager.UpdateAsync(user);
}
public ImageDto Create(ImageDto image)
{
PostImage postImage = _mapper.Map <PostImage>(image);
PostImage createdPostImage = _repository.Create(postImage);
_dal.Save();
ImageDto imageDto = _mapper.Map <ImageDto>(createdPostImage);
return(imageDto);
}
//TODO:Get null checkers for all fields
private static void UpdateMovedImageFields(ImageDto image, string stayedUri)
{
image.ImagePath = image.ImagePath.Replace(ImageDirectory.Temp.ToString(),
ImageDirectory.Uploads.ToString());
image.ImageDirectory = ImageDirectory.Uploads;
image.ImageUri = stayedUri;
image.ImageUrl =
image.ImageUrl.Replace(ImageDirectory.Temp.ToString(),
ImageDirectory.Uploads.ToString());
}
public async Task <int> CreateImage(ImageDto imageDto)
{
//Map to the Data Entity object
var recDb = Mapper.Map <Image>(imageDto);
//Insert into Message table
await _db.InsertAsync(recDb);
return(recDb.Id);
}
public IActionResult AddImage(ImageDto imageDto)
{
if (!ModelState.IsValid)
{
TempData["Error"] = "Uygun format bulunamadı.";
return(RedirectToAction("AddImage"));
}
ImageService.Instance.AddImage(imageDto, UserToken.UserTokenDto.Id);
return(RedirectToAction("Index"));
}
public static Image ToEntity(this ImageDto dto)
{
return(new Image
{
Id = dto.Id,
Name = dto.Name,
Url = dto.Url,
IsPrimary = dto.IsPrimary,
ProductId = dto.ProductId
});
}
public async void CreateImage()
{
var image = new ImageDto()
{
Url = "http://news.com",
Tags = "MotivationalDelete"
};
var result = await _service.CreateImage(image);
Assert.NotEqual(0, result);
}
public ImageDto CreateTempFiles(ImageDto dto)
{
var name = GetFileName();
return(new ImageDto()
{
Original = CreateTempFile(dto.Original, name),
Title = dto.Title
// Cropped = CreateTempFile(dto.Cropped, name, "_cropped")
});
}
public async Task <ImageDto> MoveFromTempToPostsAsync(ImageDto image)
{
var response =
await _httpClient.PostAsJsonAsync($"api/imagesaver/move", image);
var resultString = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <ImageDto>(resultString);
return(result);
}
/// <summary>
/// Mongo'da resim ve content alanını günceller
/// </summary>
/// <param name="imageDto"></param>
/// <returns></returns>
private bool EditImageMongo(ImageDto imageDto)
{
using (MongoRepository <ImageMongoModel> mongoRepository = new MongoRepository <ImageMongoModel>())
{
var image = mongoRepository.GetAll(x => x.DatabaseName.Equals("ImageApp") && x.TableName.Equals("Images") && x.ParentId == imageDto.Id).FirstOrDefault();
image.LargeImage = imageDto.LargeImage;
image.SmallImage = imageDto.SmallImage;
image.Content = imageDto.Content;
return(mongoRepository.Update(x => x.DatabaseName.Equals("ImageApp") && x.TableName.Equals("Images") && x.ParentId == imageDto.Id, image));
}
}
public async Task <CharacterDto> UpdateImageAsync(int characterId, ImageDto imageDto)
{
var imageTask = _imageService.UploadImageAsync(imageDto);
CharacterModel characterModel = await _unitOfWork.CharactersRepository.GetAsync(characterId);
characterModel.ImageUploadDate = DateTime.Now;
characterModel.ImageUrl = await imageTask;
await _unitOfWork.SaveAsync();
return(_mapper.Map <CharacterModel, CharacterDto>(characterModel));
}
public bool DeleteImage(ImageDto image)
{
var path = image.ImageUri;
if (File.Exists(path))
{
File.Delete(path);
}
return(!File.Exists(path));
}
