public ServiceManager(IServiceGateway iServiceGateway, ICommonGateway iCommonGateway, IProductReplaceGateway iProductReplaceGateway, IPolicyGateway iPolicyGateway)
{
_iServiceGateway = iServiceGateway;
_iCommonGateway = iCommonGateway;
_iProductReplaceGateway = iProductReplaceGateway;
_iPolicyGateway = iPolicyGateway;
}
public static IServiceGateway ResolveBestFitClient(string baseUrl, Type requestType)
{
var restricts = requestType.AllAttributes <RestrictAttribute>();
var inSecureAllowed = restricts.All(t => t.HasAccessTo(RequestAttributes.InSecure)) || restricts.All(t => !t.HasAccessTo(RequestAttributes.Secure));
if (!inSecureAllowed && baseUrl.StartsWith("http", StringComparison.InvariantCultureIgnoreCase))
{
baseUrl = baseUrl.Insert(4, "s"); //tack in the secure if required and not in base listening url
}
IServiceGateway gateway = null;
if (requestType.HasJsonClientSupport())
{
gateway = new JsonServiceClient(baseUrl);
}
else if (requestType.HasJsvClientSupport())
{
gateway = new JsvServiceClient(baseUrl);
}
else if (requestType.HasXmlClientSupport())
{
gateway = new XmlServiceClient(baseUrl);
}
return(gateway ?? (IServiceGateway) new JsonServiceClient(baseUrl)); //default will be Json if logic doesn't figure it out
}
public OrdersController(IRepository <Order> repos, IServiceGateway <Product> productgateway, IServiceGateway <Customer> customergateway, IMessagePublisher publisher)
{
repository = repos;
productServiceGateway = productgateway;
customerServiceGateway = customergateway;
messagePublisher = publisher;
}
public OrdersController(IRepository <Order> repos,
IServiceGateway <ProductDto> gateway,
IMessagePublisher publisher)
{
repository = repos as IOrderRepository;
productServiceGateway = gateway;
messagePublisher = publisher;
}
public OrdersController(IRepository <SharedOrders> repos,
IServiceGateway <SharedProducts> gateway,
IMessagePublisher publisher)
{
repository = repos;
productGateway = gateway;
messagePublisher = publisher;
}
public static Task SendAsync(this IServiceGateway client, IReturnVoid requestDto, CancellationToken token = default(CancellationToken))
{
var nativeAsync = client as IServiceGatewayAsync;
return(nativeAsync != null
? nativeAsync.SendAsync <byte[]>(requestDto, token)
: Task.Factory.StartNew(() => client.Send <byte[]>(requestDto), token));
}
public static Task <TResponse> SendAsync <TResponse>(this IServiceGateway client, object requestDto, CancellationToken token = default(CancellationToken))
{
var nativeAsync = client as IServiceGatewayAsync;
return(nativeAsync != null
? nativeAsync.SendAsync <TResponse>(requestDto, token)
: Task.Factory.StartNew(() => client.Send <TResponse>(requestDto), token));
}
public static Task <List <TResponse> > SendAllAsync <TResponse>(this IServiceGateway client, IEnumerable <IReturn <TResponse> > requestDtos, CancellationToken token = default(CancellationToken))
{
var nativeAsync = client as IServiceGatewayAsync;
return(nativeAsync != null
? nativeAsync.SendAllAsync <TResponse>(requestDtos, token)
: Task.Factory.StartNew(() => client.SendAll <TResponse>(requestDtos), token));
}
public static Task PublishAllAsync(this IServiceGateway client, IEnumerable <object> requestDtos, CancellationToken token = default(CancellationToken))
{
var nativeAsync = client as IServiceGatewayAsync;
return(nativeAsync != null
? nativeAsync.PublishAllAsync(requestDtos, token)
: Task.Factory.StartNew(() => client.PublishAll(requestDtos), token));
}
public OrdersController(IRepository <Order> repository,
IMessagePublisher publisher,
IServiceGateway <Product> gateway)
{
_repository = repository;
messagePublisher = publisher;
productServiceGateway = gateway;
}
public PaymentWorkerActor(IServiceGateway paymentGateway)
{
_paymentGateway = paymentGateway;
Context.SetReceiveTimeout(TimeSpan.FromSeconds(1));
Ready();
}
public OrdersController(IRepository <Order> repos,
IServiceGateway <ProductDTO> gateway,
IServiceGateway <CustomerDTO> Cgateway,
IMessagePublisher publisher)
{
repository = repos as IOrderRepository;
productServiceGateway = gateway;
customerServicegateway = Cgateway;
messagePublisher = publisher;
}
public static async Task <ApiResult <TResponse> > ApiAsync <TResponse>(this IServiceGateway client, IReturn <TResponse> requestDto, CancellationToken token = default(CancellationToken))
{
try
{
return(ApiResult.Create(await client.SendAsync <TResponse>((object)requestDto, token).ConfigAwait()));
}
catch (Exception e)
{
return(e.ToApiResult <TResponse>());
}
}
public static ApiResult <TResponse> Api <TResponse>(this IServiceGateway client, IReturn <TResponse> request)
{
try
{
return(new ApiResult <TResponse>(client.Send(request)));
}
catch (Exception ex)
{
return(ex.ToApiResult <TResponse>());
}
}
public static ApiResult <List <TResponse> > ApiAll <TResponse>(this IServiceGateway client, IEnumerable <IReturn <TResponse> > request)
{
try
{
return(ApiResult.Create(client.SendAll <TResponse>(request)));
}
catch (Exception ex)
{
return(ex.ToApiResult <List <TResponse> >());
}
}
public static ApiResult <EmptyResponse> Api(this IServiceGateway client, IReturnVoid request)
{
try
{
client.Send <byte[]>(request);
return(ApiResult.Create(new EmptyResponse()));
}
catch (Exception ex)
{
return(ex.ToApiResult());
}
}
public static Flow <string, PayResult, NotUsed> ProcessHtmlDownloadFor(
int degreeOfParallelism, IServiceGateway serviceGateway)
{
return(Flow.Create <string>()
.SelectAsync(degreeOfParallelism, doc => serviceGateway.Pay(doc).ContinueWith(tr => {
if (tr.IsFaulted || tr.IsCanceled)
{
return new PayResult("erropr!!!");
}
return tr.Result;
})));
}
public static async Task <ApiResult <TResponse> > ApiAsync <TResponse>(this IServiceGateway client, object requestDto, CancellationToken token = default(CancellationToken))
{
try
{
return(ApiResult.Create(await(client is IServiceGatewayAsync nativeAsync
? nativeAsync.SendAsync <TResponse>(requestDto, token)
: Task.Factory.StartNew(() => client.Send <TResponse>(requestDto), token)).ConfigAwait()));
}
catch (Exception e)
{
return(e.ToApiResult <TResponse>());
}
}
public static async Task <ApiResult <EmptyResponse> > ApiAsync(this IServiceGateway client, IReturnVoid requestDto, CancellationToken token = default(CancellationToken))
{
try
{
await(client is IServiceGatewayAsync nativeAsync
? nativeAsync.SendAsync <byte[]>(requestDto, token)
: Task.Factory.StartNew(() => client.Send <byte[]>(requestDto), token)).ConfigAwait();
return(ApiResult.Create(new EmptyResponse()));
}
catch (Exception e)
{
return(e.ToApiResult());
}
}
void IServiceGatewaySyncApiUsage(IServiceGateway client)
{
UsageNone none = client.Send <UsageNone>(new UsageNone());
UsageReturn @return = client.Send(new UsageReturn());
client.Send(new UsageVoid());
List <UsageReturn> @returnAll = client.SendAll(new[] { new UsageReturn() });
client.Publish(new UsageNone());
client.Publish(new UsageReturn());
client.Publish(new UsageVoid());
client.PublishAll(new[] { new UsageNone() });
client.PublishAll(new[] { new UsageReturn() });
client.PublishAll(new[] { new UsageVoid() });
}
public static Type GetResponseType(this IServiceGateway client, object request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var returnTypeDef = request.GetType().GetTypeWithGenericTypeDefinitionOf(typeof(IReturn <>));
if (returnTypeDef == null)
{
throw new ArgumentException("Late-bound Send<object> can only be called for Request DTO's implementing IReturn<T>");
}
var responseType = returnTypeDef.GetGenericArguments()[0];
return(responseType);
}
public override IServiceGateway GetGateway(Type requestType)
{
var isLocal = HostContext.Metadata.RequestTypes.Contains(requestType);
IServiceGateway gateway = null;
if (isLocal)
{
gateway = (IServiceGateway)base.localGateway;
}
else
{
if (requestTypes.ContainsKey(requestType))
{
string baseUrl = requestTypes[requestType];
return(new JsonServiceClient(baseUrl));
}
}
return(gateway);
}
async Task IServiceGatewayAsyncApiUsage(IServiceGateway client)
{
UsageNone none = await client.SendAsync <UsageNone>(new UsageNone());
UsageNone noneToken = await client.SendAsync <UsageNone>(new UsageNone(), CancellationToken.None);
UsageReturn @return = await client.SendAsync(new UsageReturn());
UsageReturn returnToken = await client.SendAsync(new UsageReturn(), CancellationToken.None);
await client.SendAsync(new UsageVoid());
await client.SendAsync(new UsageVoid(), CancellationToken.None);
List <UsageReturn> returnAll = await client.SendAllAsync(new[] { new UsageReturn() });
List <UsageReturn> returnAllToken = await client.SendAllAsync(new[] { new UsageReturn() }, CancellationToken.None);
await client.PublishAsync(new UsageNone());
await client.PublishAsync(new UsageNone(), CancellationToken.None);
await client.PublishAsync(new UsageReturn());
await client.PublishAsync(new UsageReturn(), CancellationToken.None);
await client.PublishAsync(new UsageVoid());
await client.PublishAsync(new UsageVoid(), CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageNone() });
await client.PublishAllAsync(new[] { new UsageNone() }, CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageReturn() });
await client.PublishAllAsync(new[] { new UsageReturn() }, CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageVoid() });
await client.PublishAllAsync(new[] { new UsageVoid() }, CancellationToken.None);
}
public static Task <object> SendAsync(this IServiceGateway client, Type responseType, object request, CancellationToken token = default(CancellationToken))
{
if (!LateBoundSendAsyncFns.TryGetValue(responseType, out var sendFn))
{
var mi = typeof(ServiceGatewayExtensions).GetStaticMethod("SendObjectAsync");
var genericMi = mi.MakeGenericMethod(responseType);
sendFn = (Func <IServiceGateway, object, CancellationToken, Task <object> >)
genericMi.CreateDelegate(typeof(Func <IServiceGateway, object, CancellationToken, Task <object> >));
Dictionary <Type, Func <IServiceGateway, object, CancellationToken, Task <object> > > snapshot, newCache;
do
{
snapshot = LateBoundSendAsyncFns;
newCache = new Dictionary <Type, Func <IServiceGateway, object, CancellationToken, Task <object> > >(LateBoundSendAsyncFns)
{
[responseType] = sendFn
};
} while (!ReferenceEquals(
Interlocked.CompareExchange(ref LateBoundSendAsyncFns, newCache, snapshot), snapshot));
}
return(sendFn(client, request, token));
}
public static object Send(this IServiceGateway client, Type resposneType, object request)
{
Func <IServiceGateway, object, object> sendFn;
if (!LateBoundSendSyncFns.TryGetValue(resposneType, out sendFn))
{
var mi = typeof(ServiceGatewayExtensions).GetStaticMethod("SendObject");
var genericMi = mi.MakeGenericMethod(resposneType);
sendFn = (Func <IServiceGateway, object, object>)
genericMi.CreateDelegate(typeof(Func <IServiceGateway, object, object>));
Dictionary <Type, Func <IServiceGateway, object, object> > snapshot, newCache;
do
{
snapshot = LateBoundSendSyncFns;
newCache = new Dictionary <Type, Func <IServiceGateway, object, object> >(LateBoundSendSyncFns);
newCache[resposneType] = sendFn;
} while (!ReferenceEquals(
Interlocked.CompareExchange(ref LateBoundSendSyncFns, newCache, snapshot), snapshot));
}
return(sendFn(client, request));
}
public IServiceGateway <GiftCard> GetGiftCardGateway()
{
return(_giftCardServiceGateway ?? (_giftCardServiceGateway = new GiftCardServiceGateway()));
}
public IServiceGateway <Order> GetOrderGateway()
{
return(_orderServiceGateway ?? (_orderServiceGateway = new OrderServiceGateway()));
}
internal static object SendObject <TResponse>(IServiceGateway client, object request)
{
return(client.Send <TResponse>(request));
}
public static TResponse Send <TResponse>(this IServiceGateway client, IReturn <TResponse> request)
{
return(client.Send <TResponse>(request));
}
public AlsoPurchasedController(IServiceGateway<IBooksRegistryService> bookDetailsProvider, IServiceGateway<ISalesService> priceProvider, IServiceGateway<IMarketingService> marketingInfoProvider)
{
_bookDetailsProvider = bookDetailsProvider;
_priceProvider = priceProvider;
_marketingInfoProvider = marketingInfoProvider;
}
public IServiceGateway <Event> GetEventGateway()
{
return(_eventServiceGateway ?? (_eventServiceGateway = new EventServiceGateway()));
}
public BookController(IServiceGateway<ISalesService> salesService, IServiceGateway<IBooksRegistryService> booksRegistryService)
{
_salesService = salesService;
_booksRegistryService = booksRegistryService;
}
public CartController(IBus bus, IServiceGateway<ISalesService> salesService, IServiceGateway<IBooksRegistryService> booksRegistryService)
{
_bus = bus;
_salesService = salesService;
_booksRegistryService = booksRegistryService;
}
