public override async Task <MotorDto> GetAsync(EntityDto <long> input)
{
var entity = await _motorVehicleRepository.GetAllIncluding(t => t.SubImageInfos)
.SingleOrDefaultAsync(f => f.Id == input.Id).ConfigureAwait(false);
if (entity?.SubImageInfos != null)
{
foreach (var subImageInfo in entity.SubImageInfos)
{
if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
string.IsNullOrEmpty(subImageInfo.NodeId))
{
continue;
}
GetImageRequest request = new GetImageRequest()
{
BucketName = subImageInfo.NodeId,
ImageName = subImageInfo.ImageKey
};
GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request);
subImageInfo.Data = Convert.ToBase64String(response.ImageData);
}
}
var dto = MapToEntityDto(entity);
return(dto);
}
public async Task GetImageWithBytesAsync_Test()
{
SaveImageByUrlRequest saveRequest = new SaveImageByUrlRequest()
{
ImageUrl = "https://www.baidu.com/img/bd_logo1.png?where=super"
};
SaveImageResponse saveResponse = await _imageAppService.SaveImageByUrlAsync(saveRequest);
GetImageRequest getRequest = new GetImageRequest()
{
BucketName = saveResponse.BucketName,
ImageName = saveResponse.ImageName
};
GetImageWithBytesResponse getResponse = await _imageAppService.GetImageWithBytesAsync(getRequest);
using (MD5 md5Hash = MD5.Create())
{
byte[] md5Bytes = md5Hash.ComputeHash(getResponse.ImageData);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < md5Bytes.Length; i++)
{
sb.Append(md5Bytes[i].ToString("X2"));
}
sb.ToString().ShouldBe("B15C113AEDDBEB606D938010B88CF8E6");
}
}
public override Task <GetImageResponse> GetImage(GetImageRequest request, ServerCallContext context)
{
return(Task.FromResult(new GetImageResponse
{
Header = HeaderBuilder.Build(request.Header, new CommonError {
Code = CommonError.Types.Code.Ok
}),
ImageResponses = { new ImageResponse
{
Status = ImageResponse.Types.Status.Ok,
Shot = new ImageCapture()
{
AcquisitionTime = Timestamp.FromDateTime(DateTime.UtcNow),
Image = new Image()
{
Format = Image.Types.Format.Jpeg,
Cols = 640,
Rows = 480,
Data = ByteString.CopyFrom(File.ReadAllBytes(@"assets/camera.jpg"))
}
},
Source = new ImageSource()
{
ImageType = ImageSource.Types.ImageType.Visual,
Cols = 640,
Rows = 480,
DepthScale = 1000
}
} }
}));
}
public override async Task <FaceDto> GetAsync(EntityDto <long> input)
{
Face face = await _faceRepository.GetAllIncluding(t => t.SubImageInfos)
.SingleOrDefaultAsync(f => f.Id == input.Id).ConfigureAwait(false);
if (face?.SubImageInfos != null)
{
foreach (var subImageInfo in face.SubImageInfos)
{
if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
string.IsNullOrEmpty(subImageInfo.NodeId))
{
continue;
}
GetImageRequest request = new GetImageRequest()
{
BucketName = subImageInfo.NodeId,
ImageName = subImageInfo.ImageKey
};
GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request).ConfigureAwait(false);
subImageInfo.Data = Convert.ToBase64String(response.ImageData);
}
}
var faceDto = MapToEntityDto(face);
//faceDto.SubImageList = new SubImageInfoDtoList();
//faceDto.SubImageList.SubImageInfoObject = faceDto.SubImageInfos;
//faceDto.SubImageInfos = null;
return(faceDto);
}
public async Task GetSubImageInfoDtoList(List <SubImageInfoDto> subImageInfoDtos)
{
try
{
foreach (var subImageInfo in subImageInfoDtos)
{
if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
string.IsNullOrEmpty(subImageInfo.NodeId))
{
continue;
}
GetImageRequest request = new GetImageRequest()
{
BucketName = subImageInfo.NodeId,
ImageName = subImageInfo.ImageKey
};
GetImageWithBytesResponse response = await GetImageWithBytesAsync(request).ConfigureAwait(false);
subImageInfo.Data = Convert.ToBase64String(response.ImageData);
}
}
catch (Exception)
{
throw;
}
}
public int Add(GetImageRequest request)
{
int response = 0;
List <bx_images> bxImageses = new List <bx_images>();
if (request != null)
{
if (request.yancheimgs != null && request.yancheimgs.Count > 0)
{
foreach (var item in request.yancheimgs)
{
bx_images bxImages = new bx_images();
bxImages.buid = request.buid;
bxImages.image = item;
bxImages.type = 1;
bxImageses.Add(bxImages);
}
}
if (!string.IsNullOrEmpty(request.zjimg))
{
bx_images bxImages = new bx_images();
bxImages.buid = request.buid;
bxImages.image = request.zjimg;
bxImages.type = 2;
bxImageses.Add(bxImages);
}
if (bxImageses.Count > 0)
{
response = _ImagesRepository.Add(bxImageses);
}
}
return(response);
}
public void Set(GetImageRequest request, ImageResponse imageResponse)
{
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(imageResponse.Content.Length / 1024)
.SetSlidingExpiration(TimeSpan.FromHours(_appSettings.CacheExpiryInHours));
_memoryCache.Set(request, imageResponse, cacheEntryOptions);
}
public void SetBackgroundColor(Image image, GetImageRequest queryRequest)
{
if (string.IsNullOrWhiteSpace(queryRequest.BackgroundColor))
{
return;
}
image.Mutate(x => x.BackgroundColor(Color.ParseHex(queryRequest.BackgroundColor)));
}
public void ConstrainSize(Image image, GetImageRequest request)
{
var width = request.MaxWidth ?? image.Width;
var height = request.MaxHeight ?? image.Height;
image.Mutate(x => x.Resize(new ResizeOptions {
Mode = ResizeMode.Max, Size = new Size(width, height)
}));
}
public ByteString GetImage(uint deviceID)
{
var request = new GetImageRequest {
DeviceID = deviceID
};
var response = fingerClient.GetImage(request);
return(response.BMPImage);
}
public void SetWaterMark(Image image, GetImageRequest queryRequest)
{
if (!queryRequest.WaterMarkRequested())
{
return;
}
image.Mutate(x => x.ApplyScalingWaterMark(queryRequest.WaterMark, Color.Black));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetImageRequest, GetImageResponse> ForImage(GetImageRequest request, WaiterConfiguration config, params Image.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetImageRequest, GetImageResponse>(
request,
request => client.GetImage(request),
response => targetStates.Contains(response.Image.LifecycleState.Value),
targetStates.Contains(Image.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetImageRequest, GetImageResponse>(config, agent));
}
public async Task <ImageResponse> GetProcessedImage(GetImageRequest request, CancellationToken cancellationToken)
{
var image = await _imageService.LoadImage($"{_appSettings.ProductImagesPath}{request.FileName}", cancellationToken);
_imageService.ConstrainSize(image, request);
_imageService.SetBackgroundColor(image, request);
_imageService.SetWaterMark(image, request);
var(bytes, contentType) = await _imageSavingStrategy.SaveImage(image, request.ImageFileType, cancellationToken);
return(ImageResponse.GetResponse(ResponseType.Ok, bytes, contentType));
}
public async Task GivenInvalidImageName_WhenNoParamsSet_ThenNotFoundResultReturned()
{
// Arrange
var request = new GetImageRequest {
FileName = "file-missing.png", MaxWidth = 300
};
// Act
var result = await _sut.Index(request);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest {
FileId = uploadResponse.Data.Value
};
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest {
ImageId = uploadResponse.Data.Value
};
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return(View(model));
}
/// <summary>Snippet for Get</summary>
public void GetRequestObject()
{
// Snippet: Get(GetImageRequest, CallSettings)
// Create client
ImagesClient imagesClient = ImagesClient.Create();
// Initialize request argument(s)
GetImageRequest request = new GetImageRequest
{
Image = "",
Project = "",
};
// Make the request
Image response = imagesClient.Get(request);
// End snippet
}
public async Task <IActionResult> Index(GetImageRequest request)
{
var result = await _mediator.Send(new GetImage.Query(request), CancellationToken.None);
if (result.ResponseType == ResponseType.BadRequest)
{
return(BadRequest(result.Message));
}
if (result.ResponseType == ResponseType.NotFound)
{
return(NotFound());
}
return(File(result.Content, result.ContentType));
}
public async Task GivenValidImageName_WhenNoParamsSet_ThenMissingResolutionErrorReturned()
{
// Arrange
var request = new GetImageRequest {
FileName = "file-missing.png"
};
// Act
var result = await _sut.Index(request);
// Verify type
Assert.IsType <BadRequestObjectResult>(result);
var message = ((BadRequestObjectResult)result).Value.ToString();
Assert.Contains("Max with or max height must be specified", message);
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest { FileId = uploadResponse.Data.Value };
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest { ImageId = uploadResponse.Data.Value };
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return View(model);
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetRequestObjectAsync()
{
// Snippet: GetAsync(GetImageRequest, CallSettings)
// Additional: GetAsync(GetImageRequest, CancellationToken)
// Create client
ImagesClient imagesClient = await ImagesClient.CreateAsync();
// Initialize request argument(s)
GetImageRequest request = new GetImageRequest
{
Image = "",
Project = "",
};
// Make the request
Image response = await imagesClient.GetAsync(request);
// End snippet
}
/// <summary>
/// Gets the specified image.
/// </summary>
/// <param name="getRequest"></param>
/// <returns></returns>
public async Task <GetImageResponse> GetImage(GetImageRequest getRequest)
{
var uri = new Uri($"{GetEndPoint(CoreServices.Image, this.Region)}/{getRequest.ImageId}");
using (var webResponse = await this.RestClientAsync.Get(uri))
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = await reader.ReadToEndAsync();
return(new GetImageResponse()
{
Image = this.JsonSerializer.Deserialize <Image>(response),
ETag = webResponse.Headers.Get("ETag"),
OpcRequestId = webResponse.Headers.Get("opc-request-id")
});
}
}
public async Task <PagedResultDto <ClusteringFaceDto> > QueryClusteringFaceByParams(PagedAndSortedRequestDto input)
{
var query = _faceRepository.GetAllIncluding(p => p.SubImageInfos);
query = await _faceRepository.QueryByParams(input.Parameters, query).ConfigureAwait(false);
//var faces = await GetAllAsync(input).ConfigureAwait(false);
var faces = PagingAndSorting(input, query);
if (input.ImageRequred == 1)
{
foreach (var face in faces.Items)
{
var imageToQuery = face.SubImageList.SubImageInfoObject;
//imageType
if (input.ImageType == "11" || input.ImageType == "14")
{
imageToQuery = imageToQuery.Where(p => p.Type == input.ImageType).ToList();
}
foreach (var subImageInfo in imageToQuery)
{
if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
string.IsNullOrEmpty(subImageInfo.NodeId))
{
continue;
}
GetImageRequest request = new GetImageRequest()
{
BucketName = subImageInfo.NodeId,
ImageName = subImageInfo.ImageKey
};
GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request).ConfigureAwait(false);
subImageInfo.Data = Convert.ToBase64String(response.ImageData);
}
}
}
return(new PagedResultDto <ClusteringFaceDto>(faces.TotalCount, ObjectMapper.Map <List <ClusteringFaceDto> >(faces.Items)));
}
public async Task GetImageStatusAsync_Test()
{
SaveImageByUrlRequest saveRequest = new SaveImageByUrlRequest()
{
ImageUrl = "https://www.baidu.com/img/bd_logo1.png?where=super"
};
SaveImageResponse saveResponse = await _imageAppService.SaveImageByUrlAsync(saveRequest);
GetImageRequest getRequest = new GetImageRequest()
{
BucketName = saveResponse.BucketName,
ImageName = saveResponse.ImageName
};
GetImageStatusResponse getResponse = await _imageAppService.GetImageStatusAsync(getRequest);
getResponse.ImageName.ShouldBe("B15C113AEDDBEB606D938010B88CF8E6");
getResponse.Size.ShouldBe(7877);
}
public async Task <GetImageStatusResponse> GetImageStatusAsync(GetImageRequest request)
{
try
{
ImageLocationParam param = new ImageLocationParam()
{
BucketName = request.BucketName,
ImageName = request.ImageName
};
GetImageStatusResult result = await _minioRepository.GetImageStatusAsync(param);
return(new GetImageStatusResponse(result));
}
catch (Exception exception)
{
//SentrySdk.CaptureException(exception);
throw;
}
}
private void HandleOutput(GetImageRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForImage(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetImage(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Image);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetImageRequest request;
try
{
request = new GetImageRequest
{
ImageId = ImageId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task GetImage_ValidatesRequest(string fileName, int?maxWith, int?maxHeight, string backgroundColor, bool isValid)
{
// Arrange
var request = new GetImageRequest
{
FileName = fileName, MaxWidth = maxWith, MaxHeight = maxHeight, BackgroundColor = backgroundColor
};
// Act
var result = await _sut.Handle(new GetImage.Query(request), CancellationToken.None);
// Assert
if (isValid)
{
Assert.True(result.ResponseType == ResponseType.Ok);
}
else
{
Assert.True(result.ResponseType == ResponseType.BadRequest);
}
}
public async Task GivenValidImageName_WhenBackgroundColourSpecified_ThenValidImageReturned()
{
// Arrange
const int maxHeight = 100;
var request = new GetImageRequest {
FileName = "01_04_2019_001106.png", MaxHeight = maxHeight, BackgroundColor = "#000000"
};
// Act
var result = await _sut.Index(request);
// Verify type
Assert.IsType <FileContentResult>(result);
// Load image
var(image, errorLoading) = await LoadImage(result);
Assert.False(errorLoading);
Assert.Equal(maxHeight, image.Height);
}
public async Task GivenValidImageName_WhenMaxWidthSet_ThenImageConstrainedToMaxWith()
{
// Arrange
const int maxWidth = 200;
var request = new GetImageRequest {
FileName = "01_04_2019_001106.png", MaxWidth = maxWidth
};
// Act
var result = await _sut.Index(request);
// Verify type
Assert.IsType <FileContentResult>(result);
// Load image
var(image, errorLoading) = await LoadImage(result);
Assert.False(errorLoading);
Assert.Equal(maxWidth, image.Width);
}
public async Task <GetImageBase64Response> GetImageBase64Async(GetImageRequest request)
{
try
{
ImageLocationParam param = new ImageLocationParam()
{
BucketName = request.BucketName,
ImageName = request.ImageName
};
GetImageResult result = await _minioRepository.GetImageByteAsync(param);
return(new GetImageBase64Response()
{
ImageBase64 = Convert.ToBase64String(result.ImageData.GetAllBytes())
});
}
catch (Exception exception)
{
//SentrySdk.CaptureException(exception);
throw;
}
}
public HttpResponseMessage Add([FromBody] GetImageRequest request)
{
BaseViewModel viewModel = new BaseViewModel();
try
{
int count = _imagesService.Add(request);
if (count == 0)
{
viewModel.BusinessStatus = 1;
}
else
{
viewModel.BusinessStatus = 10002;
viewModel.StatusMessage = "添加图片失败";
}
}
catch (Exception)
{
viewModel.BusinessStatus = 10002;
viewModel.StatusMessage = "添加图片异常";
}
return(viewModel.ResponseToJson());
}
/// <summary>
/// Gets the specified image.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>GetImageRequest</c> with an image.
/// </returns>
public GetImageResponse Get(GetImageRequest request)
{
var model = repository
.AsQueryable<MediaImage>(media => media.Id == request.ImageId && media.Type == Module.MediaManager.Models.MediaType.Image)
.Select(media => new ImageModel
{
Id = media.Id,
Version = media.Version,
CreatedBy = media.CreatedByUser,
CreatedOn = media.CreatedOn,
LastModifiedBy = media.ModifiedByUser,
LastModifiedOn = media.ModifiedOn,
Title = media.Title,
Description = media.Description,
Caption = media.Caption,
FileExtension = media.OriginalFileExtension,
FileSize = media.Size,
ImageUrl = media.PublicUrl,
Width = media.Width,
Height = media.Height,
ThumbnailUrl = media.PublicThumbnailUrl,
ThumbnailWidth = media.ThumbnailWidth,
ThumbnailHeight = media.ThumbnailHeight,
ThumbnailSize = media.ThumbnailSize,
IsArchived = media.IsArchived,
FolderId = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Id : (Guid?)null,
FolderName = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Title : null,
PublishedOn = media.PublishedOn,
OriginalFileName = media.OriginalFileName,
OriginalFileExtension = media.OriginalFileExtension,
OriginalWidth = media.OriginalWidth,
OriginalHeight = media.OriginalHeight,
OriginalSize = media.OriginalSize,
OriginalUrl = media.PublicOriginallUrl,
FileUri = media.FileUri.ToString(),
IsUploaded = media.IsUploaded,
IsTemporary = media.IsTemporary,
IsCanceled = media.IsCanceled,
OriginalUri = media.OriginalUri.ToString(),
ThumbnailUri = media.ThumbnailUri.ToString()
})
.FirstOne();
model.ImageUrl = fileUrlResolver.EnsureFullPathUrl(model.ImageUrl);
model.ThumbnailUrl = fileUrlResolver.EnsureFullPathUrl(model.ThumbnailUrl);
model.OriginalUrl = fileUrlResolver.EnsureFullPathUrl(model.OriginalUrl);
IList<TagModel> tags;
if (request.Data.IncludeTags)
{
tags =
repository.AsQueryable<MediaTag>(mediaTag => mediaTag.Media.Id == request.ImageId && !mediaTag.Tag.IsDeleted)
.OrderBy(mediaTag => mediaTag.Tag.Name)
.Select(media => new TagModel
{
Id = media.Tag.Id,
Version = media.Tag.Version,
CreatedBy = media.Tag.CreatedByUser,
CreatedOn = media.Tag.CreatedOn,
LastModifiedBy = media.Tag.ModifiedByUser,
LastModifiedOn = media.Tag.ModifiedOn,
Name = media.Tag.Name
})
.ToList();
}
else
{
tags = null;
}
return new GetImageResponse
{
Data = model,
Tags = tags
};
}
