private async Task UploadImagesWithDifferentSizesAsync(Remark remark, RemarkUser user, File originalPhoto, string metadata = null)
{
var extension = originalPhoto.Name.Split('.').Last();
var uniqueNumber = _uniqueNumberGenerator.Generate();
var groupId = Guid.NewGuid();
var size = "big";
var fileName = metadata == null
? $"remark_{remark.Id:N}_{uniqueNumber}.{extension}"
: $"remark_{remark.Id:N}_{metadata}_{uniqueNumber}.{extension}";
var baseImageUrl = "";
await _fileHandler.UploadAsync(originalPhoto, fileName, (baseUrl, fullUrl) =>
{
baseImageUrl = baseUrl;
remark.AddPhoto(RemarkPhoto.Create(groupId, fileName, size, fullUrl, user, metadata));
});
var smallImageFileName = $"200x200/{fileName}";
var mediumImageFileName = $"600x600/{fileName}";
var smallImageUrl = $"{baseImageUrl}/{smallImageFileName}";
var mediumImageUrl = $"{baseImageUrl}/{mediumImageFileName}";
remark.AddPhoto(RemarkPhoto.Create(groupId, smallImageFileName, "small", smallImageUrl, user, metadata));
remark.AddPhoto(RemarkPhoto.Create(groupId, mediumImageFileName, "medium", mediumImageUrl, user, metadata));
//Trigger resizing images using AWS Lambda, so they shall be accessible with https.
await Task.WhenAll(new List <Task>
{
TriggerImageResizeAsync(smallImageUrl),
TriggerImageResizeAsync(mediumImageUrl)
});
}
public async Task AddPhotosAsync(Guid remarkId, string userId, params File[] photos)
{
if (photos == null || !photos.Any())
{
throw new ServiceException(OperationCodes.NoFiles,
$"There are no photos to be added to the remark with id: '{remarkId}'.");
}
var user = await _userRepository.GetOrFailAsync(userId);
Logger.Debug($"Adding {photos.Count()} photos to remark with id: '{remarkId}'.");
var remark = await _remarkRepository.GetOrFailAsync(remarkId);
if (remark.Photos.GroupBy(x => x.Size).Count() + photos.Count() > _settings.PhotosLimit)
{
throw new ServiceException(OperationCodes.TooManyFiles,
$"There are too many photos ({photos.Count()}) to be added to the remark with id: '{remarkId}'.");
}
var tasks = new List <Task>();
foreach (var photo in photos)
{
var task = UploadImagesWithDifferentSizesAsync(remark, RemarkUser.Create(user), photo);
tasks.Add(task);
}
await Task.WhenAll(tasks);
await _remarkRepository.UpdateAsync(remark);
Logger.Debug($"Added {photos.Count()} photos to remark with id: '{remarkId}'.");
}
protected static void Initialize()
{
RemarkRepositoryMock = new Mock <IRemarkRepository>();
UserRepositoryMock = new Mock <IUserRepository>();
RemarkPhotoServiceMock = new Mock <IRemarkPhotoService>();
GeneralSettings = new GeneralSettings
{
AllowedDistance = 15.0
};
RemarkStateService = new RemarkStateService(RemarkRepositoryMock.Object,
UserRepositoryMock.Object,
RemarkPhotoServiceMock.Object,
GeneralSettings);
var user = new User(UserId, "name", "user");
var category = new Category("category");
Description = "test";
Remark = new Remark(RemarkId, user, category, Location);
Remark.AddPhoto(RemarkPhoto.Small(Guid.NewGuid(), "test.jpg", "http://my-test-image.com", RemarkUser.Create(user)));
RemarkRepositoryMock.Setup(x => x.GetByIdAsync(Moq.It.IsAny <Guid>()))
.ReturnsAsync(Remark);
UserRepositoryMock.Setup(x => x.GetByUserIdAsync(Moq.It.IsAny <string>()))
.ReturnsAsync(User);
}
protected static void Initialize()
{
ExceptionHandlerMock = new Mock <IExceptionHandler>();
Handler = new Handler(ExceptionHandlerMock.Object);
RemarkRepositoryMock = new Mock <IRemarkRepository>();
RemarkRepositoryMock = new Mock <IRemarkRepository>();
GroupRemarkRepositoryMock = new Mock <IGroupRemarkRepository>();
RemarkServiceClientMock = new Mock <IRemarkServiceClient>();
RemarkCacheMock = new Mock <IRemarkCache>();
RemarkResolvedHandler = new RemarkResolvedHandler(Handler,
RemarkRepositoryMock.Object,
GroupRemarkRepositoryMock.Object,
RemarkServiceClientMock.Object,
RemarkCacheMock.Object);
User = new User
{
UserId = UserId,
Name = "TestUser"
};
Event = new RemarkResolved(Guid.NewGuid(), Resource.Create("test", "test"), UserId, RemarkId);
Author = new RemarkUser
{
UserId = UserId,
Name = "TestUser"
};
Category = new RemarkCategory
{
Id = Guid.NewGuid(),
Name = "Test"
};
Location = new Location
{
Address = "address",
Coordinates = new[] { 1.0, 1.0 },
Type = "point"
};
Remark = new Remark
{
Id = RemarkId,
Author = Author,
Category = Category,
CreatedAt = CreatedAt,
Description = "test",
Location = Location,
Photos = new List <File>()
};
var resolvedRemark = new Remark
{
Id = RemarkId,
Author = Author,
Category = Category,
CreatedAt = CreatedAt,
Description = "test",
Location = Location,
State = new RemarkState
{
State = "resolved",
User = new RemarkUser
{
UserId = UserId,
}
},
Photos = new List <File>()
};
RemarkServiceClientMock
.Setup(x => x.GetAsync <Remark>(RemarkId))
.ReturnsAsync(resolvedRemark);
RemarkRepositoryMock.Setup(x => x.GetByIdAsync(Moq.It.IsAny <Guid>()))
.ReturnsAsync(Remark);
}
protected static void Initialize()
{
FileHandlerMock = new Mock <IFileHandler>();
RemarkRepositoryMock = new Mock <IRemarkRepository>();
RemarkCategoryRepositoryMock = new Mock <ICategoryRepository>();
TagRepositoryMock = new Mock <ITagRepository>();
UserRepositoryMock = new Mock <IUserRepository>();
CategoryRepositoryMock = new Mock <ICategoryRepository>();
GroupRepositoryMock = new Mock <IGroupRepository>();
ImageServiceMock = new Mock <IImageService>();
RemarkPhotoServiceMock = new Mock <IRemarkPhotoService>();
UniqueNumberGeneratorMock = new Mock <IUniqueNumberGenerator>();
GeneralSettings = new GeneralSettings
{
AllowedDistance = 15.0
};
RemarkService = new RemarkService(RemarkRepositoryMock.Object,
UserRepositoryMock.Object,
CategoryRepositoryMock.Object,
TagRepositoryMock.Object,
GroupRepositoryMock.Object,
RemarkPhotoServiceMock.Object,
GeneralSettings);
var user = new User(UserId, "name", "user");
var category = new Category("category");
Remark = new Remark(RemarkId, user, category, Location);
Remark.AddPhoto(RemarkPhoto.Small(Guid.NewGuid(), "test.jpg", "http://my-test-image.com", RemarkUser.Create(user)));
RemarkRepositoryMock.Setup(x => x.GetByIdAsync(Moq.It.IsAny <Guid>()))
.ReturnsAsync(Remark);
UserRepositoryMock.Setup(x => x.GetByUserIdAsync(Moq.It.IsAny <string>()))
.ReturnsAsync(User);
ImageServiceMock.Setup(x => x.ProcessImage(Moq.It.IsAny <File>()))
.Returns(new Dictionary <string, File>
{
{ "small", File },
{ "medium", File },
{ "big", File }
});
}
public async Task UploadImagesWithDifferentSizesAsync(Remark remark, string userId, File originalPhoto, string metadata = null)
{
var user = await _userRepository.GetOrFailAsync(userId);
await UploadImagesWithDifferentSizesAsync(remark, RemarkUser.Create(user), originalPhoto, metadata);
}
