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