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 }; }