public async Task <IActionResult> DeleteUser(DeleteUserViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
HttpParameters httpParameters = HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.DeleteUser),
HttpMethod.Delete,
string.Empty,
authorization
);
DeleteUserResponse deleteUserResult = await _gWService.PostTo <DeleteUserResponse>(httpParameters);
if (deleteUserResult.StatusCode == 404)
{
return(await ResponseService.GetResponse <NotFoundObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
else if (deleteUserResult.StatusCode == 422)
{
return(await ResponseService.GetResponse <UnprocessableEntityObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
else if (deleteUserResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
return(new OkObjectResult(deleteUserResult));
}
public async Task <IActionResult> GetAllPatientJournals([FromBody] GetAllPatientJournalslWithCapViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HttpParameters httpParameters =
HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.GetAllPatientJournals),
HttpMethod.Post,
string.Empty,
authorization);
GetAllPatientJournalsResponse getPatientJournalsResult =
await _gWService.PostTo <GetAllPatientJournalsResponse>(httpParameters);
if (getPatientJournalsResult.StatusCode == 422)
{
return(await ResponseService
.GetResponse <UnprocessableEntityObjectResult, GetAllPatientJournalsResponse>(getPatientJournalsResult, ModelState));
}
return(new OkObjectResult(getPatientJournalsResult));
}
static void HttpSoapSample()
{
//获取配置参数
string[] p = new string[] { (string)InterfaceParameter.Instance.GetGlobalParameters()["POS"], string.Empty,
System.DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd") };
//创建Soap实体对象并添加参数
SoapParameter soap = new SoapParameter();
StringBuilder sb = new StringBuilder();
//添加根节点
soap.RootNode = "soapenv";
soap.RootDefaultNameSpace = "xmlns:ws=\"http://ws.nip.com\"";
soap.SoapAction = "";
//添加函数API
soap.MethodNode = "ws:shopSystemInspectData";
soap.MethodDefaultNameSpace = "soapenv:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"";
//添加参数
sb.AppendFormat("<shopcode xsi:type=\"xsd:string\">{0}</shopcode>", p[1]);
sb.AppendFormat("<idate xsi:type=\"xsd:string\">{0}</idate>", p[2]);
//返回Soap信息
soap.MethodParameterValue = sb.ToString();
//创建请求对象
HttpParameters query = InterfaceHttpConfig.Setting(p[0], soap.ToString(), DataFormatter.SOAP);
//调用接口获取返回信息；
HttpParameters http = (HttpParameters)query;
XmlDocument doc = InterfaceHttpRequest.QueryXml(http);
}
private static string ToPost(HttpParameters http)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(http.Url);
request.Timeout = 10 * 60 * 1000;
request.Method = WebRequestMethods.Http.Post;
request.ContentType = http.ContentType;
request.Headers.Add("soapAction", http.soapAction);
request.Credentials = http.Authorization;
request.Accept = http.ContentType;
byte[] data = Encoding.UTF8.GetBytes(http.ParameterValue);
request.ContentLength = data.Length;
using (Stream stream = request.GetRequestStream())
{
stream.Write(data, 0, data.Length);
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
_isConnec = true;
return(reader.ReadToEnd());
}
}
}
public async Task <IActionResult> GetPatientJournalById(Guid id, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id == Guid.Empty)
{
return(BadRequest("id can not be empty"));
}
HttpParameters httpParameters =
HttpParametersService.GetHttpParameters(
null,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.GetPatientJournalById),
HttpMethod.Get,
id.ToString(),
authorization
);
GetPatientJournalResponse patientJournalResult = await _gWService.Get <GetPatientJournalResponse>(httpParameters);
if (patientJournalResult.StatusCode == 400)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, GetPatientJournalResponse>(patientJournalResult, ModelState));
}
else if (patientJournalResult.StatusCode == 404)
{
return(await ResponseService.GetResponse <NotFoundObjectResult, GetPatientJournalResponse>(patientJournalResult, ModelState));
}
return(new OkObjectResult(patientJournalResult));
}
public void GetQueryStringParameterWithIntValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
int value = httpParameters.GetValue <int>("key1");
Assert.AreEqual(2, value);
}
public async Task <IActionResult> GetPatientJournalById([FromQuery] Guid id, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id == Guid.Empty)
{
return(new JsonResult(new { error = "error" }));
}
HttpParameters httpParameters =
HttpParametersService.GetHttpParameters(
null,
ConfigHelper.AppSetting(AerendeConstants.ServerUrls, AerendeConstants.GetPatientJournalById),
HttpMethod.Get,
id.ToString(),
authorization
);
GetPatientJournalResponse patientJournalResponse = await _aerendeService.Get <GetPatientJournalResponse>(httpParameters);
return(new JsonResult(patientJournalResponse));
}
public static string Query(HttpParameters http)
{
string result = string.Empty;
try
{
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
switch (http.Method)
{
case RequestMethod.Get:
result = ToGet(http);
break;
case RequestMethod.Post:
result = ToPost(http);
break;
default:
break;
}
}
catch (WebException wex)
{
_isConnec = false;
if (result.Length == 0)
{
result = wex.Message;
}
}
return(result);
}
// POST api/gateway/login
public async Task <IActionResult> LogIn([FromBody] LogInViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Prepare httpParameters for request
HttpParameters httpParameters =
HttpParametersService.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.Auth),
HttpMethod.Post,
string.Empty);
//httpclient request from class library
JwtResponse authResult = await _gWService.PostTo <JwtResponse>(httpParameters);
if (authResult.StatusCode == 400)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, JwtResponse>(authResult, ModelState));
}
//return jwt token
return(new OkObjectResult(authResult));
}
// POST api/gateway/signup
public async Task <IActionResult> SignUp([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
BadRequest(ModelState);
}
//Prepare httpParameters for request
HttpParameters httParameters =
HttpParametersService.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.SignUp),
HttpMethod.Post,
string.Empty
);
SignUpResponse signUpResult = await _gWService.PostTo <SignUpResponse>(httParameters);
if (signUpResult.StatusCode == 422)
{
return(await ResponseService.GetResponse <UnprocessableEntityObjectResult, SignUpResponse>(signUpResult, ModelState));
}
else if (signUpResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, SignUpResponse>(signUpResult, ModelState));
}
return(new OkObjectResult(signUpResult));
}
public static HttpParameters Setting(string url, string request, DataFormatter formatter)
{
HttpParameters parameter = new HttpParameters();
parameter.Url = url;
switch (formatter)
{
case DataFormatter.SOAP:
parameter.ContentType = ContentType.Soap;
parameter.ParameterValue = request;
break;
case DataFormatter.OData:
parameter.ContentType = ContentType.Soap;
parameter.ParameterValue = request;
break;
case DataFormatter.XML:
parameter.ContentType = ContentType.Xml;
parameter.ParameterValue = request;
break;
case DataFormatter.JSON:
parameter.ContentType = ContentType.Json;
parameter.ParameterValue = request;
break;
default:
break;
}
return(parameter);
}
public void GetFormEnumParameterWithEnumValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
PropertyType value = httpParameters.GetValue <PropertyType>("formkey3");
Assert.AreEqual(PropertyType.SingleFamilyHome, value);
}
public async Task <IActionResult> GetUserRoles(string id, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
BadRequest(id);
}
HttpParameters httpParameters = HttpParametersService
.GetHttpParameters(
null,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.GetUserRoles),
HttpMethod.Get,
id,
authorization
);
GetUserRolesResponse getUserRolesResult = await _gWService.Get <GetUserRolesResponse>(httpParameters);
if (getUserRolesResult.StatusCode == 404)
{
return(await ResponseService.GetResponse <NotFoundObjectResult, GetUserRolesResponse>(getUserRolesResult, ModelState));
}
else if (getUserRolesResult.StatusCode == 401)
{
return(await ResponseService.GetResponse <UnauthorizedObjectResult, GetUserRolesResponse>(getUserRolesResult, ModelState));
}
else if (getUserRolesResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, GetUserRolesResponse>(getUserRolesResult, ModelState));
}
return(new OkObjectResult(getUserRolesResult));
}
// POST api/gateway/addusertorole
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HttpParameters httParameters =
HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.AddUserToRole),
HttpMethod.Put,
string.Empty,
authorization
);
AddUserToRoleResponse addUserToRoleResult = await _gWService.PostTo <AddUserToRoleResponse>(httParameters);
if (addUserToRoleResult.StatusCode == 401)
{
return(await ResponseService.GetResponse <UnauthorizedObjectResult, AddUserToRoleResponse>(addUserToRoleResult, ModelState));
}
else if (addUserToRoleResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, AddUserToRoleResponse>(addUserToRoleResult, ModelState));
}
return(new OkObjectResult(addUserToRoleResult));
}
public static void getWeather(double Latitude, double Longitude, Action <WeatherResult> callback)
{
var parameters = new HttpParameters();
parameters.Add("APPID", APIKEY);
parameters.Add("lat", Latitude);
parameters.Add("lon", Longitude);
HttpCommunicator.Get(HOST, null, parameters,
(response) => {
JObject js = JObject.Parse(response);
var temp = js["main"]["temp"].ToString();
var weat = js["weather"][0]["main"].ToString();
var obj = new WeatherResult();
obj.tempreture = K2C(float.Parse(temp)).ToString("0.##");
obj.weather = weat;
if (callback != null)
{
callback.Invoke(obj);
}
},
(e, retry) => {
Log.Error("Weather", "ERROR {0} : retry after 3sec", e);
Thread.Sleep(3000);
if (retry != null)
{
retry.Invoke();
}
});
}
public void GetQueryStringParameterWithStringValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
string value = httpParameters.GetValue <string>("key2");
Assert.AreEqual("stuff", value);
}
private IEnumerable <IParameter> GetHttpParameters(HttpMethod method)
{
if (HttpParameters.ContainsKey(method))
{
return(HttpParameters[method]);
}
else
{
return(Enumerable.Empty <IParameter>());
}
}
static void HttpRequestSample()
{
HttpParameters p = new HttpParameters();
p.Url = "http://dmscn-m-dev.carlsberg.asia/Carlsberg/Service.svc/Customer/GetCustomerChain";
p.Method = RequestMethod.Post;
p.ContentType = ContentType.Json;
p.ParameterValue = "";
string result = InterfaceHttpRequest.Query(p);
}
/// <summary>
/// Instantiates and initializes the Ajax, Html, and Url properties.
/// </summary>
public virtual void InitHelpers(ViewContext context)
{
Precondition.Require(context,
() => ViewError.ArgumentNull("context"));
SetContentType(context.Context);
_httpParameters = context.Context.Request.Parameters;
_html = new HtmlHelper(context);
_url = new UrlHelper(context);
_ajax = new AjaxHelper(context);
_validation = new ValidationHelper(context);
}
public async Task<T> PostRequestWithContent<T>(HttpParameters httpParameters)
{
try
{
T result = await HttpService.PostStreamAsyncContent<T>(httpParameters);
return result;
}
catch (CustomApiException ex)
{
throw ex;
}
}
public async Task<T> GetRequest<T>(HttpParameters httpParameters)
{
try
{
var result = await HttpService.GenericHttpGet<T>(httpParameters);
return result;
}
catch (Exception ex)
{
throw ex;
}
}
public static XmlDocument QueryXml(HttpParameters http)
{
string result = Query(http);
XmlDocument doc = new XmlDocument();
if (IsConnec && !string.IsNullOrEmpty(result))
{
doc.LoadXml(result);
}
return(doc);
}
public async Task <T> PostRequestWithQueryString <T>(HttpParameters httpParameters)
{
try
{
T result = await HttpService.PostStreamAsyncQueryString <T>(httpParameters);
return(result);
}
catch (CustomApiException ex)
{
throw ex;
}
}
private static string ToGet(HttpParameters http)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(http.Url + "/?" + http.ParameterValue);
request.Timeout = 10 * 60 * 1000;
request.Method = WebRequestMethods.Http.Get;
request.ContentType = http.ContentType;
request.Headers.Add("soapAction", http.soapAction);
request.Credentials = http.Authorization;
request.Accept = http.ContentType;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
_isConnec = true;
return(reader.ReadToEnd());
}
}
public override string ToString()
{
//don't serialize sensitive data
HttpParameters.Remove("PATH_TRANSLATED");
HttpParameters.Remove("HTTP_COOKIE");
HttpParameters.RemoveWhere(x => x.StartsLike("ALL_"));
HttpParameters.RemoveWhere(x => x.StartsLike("APPL_"));
HttpParameters.RemoveWhere(x => x.StartsLike("ASP.NET"));
HttpParameters.RemoveWhere(x => x.StartsLike("AUTH_"));
HttpParameters.RemoveWhere(x => x.StartsLike("CERT_"));
HttpParameters.RemoveWhere(x => x.StartsLike("LOCAL_ADDR"));
HttpParameters.RemoveWhere(x => x.StartsLike("HTTPS_"));
HttpParameters.RemoveWhere(x => x.StartsLike("INSTANCE_"));
var serializer = new JavaScriptSerializer();
return(serializer.Serialize(this));
}
static void InterfaceRequestSample()
{
int sequence = (int)ServiceName.UserService;
string url = (string)InterfaceParameter.Instance.GetGlobalParameters()["POS"];
string[] p = new string[] { url, string.Empty };
HttpParameters query = InterfaceParameter.Instance.GetHttpParameters(sequence, p);
InterfaceRequest request = new InterfaceRequest();
request.Sequence = sequence;
request.Parameter.Add(query);
InterfaceResult <UserEntity> result = InterfaceHandler.Instance.DownEntities <UserEntity>(request);
if (result.Status == Status.Failed)
{
InterfaceHandler.Instance.Throw();
}
}
public async Task <IActionResult> GetAllUsers([FromHeader] string authorization)
{
HttpParameters httpParameters = HttpParametersService
.GetHttpParameters(
null,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.GetAllUsers),
HttpMethod.Get,
string.Empty,
authorization
);
GetAllUsersResponse getAllRolesResult = await _gWService.Get <GetAllUsersResponse>(httpParameters);
if (getAllRolesResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, GetAllUsersResponse>(getAllRolesResult, ModelState));
}
return(new OkObjectResult(getAllRolesResult));
}
public async Task <IActionResult> GetAllPatientJournals(GetAllPatientJournalslWithCapViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HttpParameters httpParameters =
HttpParametersService.GetHttpParameters(
model,
ConfigHelper.AppSetting(AerendeConstants.ServerUrls, AerendeConstants.PatientJournals),
HttpMethod.Post,
string.Empty,
authorization
);
GetAllPatientJournalsResponse getPatientJournalsResult = await _aerendeService.PostTo <GetAllPatientJournalsResponse>(httpParameters);
return(new JsonResult(getPatientJournalsResult));
}
public string UpdateOutboundCalls(HttpParameters restparameters)
{
string updateResponse = string.Empty;
Press3.DataAccessLayer.SipPhoneRegistration SipPhoneRegister = new DataAccessLayer.SipPhoneRegistration(AppConfig.ConnectionString);
var ds = SipPhoneRegister.UpdateOutboundCalls(restparameters);
helper = new Helper();
if (ds == null)
{
helper.CreateProperty(UDC.Label.MESSAGE, "No data returned from database");
helper.CreateProperty(UDC.Label.SUCCESS, false);
}
else
{
helper.ParseDataSet(ds);
}
JObject updateOutBoundDetails = helper.GetResponse();
Logger.Info("Updating hangup for agent outbound calls" + updateOutBoundDetails.ToString());
if (updateOutBoundDetails.SelectToken("Success").ToString() == "True")
{
// JArray AgentOutBoundDetails = (JArray)outbounddetails.SelectToken("AgentOutboundDetails");
if (updateOutBoundDetails.SelectToken("Message") != null)
{
updateResponse = updateOutBoundDetails.SelectToken("Message").ToString();
}
}
else
{
Logger.Info("No data Returned from database so no agent typ and no callertype un authorised.");
}
return(updateResponse);
}
public JObject UpdateDial(HttpParameters freeswitchparameters)
{
helper = new Helper();
Press3.DataAccessLayer.SipPhoneRegistration SipPhoneRegister = new DataAccessLayer.SipPhoneRegistration(AppConfig.ConnectionString);
var ds = SipPhoneRegister.UpdateDial(freeswitchparameters);
if (ds == null)
{
helper.CreateProperty(UDC.Label.MESSAGE, "No data returned from database");
helper.CreateProperty(UDC.Label.SUCCESS, false);
}
else
{
helper.ParseDataSet(ds);
}
JObject ResponseJobj = helper.GetResponse();
Logger.Info("Response Xml: response:" + ResponseJobj.ToString());
return(ResponseJobj);
}
public void PostCredentials_ApiCallSuccessful_ReturnToken()
{
const string GRANT_TYPE = "grant_type=client_credentials";
var client = new HttpClientService();
var content = new StringContent(GRANT_TYPE);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
var postParam = new HttpParameters
{
BaseUrl = _baseUrl,
AuthorizationHeader = new AuthenticationHeaderValue(
"Basic",
Convert.ToBase64String(
Encoding.ASCII.GetBytes(
string.Format("{0}:{1}", Uri.EscapeDataString(_oauthConsumerKey),
Uri.EscapeDataString(_oauthConsumerSecret))))),
Content = content,
DefaultHeaders = new Dictionary<string, string> { { "Accept-Encoding", "gzip" }, { "Host", "api.twitter.com" } },
ResourceUrl = "oauth2/token"
};
var result = client.Post(postParam);
var token = JsonConvert.DeserializeObject<TwitterAuthorizationToken>(result);
var getParam = new HttpParameters
{
BaseUrl = _baseUrl,
DefaultHeaders = new Dictionary<string, string> { { "Accept-Encoding", "gzip" }, {"Authorization",
string.Format("{0} {1}",
token.TokenType,
token.AccessToken)}},
ResourceUrl = "1.1/search/tweets.json?q=%23freebandnames&since_id=24012619984051000&max_id=250126199840518145&result_type=mixed&count=4"
};
var payloade = client.Get(getParam);
}
/// <summary>
/// Instantiates and initializes the Ajax, Html, and Url properties.
/// </summary>
public virtual void InitHelpers(ViewContext context)
{
Precondition.Require(context,
() => Mvc.Error.ArgumentNull("context"));
SetContentType(context.Context);
_parameters = context.Context.Request.Parameters;
_html = new HtmlHelper(context);
_url = new UrlHelper(context);
_ajax = new AjaxHelper(context);
_validation = new ValidationHelper(context);
}
internal HttpRequest()
{
Parameters = new HttpParameters();
Headers = new Dictionary<string, string>();
}
public void GetQueryStringParameterWithStringValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
string value = httpParameters.GetValue<string>("key2");
Assert.AreEqual("stuff", value);
}
public void GetFormEnumParameterWithEnumValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
PropertyType value = httpParameters.GetValue<PropertyType>("formkey3");
Assert.AreEqual(PropertyType.SingleFamilyHome, value);
}
public void GetQueryStringParameterWithIntValue()
{
IHttpParameters httpParameters = new HttpParameters(_testContext);
int value = httpParameters.GetValue<int>("key1");
Assert.AreEqual(2, value);
}
