private void GetClientEndpoint()
{
var clientFactory = new ClientFactory();
var clientConfig = new ClientConfiguration();
clientConfig.MaxSessions = 10;
client = clientFactory.MakeNew(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3000), clientConfig);
}
public void DelegatingHandlersAreCloned()
{
string userAccount = "*****@*****.**";
Guid subscriptionId = Guid.NewGuid();
AzureContext context = new AzureContext
(
new AzureSubscription()
{
Account = userAccount,
Environment = "AzureCloud",
Id = subscriptionId,
Properties = new Dictionary<AzureSubscription.Property, string>() { { AzureSubscription.Property.Tenants, "common" } }
},
new AzureAccount()
{
Id = userAccount,
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>() { { AzureAccount.Property.Tenants, "common" } }
},
AzureEnvironment.PublicEnvironments["AzureCloud"]
);
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(userAccount, Guid.NewGuid().ToString());
var mockHandler = new MockDelegatingHandler();
var factory = new ClientFactory();
factory.AddHandler(mockHandler);
var client = factory.CreateClient<StorageManagementClient>(context, AzureEnvironment.Endpoint.ServiceManagement);
client = factory.CreateClient<StorageManagementClient>(context, AzureEnvironment.Endpoint.ServiceManagement);
client = factory.CreateClient<StorageManagementClient>(context, AzureEnvironment.Endpoint.ServiceManagement);
client = factory.CreateClient<StorageManagementClient>(context, AzureEnvironment.Endpoint.ServiceManagement);
client = factory.CreateClient<StorageManagementClient>(context, AzureEnvironment.Endpoint.ServiceManagement);
Assert.Equal(5, MockDelegatingHandler.cloneCount);
}
public void VerifyUserAgentValuesAreTransmitted()
{
var storedClientFactory = AzureSession.ClientFactory;
var storedAuthFactory = AzureSession.AuthenticationFactory;
try
{
var authFactory = new AuthenticationFactory();
authFactory.TokenProvider = new MockAccessTokenProvider(Guid.NewGuid().ToString(), "*****@*****.**");
AzureSession.AuthenticationFactory = authFactory;
var factory = new ClientFactory();
AzureSession.ClientFactory = factory;
factory.UserAgents.Clear();
factory.AddUserAgent("agent1");
factory.AddUserAgent("agent1", "1.0.0");
factory.AddUserAgent("agent1", "1.0.0");
factory.AddUserAgent("agent1", "1.9.8");
factory.AddUserAgent("agent2");
Assert.Equal(4, factory.UserAgents.Count);
var client = factory.CreateClient<NullClient>(new AzureContext(
new AzureSubscription
{
Id = Guid.NewGuid(),
Properties = new Dictionary<AzureSubscription.Property, string>
{
{AzureSubscription.Property.Tenants, "123"}
}
},
new AzureAccount
{
Id = "*****@*****.**",
Type = AzureAccount.AccountType.User,
Properties = new Dictionary<AzureAccount.Property, string>
{
{AzureAccount.Property.Tenants, "123"}
}
},
AzureEnvironment.PublicEnvironments["AzureCloud"]
), AzureEnvironment.Endpoint.ResourceManager);
Assert.Equal(5, client.HttpClient.DefaultRequestHeaders.UserAgent.Count);
Assert.True(client.HttpClient.DefaultRequestHeaders.UserAgent.Contains(new ProductInfoHeaderValue("agent1", "")));
Assert.True(client.HttpClient.DefaultRequestHeaders.UserAgent.Contains(new ProductInfoHeaderValue("agent1", "1.0.0")));
Assert.True(client.HttpClient.DefaultRequestHeaders.UserAgent.Contains(new ProductInfoHeaderValue("agent1", "1.9.8")));
Assert.True(client.HttpClient.DefaultRequestHeaders.UserAgent.Contains(new ProductInfoHeaderValue("agent2", "")));
}
finally
{
AzureSession.ClientFactory = storedClientFactory;
AzureSession.AuthenticationFactory = storedAuthFactory;
}
}
static AzureSession()
{
ClientFactory = new ClientFactory();
AuthenticationFactory = new AuthenticationFactory();
CurrentContext = new AzureContext();
CurrentContext.Environment = AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud];
AzureSession.OldProfileFile = "WindowsAzureProfile.xml";
AzureSession.OldProfileFileBackup = "WindowsAzureProfile.xml.bak";
AzureSession.ProfileDirectory = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
Resources.AzureDirectoryName); ;
AzureSession.ProfileFile = "AzureProfile.json";
AzureSession.TokenCacheFile = "TokenCache.dat";
}
static AzureSession()
{
ClientFactory = new ClientFactory();
AuthenticationFactory = new AuthenticationFactory();
DataStore = new MemoryDataStore();
TokenCache = new TokenCache();
OldProfileFile = "WindowsAzureProfile.xml";
OldProfileFileBackup = "WindowsAzureProfile.xml.bak";
ProfileDirectory = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
Resources.AzureDirectoryName); ;
ProfileFile = "AzureProfile.json";
TokenCacheFile = "TokenCache.dat";
}
public static IMetaService CreateMeta(string ip, int port)
{
try
{
var channel = new ClientFactory<IMetaService>().CreateConnection(String.Format("{0}:{1}", ip, port), "MPExtended/MetaService");
if (!channel.TestConnection())
return null;
return channel;
}
catch (Exception)
{
return null;
}
}
static void Main(string[] args)
{
var r = new ServiceFactory(ServicesConfiguration.LoadFromJson("services.config.json"));
var host1 = r.CreateHost<ServiceA>();
host1.Open();
var host2 = r.CreateHost<ServiceB>();
host2.Open();
var cli1 = new ClientFactory(ClientsConfiguration.LoadFromJson("clients.config.json")).CreateClient<IServiceA>();
Console.WriteLine(cli1.Operation1());
Console.WriteLine("Services are created and listening. Press ENTER to terminate...");
Console.ReadLine();
host1.Close();
host2.Close();
}
public void CreateCollectionTest()
{
var builder = new ClientFactory();
var result1 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Path,
Name = "Client 1",
Path = @"\\test\path1\"
};
var result2 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Http,
Name = "Client 2",
Path = @"\\test\path2\"
};
var result3 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Ftp
};
var instances = builder.CreateCollection(new[] { result1, result2, result3 });
Assert.AreEqual(2, instances.Count());
}
public void CreateCollectionTest()
{
var legacyClientFactory = MockRepository.GenerateStub<ILegacyClientFactory>();
legacyClientFactory.Stub(x => x.Create()).Return(new LegacyClient());
var builder = new ClientFactory { LegacyClientFactory = legacyClientFactory };
var result1 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Path,
Name = "Client 1",
Path = @"\\test\path1\"
};
var result2 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Http,
Name = "Client 2",
Path = @"\\test\path2\"
};
var result3 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Ftp
};
var instances = builder.CreateCollection(new[] { result1, result2, result3 });
Assert.AreEqual(2, instances.Count());
}
public HttpClient CreateHttpClient(string endpoint, ICredentials credentials)
{
return(CreateHttpClient(endpoint, ClientFactory.CreateHttpClientHandler(endpoint, credentials)));
}
protected override async Task OnInitializedAsync()
{
var client = ClientFactory.CreateClient("ServerAPI");
LikeResult = await client.GetFromJsonAsync <LikingDto>($"/api/liking/{Id}");
}
internal static List <ChannelEndpointElement> GetClientConfigurationNames <T>()
{
return(ClientFactory.GetClientConfigurationNames <T>(_configDictionary));
}
public void CreateArgumentNullTest()
{
var builder = new ClientFactory();
builder.Create(null);
}
public async void ShouldReturnAJObjectRepresentingTheTransactionStack()
{
var result = await ExecuteAsync(ClientFactory.GetClient());
Assert.NotNull(result);
}
public void Create_LegacyClientFactoryNull_Test()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "LegacyClient",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNull(instance);
}
public void CreatePathEmptyTest()
{
var builder = new ClientFactory();
builder.Create(new ClientSettings(ClientType.Legacy)
{
Name = "Client 1"
});
}
public async void ShouldReturnAJObject()
{
var result = await ExecuteAsync(ClientFactory.GetClient());
Assert.NotNull(result);
}
public static HttpClient GetHttplClient(string str)
{
HttpClient client = ClientFactory.GetHttplClient(str);
return(client);
}
public CarPaymentsController()
{
_clientFactory = new ClientFactory();
}
public void OneTimeSetup()
{
FleetManagerClient = ClientFactory.CreateTcpFleetManagerClient(new EndpointSettings(IPAddress.Loopback));
}
public async void ShouldDecodeTheBlockRplAsJObject()
{
var result = await ExecuteAsync(ClientFactory.GetClient());
Assert.NotNull(result);
}
public PerformanceChild(Logger logger, int id)
{
client = ClientFactory.Create(logger);
this.id = id;
Tag = "client" + id;
}
public async Task<IActionResult> Post(OrderCreationInputModel2 model)
{
var userId = long.Parse(User.Claims.First(x => x.Type == "sub").Value);
var client = ClientFactory.CreateClient();
var transactionId = Generator.Generate();
var productId = long.Parse(model.ProductId);
var jsonSerializerOptions = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
var productInfoResp = await client.GetAsync($"{Configuration["Product"]}/products/{productId}");
var productInfoContent = await productInfoResp.Content.ReadAsStringAsync();
if (!productInfoResp.IsSuccessStatusCode)
{
Logger.LogError("获取产品信息失败, {message}", productInfoContent);
return StatusCode(500, new ApiErrorResult<ApiError>(new ApiError("ServerError", "获取产品信息失败")));
}
var productInfo = JsonSerializer.Deserialize<ApiResult<ProductViewModel>>(productInfoContent, jsonSerializerOptions).Value;
// 仅适用于演示
var saleTask = client.PostAsync($"{Configuration["Product"]}/transactions",
new StringContent(JsonSerializer.Serialize(new ProductReserveInputModel
{
UserId = userId,
TransactionId = transactionId,
ProductId = productId,
Qty = 1
}), Encoding.UTF8, "application/json"));
var orderTask = client.PostAsync($"{Configuration["Order"]}/transactions",
new StringContent(JsonSerializer.Serialize(new OrderCreationInputModel
{
UserId = userId,
TransactionId = transactionId,
Items = new List<OrderItemCreationInputModel>
{
new OrderItemCreationInputModel
{
ProductId = productId,
Qty = 1,
Price = productInfo.Price,
Image = productInfo.Image,
Name = productInfo.Name
}
}
}), Encoding.UTF8, "application/json"));
var billTask = client.PostAsync($"{Configuration["Payment"]}/transactions",
new StringContent(JsonSerializer.Serialize(new BillCreationInputModel
{
UserId = userId,
TransactionId = transactionId,
Amount = -productInfo.Price
}), Encoding.UTF8, "application/json"));
Task.WaitAll(saleTask, orderTask, billTask);
var saleResult = await saleTask.Result.Content.ReadAsStringAsync();
var orderResult = await orderTask.Result.Content.ReadAsStringAsync();
var billResult = await billTask.Result.Content.ReadAsStringAsync();
Logger.LogInformation("产品系统返回结果: {code} {json}", saleTask.Result.StatusCode, saleResult);
Logger.LogInformation("订单系统返回结果: {code} {json}", orderTask.Result.StatusCode, orderResult);
Logger.LogInformation("账单系统返回结果: {code} {json}", billTask.Result.StatusCode, billResult);
if (!saleTask.Result.IsSuccessStatusCode)
{
var apiResult = JsonSerializer.Deserialize<ApiErrorResult<ApiError>>(saleResult, jsonSerializerOptions);
if (apiResult.Error.Code.Equals("OutOfStock", StringComparison.OrdinalIgnoreCase))
{
return BadRequest(apiResult); // 等待系统自动撤销账单
}
throw new NotImplementedException();
}
if (!billTask.Result.IsSuccessStatusCode)
{
var apiResult = JsonSerializer.Deserialize<ApiErrorResult<ApiError>>(billResult, jsonSerializerOptions);
if (apiResult.Error.Code.Equals("InsufficientBalance", StringComparison.OrdinalIgnoreCase))
{
return BadRequest(apiResult);
}
throw new NotImplementedException();
}
var saleInfo = JsonSerializer.Deserialize<TransactionObjectCreatedOutputModel<long>>(saleResult, jsonSerializerOptions);
var orderInfo = JsonSerializer.Deserialize<TransactionObjectCreatedOutputModel<long>>(orderResult, jsonSerializerOptions);
var billInfo = JsonSerializer.Deserialize<TransactionObjectCreatedOutputModel<long>>(billResult, jsonSerializerOptions);
var links = new List<Link>
{
new Link
{
Uri = saleInfo.Location,
Expires = saleInfo.Expires
},
new Link
{
Uri = billInfo.Location,
Expires = billInfo.Expires
},
new Link
{
Uri = orderInfo.Location,
Expires = orderInfo.Expires
}
};
var resp = await client.PutAsync($"{Configuration["Coordinator"]}/coordinator/confirm",
new StringContent(JsonSerializer.Serialize(new CoordinatorViewModel
{
Links = links
}), Encoding.UTF8, "application/json"));
Logger.LogInformation("协调器返回结果: {code}", resp.StatusCode);
return StatusCode(201);
}
public RequestController(ClientFactory clientFactory)
{
_factory = clientFactory;
}
public static INotifySubscriberContract CreateClient(string serviceName)
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <NotifySubscriberClient, INotifySubscriberContract>(serviceName));
}
/// <summary>
/// Initialisiert eine neue Instanz der Server-Klasse unter verwendung des angegebenen Ports.
/// </summary>
/// <param name="port">Der zu verwendene Port.</param>
public Server(int port)
{
this.Port = port;
ClientFactory = new ClientFactory();
this.AcceptNew = true;
}
public static INotifySubscriberContract CreateClient(Uri serviceUri, ServicePartitionKey servicePartitionKey)
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <NotifySubscriberClient, INotifySubscriberContract>(serviceUri, servicePartitionKey));
}
public PartnersController()
{
_clientFactory = new ClientFactory();
}
public async void ShouldReturnStacksAsString()
{
var result = await ExecuteAsync(ClientFactory.GetClient());
Assert.NotNull(result);
}
public void CreateTest()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "Client{ 1",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNotNull(instance);
Assert.AreEqual("Client 1", instance.Settings.Name);
}
public async void Test()
{
/*
* contract Hashes{
*
* function sha3Test(string _myvalue) returns (bytes32 val){
* return sha3(_myvalue);
* }
*
* bytes32 public myHash;
*
* function storeMyHash(bytes32 _myHash){
* myHash = _myHash;
* }
* }
*/
var text = "code monkeys are great";
var hash = "0x1c21348936d43dc62d853ff6238cff94e361f8dcee9fde6fd5fbfed9ff663150";
var web3 = new Web3(ClientFactory.GetClient());
var sha3Hello = web3.Sha3(text);
Assert.Equal(hash, "0x" + sha3Hello);
var contractByteCode =
"0x6060604052610154806100126000396000f360606040526000357c0100000000000000000000000000000000000000000000000000000000900480632bb49eb71461004f5780637c886096146100bd578063b6f61649146100d55761004d565b005b6100a36004808035906020019082018035906020019191908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509090919050506100fc565b604051808260001916815260200191505060405180910390f35b6100d3600480803590602001909190505061013d565b005b6100e2600480505061014b565b604051808260001916815260200191505060405180910390f35b600081604051808280519060200190808383829060006004602084601f0104600f02600301f15090500191505060405180910390209050610138565b919050565b806000600050819055505b50565b6000600050548156";
var abi =
@"[{""constant"":false,""inputs"":[{""name"":""_myvalue"",""type"":""string""}],""name"":""sha3Test"",""outputs"":[{""name"":""val"",""type"":""bytes32""}],""type"":""function""},{""constant"":false,""inputs"":[{""name"":""_myHash"",""type"":""bytes32""}],""name"":""storeMyHash"",""outputs"":[],""type"":""function""},{""constant"":true,""inputs"":[],""name"":""myHash"",""outputs"":[{""name"":"""",""type"":""bytes32""}],""type"":""function""}]";
var gethTester = GethTesterFactory.GetLocal(web3);
var receipt = await gethTester.DeployTestContractLocal(contractByteCode);
//"0x350b79547251fdb18b64ec17cf3783e7d854bd30" (prev deployed contract)
var contract = web3.Eth.GetContract(abi, receipt.ContractAddress);
var sha3Function = contract.GetFunction("sha3Test");
var result = await sha3Function.CallAsync <byte[]>(text);
Assert.Equal(hash, "0x" + result.ToHex());
var storeMyHash = contract.GetFunction("storeMyHash");
await gethTester.StartMining();
await gethTester.UnlockAccount();
var txn = await storeMyHash.SendTransactionAsync(gethTester.Account, hash.HexToByteArray());
await gethTester.GetTransactionReceipt(txn);
await gethTester.StopMining();
var myHashFuction = contract.GetFunction("myHash");
result = await myHashFuction.CallAsync <byte[]>();
Assert.Equal(hash, "0x" + result.ToHex());
}
public void CreateCollectionArgumentNullTest()
{
var builder = new ClientFactory();
builder.CreateCollection((null));
}
public static IModelUpdateCommandEnqueuerContract CreateClient()
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <ModelUpdateCommandEnqueuerClient, IModelUpdateCommandEnqueuerContract>(microserviceName));
}
public void CreateNameEmptyTest()
{
var builder = new ClientFactory();
builder.Create(new ClientSettings(ClientType.Legacy));
}
public void CreateArgumentNullTest()
{
var builder = new ClientFactory();
Assert.Throws<ArgumentNullException>(() => builder.Create(null));
}
public static bool SetClientEndpointAddress(string clientEndpointName, string address)
{
return(ClientFactory.SetClientEndpointAddress(_configDictionary, clientEndpointName, address));
}
public void CreateNameFailedCleanupTest()
{
var builder = new ClientFactory();
var invalidChars = System.IO.Path.GetInvalidFileNameChars();
Assert.Throws<ArgumentException>(() => builder.Create(new ClientSettings(ClientType.Legacy)
{
Name = " " + invalidChars[0] + invalidChars[1] + " ",
Path = @"\\test\path\"
}));
}
public static Web3.Web3 GetWeb3Managed()
{
return(new Web3.Web3(AccountFactory.GetManagedAccount(), ClientFactory.GetClient()));
}
public void Test()
{
ClientFactory.Verify(f => f.Create(), Times.Exactly(2));
}
public void VerifyProductInfoHeaderValueEquality()
{
ClientFactory factory = new ClientFactory();
factory.AddUserAgent("test1", "123");
factory.AddUserAgent("test2", "123");
factory.AddUserAgent("test1", "123");
factory.AddUserAgent("test1", "456");
factory.AddUserAgent("test3");
factory.AddUserAgent("tesT3");
Assert.Equal(4, factory.UserAgents.Count);
Assert.True(factory.UserAgents.Any(u => u.Product.Name == "test1" && u.Product.Version == "123"));
Assert.True(factory.UserAgents.Any(u => u.Product.Name == "test2" && u.Product.Version == "123"));
Assert.True(factory.UserAgents.Any(u => u.Product.Name == "test1" && u.Product.Version == "456"));
Assert.True(factory.UserAgents.Any(u => u.Product.Name == "test3" && u.Product.Version == null));
}
protected RPCRequestTester()
{
Settings = new TestSettings();
Client = ClientFactory.GetClient(Settings);
StreamingClient = ClientFactory.GetStreamingClient(Settings);
}
public async void ShouldRetrieveBlockNumberBiggerThanZero()
{
var blockNumber = await ExecuteAsync(ClientFactory.GetClient());
Assert.True(blockNumber.Value > 0);
}
public async Task <WriteResponse> UpsertAsync <T>(T item, [CallerMemberName] string callerName = "", [CallerFilePath] string path = "", [CallerLineNumber] int lineNumber = 0) where T : IViewModel
{
var container = await ClientFactory.GetContainerAsync(Settings).ConfigureAwait(false);
return(await UpsertAsync(container, item, callerName, path, lineNumber).ConfigureAwait(false));
}
public void Create_FahClientFactoryNull_Test()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.FahClient)
{
Name = "FahClient",
Server = "192.168.100.200"
};
var instance = builder.Create(settings);
Assert.IsNull(instance);
}
public MyProject(ClientFactory factory)
{
_factory = factory;
}
public static IModelUpdateCommandEnqueuerContract CreateClient(Uri serviceUri, ServicePartitionKey servicePartitionKey)
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <ModelUpdateCommandEnqueuerClient, IModelUpdateCommandEnqueuerContract>(serviceUri, servicePartitionKey));
}
public void Test()
{
ClientFactory.Verify(f => f.Create(), Times.Once());
}
public void CreatePathEmptyTest()
{
var builder = new ClientFactory();
Assert.Throws<ArgumentException>(() => builder.Create(new ClientSettings(ClientType.Legacy) { Name = "Client 1" }));
}
public static IOutageAccessContract CreateClient()
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <OutageAccessClient, IOutageAccessContract>(microserviceName));
}
public void CreateTest()
{
var legacyClientFactory = MockRepository.GenerateStub<ILegacyClientFactory>();
legacyClientFactory.Stub(x => x.Create()).Return(new LegacyClient());
var builder = new ClientFactory { LegacyClientFactory = legacyClientFactory };
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "Client{ 1",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNotNull(instance);
Assert.AreEqual("Client 1", instance.Settings.Name);
}
public static IOutageAccessContract CreateClient(Uri serviceUri, ServicePartitionKey servicePartitionKey)
{
ClientFactory factory = new ClientFactory();
return(factory.CreateClient <OutageAccessClient, IOutageAccessContract>(serviceUri, servicePartitionKey));
}
private String RequestAccessThroughPrivateUSS(string token, string client, string ip, CancellationTokenSource cancelToken)
{
IPrivateUserSessionService channel = null;
try
{
var factory = new ClientFactory<IPrivateUserSessionService>();
channel = factory.CreateLocalTcpConnection(9751, "MPExtended/UserSessionServicePrivate");
// request access
bool result = channel.RequestAccess(token, client, ip, Configuration.Authentication.Users.Select(x => x.Username).ToList());
String selectedUser = null;
if (result)
{
while (!cancelToken.IsCancellationRequested)
{
WebAccessRequestResponse response = channel.GetAccessRequestStatus(token);
if (response.UserHasResponded)
{
selectedUser = response.IsAllowed ? response.Username : null;
break;
}
Thread.Sleep(500);
}
}
if (cancelToken.IsCancellationRequested)
{
channel.CancelAccessRequest(token);
}
// close channel
(channel as ICommunicationObject).Close();
return selectedUser;
}
catch (Exception ex)
{
Log.Error(String.Format("Failed to request access for client {0} at {1} through USS", client, ip), ex);
return ERROR;
}
}
public async Task <T> ExecuteAsync <T>(IUnionPayRequest <T> request) where T : UnionPayResponse
{
var version = string.Empty;
if (!string.IsNullOrEmpty(request.GetApiVersion()))
{
version = request.GetApiVersion();
}
else
{
version = Options.Version;
}
var merId = Options.MerId;
if (Options.TestMode && (request is UnionPayForm05_7_FileTransferRequest || request is UnionPayForm_6_6_FileTransferRequest))
{
merId = "700000000000001";
}
var txtParams = new UnionPayDictionary(request.GetParameters())
{
{ VERSION, version },
{ ENCODING, Options.Encoding },
{ SIGNMETHOD, Options.SignMethod },
{ ACCESSTYPE, Options.AccessType },
{ MERID, merId },
};
if (request.HasEncryptCertId())
{
txtParams.Add(ENCRYPTCERTID, Options.EncryptCertificate.certId);
}
UnionPaySignature.Sign(txtParams, Options.SignCertificate.certId, Options.SignCertificate.key, Options.SecureKey);
var query = UnionPayUtility.BuildQuery(txtParams);
Logger?.LogTrace(0, "Request:{query}", query);
using (var client = ClientFactory.CreateClient(UnionPayOptions.DefaultClientName))
{
var body = await HttpClientUtility.DoPostAsync(client, request.GetRequestUrl(Options.TestMode), query);
Logger?.LogTrace(1, "Response:{content}", body);
var dic = ParseQueryString(body);
if (string.IsNullOrEmpty(body))
{
throw new Exception("sign check fail: Body is Empty!");
}
var ifValidateCNName = !Options.TestMode;
if (!UnionPaySignature.Validate(dic, Options.RootCertificate.cert, Options.MiddleCertificate.cert, Options.SecureKey, ifValidateCNName))
{
throw new Exception("sign check fail: check Sign and Data Fail!");
}
var parser = new UnionPayDictionaryParser <T>();
var rsp = parser.Parse(dic);
rsp.Body = body;
return(rsp);
}
}
