public void QueueMessage(IRequestModel model) { var QueueName = _brokerOptions.QueueName; var factory = new ConnectionFactory { HostName = _brokerOptions.HostName, UserName = _brokerOptions.UserName, Password = _brokerOptions.Password, }; using (var connection = factory.CreateConnection()) using (var channel = connection.CreateModel()) { channel.QueueDeclare( queue: QueueName, durable: false, exclusive: false, autoDelete: false, arguments: null); JsonConvert.DefaultSettings = () => new Newtonsoft.Json.JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }; var message = JsonConvert.SerializeObject(model); var body = Encoding.UTF8.GetBytes(message); channel.BasicPublish(exchange: "", routingKey: QueueName, basicProperties: null, body: body); } }
public static CommandMessageFake GetCommandMessageFake(IRequestModel requestModel, IResponseModel responseModel) { return(new CommandMessageFake { RequestData = requestModel.ToBytes(), ResponseData = responseModel.ToBytes() }); }
public HttpResponseMessage DataByZipCode(ZipCodeModel zipCode) { IRequestModel tmp = zipCode; GenerateURL urlobj = new GenerateURL(Endpoints.ByZipCode, tmp.Get()); return(new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }); }
public HttpResponseMessage DataByCoordinates(CoordinatesModel coOrdinates) { IRequestModel tmp = coOrdinates; GenerateURL urlobj = new GenerateURL(Endpoints.ByCoordinates, tmp.Get()); return(new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }); }
public HttpResponseMessage DataByCitiesCycle(CitiesCycleModel citiesCycle) { IRequestModel tmp = citiesCycle; GenerateURL urlobj = new GenerateURL(Endpoints.ByCitiesCycle, tmp.Get()); return(new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }); }
public static async Task <string> RequestGetAsync(IRequestModel model) { var getUrl = RequestFactory.CreateGet(model); var resp = await getUrl.GetAsync(); resp.EnsureSuccessStatusCode(); var resultData = await resp.Content.ReadAsStringAsync(); return(resultData); }
public static async Task <string> RequestPostAsync(IRequestModel model) { var postData = RequestFactory.CreatePost(model); var resp = await $"{AppConsts.Protocol}://{AppConsts.Gateway}".PostUrlEncodedAsync(postData); resp.EnsureSuccessStatusCode(); var resultData = await resp.Content.ReadAsStringAsync(); return(resultData); }
public HttpResponseMessage DataByRectangleZone(RectangelZoneModel rectangleZone) { IRequestModel tmp = rectangleZone; GenerateURL urlobj = new GenerateURL(Endpoints.ByRectangleZone, tmp.Get()); return(new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }); }
public HttpResponseMessage DataByCitiesId(MultipleCitiesModel multipleCitiesId) { IRequestModel tmp = multipleCitiesId; GenerateURL urlobj = new GenerateURL(Endpoints.ByCitiesId, tmp.Get()); return(new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }); }
public static async Task <T> Request <T>(IRequestModel model) { switch (AppConsts.DefaultRequestMethod) { case RequestMethod.GET: return(await RequestGetAsync <T>(model)); case RequestMethod.POST: return(await RequestPostAsync <T>(model)); default: throw new InvalidOperationException("不支持的请求方式"); } }
public static string GetJson(IRequestModel modelo) { KeyValuePair <string, string>[] values = modelo.ToKeyPair(); string json = "{"; for (int index = 0; index < values.Length; index++) { KeyValuePair <string, string> value = values[index]; json += string.Format(FORMAT, value.Key, value.Value); json += (index < values.Length - 1 ? "," : "}"); } return(json); }
public HttpResponseMessage DataByName(CityNameModel cityName) { IRequestModel tmp = cityName; GenerateURL urlobj = new GenerateURL(Endpoints.ByCityName, tmp.Get()); var response = new HttpResponseMessage() { Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL)) }; //string str = response.ToString(); //var yourObject = JsonConvert.DeserializeObject<Weather.Models.Weathers>(str); return(response); }
/// <summary> /// Post /// </summary> /// <param name="dataModel"></param> /// <returns></returns> public static string CreatePost(IRequestModel dataModel) { if (dataModel == null) { throw new ArgumentNullException(nameof(dataModel)); } var originData = $"Action={dataModel.Action}&Nonce={new Random(DateTime.Now.Millisecond).Next(10000, 99999)}&SecretId={AppConsts.SecretId}&SignatureMethod={AppConsts.SignatureMethod.ToString()}&Timestamp={DateTimeOffset.Now.ToUnixTimeSeconds()}"; var data = $"{AppConsts.Gateway}?{originData}"; var serializeData = JsonConvert.SerializeObject(dataModel, new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() }); var json = JObject.Parse(serializeData); var dic = new SortedDictionary <string, string>(); foreach (var item in json) { dic.Add(item.Key, item.Value.Value <string>()); } dic.Remove("action"); StringBuilder sb = new StringBuilder(); foreach (var dicKey in dic.Keys) { sb.Append($"{dicKey}={dic[dicKey]}&"); } serializeData = sb.ToString().TrimEnd(new[] { '&' }); if (!string.IsNullOrEmpty(serializeData)) { data = $"{data}&{serializeData}"; originData = $"{originData}&{serializeData}"; } var encryptData = $"POST{data}"; var signature = AppConsts.SignatureMethod == HmacType.HmacSHA1 ? HmacUtil.EncryptWithSha1(encryptData, AppConsts.SecretKey) : HmacUtil.EncryptWithSha256(encryptData, AppConsts.SecretKey); var resultData = $"{originData}&Signature={WebUtility.UrlEncode(signature)}"; return(resultData); }
public static HttpResponseMessage MakeRequest(HttpMethod method, Uri uri, IRequestModel content = null, CancellationTokenSource cts = null) { try { httpClient = new HttpClient(); HttpRequestMessage request = new HttpRequestMessage(method, uri); if (content != null) { request.Content = new StringContent(content.ToJson(), Encoding.Default, "application/json"); var contentString = request.Content.ReadAsStringAsync(); } if (cts != null) { return(httpClient.SendAsync(request, cts.Token).Result); } else { return(httpClient.SendAsync(request).Result); } } catch (HttpRequestException hre) { throw; } catch (AggregateException ae) { throw; } catch (Exception ex) { reset(); throw; } finally { httpClient = null; } }
/// <summary> /// Execution of CommandHandlers are internally executed through this method /// </summary> /// <param name="requestModel"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <IResponseModel> ExecuteInternalAsync(IRequestModel requestModel, CancellationToken cancellationToken) { return(await ExecuteAsync((TRequest)requestModel, cancellationToken)); }
public void Persistence(IRequestModel model) { var str = Newtonsoft.Json.JsonConvert.SerializeObject(model); _logger.LogInformation($"[RequestCatcher]-{DateTime.Now.ToString()}:{str}"); }
/// <summary> /// Initializes a new instance of the <see cref="BatchPartRequest"/> class. /// </summary> /// <param name="request">inner request.</param> public BatchPartRequest(IRequestModel request) { this.request = request ?? throw new ArgumentNullException(nameof(request)); }
private async Task <ConnectionResponse <PaymentResponse <T> > > PaymentOperation <T>(PaymentOptions PaymentOptions, IRequestModel requestModel, string apiUrl) { var header = new Dictionary <string, string>(); header.Add("api_key", PaymentOptions.ApiKey); header.Add("secret_key", PaymentOptions.SecretKey); var authResponse = await ApiConnection.Instance.Post <PaymentResponse <T> >(PaymentOptions.BaseUrl + apiUrl, requestModel, header, PaymentOptions.UseEncryption, PaymentOptions.EncryptionPassword); var payResponse = new ConnectionResponse <PaymentResponse <T> >(); if (!authResponse.IsSuccess) { payResponse.StatusCode = authResponse.StatusCode; return(payResponse); } payResponse.IsConnectionSuccess = true; payResponse.Result = authResponse.Result; return(payResponse); }
public static async Task <T> RequestPostAsync <T>(IRequestModel model) { var postData = RequestFactory.CreatePost(model); return(await $"{AppConsts.Protocol}://{AppConsts.Gateway}".PostUrlEncodedAsync(postData).ReceiveJson <T>()); }
public BundleContext(IRequestModel bundleRequest, FileInfo bundleCompositeFile) { BundleRequest = bundleRequest; _bundleCompositeFile = bundleCompositeFile; }
public static async Task <T> RequestGetAsync <T>(IRequestModel model) { var getUrl = RequestFactory.CreateGet(model); return(await getUrl.GetJsonAsync <T>()); }
public async Task <IRestResponse> GetNewsAsync(IRequestModel requestModel, string userName = "") { try { string methodName = GenericFactory <RuntimeInfo> .CreateInstance() .GetMethodName(); if (String.IsNullOrEmpty(requestModel.Url)) { throw new CustomException(ExceptionMessages.UrlIsEmpty, methodName); } var client = new RestClient(requestModel.Url); client.Timeout = requestModel.Timeout; var request = new RestRequest(Method.GET); string datefrom = (requestModel.published_after == DateTime.MinValue ? DateTime.Now.AddYears(-20) : requestModel.published_after).ToString("yyyy-MM-dd"); string dateto = (requestModel.published_before == DateTime.MinValue ? DateTime.Now : requestModel.published_before).ToString("yyyy-MM-dd"); if (String.IsNullOrEmpty(requestModel.Token)) { throw new CustomException(ExceptionMessages.TokenIsEmpty, methodName); } request.AddQueryParameter("api_token", requestModel.Token); if (!String.IsNullOrEmpty(requestModel.Categories)) { request.AddQueryParameter("categories", requestModel.Categories); } if (!String.IsNullOrEmpty(requestModel.Search)) { request.AddQueryParameter("search", requestModel.Search); } request.AddQueryParameter("limit", requestModel.Limit.ToString()); if (!String.IsNullOrEmpty(requestModel.language)) { request.AddQueryParameter("language", requestModel.language); } request.AddQueryParameter("published_after", datefrom); request.AddQueryParameter("published_before", dateto); if (!String.IsNullOrEmpty(requestModel.domains)) { request.AddQueryParameter("domains", requestModel.domains); } IRestResponse response = await client.ExecuteAsync(request); if (!String.IsNullOrEmpty(userName)) { if (!String.IsNullOrEmpty(response?.ResponseUri?.OriginalString)) { var dll = GenericFactory <DLL> .CreateInstance("https://newsapp-292a3-default-rtdb.europe-west1.firebasedatabase.app/Users/{node}"); List <string> fav = new List <string>(); var data = dll.GetUserInfo(userName, DbRequestType.History); if (data != null) { fav.AddRange(data); } if (!fav.Contains(response.ResponseUri.OriginalString)) { fav.Add(response.ResponseUri.OriginalString); dll.PutUserData(fav, DbRequestType.History, userName); } } } Debug.WriteLine(response.Content); return(response); } catch (Exception ex) { throw ex; } }
/// <summary> /// /// </summary> /// <param name="actionContext"></param> public override void OnActionExecuting(HttpActionContext actionContext) { ServiceContainer.Resolve <IInitRequestScopeContext>().BeginRequest(actionContext.Request); if (!actionContext.HasMarkerAttribute <NonTracingAttribute>()) { var request = actionContext.Request; IRequestModel <Header> reqModel = null; Header reqHeader = null; if (actionContext.ActionArguments.Count > 0) { foreach (var dic in actionContext.ActionArguments) { //if (dic.Value is RequestModel) //{ // reqModel = dic.Value as RequestModel; // break; //} reqModel = dic.Value as IRequestModel <Header>; if (reqModel != null) { break; } } } if (reqModel == null && actionContext.Request.Content != null && string.Equals(actionContext.Request.Method.Method, "post", StringComparison.CurrentCultureIgnoreCase)) { try { reqModel = actionContext.Request.Content.ReadAsAsync <RequestModel>().Result; } catch { } if (reqModel != null) { actionContext.ActionArguments.Add(Guid.NewGuid().ToString("N"), reqModel); } } if (reqModel != null && reqModel.Header != null) { reqHeader = reqModel.Header; if (string.IsNullOrWhiteSpace(reqHeader.TraceID)) { reqHeader.TraceID = Generate.GenerateId();// Util.GetUniqueCode32(); } if (string.IsNullOrWhiteSpace(reqHeader.RpcID)) { reqHeader.RpcID = "0"; } //HttpContentData.SetTrackID(reqHeader.TraceID); //HttpContentData.SubRpcID = reqHeader.RpcID + ".0"; //var header = HttpContentData.CloneRequestHeader(reqModel.Header); //header.RpcID = header.RpcID + ".0"; } else { reqHeader = TracingContextData.GetDefaultRequestHeader(); //HttpContentData.SetTrackID(reqHeader.TraceID); } TracingContextData.SetSubRpcID(reqHeader.RpcID + ".0"); TracingContextData.SetRequestHeader(reqHeader); //HttpContentData.RequestHeader = reqHeader; //Not To Log if (!actionContext.HasMarkerAttribute <NotToLogAttribute>()) { TraceLogs trace = new TraceLogs(); trace.ContextType = ContextType.Server.ToString(); trace.StartTime = DateTime.Now; trace.MachineAddr = Util.TracingContextHelper.GetServerAddress(); trace.TraceId = reqHeader.TraceID; trace.RpcId = reqHeader.RpcID; trace.Protocol = string.Format("{0}/{1}", actionContext.Request.RequestUri.Scheme, actionContext.Request.Version); trace.Environment = this.environment ?? EnvironmentConfig.Environment; trace.SystemID = this.systemID ?? EnvironmentConfig.SystemID; trace.SystemName = this.systemName ?? EnvironmentConfig.SystemName; //InvokeID trace.InvokeID = request.RequestUri.AbsolutePath; IEnumerable <string> folder; if (actionContext.Request.Headers.TryGetValues(Config.ResponseHeaderFolderKey, out folder)) { trace.ServerHost = actionContext.Request.RequestUri.Host + folder.FirstOrDefault(); } else { trace.ServerHost = actionContext.Request.RequestUri.Host; } //SearchKey var searchKey = reqModel as ISearchKey; if (searchKey != null) { trace.SearchKey = searchKey.GetSearchKey(); } TraceExtensionOnActionExecuting(actionContext, trace); //srs.InvokeID = string.Format("{0}_{1}", actionContext.ControllerContext.ControllerDescriptor.ControllerName.ToLower(), actionContext.ActionDescriptor.ActionName.ToLower()); //if (actionContext.ActionArguments != null && actionContext.ActionArguments.Count > 0) //{ // srs.Extension.Add(Config.ParamsKey, actionContext.ActionArguments); //} //ServerRS Log Data TODO Util.TracingContextHelper.SetContextItem(Config.ServerRSKey, trace); } } base.OnActionExecuting(actionContext); }
/// <summary> /// Serializes requestmodel /// </summary> /// <param name="requestModel">Instance of class implementing IRequestModel</param> /// <returns></returns> public static byte[] ToBytes(this IRequestModel requestModel) { return(GenericSerializer.Serialize(requestModel)); }