public Task <DowndloadImageResponse> DownloadImage(DownloadImageRequest request)
{
Stream stream = File.OpenRead("moon.jpg");
return(Task.FromResult(new DowndloadImageResponse
{
FileName = "moon.jpg",
ContentType = "image/jpg",
Image = stream
}));
}
public async Task <IActionResult> DownloadImage([FromQuery] DownloadImageRequest __request)
{
var result = await _service.DownloadImage(__request);
if (Request.Headers.ContainsKey("Accept") &&
System.Net.Http.Headers.MediaTypeHeaderValue.TryParse(Request.Headers["Accept"], out var mimeType) && mimeType?.MediaType == "application/x-cybtans")
{
return(new ObjectResult(result));
}
return(new FileStreamResult(result.Image, result.ContentType)
{
FileDownloadName = result.FileName
});
}
/// <summary>
/// Downloads the image.
/// </summary>
/// <param name="request">The download image request.</param>
/// <returns>The <see cref="Task"/> containing the API response with image data.</returns>
public virtual Task <ApiResponse <byte[]> > DownloadAsync(DownloadImageRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Image == null)
{
throw new ApiException(400, $"Parameter '{nameof(request.Image)}' is missed.");
}
var downloadHref = request.Image.GetDownloadHref(request.ImageType);
var requestContext = PrepareRequestContext(path: downloadHref);
return(CallAsync <byte[]>(requestContext));
}
public async Task <FileStreamResult> DownloadImageAsync(DownloadImageRequest request)
{
try
{
ImageLocationParam param = new ImageLocationParam()
{
BucketName = request.BucketName,
ImageName = request.ImageName
};
GetImageResult result = await _minioRepository.GetImageByteAsync(param);
return(new FileStreamResult(new MemoryStream(result.ImageData.GetAllBytes()), "image/jpeg"));
}
catch (Exception exception)
{
//SentrySdk.CaptureException(exception);
throw;
}
}
public async Task DownloadImageAsync_Test()
{
SaveImageByUrlRequest saveRequest = new SaveImageByUrlRequest()
{
ImageUrl = "https://www.baidu.com/img/bd_logo1.png?where=super"
};
SaveImageResponse saveResponse = await _imageAppService.SaveImageByUrlAsync(saveRequest);
DownloadImageRequest downloadRequest = new DownloadImageRequest()
{
BucketName = saveResponse.BucketName,
ImageName = saveResponse.ImageName,
ImageType = "png"
};
FileStreamResult getResponse = await _imageAppService.DownloadImageAsync(downloadRequest);
getResponse.FileStream.Length.ShouldBe(7877);
}
public void AddTestDefinitions()
{
#region CustomerService
FieldAsync <GetAllCustomerResponseGraphType>("customers",
description: "Returns a collection of CustomerDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
var authorizationService = context.RequestServices.GetRequiredService <IAuthorizationService>();
var authorizationResult = await authorizationService.AuthorizeAsync(httpContext.User, "AdminUser");
if (!authorizationResult.Succeeded)
{
throw new UnauthorizedAccessException("Policy Authorization Required");
}
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ICustomerServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <CustomerDtoGraphType>("customer",
description: "Returns one CustomerDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <GuidGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
var authorizationService = context.RequestServices.GetRequiredService <IAuthorizationService>();
var authorizationResult = await authorizationService.AuthorizeAsync(httpContext.User, "AdminUser");
if (!authorizationResult.Succeeded)
{
throw new UnauthorizedAccessException("Policy Authorization Required");
}
var request = new GetCustomerRequest();
request.Id = context.GetArgument <Guid>("id", default(Guid));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ICustomerServiceClient>();
return(await service.Get(request));
}
);
#endregion CustomerService
#region CustomerEventService
FieldAsync <GetAllCustomerEventResponseGraphType>("customerEvents",
description: "Returns a collection of CustomerEventDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.Identity.IsAuthenticated)
{
throw new UnauthorizedAccessException("Authentication Required");
}
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ICustomerEventServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <CustomerEventDtoGraphType>("customerEvent",
description: "Returns one CustomerEventDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <GuidGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.Identity.IsAuthenticated)
{
throw new UnauthorizedAccessException("Authentication Required");
}
var request = new GetCustomerEventRequest();
request.Id = context.GetArgument <Guid>("id", default(Guid));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ICustomerEventServiceClient>();
return(await service.Get(request));
}
);
#endregion CustomerEventService
#region OrderService
FieldAsync <DowndloadImageResponseGraphType>("OrderService_DownloadImage",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Name"
},
},
resolve: async context =>
{
var request = new DownloadImageRequest();
request.Name = context.GetArgument <string>("name", default(string));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderServiceClient>();
return(await service.DownloadImage(request));
}
);
FieldAsync <GetAllNamesResponseGraphType>("ordernames",
resolve: async context =>
{
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderServiceClient>();
return(await service.GetAllNames());
}
);
FieldAsync <OrderNamesDtoGraphType>("OrderService_OrderName",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var request = new GetOrderNameRequest();
request.Id = context.GetArgument <string>("id", default(string));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderServiceClient>();
return(await service.GetOrderName(request));
}
);
FieldAsync <GetAllOrderResponseGraphType>("orders",
description: "Returns a collection of OrderDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <OrderDtoGraphType>("order",
description: "Returns one OrderDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <GuidGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var request = new GetOrderRequest();
request.Id = context.GetArgument <Guid>("id", default(Guid));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderServiceClient>();
return(await service.Get(request));
}
);
#endregion OrderService
#region OrderStateService
FieldAsync <GetAllOrderStateResponseGraphType>("orderStates",
description: "Returns a collection of OrderStateDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.IsInRole("admin"))
{
throw new UnauthorizedAccessException("Roles Authorization Required");
}
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderStateServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <OrderStateDtoGraphType>("orderState",
description: "Returns one OrderStateDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <IntGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.IsInRole("admin"))
{
throw new UnauthorizedAccessException("Roles Authorization Required");
}
var request = new GetOrderStateRequest();
request.Id = context.GetArgument <int>("id", default(int));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IOrderStateServiceClient>();
return(await service.Get(request));
}
);
#endregion OrderStateService
#region ReadOnlyEntityService
FieldAsync <GetAllReadOnlyEntityResponseGraphType>("readOnlyEntities",
description: "Returns a collection of ReadOnlyEntityDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.IsInRole("admin"))
{
throw new UnauthorizedAccessException("Roles Authorization Required");
}
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IReadOnlyEntityServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <ReadOnlyEntityDtoGraphType>("readOnlyEntity",
description: "Returns one ReadOnlyEntityDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <IntGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext;
if (!httpContext.User.IsInRole("admin"))
{
throw new UnauthorizedAccessException("Roles Authorization Required");
}
var request = new GetReadOnlyEntityRequest();
request.Id = context.GetArgument <int>("id", default(int));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.IReadOnlyEntityServiceClient>();
return(await service.Get(request));
}
);
#endregion ReadOnlyEntityService
#region SoftDeleteOrderService
FieldAsync <GetAllSoftDeleteOrderResponseGraphType>("softDeleteOrders",
description: "Returns a collection of SoftDeleteOrderDto",
arguments: new QueryArguments()
{
new QueryArgument <StringGraphType>()
{
Name = "Filter"
},
new QueryArgument <StringGraphType>()
{
Name = "Sort"
},
new QueryArgument <IntGraphType>()
{
Name = "Skip"
},
new QueryArgument <IntGraphType>()
{
Name = "Take"
},
},
resolve: async context =>
{
var request = new GetAllRequest();
request.Filter = context.GetArgument <string>("filter", default(string));
request.Sort = context.GetArgument <string>("sort", default(string));
request.Skip = context.GetArgument <int?>("skip", default(int?));
request.Take = context.GetArgument <int?>("take", default(int?));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ISoftDeleteOrderServiceClient>();
return(await service.GetAll(request));
}
);
FieldAsync <SoftDeleteOrderDtoGraphType>("softDeleteOrder",
description: "Returns one SoftDeleteOrderDto by Id",
arguments: new QueryArguments()
{
new QueryArgument <GuidGraphType>()
{
Name = "Id"
},
},
resolve: async context =>
{
var request = new GetSoftDeleteOrderRequest();
request.Id = context.GetArgument <Guid>("id", default(Guid));
var service = context.RequestServices.GetRequiredService <global::Cybtans.Tests.Clients.ISoftDeleteOrderServiceClient>();
return(await service.Get(request));
}
);
#endregion SoftDeleteOrderService
}
public DownloadImageResponse DownloadImage(DownloadImageRequest request)
{
string imageUrl = string.Empty;
string storagePath = string.Empty;
var extension = Path.GetExtension(request.ImageInputUrl) == "" ? ".JPEG" : Path.GetExtension(request.ImageInputUrl);
string storageName = Guid.NewGuid().ToString() + extension;
string fileOriginalName = Path.GetFileName(request.ImageInputUrl);
var imagePhysicalPath = ConfigurationManager.AppSettings["IMAGE_PHYSICAL_PATH"].ToString();
DownloadImageResponse downloadResponse = new DownloadImageResponse();
ImageViewModel imageViewModel = new ImageViewModel();
//Checking for EditMode
if (!System.IO.File.Exists(imagePhysicalPath + "/" + request.ImageInputUrl))
{
try
{
WebRequest req = WebRequest.Create(request.ImageInputUrl);
req.Timeout = 10000;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls
| SecurityProtocolType.Tls11
| SecurityProtocolType.Tls12
| SecurityProtocolType.Ssl3;
WebResponse response = req.GetResponse();
Stream stream = response.GetResponseStream();
Image Image = Image.FromStream(stream);
if (!System.IO.Directory.Exists(imagePhysicalPath + "/" + request.AccountId))
{
Directory.CreateDirectory(imagePhysicalPath + "/" + request.AccountId);
}
switch (request.ImgCategory)
{
case ImageCategory.ContactProfile:
storagePath = request.AccountId + "/" + "pi";
imageViewModel.FriendlyName = fileOriginalName;
break;
case ImageCategory.Campaigns:
storagePath = request.AccountId + "/" + "ci";
break;
default:
break;
}
imagePhysicalPath = imagePhysicalPath + "/" + storagePath;
if (!System.IO.Directory.Exists(imagePhysicalPath))
{
System.IO.Directory.CreateDirectory(imagePhysicalPath);
}
imagePhysicalPath = Path.Combine(imagePhysicalPath, storageName);
if (!System.IO.File.Exists(imagePhysicalPath))
{
Image.Save(imagePhysicalPath, ImageFormat.Jpeg);
}
imageUrl = storageName;
imageViewModel.ImageContent = imageUrl;
imageViewModel.OriginalName = fileOriginalName;
imageViewModel.ImageType = Path.GetExtension(request.ImageInputUrl) == "" ? ".JPEG" : Path.GetExtension(request.ImageInputUrl);
imageViewModel.StorageName = storageName;
imageViewModel.ImageCategoryID = request.ImgCategory;
imageViewModel.AccountID = Convert.ToInt16(request.AccountId);
}
catch (Exception ex)
{
Logger.Current.Error("An error occured while downloading image from specified path : " + request.ImageInputUrl + " AccountID : " + request.AccountId, ex);
}
}
else
{
imageUrl = request.ImageInputUrl;
}
downloadResponse.ImageViewModel = imageViewModel;
return(downloadResponse);
}
