private static async Task<RequestResponse> ProcessRequest(EasypayConfig config, string data, HttpMethod httpMethod, string path, string reqId)
{
var contentType = httpMethod.Method == "GET" ? "" : "application/vnd.ch.swisscom.easypay.direct.payment+json";
var url = new Uri("https://" + config.Host + config.Basepath + path);
var now = DateTime.Now;
var date = now.ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss", CultureInfo.GetCultureInfoByIetfLanguageTag("en")) + " +0000"; //Mon, 07 Dec 2015 09:01:30 +0000
var client = new HttpClient();
var request = new HttpRequestMessage(httpMethod, url);
request.Headers.Add("X-SCS-Date", date);
request.Headers.Add("X-Request-Id", reqId);
request.Headers.Add("X-Merchant-Id", config.MerchantId);
request.Headers.Add("X-CE-Client-Specification-Version", "1.1");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.ch.swisscom.easypay.message.list+json"));
request.Headers.Date = now;
var md5Hash = data != null ? Signature.HashData(Encoding.UTF8.GetBytes(data)) : null;
var hashString = Signature.CreateHashString(httpMethod.Method, md5Hash != null ? Convert.ToBase64String(md5Hash) : "", contentType, date, path);
var signature = Signature.Sign(Encoding.UTF8.GetBytes(config.EasypaySecret), Encoding.UTF8.GetBytes(hashString));
request.Headers.Add("X-SCS-Signature", Convert.ToBase64String(signature));
if (data != null)
{
request.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
request.Content = new StringContent(data);
request.Content.Headers.ContentMD5 = md5Hash;
}
var result = await client.SendAsync(request);
var ret = new RequestResponse {Response = await result.Content.ReadAsStringAsync(), StatusCode = result.StatusCode};
return ret;
}
public static FileResponse GetDocument(RequestResponse response)
{
using (var client = new HttpClient())
{
using (var message = client.GetAsync(string.Format("https://developers.isign.io/mobile/sign/status/{0}.json?access_token=" + Api.accessToken, response.Token)))
{
var input = message.Result;
var serializator = new DataContractJsonSerializer(typeof(FileResponse));
return (FileResponse)serializator.ReadObject(input.Content.ReadAsStreamAsync().Result);
}
}
}
public void Get_Called_ReturnsRequestResponse()
{
// Given
var response = new RequestResponse { Item = new Request { Id = 1 } };
_client.Setup(b => b.Get<RequestResponse>(It.IsAny<Uri>())).Returns(response);
var resource = new RequestResource(_client.Object);
// When
var result = resource.Get(321);
// Then
Assert.That(result, Is.EqualTo(response));
}
public void Put_CalledWithRequest_ReturnsRequestReponse()
{
// Given
var response = new RequestResponse { Item = new Request { Subject = "blah blah" } };
var request = new RequestRequest { Item = new Request { Subject = "blah blah", Id = 123 } };
_client.Setup(b => b.Put<RequestResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
var resource = new RequestResource(_client.Object);
// When
var result = resource.Put(request);
// Then
Assert.That(result, Is.EqualTo(response));
}
public override SoapFilterResult ProcessMessage(SoapEnvelope envelope)
{
try
{
var env = XElement.Load(envelope.GetDocumentReader());
RequestResponse.SetIds(env);
using (var rd = env.CreateReader())
{
envelope.Load(rd);
}
}
catch
{
}
return(SoapFilterResult.Continue);
}
public void Delete_Called_CallsDeleteOnClient()
{
// Given
var response = new RequestResponse {
Item = new Request {
Id = 1
}
};
_client.Setup(b => b.Get <RequestResponse>(It.IsAny <Uri>())).Returns(response);
var requestResource = new RequestResource(_client.Object);
// When
requestResource.Delete(321);
// Then
_client.Verify(c => c.Delete(It.IsAny <Uri>()));
}
public async void DeleteAsync_Called_CallsDeleteOnClient()
{
// Given
var response = new RequestResponse {
Item = new Request {
Id = 1
}
};
_client.Setup(b => b.GetAsync <RequestResponse>(It.IsAny <Uri>())).Returns(TaskHelper.CreateTaskFromResult(response));
var requestResource = new RequestResource(_client.Object);
// When
await requestResource.DeleteAsync(321);
// Then
_client.Verify(c => c.DeleteAsync(It.IsAny <Uri>()));
}
public RequestResponse DeleteSingleWorkflowCategorySteps(int id)
{
RequestResponse RequestResponse = new RequestResponse();
try
{
new WorkflowCategoryCRUD().DeleteSingleWorkflowCategoryStep(id);
RequestResponse.Message = "Record deleted";
RequestResponse.Success = true;
}
catch (Exception ex)
{
RequestResponse.Message = ex.Message;
RequestResponse.Success = false;
}
return(RequestResponse);
}
public RequestResponse DeleteSingleDocType(int id)
{
RequestResponse RequestResponse = new RequestResponse();
try
{
new DocTypeCRUD().DeleteSingle(id);
RequestResponse.Message = "Record deleted";
RequestResponse.Success = true;
}
catch (Exception ex)
{
RequestResponse.Message = ex.Message;
RequestResponse.Success = false;
}
return(RequestResponse);
}
public async void GetAsync_Called_ReturnsRequestResponse()
{
// Given
var response = new RequestResponse {
Item = new Request {
Id = 1
}
};
_client.Setup(b => b.GetAsync <RequestResponse>(It.IsAny <Uri>())).Returns(TaskHelper.CreateTaskFromResult(response));
var resource = new RequestResource(_client.Object);
// When
var result = await resource.GetAsync(321);
// Then
Assert.That(result, Is.EqualTo(response));
}
public void Get_Called_ReturnsRequestResponse()
{
// Given
var response = new RequestResponse {
Item = new Request {
Id = 1
}
};
_client.Setup(b => b.Get <RequestResponse>(It.IsAny <Uri>())).Returns(response);
var resource = new RequestResource(_client.Object);
// When
var result = resource.Get(321);
// Then
Assert.That(result, Is.EqualTo(response));
}
public RequestResponse Delete(string id)
{
var response = new RequestResponse();
try
{
ShopDac.DeleteOne(s => s.Id == id);
response.Code = 200;
response.Message = "success.";
}
catch (Exception ex)
{
response.Code = 500;
response.Message = "error: " + ex.Message;
}
return(response);
}
/// <summary>
/// Read a payment cancel request
/// </summary>
/// <param name="reader"></param>
/// <param name="result"></param>
public static void Read(XmlReader reader, RequestResponse result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Text:
result.Response = reader.Value;
break;
}
}
}
public RequestResponse DeleteSingleProject(int id, bool isDelete)
{
RequestResponse RequestResponse = new RequestResponse();
try
{
new ProjectCRUD().DeleteSingle(id, isDelete);
RequestResponse.Message = "Project status updated";
RequestResponse.Success = true;
}
catch (Exception ex)
{
RequestResponse.Message = ex.Message;
RequestResponse.Success = false;
}
return(RequestResponse);
}
protected override RequestResponse <DownloadTokenResult> DeserializeMessage(string responseText)
{
var m = Regex.Match(responseText,
@"""tokens"":{""download""\s*:\s*""(?<token>.*?)""");
var msg = new RequestResponse <DownloadTokenResult>
{
Ok = m.Success,
Result = new DownloadTokenResult
{
body = new DownloadTokenBody {
token = m.Groups["token"].Value
}
}
};
return(msg);
}
/// <summary>
/// Serialize a <see cref="RequestResponse"/>.
/// </summary>
/// <param name="response">Response to serialize</param>
public void SerializeResponse(RequestResponse response)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
this.binaryWriter.Write((uint)RequestType.RequestResponse);
this.binaryWriter.Write((ulong)response.CallId);
this.binaryWriter.Write((int)response.ResultCode);
this.SerializeNullableString(response.ResponsePath);
this.SerializeStat(response.Stat);
this.SerializeContent(response.Content);
}
public async Task <ActionResult <RequestResponse> > ResetPassword([FromBody] PasswordReset passwordReset)
{
try
{
if (passwordReset is null || string.IsNullOrWhiteSpace(passwordReset.Email))
{
return(BadRequest(RequestResponse.BadRequest("Please check your input.")));
}
await firebaseAuthService.SendPasswordResetEmail(passwordReset.Email);
return(Ok(RequestResponse.Success()));
}
catch (Exception)
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong trying to send reset email.")));
}
}
public async Task <ActionResult <ApiResponse <LoginStatus> > > RegisterUser([FromBody] Register register)
{
try
{
if (register is null || string.IsNullOrWhiteSpace(register.Email) || string.IsNullOrWhiteSpace(register.Password))
{
return(BadRequest(RequestResponse.BadRequest("Please check your input.")));
}
var result = await firebaseAuthService.RegisterUser(register);
return(Ok(new ApiResponse <LoginStatus>(result)));
}
catch (Exception)
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong during the registration.")));
}
}
private async Task <bool> Login(Proxy proxy, string username, string password)
{
using (WebSession session = new WebSession(proxy)) {
RequestResponse rr = session.DispatchRequest(new GetRequest("https://www.pornhub.com/login"));
if (!rr.Validate())
{
Debug.WriteLine("Failed to load login page");
return(false);
}
Element tokenEl = rr.GetAsDoc().Select("[name=token]").First();
if (tokenEl is null)
{
Debug.WriteLine("Token not found");
return(false);
}
string token = tokenEl.Val;
FormBody fb = new FormBody();
fb.Add("loginPage", 1);
fb.Add("redirect", "");
fb.Add("token", token);
fb.Add("taste_profile", "");
fb.Add("username", username);
fb.Add("password", password);
fb.Add("remember_me", "on");
rr = session.DispatchRequest(new PostRequest("https://www.pornhub.com/front/authenticate", fb));
if (!rr.Validate())
{
if (rr.ResponseCode == 500)
{
Debug.WriteLine("Blocked connection");
return(false);
}
Debug.WriteLine("Failed to login");
return(false);
}
Debug.WriteLine(rr.GetResponseContent());
return(true);
}
}
private RequestResponse TestData()
{
var requestResponse = new RequestResponse
{
AcceptableResponseTimeMs = 500,
Id = Guid.NewGuid(),
Interval = 10000,
IsActive = true,
Method = HttpMethod.Get.Method,
RequestBody = string.Empty,
ResponseStatus = System.Net.HttpStatusCode.OK,
Url = new Uri("https://www.google.co.uk")
};
requestResponse.AddRequestHeader("Host", "www.google.co.uk");
requestResponse.AddRequestHeader("Accept", "text/html");
return(requestResponse);
}
public RequestResponse PostAllow(RequestResponse r)
{
dynamic v = r.Data;
dynamic d = v.ToObject <List <string> >();
List <string> l = (List <string>)d;
bool b = dtoShop.comparePassword(l[0], Convert.ToInt32(l[1]));
RequestResponse response = new RequestResponse();
response.Result = b;
if (!b)
{
response.Message = "סיסמא לא תקינה";
}
else
{
response.Message = "לא יאומן, אבל הסיסמא תקינה!!!";
}
return(response);
}
public static RequestResponse <List <Product> > GetAllPro(string provider, string connectionString)
{
RequestResponse <List <Product> > response = new RequestResponse <List <Product> >();
try
{
SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
string query = ResourceHelper.GetQuery(ReadResources.Queries, provider, ReadsConstants.GET_ALL_PRODUCT);
SqlCommand cmd = new SqlCommand(query, connection);
cmd.CommandText = cmd.CommandText;
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
response.Result = new List <Product>();
response.Successful = true;
while (reader.Read())
{
Product product = new Product
{
Proide = reader.GetInt64(reader.GetOrdinal("proide")),
Pronom = reader.GetString(reader.GetOrdinal("pronom")),
Propre = reader.GetDecimal(reader.GetOrdinal("propre")),
Profcr = reader.GetDateTime(reader.GetOrdinal("profcr")),
Procan = reader.GetInt32(reader.GetOrdinal("catcan")),
Proref = reader.GetString(reader.GetOrdinal("catref"))
};
response.Result.Add(product);
}
}
else
{
response.Successful = false;
}
}
catch (Exception ex)
{
response.Message = ex.Message;
response.Successful = false;
}
return(response);
}
public async Task <ActionResult <RequestResponse> > MfaAuth([FromBody] VerifyMfa mfaEnable)
{
try
{
if (mfaEnable is null || string.IsNullOrWhiteSpace(mfaEnable.MfaCode))
{
return(BadRequest(RequestResponse.BadRequest("Mfa code is required for verification.")));
}
var userName = User?.Identity?.Name;
var userId = User?.Claims.Where(x => x.Type == CustomClaims.USER_ID).FirstOrDefault()?.Value;
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(userId))
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong trying to validate your request.")));
}
var userProperties = await firebaseDbService.GetUserProperties(userId);
if (userProperties is null)
{
return(NotFound(RequestResponse.NotFound("Error finding the data you are looking for.")));
}
if (!userProperties.IsMfaEnabled)
{
return(BadRequest(RequestResponse.BadRequest("Mfa not enabled for this user.")));
}
var verified = twoFactorAuth.VerifyCode(userProperties.Secret, mfaEnable.MfaCode);
if (!verified)
{
return(BadRequest(RequestResponse.BadRequest("Invalid Mfa code provided. Please try again.")));
}
return(Ok(RequestResponse.Success()));
}
catch (Exception)
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong trying to enable Mfa.")));
}
}
public async Task <ActionResult <ApiResponse <UserProperties> > > EnableMfa()
{
try
{
var userName = User?.Identity?.Name;
var userId = User?.Claims.Where(x => x.Type == CustomClaims.USER_ID).FirstOrDefault()?.Value;
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(userId))
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong trying to validate your request.")));
}
string secret;
var cacheKey = $"{MFA_CACHE_KEY}{userId}";
bool doesExists = memoryCache.TryGetValue(cacheKey, out secret);
var currentProperties = await firebaseDbService.GetUserProperties(userId);
if (currentProperties != null && currentProperties.IsMfaEnabled)
{
memoryCache.Remove(cacheKey);
memoryCache.Set(cacheKey, currentProperties.Secret, cacheEntryOptions);
currentProperties.Account = userName;
currentProperties.Issuer = issuer;
return(Ok(new ApiResponse <UserProperties>(currentProperties)));
}
if (!doesExists)
{
secret = twoFactorAuth.CreateSecret(160);
memoryCache.Set(cacheKey, secret, cacheEntryOptions);
var result = new UserProperties(userId, secret, issuer, userName);
return(Ok(new ApiResponse <UserProperties>(result)));
}
var cacheResult = new UserProperties(userId, secret, issuer, userName);
return(Ok(new ApiResponse <UserProperties>(cacheResult)));
}
catch (Exception)
{
return(BadRequest(RequestResponse.BadRequest("Something went wrong trying to enable Mfa.")));
}
}
public LoginResult GetRequestVerificationToken(Uri uri, bool sisi, out string verificationToken)
{
Response response;
verificationToken = null;
var req = RequestResponse.CreateGetRequest(uri, sisi, true, "URL", Cookies);
req.ContentLength = 0;
var result = RequestResponse.GetHttpWebResponse(req, UpdateCookieStorage, out response);
if (result == LoginResult.Success)
{
verificationToken = RequestResponse.GetRequestVerificationTokenResponse(response);
}
return(result);
}
public RequestResponse getResponse(RequestResponse recievedResponse)
{
var sendResponse = new RequestResponse();
var requestvalidator = new RequestResponseValidation();
var suggestionPathObj = new SuggestionPaths();
if (requestvalidator.IsChoicesMade(recievedResponse.ChoiceDictionary[recievedResponse.Layer]))
{
sendResponse.Layer = suggestionPathObj.NextLayer(recievedResponse.Layer);
sendResponse.LayerMembers = suggestionPathObj.NextLayerMembers(recievedResponse.ChoiceDictionary[recievedResponse.Layer]);
sendResponse.ChoiceDictionary = recievedResponse.ChoiceDictionary;
return(sendResponse);
}
else
{
sendResponse.Layer = "Invalid RequestResponse Sent";
return(sendResponse);
}
}
public async Task <RequestResponse> DeleteRoleAsync(DeleteRoleCommand role)
{
var existRole = await _roleManager.FindByIdAsync(role.Id.ToString());
if (existRole == null)
{
throw new Exception("The role doesn't exist");
}
var users = await _userManager.GetUsersInRoleAsync(existRole.Name);
if (users.Count > 0)
{
throw new Exception("The role has users assigned");
}
await _roleManager.DeleteAsync(existRole);
return(RequestResponse.Success());
}
public RequestResponse Create([FromBody] Shop request)
{
var response = new RequestResponse();
try
{
request.Id = Guid.NewGuid().ToString();
ShopDac.Create(request);
response.Code = 200;
response.Message = "success.";
}
catch (Exception ex)
{
response.Code = 500;
response.Message = "error: " + ex.Message;
}
return(response);
}
public async Task <RequestResponse> CreateRoleAsync(CreateRoleCommand role)
{
var existRole = await _roleManager.FindByNameAsync(role.Name);
if (existRole == null)
{
await _roleManager.CreateAsync(new AppRole
{
Name = role.Name,
NormalizedName = role.Name.ToUpper()
});
return(RequestResponse.Success());
}
else
{
throw new Exception("The role already exist");
}
}
private void HandleUserLoginResult(NetworkPacket netPacket, string defaultChat, RequestLogin requestLogin, byte loginResult)
{
User user = new User(-1, "", null);
switch (loginResult)
{
case RequestID.LOGIN_ACTION.LoginSuccess: {
/*
* Add user to chat users list
*/
user = AddUserToUserList(requestLogin.Username, netPacket.WorkSocket);
/*
* Send login request response to the user
*/
RequestResponse requestResponse = new RequestResponse(RequestID.RequestResponse, user.UserID, RequestID.LoginRequestAction, loginResult);
NetworkPacket response = new NetworkPacket(netPacket.WorkSocket, requestResponse.Serialize());
//TODO Handle send error
int result = networkManager.Send(response);
AddUserToChat(netPacket, defaultChat, user);
break;
}
case RequestID.LOGIN_ACTION.LoginError:
default: {
/*
* Send login request response to the user
*/
RequestResponse requestResponse = new RequestResponse(RequestID.RequestResponse, user.UserID, RequestID.LoginRequestAction, loginResult);
NetworkPacket response = new NetworkPacket(netPacket.WorkSocket, requestResponse.Serialize());
//TODO Handle send error
int result = networkManager.Send(response);
/*
* Close user's socket on login error
*/
netPacket.CloseSocket();
break;
}
}
}
public static async Task <RequestResponse> PostAsync(string url, string param, string token = null)
{
RequestResponse res = null;
try
{
byte[] payload = Encoding.UTF8.GetBytes(param);
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "POST";
request.ContentType = "application/json;charset=UTF-8";
request.ContentLength = payload.Length;
if (!string.IsNullOrEmpty(token))
{
request.Headers.Add("access_token", token);
}
var streamTask = request.GetRequestStreamAsync();
await streamTask;
if (streamTask.Result == null)
{
return(res);
}
Stream writer = streamTask.Result;
writer.Write(payload, 0, payload.Length);
writer.Close();
var resTask = request.GetResponseAsync();
await resTask;
if (!(resTask.Result is HttpWebResponse response))
{
return(res);
}
Stream readStream = response.GetResponseStream();
StreamReader Reader = new StreamReader(readStream, Encoding.UTF8);
res = JsonSrialize.Desrialize <RequestResponse>(Reader.ReadLine());
}
catch (Exception ex)
{
LogHelper.Error(ex);
}
return(res);
}
public RequestResponse Edit([FromBody] Shop request)
{
var response = new RequestResponse();
try
{
var shop = ShopDac.Get(s => s.Id == request.Id);
shop.Name = request.Name;
ShopDac.UpdateOne(s => s.Id == request.Id, shop);
response.Code = 200;
response.Message = "success.";
}
catch (Exception ex)
{
response.Code = 500;
response.Message = "error: " + ex.Message;
}
return(response);
}
public RequestResponse SetDefaultMenu(string shopid, string defaultmenuid)
{
var response = new RequestResponse();
try
{
var shop = ShopDac.Get(s => s.Id == shopid);
shop.DefaultMenuId = defaultmenuid;
ShopDac.UpdateOne(s => s.Id == shopid, shop);
response.Code = 200;
response.Message = "success.";
}
catch (Exception ex)
{
response.Code = 500;
response.Message = "error: " + ex.Message;
}
return(response);
}
public RequestResponse DeleteMenu(string menuid, string shopid)
{
var response = new RequestResponse();
try
{
var shop = ShopDac.Get(s => s.Id == shopid);
shop.Menues = shop.Menues.Where(m => m.Id != menuid).ToList();
ShopDac.UpdateOne(s => s.Id == shopid, shop);
response.Code = 200;
response.Message = "success.";
}
catch (Exception ex)
{
response.Code = 500;
response.Message = "error: " + ex.Message;
}
return(response);
}
public void Delete_Called_CallsDeleteOnClient()
{
// Given
var response = new RequestResponse { Item = new Request { Id = 1 } };
_client.Setup(b => b.Get<RequestResponse>(It.IsAny<Uri>())).Returns(response);
var requestResource = new RequestResource(_client.Object);
// When
requestResource.Delete(321);
// Then
_client.Verify(c => c.Delete(It.IsAny<Uri>()));
}
/// <summary>
/// Makes the get request asynchronous to the cloud api
/// </summary>
/// <param name="method">The method to call i.e. devices</param>
/// <returns>The results of the request.</returns>
public virtual async Task<RequestResponse> MakeGetRequestAsync(String method)
{
if (String.IsNullOrWhiteSpace(method))
{
throw new ArgumentNullException(nameof(method));
}
if (authResults == null)
{
throw new ParticleAuthenticationExeption(String.Format(Messages.YouMusthAuthenticateBeforeCalling, method));
}
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResults.AccessToken);
HttpResponseMessage response = await client.GetAsync(method);
var str = await response.Content.ReadAsStringAsync();
RequestResponse rr = new RequestResponse();
rr.StatusCode = response.StatusCode;
rr.Response = await Task.Run(() => JToken.Parse(str));
return rr;
}
/// <summary>
/// Makes the put request asynchronous to the particle cloud
/// </summary>
/// <param name="method">The method to call</param>
/// <param name="arguments">The arguments to pass during the call</param>
/// <returns>The results of the request</returns>
public virtual async Task<RequestResponse> MakePutRequestAsync(String method, params KeyValuePair<String, String>[] arguments)
{
if (String.IsNullOrWhiteSpace(method))
{
throw new ArgumentNullException(nameof(method));
}
if (authResults == null)
{
throw new ParticleAuthenticationExeption(String.Format(RH.C.GetString("YouMusthAuthenticateBeforeCalling"), method));
}
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResults.AccessToken);
HttpResponseMessage response;
if (arguments != null)
{
response = await client.PutAsync(method, new FormUrlEncodedContent(arguments));
}
else
{
response = await client.PutAsync(method, null);
}
var str = await response.Content.ReadAsStringAsync();
RequestResponse rr = new RequestResponse();
rr.StatusCode = response.StatusCode;
rr.Response = await Task.Run(() => JToken.Parse(str));
return rr;
}
public RequestResponse requestToken(String APIusername, String APIpassword, String transID, String amount, String referenceField, String MSISDN, String MerchantAMN)
{
//APIusername = "******";
//APIpassword = "******";
Assignvalues(APIusername, APIpassword, transID, amount, referenceField, MSISDN, MerchantAMN);
RequestResponse ResponseData = new RequestResponse();
ResponseData.Status = requestres.Status;
ResponseData.TransID = requestres.TransID;
ResponseData.Amount = requestres.Amount;
ResponseData.ReferenceField = requestres.ReferenceField;
ResponseData.MSISDN = requestres.MSISDN;
ResponseData.Message = requestres.Message;
return ResponseData;
}
/// <summary>
/// Makes the post request without authentication asynchronous to the particle cloud.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="arguments">The arguments.</param>
/// <returns>The Results of the request</returns>
public virtual async Task<RequestResponse> MakePostRequestWithoutAuthAsync(String method, params KeyValuePair<String, String>[] arguments)
{
if (String.IsNullOrWhiteSpace(method))
{
throw new ArgumentNullException(nameof(method));
}
client.DefaultRequestHeaders.Clear();
HttpResponseMessage response;
if (arguments != null)
{
response = await client.PostAsync(method, new FormUrlEncodedContent(arguments));
}
else
{
response = await client.PostAsync(method, null);
}
var str = await response.Content.ReadAsStringAsync();
RequestResponse rr = new RequestResponse();
rr.StatusCode = response.StatusCode;
rr.Response = await Task.Run(() => JToken.Parse(str));
return rr;
}
public void Put_RequestHasNoId_ThrowsException()
{
// Given
var response = new RequestResponse { Item = new Request { Subject = "blah blah" } };
var request = new RequestRequest { Item = new Request { Subject = "blah blah" } };
_client.Setup(b => b.Put<RequestResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
var requestResource = new RequestResource(_client.Object);
// When, Then
Assert.Throws<ArgumentException>(() => requestResource.Put(request));
}
