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); } }