public async Task <IActionResult> UploadImages([FromForm] UploadImageDto imageDto)
{
if (imageDto.Image == null)
{
return(BadRequest("Image file should be selected"));
}
if (imageDto.NewBiggestDimension < 100 || imageDto.NewBiggestDimension > 10000)
{
return(BadRequest("Dimension size should be between 100 and 10 000"));
}
try
{
var newImageId = await _imagesService.AddImage(imageDto.Image, imageDto.ImageName, imageDto.NewBiggestDimension);
if (imageDto.TargetRecordId != null && imageDto.TargetRecordId != Guid.Empty)
{
await _recordsImagesService.AddRecordImage(imageDto.TargetRecordId.Value, newImageId);
}
var newImageUri = $@"{await _appSettingsService.GetHostAndPort()}/api/v1.0/images/{newImageId}";
return(Created(newImageUri, newImageId));
}
catch (ArgumentException exc)
{
return(BadRequest(exc.Message));
}
}
public IActionResult Post(
[FromForm] UploadImageDto dto,
[FromServices] IUploadImageCommand command)
{
_executor.ExecuteCommand(command, dto);
return(StatusCode(StatusCodes.Status201Created));
}
public async Task <ApiResult> UploadByBase64(UploadImageDto input)
{
if (!string.IsNullOrEmpty(input.Base64Body))
{
try
{
var dir = $"{DateTime.Now:yyyyMM}";
var imageurl = $"{dir}/{Guid.NewGuid()}.jpg";
byte[] imageBytes = Convert.FromBase64String(input.Base64Body.Replace("data:image/jpeg;base64,", ""));
Directory.CreateDirectory($"wwwroot/{dir}");
using var ms = new FileStream($"wwwroot/{imageurl}", FileMode.Create);
await ms.WriteAsync(imageBytes, 0, imageBytes.Length);
return(ApiResult.Ok(imageurl, ""));
}
catch (Exception)
{
return(ApiResult.Err());
}
}
else
{
throw new ApplicationServiceException("无法识别的图片");
}
}
/// <summary>
/// Kép feltöltése az aktuális felhasználóhoz tartozó étteremhez.
/// </summary>
/// <param name="uploadedImage">A feltöltendő kép.</param>
/// <returns>A kép relatív elérési útvonala.</returns>
public async Task <string> UploadMyRestaurantImage(UploadImageDto uploadedImage)
{
string userId = httpContext.GetCurrentUserId();
int ownerRestaurantId = await userRepository.GetMyRestaurantId(userId);
return(await restaurantRepository.UploadRestaurantImage(ownerRestaurantId, uploadedImage));
}
public IActionResult Upload([FromForm] UploadImageDto uploadImageDto)
{
if (!ModelState.IsValid)
return View(uploadImageDto);
var imageDataEntity = Mapper.Map<ImageData>(uploadImageDto);
_dbContext.Images.Add(imageDataEntity);
if (_dbContext.SaveChanges() > 0)
throw new Exception("Failed to save image.");
return RedirectToAction(nameof(Upload));
}
/// <summary>
/// Kép feltöltése a megadott azonosítóval rendelkező ételhez, ha az étel ugyanahhoz
/// az étteremhez tartozik, mint amit az aktuális felhasználó birtokol.
/// </summary>
/// <param name="foodId">Az étel azonosítója.</param>
/// <param name="uploadedImage">A képet tartalmazó osztály.</param>
/// <returns>A kép relatív elérési útja.</returns>
public async Task <string> UploadFoodImage(int foodId, UploadImageDto uploadedImage)
{
string userId = httpContext.GetCurrentUserId();
int ownerRestaurantId = await userRepository.GetMyRestaurantId(userId);
int foodRestaurantId = await foodRepository.GetFoodRestaurantId(foodId);
if (ownerRestaurantId == foodRestaurantId)
{
return(await foodRepository.UploadFoodImage(foodId, uploadedImage));
}
throw new ProblemDetailsException(StatusCodes.Status400BadRequest,
"A megadott azonosítóval rendelkező étel képének megváltoztatásához nincs jogosultságod.");
}
/// <summary>
/// Kép hozzáadása a megadott azonosítójú ételhez.
/// Ha a megadott azonosítóval étel nem található, akkor kivételt dobunk,
/// egyébként feltöltjük a képet és beállítjuk rá az étel relatív elérési útját.
/// </summary>
/// <param name="foodId">Az étel azonosítója.</param>
/// <param name="uploadedImage">A feltöltendő kép.</param>
/// <returns>A kép relatív elérési útja.</returns>
public async Task <string> UploadFoodImage(int foodId, UploadImageDto uploadedImage)
{
var dbFood = (await dbContext.Foods
.SingleOrDefaultAsync(f => f.Id == foodId))
.CheckIfFoodNull();
string relativeImagePath = await imageRepository.UploadImage(uploadedImage.ImageFile, "food");
imageRepository.DeleteImage(dbFood.ImagePath);
dbFood.ImagePath = relativeImagePath;
await dbContext.SaveChangesAsync();
return(relativeImagePath);
}
public IActionResult OnPost([FromForm] UploadImageDto imageDto)
{
if (_userManager.Users.FirstOrDefault(u => u.UserName == imageDto.UserName) == null)
{
return(Unauthorized());
}
foreach (var img in imageDto.ImageFiles)
{
if (!_fileRepository.SaveImage(imageDto.UserName, img))
{
throw new Exception("Image Upload Failed");
}
}
return(RedirectToPage("AuthorDashboard"));
}
/// <summary>
/// Kép hozzáadása a megadott azonosítójú étteremhez.
/// Ha a megadott azonosítóval étterem nem található, akkor kivételt dobunk,
/// egyébként feltöltjük a képet és beállítjuk rá az étterem relatív elérési útját.
/// </summary>
/// <param name="restaurantId">Az étterem azonosítója.</param>
/// <param name="uploadedImage">A feltöltendő kép.</param>
/// <returns>A kép relatív elérési útja.</returns>
public async Task <string> UploadRestaurantImage(int restaurantId, UploadImageDto uploadedImage)
{
var dbRestaurant = (await dbContext.Restaurants
.SingleOrDefaultAsync(r => r.Id == restaurantId))
.CheckIfRestaurantNull();
string relativeImagePath = await imageRepository.UploadImage(uploadedImage.ImageFile, "restaurant");
imageRepository.DeleteImage(dbRestaurant.ImagePath);
dbRestaurant.ImagePath = relativeImagePath;
await dbContext.SaveChangesAsync();
return(relativeImagePath);
}
public async Task <UploadImageDto> GenerateSasTokenWithPermissionWrite(string fileExtension, string containerName)
{
var fileName = $"{Guid.NewGuid()}.{fileExtension}";
var permissions = SharedAccessBlobPermissions.Write;
var shareAccessBlobPolicy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTime.UtcNow.AddMinutes(StartValidTimeForSas),
SharedAccessExpiryTime = DateTime.UtcNow.AddMinutes(ExpiredTimeForWriteFileInTempStorage),
Permissions = permissions
};
CloudBlobContainer cloudBlobContainer = GetContainer(containerName);
string uploadUrl = String.Format("{0}/{1}{2}", cloudBlobContainer.Uri, fileName, cloudBlobContainer.GetSharedAccessSignature(shareAccessBlobPolicy, null));
var uploadImageDto = new UploadImageDto
{
ImageName = fileName,
ImageUploadUrl = uploadUrl
};
return(uploadImageDto);
}
public static UploadImageDto UploadImageToCloudinary(UploadImageDto uploadImageDto)
{
var file = uploadImageDto.File;
var uploadresult = new ImageUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new ImageUploadParams
{
File = new FileDescription(file.Name, stream)
};
uploadresult = _cloudinary.Upload(uploadParams);
}
}
uploadImageDto.Url = uploadresult.Uri.ToString();
uploadImageDto.PublicId = uploadresult.PublicId;
return(uploadImageDto);
}
public void Execute(UploadImageDto request)
{
var guid = Guid.NewGuid();
var extension = Path.GetExtension(request.Image.FileName);
var newFileName = guid + extension;
var path = Path.Combine("wwwroot", "images", newFileName);
using (var fileStream = new FileStream(path, FileMode.Create))
{
request.Image.CopyTo(fileStream);
}
var image = new Image
{
ImageName = newFileName
};
_context.Images.Add(image);
_context.SaveChanges();
}
public async Task <ActionResult> UploadMyRestaurantImage([FromForm] UploadImageDto uploadedImage)
{
string relativeImagePath = await restaurantManager.UploadMyRestaurantImage(uploadedImage);
return(Ok(new { relativeImagePath }));
}
public async Task <ActionResult> UploadFoodImage(int foodId, [FromForm] UploadImageDto uploadedImage)
{
string relativeImagePath = await foodManager.UploadFoodImage(foodId, uploadedImage);
return(Ok(new { relativeImagePath }));
}
