public Image CreateImageWithNativeAPI(CreateImageDto createImageDto)
{
//The album post is created as master. The masterImageId is assigned to the master version.
LibrariesManager librariesManager = LibrariesManager.GetManager();
Guid imageId = Guid.NewGuid();
Image image = librariesManager.CreateImage(imageId);
//Set the parent album.
Album album = librariesManager.GetAlbums().SingleOrDefault();
image.Parent = album;
//Set the properties of the album post.
image.Title = createImageDto.Title;
image.DateCreated = DateTime.Now;
image.PublicationDate = DateTime.Now;
image.LastModified = DateTime.Now;
image.UrlName = Regex.Replace($"{createImageDto.Title}-{imageId}".ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
image.MediaFileUrlName = Regex.Replace(createImageDto.FileName.ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
//Upload the image file.
// The imageExtension parameter must contain '.', for example '.jpeg'
librariesManager.Upload(image, createImageDto.Stream, createImageDto.FileExtension);
//Save the changes.
librariesManager.SaveChanges();
//Publish the Albums item. The live version acquires new ID.
var bag = new Dictionary <string, string>();
bag.Add("ContentType", typeof(Image).FullName);
WorkflowManager.MessageWorkflow(imageId, typeof(Image), null, "Publish", false, bag);
return(image);
}
public async Task <int> CreateImageAsync(CreateImageDto createImageDto)
{
if (!createImageDto.MimeType.Contains("image"))
{
throw new ArgumentException("File type should be image");
}
using (var transaction = _photoSNDbContext.Database.BeginTransaction())
{
try
{
var newImage = _mapper.Map <Image>(createImageDto);
newImage.User = await _photoSNDbContext.Users.FindAsync(createImageDto.UserId);
newImage.Created = DateTime.Now;
await _photoSNDbContext.Images.AddAsync(newImage);
await _photoSNDbContext.SaveChangesAsync();
await transaction.CommitAsync();
return(newImage.ImageId);
}
catch (Exception e)
{
transaction.Rollback();
throw e;
}
}
}
public async Task <IActionResult> Create([FromBody] CreateImageDto image, [FromHeader] string username = null, [FromHeader] string password = null)
{
var request = new CreateImageRequest(username, password, image);
var response = await _mediator.Send(request);
var envelope = new Envelope <string>(response);
return(CreatedAtAction(nameof(Retrieve), new { id = envelope.Data }, envelope));
}
public static CreateTorrentDto CreateTorrent(CreateTorrentWidgetModel model)
{
CreateImageDto image = CreateImage(model);
CreateDocumentDto document = CreateDocument(model);
return(new CreateTorrentDto
{
Title = model.Title,
Description = model.Description,
AdditionalInfo = model.AdditionalInfo,
Genres = model.Genres,
ImageDto = image,
DocumentDto = document
});
}
public async Task <ActionResult <ImageDto> > CreateImage(int userId, CreateImageDto createImageDto)
{
var image = new Image
{
Comment = createImageDto.Comment,
Uri = createImageDto.Uri,
User = await _unitOfWork.UserRepository.GetUserByIdAsync(userId)
};
_unitOfWork.ImageRepository.AddItem(image);
if (await _unitOfWork.Complete())
{
return(Ok(_mapper.Map <ImageDto>(image)));
}
return(BadRequest("Unable to create Image"));
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ManageAvatarViewModel.AvatarImage.ContentType.Contains("image"))
{
ModelState.AddModelError("FileType", "File type should be image.");
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var guid = Guid.NewGuid();
await _imageHelper.SaveAvatarAsync(ManageAvatarViewModel.AvatarImage, guid);
var createImageDto = new CreateImageDto
{
Guid = guid,
UserId = user.Id,
MimeType = ManageAvatarViewModel.AvatarImage.ContentType
};
var newImageId = await _photoSNRepository.CreateImageAsync(createImageDto);
var createAvatarDto = new AvatarDto
{
UserId = user.Id,
ImageId = newImageId
};
await _photoSNRepository.CreateAvatarAsync(createAvatarDto);
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile picture has been updated";
return(RedirectToPage());
}
public async Task <ImageDto> CreateAsync(CreateImageDto dto)
{
await _validator.ValidateAsync <UpsertImageDto>(dto);
var imageEntity = _mapper.Map <ImageEntity>(dto);
imageEntity.ImageCategories = dto.CategoryIds
.Select(n => new ImageCategoryEntity
{
CategoryId = n,
Image = imageEntity
}).ToList();
await _context.Images.AddAsync(imageEntity);
await _context.SaveChangesAsync();
return(_mapper.Map <ImageDto>(imageEntity));
}
public async Task <IActionResult> CreateImages(IFormFileCollection imageFiles)
{
try
{
if (!imageFiles.Any())
{
throw new ArgumentOutOfRangeException("Upload at least 1 image.");
}
foreach (var imageFile in imageFiles)
{
if (!imageFile.ContentType.Contains("image"))
{
throw new ArgumentException("File type should be image");
}
}
var imageIds = new List <int>();
var userId = (await _userManager.GetUserAsync(User)).Id;
foreach (var imageFile in imageFiles)
{
var newGuid = Guid.NewGuid();
var createImageDto = new CreateImageDto
{
UserId = userId,
MimeType = imageFile.ContentType,
Guid = newGuid
};
imageIds.Add(await _photoSNRepository.CreateImageAsync(createImageDto));
await _imageHelper.SaveImageAsync(imageFile, newGuid);
}
return(StatusCode(StatusCodes.Status201Created, imageIds));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Create([FromForm] CreateImageDto dto)
=> await GetResponse(async() =>
new ApiResponseViewModel(true, "Create Image Successfully",
await _imageService.Create(dto, UserId)));
public CreateImageRequest(string username, string password, CreateImageDto image)
{
Username = username;
Password = password;
Image = image;
}
