public ClientResponse Request(string endpoint, ClientMethod method = ClientMethod.GET, ByteArrayContent content = null)
{
Task <HttpResponseMessage> httpResponse = null;
switch (method)
{
case ClientMethod.GET:
httpResponse = _httpClient.GetAsync(endpoint);
break;
case ClientMethod.POST:
httpResponse = _httpClient.PostAsync(endpoint, content);
break;
case ClientMethod.PUT:
httpResponse = _httpClient.PutAsync(endpoint, content);
break;
case ClientMethod.DELETE:
httpResponse = _httpClient.DeleteAsync(endpoint);
break;
}
return(new ClientResponse(httpResponse));
}
public void PopulateVM(ClientMethod entityModel, string passphrase)
{
if (entityModel == null)
{
return;
}
Id = entityModel.Id;
IsNewItem = false;
string[] items = Crypto.Decrypt(entityModel.Details, passphrase).Split('|');
ClientId = (Helpers.IsValidGuid(items[1])) ? items[1].ToString() : "";
CardCVV = items[2];
ExpiryYear = items[3];
ExpiryMonth = items[4];
CardName = items[5];
_cardNumberPart3 = items[6];
_cardNumberPart4 = items[7];
_cardNumberPart1 = items[8];
_cardNumberPart2 = items[9];
CardType = items[10];
ClientReferenceCode = items[11];
}
public IActionResult Client(ClientViewModel model)
{
if (ModelState.IsValid)
{
_contextConfig.Database.Migrate();
var decide = _contextConfig.Clients.Count(m=>m.ClientId==model.ClientId);
if (decide == 0)
{
foreach (var client in ClientMethod.GetClients(model))
{
_contextConfig.Clients.Add(client.ToEntity());
}
try
{
_contextConfig.SaveChanges();
ViewData["Error"] = "客户端注册成功";
}
catch (Exception ex)
{
ViewData["Error"] = "客户端注册失败!错误:" + ex.ToString();
}
}
else
{
ViewData["Error"] = "客户端已注册！";
}
}
return View();
}
public IActionResult InsertApi(ApiResourceViewModel model)
{
if (ModelState.IsValid)
{
_contextConfig.Database.Migrate();
var api = _contextConfig.ApiResources.Count(m => m.Name == model.Name);
if (api == 0)
{
foreach (var resource in ClientMethod.GetApiResources(model))
{
_contextConfig.ApiResources.Add(resource.ToEntity());
}
try
{
_contextConfig.SaveChanges();
ViewData["Error"] = "服务端注册成功";
}
catch (Exception ex)
{
ViewData["Error"] = "服务端注册失败!错误:" + ex.ToString();
}
}
else;
{
ViewData["Error"] = "服务已存在！";
}
}
return View();
}
async Task InvokeApiCall(
ClientMethod method,
Func <string, IElasticClient, ValueTask <TResponse> > invoke
)
{
usage.CallUniqueValues.CurrentView = method;
var uniqueValue = uniqueValueSelector?.Invoke(usage.CallUniqueValues) ?? _values[method];
var response = await invoke(uniqueValue, client);
dict.Add(method, response);
onResponse?.Invoke(response, usage.CallUniqueValues);
}
public void GetClientMethodTest()
{
//Arrange
Worker target = new Worker();
//Act
ClientMethod actual = target.GetClientMethod();
//Assert
Assert.IsNotNull(actual);
Assert.AreSame(typeof(ServiceConcrete1), actual.Service.GetType());
}
public void GetClientMethodTest()
{
//Arrange
Worker target = new Worker();
//Act
ClientMethod actual = target.GetClientMethod();
//Assert
Assert.IsNotNull(actual);
Assert.AreSame(typeof(ServiceConcrete2), actual.Service.GetType(), "Returned type was: " + actual.Service.GetType().ToString());
}
public void MethodTestFluent()
{
//Arrange
ServiceConcrete1 expected = new ServiceConcrete1();
var container = DIHelper.GetContainer();
//Act
ClientMethod actual = container.Resolve <ClientMethod>();
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(expected.GetType(), actual.Service.GetType());
}
public Tuple <ResponseInfo, T> UploadJson <T>(string url, string body, ClientMethod method, Dictionary <string, string> headers = null)
{
Tuple <ResponseInfo, string> response = Upload(url, body, method, headers);
// TODO: Propagate exception instead of using the error JSON
try
{
return(new Tuple <ResponseInfo, T>(response.Item1, JsonConvert.DeserializeObject <T>(response.Item2, JsonSettings)));
}
catch (JsonException)
{
return(new Tuple <ResponseInfo, T>(response.Item1, JsonConvert.DeserializeObject <T>(ClientConstants.UnknownErrorJson, JsonSettings)));
}
}
public Tuple <ResponseInfo, byte[]> UploadRaw(string url, string body, ClientMethod method, Dictionary <string, string> headers = null)
{
if (headers != null)
{
AddHeaders(headers);
}
using (HttpRequestMessage message = new HttpRequestMessage(new HttpMethod(method.ToString().ToUpper()), url))
{
message.Content = new StringContent(body, Encoding, ContentType);
using (HttpResponseMessage response = Task.Run(() => client.SendAsync(message)).Result)
{
return(new Tuple <ResponseInfo, byte[]>(new ResponseInfo
{
StatusCode = response.StatusCode,
Headers = ConvertHeaders(response.Headers)
}, Task.Run(() => response.Content.ReadAsByteArrayAsync()).Result));
}
}
}
public Tuple <ResponseInfo, string> Upload(string url, string body, ClientMethod method, Dictionary <string, string> headers = null)
{
Tuple <ResponseInfo, byte[]> data = UploadRaw(url, body, method, headers);
return(new Tuple <ResponseInfo, string>(data.Item1, data.Item2.Length > 0 ? Encoding.GetString(data.Item2) : ClientConstants.EmptyJson));
}
private async Task CallAsync(IElasticClient client, IDictionary <ClientMethod, IResponse> dict, ClientMethod method,
Func <string, Task <TResponse> > call
)
{
CallUniqueValues.CurrentView = method;
OnBeforeCall?.Invoke(client);
dict.Add(method, await call(CallUniqueValues.Value));
OnAfterCall?.Invoke(client);
}
public override bool IsElementUpdatable(ClientMethod <ISingleDataProvider <string, string>, string, string> .Element element)
{
return((element as ElementStub).Updatable);
}
public override bool IsElementSucceeded(ClientMethod <ISingleDataProvider <string, string>, string, string> .Element element)
{
return((element as ElementStub).Succeeded);
}
public async Task <Tuple <ResponseInfo, string> > UploadAsync(string url, string body, ClientMethod method, Dictionary <string, string> headers = null)
{
Tuple <ResponseInfo, byte[]> data = await UploadRawAsync(url, body, method, headers).ConfigureAwait(false);
return(new Tuple <ResponseInfo, string>(data.Item1, data.Item2.Length > 0 ? Encoding.GetString(data.Item2) : ClientConstants.EmptyJson));
}
private void WriteClientMethod(CodeWriter writer, ClientMethod clientMethod, bool async)
{
CSharpType?bodyType = clientMethod.RestClientMethod.ReturnType;
CSharpType responseType = bodyType != null ?
new CSharpType(typeof(Response <>), bodyType) :
typeof(Response);
responseType = async ? new CSharpType(typeof(Task <>), responseType) : responseType;
var parameters = clientMethod.RestClientMethod.Parameters;
writer.WriteXmlDocumentationSummary(clientMethod.Description);
foreach (Parameter parameter in parameters)
{
writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description);
}
writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use.");
var methodName = CreateMethodName(clientMethod.Name, async);
var asyncText = async ? "async" : string.Empty;
writer.Append($"public virtual {asyncText} {responseType} {methodName}(");
foreach (Parameter parameter in parameters)
{
writer.WriteParameter(parameter);
}
writer.Line($"{typeof(CancellationToken)} cancellationToken = default)");
using (writer.Scope())
{
WriteDiagnosticScope(writer, clientMethod.Diagnostics, writer =>
{
writer.Append($"return (");
if (async)
{
writer.Append($"await ");
}
writer.Append($"RestClient.{CreateMethodName(clientMethod.RestClientMethod.Name, async)}(");
foreach (var parameter in clientMethod.RestClientMethod.Parameters)
{
writer.Append($"{parameter.Name:I}, ");
}
writer.Append($"cancellationToken)");
if (async)
{
writer.Append($".ConfigureAwait(false)");
}
writer.Append($")");
if (bodyType == null && clientMethod.RestClientMethod.HeaderModel != null)
{
writer.Append($".GetRawResponse()");
}
writer.Line($";");
});
}
writer.Line();
}
public static async Task <HttpResponseMessage> DoRequest(string pRequest, string pBody, ClientMethod pClientMethod)
{
try
{
ReadConfig();
HttpClientHandler _httpClientH = new HttpClientHandler();
if (UseDefCreds)
{
_httpClientH.Credentials = CredentialCache.DefaultCredentials;
}
else if (Domain == "")
{
_httpClientH.Credentials = new NetworkCredential(userName, Password);
}
else
{
_httpClientH.Credentials = new NetworkCredential(userName, Password, Domain);
}
using (HttpClient _httpClient = new HttpClient(_httpClientH))
{
switch (pClientMethod)
{
case ClientMethod.GET:
return(await _httpClient.GetAsync(pRequest));
case ClientMethod.POST:
return(await _httpClient.PostAsync(pRequest, new StringContent(pBody, Encoding.UTF8, "application/json")));
case ClientMethod.PATCH:
var _request = new HttpRequestMessage(new HttpMethod("PATCH"), pRequest);
_request.Content = new StringContent(pBody, Encoding.UTF8, "application/json-patch+json");
return(await _httpClient.SendAsync(_request));
default:
return(null);
}
}
}
catch (Exception ex)
{
//addexeptionx(ex);
return(null);
}
}
