public async stt::Task GetCustomerAsync()
{
moq::Mock <CustomerService.CustomerServiceClient> mockGrpcClient = new moq::Mock <CustomerService.CustomerServiceClient>(moq::MockBehavior.Strict);
GetCustomerRequest request = new GetCustomerRequest
{
ResourceNameAsCustomerName = gagvr::CustomerName.FromCustomer("[CUSTOMER]"),
};
gagvr::Customer expectedResponse = new gagvr::Customer
{
ResourceNameAsCustomerName = gagvr::CustomerName.FromCustomer("[CUSTOMER]"),
Id = -6774108720365892680L,
DescriptiveName = "descriptive_nameee37a0bc",
CurrencyCode = "currency_code7f81e352",
TimeZone = "time_zone73f23b20",
TrackingUrlTemplate = "tracking_url_template157f152a",
AutoTaggingEnabled = true,
HasPartnersBadge = true,
CallReportingSetting = new gagvr::CallReportingSetting(),
FinalUrlSuffix = "final_url_suffix046ed37a",
Manager = false,
TestAccount = true,
ConversionTrackingSetting = new gagvr::ConversionTrackingSetting(),
RemarketingSetting = new gagvr::RemarketingSetting(),
PayPerConversionEligibilityFailureReasons =
{
gagve::CustomerPayPerConversionEligibilityFailureReasonEnum.Types.CustomerPayPerConversionEligibilityFailureReason.HasCampaignWithSharedBudget,
},
};
mockGrpcClient.Setup(x => x.GetCustomerAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <gagvr::Customer>(stt::Task.FromResult(expectedResponse), null, null, null, null));
CustomerServiceClient client = new CustomerServiceClientImpl(mockGrpcClient.Object, null);
gagvr::Customer responseCallSettings = await client.GetCustomerAsync(request.ResourceName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
Assert.AreEqual(expectedResponse, responseCallSettings);
gagvr::Customer responseCancellationToken = await client.GetCustomerAsync(request.ResourceName, st::CancellationToken.None);
Assert.AreEqual(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public ActionResult <AccountView> ReceiveTokenAndLogon(string token, string returnUrl)
{
User user = _externalAuthenticationService.GetUserDetailsFrom(token);
if (user.IsAuthenticated)
{
_formsAuthentication.SetAuthenticationToken(user.AuthenticationToken);
GetCustomerRequest getCustomerRequest = new GetCustomerRequest();
getCustomerRequest.CustomerIdentityToken = user.AuthenticationToken;
GetCustomerResponse getCustomerResponse =
_customerService.GetCustomer(getCustomerRequest);
if (getCustomerResponse.CustomerFound)
{
return(RedirectBasedOn(returnUrl));
}
else
{
AccountView accountView = InitializeAccountViewWithIssue(true,
"Sorry we could not find your customer account. " +
"If you don't have an account with use " +
"please register.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(accountView);
}
}
else
{
AccountView accountView = InitializeAccountViewWithIssue(true,
"Sorry we could not log you in." +
" Please try again.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(accountView);
}
}
public void GetCustomerRequestObject()
{
moq::Mock <CustomerService.CustomerServiceClient> mockGrpcClient = new moq::Mock <CustomerService.CustomerServiceClient>(moq::MockBehavior.Strict);
GetCustomerRequest request = new GetCustomerRequest
{
ResourceNameAsCustomerName = gagvr::CustomerName.FromCustomer("[CUSTOMER_ID]"),
};
gagvr::Customer expectedResponse = new gagvr::Customer
{
ResourceNameAsCustomerName = gagvr::CustomerName.FromCustomer("[CUSTOMER_ID]"),
CallReportingSetting = new gagvr::CallReportingSetting(),
ConversionTrackingSetting = new gagvr::ConversionTrackingSetting(),
RemarketingSetting = new gagvr::RemarketingSetting(),
PayPerConversionEligibilityFailureReasons =
{
gagve::CustomerPayPerConversionEligibilityFailureReasonEnum.Types.CustomerPayPerConversionEligibilityFailureReason.HasCampaignWithSharedBudget,
},
Id = -6774108720365892680L,
DescriptiveName = "descriptive_nameee37a0bc",
CurrencyCode = "currency_code7f81e352",
TimeZone = "time_zone73f23b20",
TrackingUrlTemplate = "tracking_url_template157f152a",
FinalUrlSuffix = "final_url_suffix046ed37a",
AutoTaggingEnabled = true,
HasPartnersBadge = true,
Manager = false,
TestAccount = true,
OptimizationScore = -4.7741588361660064E+17,
OptimizationScoreWeight = -89016329767571470,
};
mockGrpcClient.Setup(x => x.GetCustomer(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
CustomerServiceClient client = new CustomerServiceClientImpl(mockGrpcClient.Object, null);
gagvr::Customer response = client.GetCustomer(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task UpdateReservationTest()
{
//arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
ReservationDto toUpdate = _target.GetReservation(requestId);
GetCustomerRequest customerRequest = new GetCustomerRequest {
IdFilter = 1
};
CustomerDto customer = _kundeClient.GetCustomer(customerRequest);
//act
toUpdate.Customer = customer;
Empty emptyUpdate = _target.UpdateReservation(toUpdate);
// assert
ReservationDto expected = _target.GetReservation(requestId);
Assert.Equal(1, expected.Customer.Id);
}
public GetCustomerResponse GetCustomer(GetCustomerRequest getCustomerRequest)
{
var getCustomerResponse = new GetCustomerResponse();
Customer customer = null;
try
{
customer = _customerRepository.FindById(getCustomerRequest.Id);
if (customer == null)
{
getCustomerResponse.Exception = new Exception("");
}
else
{
getCustomerResponse.Customer = customer.ConvertToViewModel();
}
}
catch (Exception ex)
{
getCustomerResponse.Exception = ex;
}
return(getCustomerResponse);
}
public async Task <IActionResult> EditDeliveryAddress(int deliveryAddressId)
{
GetCustomerRequest customerRequest = new GetCustomerRequest();
customerRequest.CustomerEmail = _cookieAuthentication.GetAuthenticationToken();
GetCustomerResponse response = _customerService.GetCustomer(customerRequest);
if (response.CustomerFound)
{
CustomerDeliveryAddressView deliveryAddressView = new CustomerDeliveryAddressView();
deliveryAddressView.CustomerView = response.Customer;
deliveryAddressView.Address = response.Customer.DeliveryAddressBook.FirstOrDefault(d => d.Id == deliveryAddressId);
deliveryAddressView.BasketSummary = GetBasketSummaryView();
return(View(deliveryAddressView));
}
else
{
await _cookieAuthentication.SignOut();
return(RedirectToAction("Register", "AccountRegister"));
}
}
public GetCustomerResponse GetCustomer(GetCustomerRequest getCustomerRequest)
{
GetCustomerResponse getCustomerResponse = new GetCustomerResponse();
Customer customer = null;
try
{
customer = _customerRepository.FindBy(getCustomerRequest.Id);
if (customer == null)
{
getCustomerResponse.Exception = GetStandardCustomerNotFoundException();
}
else
{
getCustomerResponse.Customer = customer.ConvertToViewModel();
}
}
catch (Exception ex)
{
getCustomerResponse.Exception = ex;
}
return(getCustomerResponse);
}
public GetCustomerResponse GetCustomer(GetCustomerRequest request)
{
GetCustomerResponse response = new GetCustomerResponse();
Customer customer = _customerRepository.FindBy(request.CustomerIdentityToken);
if (customer != null)
{
response.CustomerFound = true;
response.Customer = customer.ConvertToCustomerDetailView();
if (request.LoadOrderSummary)
{
response.Orders = customer.Orders.OrderByDescending(o => o.Created).ConvertToOrderSummaryViews();
}
}
else
{
response.CustomerFound = false;
}
return(response);
}
public JsonResult Update(OrderDetailView vm)
{
GetOrderRequest request = new GetOrderRequest();
request.OrderID = vm.OrderID;
ModifyOrderRequest updateRequest = _orderService.GetOrder(request).Order.ConvertToModifyOrderRequest();
updateRequest.OrderID = vm.OrderID;
GetCustomerRequest customerRequest = new GetCustomerRequest();
customerRequest.CustomerID = vm.CustomerCustomerID;
updateRequest.Customer = _customerService.GetCustomer(customerRequest).Customer;
GetEmployeeRequest employeeRequest = new GetEmployeeRequest();
employeeRequest.EmployeeID = vm.EmployeeEmployeeID;
updateRequest.Employee = _employeeService.GetEmployee(employeeRequest).Employee;
updateRequest.OrderDate = vm.OrderDate;
updateRequest.RequiredDate = vm.RequiredDate;
updateRequest.ShippedDate = vm.ShippedDate;
GetShipperRequest shipperRequest = new GetShipperRequest();
shipperRequest.ShipperID = vm.ShipperShipperID;
updateRequest.Shipper = _shipperService.GetShipper(shipperRequest).Shipper;
updateRequest.Freight = vm.Freight;
updateRequest.ShipName = vm.ShipName;
updateRequest.ShipAddress = vm.ShipAddress;
updateRequest.ShipCity = vm.ShipCity;
updateRequest.ShipRegion = vm.ShipRegion;
updateRequest.ShipPostalCode = vm.ShipPostalCode;
updateRequest.ShipCountry = vm.ShipCountry;
ModifyOrderResponse response = _orderService.ModifyOrder(updateRequest);
return(Json(response));
}
/// <summary>
/// Gets a single Customer based on it's unique identifier
/// </summary>
/// <getCustomerByIdParam name="getCustomerByIdParam">The Repository call params <see cref="GetCustomerByIdParam"/></getCustomerByIdParam>
/// <returns>
/// The Customer matching the requested ID, or null
/// </returns>
public virtual Task <Customer> GetCustomerByIdAsync(GetCustomerByIdParam getCustomerByIdParam)
{
if (getCustomerByIdParam == null)
{
throw new ArgumentNullException(nameof(getCustomerByIdParam));
}
if (getCustomerByIdParam.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(getCustomerByIdParam.CultureInfo)), nameof(getCustomerByIdParam));
}
if (string.IsNullOrWhiteSpace(getCustomerByIdParam.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(getCustomerByIdParam.Scope)), nameof(getCustomerByIdParam));
}
if (getCustomerByIdParam.CustomerId == Guid.Empty)
{
throw new ArgumentException(GetMessageOfEmpty(nameof(getCustomerByIdParam.CustomerId)), nameof(getCustomerByIdParam));
}
var cacheKey = new CacheKey(CacheConfigurationCategoryNames.Customer)
{
Scope = getCustomerByIdParam.Scope,
CultureInfo = getCustomerByIdParam.CultureInfo,
};
cacheKey.AppendKeyParts(getCustomerByIdParam.CustomerId);
var getCustomerByUsernameRequest = new GetCustomerRequest
{
IncludeAddresses = getCustomerByIdParam.IncludeAddresses,
ScopeId = getCustomerByIdParam.Scope,
CustomerId = getCustomerByIdParam.CustomerId,
};
return(CacheProvider.GetOrAddAsync(cacheKey, () => OvertureClient.SendAsync(getCustomerByUsernameRequest)));
}
public JsonResult Update(CustomerDetailView vm)
{
GetCustomerRequest request = new GetCustomerRequest();
request.CustomerID = vm.CustomerID;
ModifyCustomerRequest updateRequest = _customerService.GetCustomer(request).Customer.ConvertToModifyCustomerRequest();
updateRequest.CustomerID = vm.CustomerID;
updateRequest.CompanyName = vm.CompanyName;
updateRequest.ContactName = vm.ContactName;
updateRequest.ContactTitle = vm.ContactTitle;
updateRequest.Address = vm.Address;
updateRequest.City = vm.City;
updateRequest.Region = vm.Region;
updateRequest.PostalCode = vm.PostalCode;
updateRequest.Country = vm.Country;
updateRequest.Phone = vm.Phone;
updateRequest.Fax = vm.Fax;
ModifyCustomerResponse response = _customerService.ModifyCustomer(updateRequest);
return(Json(response));
}
public async Task <IActionResult> List()
{
GetCustomerRequest request = new GetCustomerRequest
{
CustomerEmail = _cookieAuthentication.GetAuthenticationToken(),
LoadOrderSummary = true
};
GetCustomerResponse response = _customerService.GetCustomer(request);
if (response.CustomerFound)
{
CustomersOrderSummaryView customersOrderSummaryView = new CustomersOrderSummaryView();
customersOrderSummaryView.Orders = response.Orders;
customersOrderSummaryView.BasketSummary = GetBasketSummaryView();
return(View(customersOrderSummaryView));
}
else
{
await _cookieAuthentication.SignOut();
return(RedirectToAction("Register", "AccountRegister"));
}
}
public IHttpActionResult Get([FromUri] GetCustomerRequest request)
{
var result = _getCustomerByIdProcessor.Process(request);
return(Ok(result));
}
public GetCustomerRequest1(GetCustomerRequest GetCustomerRequest)
{
this.GetCustomerRequest = GetCustomerRequest;
}
public GetCustomerResponse GetCustomer(GetCustomerRequest getCustomerRequest)
{
return(_innerCustomerService.GetCustomer(getCustomerRequest));
}
public Task <CustomerDto> Get(Guid id, [FromQuery] GetCustomerRequest __request)
{
__request.Id = id;
return(_service.Get(__request));
}
public async Task <string> Resolve(string message, WebSocketConnection ws)
{
WebMessageBase request = JsonConvert.DeserializeObject <WebMessageBase>(message);
Console.WriteLine("[{0}] Resolving request: \"{1}\", status: {2}", DateTime.Now.ToString("HH:mm:ss.fff"), request.Tag, request.Status);
string output = String.Empty;
switch (request.Tag)
{
case "get_customer":
{
GetCustomerRequest customerRequest = JsonConvert.DeserializeObject <GetCustomerRequest>(message);
output = await ProcessGetCustomerRequest(customerRequest);
break;
}
case "get_merchandises":
{
GetMerchandisesRequest merchandiseRequest = JsonConvert.DeserializeObject <GetMerchandisesRequest>(message);
output = await ProcessGetMerchandisesRequest(merchandiseRequest);
break;
}
case "get_order":
{
GetOrderRequest ordeRequest = JsonConvert.DeserializeObject <GetOrderRequest>(message);
output = await ProcessGetOrderRequest(ordeRequest);
break;
}
case "make_order":
{
OrderRequestResponse orderRequest = JsonConvert.DeserializeObject <OrderRequestResponse>(message);
output = await ProcessMakeOrderRequest(orderRequest);
break;
}
case "subscription":
{
WebMessageBase subRequest = JsonConvert.DeserializeObject <WebMessageBase>(message);
output = await ProcessSubscriptionRequest(subRequest, ws);
break;
}
case "unsubscription":
{
WebMessageBase unSubRequest = JsonConvert.DeserializeObject <WebMessageBase>(message);
output = await ProcessUnsubscriptionRequest(unSubRequest, ws);
break;
}
}
return(output);
}
public async Task <ActionResult <GetCustomersResult> > Get(GetCustomerRequest request)
{
return(await _requestDispatcher.Dispatch <GetCustomerRequest, GetCustomersResult>(request));
}
public ActionResult <GetCustomerResponse> Get([FromRoute] GetCustomerRequest request)
{
return(Ok(Mediator.Send(request)));
}
public ResponseBase GetCustomer(GetCustomerRequest request)
{
return(RequestManager.Execute(request));
}
public async Task <ActionResult <GetCustomerResponse> > Get([FromRoute] GetCustomerRequest request) => await _mediator.Send(request);
public ApiResponse <Customer> GetCustomer(GetCustomerRequest request)
{
ApiResponse <Customer> response = SendApiRequest <GetCustomerRequest, Customer>(request);
return(response);
}
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 ResponseModel Get(GetCustomerRequest customerRequest)
{
ICustomer customer = _service.Find(customerRequest.Id);
return(customer.CreateResponse());
}
public async Task <IActionResult> GetCustomer(GetCustomerRequest request)
{
return(Ok(await _mediator.Send <CustomerResponse>(request)));
}
public CustomerResponse Get(GetCustomerRequest request)
{
return(_customerService.Get(request));
}
