/// <summary> /// Removes the response /// </summary> /// <returns>The response</returns> /// <param name="pos">Position</param> public WebServiceResponse RemoveResponse(int pos) { WebServiceResponse returnResponse = GetResponse(pos); Responses.Remove(returnResponse); return(returnResponse); }
protected void OnLinkButtonCommand(object sender, CommandEventArgs e) { WebServiceResponse response = null; try { switch (e.CommandName) { case "RemoveIrcIdentity": response = Master.WebService.RemoveIdentity(Master.WebServiceLogin, int.Parse((string)e.CommandArgument), null); break; case "RemoveEmailIdentity": response = Master.WebService.RemoveIdentity(Master.WebServiceLogin, null, int.Parse((string)e.CommandArgument)); break; } if (response != null) { if (response.Exception != null) { lblMessage.Text = response.Exception.Message; } else { Response.Redirect("Identities.aspx", false); } } } catch (Exception ex) { lblMessage.Text = ex.Message; } }
public WebServiceResponse Calculator(int firstVal, int secondVal, string operation) { WebServiceResponse response = new WebServiceResponse(); try { switch (operation) { case "+": response.Result = Convert.ToString(firstVal + secondVal); break; case "-": response.Result = Convert.ToString(firstVal - secondVal); break; case "*": response.Result = Convert.ToString(firstVal * secondVal); break; case "/": response.Result = Convert.ToString(firstVal / secondVal); break; } response.ErrorMessage = string.Empty; } catch (Exception ex) { response.Result = string.Empty; response.ErrorMessage = "Error: " + ex.Message; } return(response); }
//******************************************************* /// <summary> /// Ingest a new device /// </summary> /// <returns>EUS info</returns> /// <param name="username">Username.</param> /// <param name="password">Password.</param> /// <param name="assetId">AssetId.</param> /// <param name="IMEI">IMEI.</param> /// <param name="typeOf">typeOf.</param> /// <param name="fromCostCode">FromCostCode.</param> /// <param name="receipientUsername">ReceipientUsername.</param> /// <param name="receipientCostCode">ReceipientCostCode.</param> /// /// public async Task <WebServiceResponse> CreateDevice(string username, string password, string assetId, string IMEI, string typeOf, string fromCostCode, string receipientUsername, string receipientCostCode) { WebServiceResponse response; if (CurrentEnvironment.IsMock) { response = new WebServiceResponse(); response.ResponseCode = 200;//StatusCode response.ResponseString = "{eusAddress: \"0x038F817cCd8c59f710BdB5806213c3EC996ec2f3\",eusPassword: \"testPass\",deviceAddress: \"0x0076ed2DD9f7dc78e3f336141329F8784D8cd564\",assetId: \"0x12345678\",typeOf: \"0xA0123456\"}"; await Task.Delay(MOCK_SERVICE_DELAY); } else { JObject jObject = new JObject(); jObject.Add("username", username); jObject.Add("password", password); jObject.Add("assetId", assetId); jObject.Add("IMEI", IMEI); jObject.Add("typeOf", typeOf); jObject.Add("fromCostCode", fromCostCode); jObject.Add("receipientUsername", receipientUsername); jObject.Add("receipientCostCode", receipientCostCode); string payload = JsonConvert.SerializeObject(jObject); response = await CallWebService(Constants.ingestDeviceURL, "POST", payload); } return(response); }
//******************************************************* /// <summary> /// activateDevice /// </summary> /// <returns>Device signature and information</returns> /// <param name="assetId">AssetId.</param> /// <param name="username">Username.</param> /// <param name="password">Password.</param> /// <param name="isDisposalAccept">IsDisposalAccept.</param> public async Task <WebServiceResponse> ActivateDevice(string assetId, string username, string password, bool isDisposalAccept) { WebServiceResponse response; if (CurrentEnvironment.IsMock) { response = new WebServiceResponse(); response.ResponseCode = 200; response.ResponseString = "{deviceSignature: {v: 28, r: \"0x907c81a899c69b98fac4cbeb60dda208665aefd161a6a98fa39737c224b94587\", " + "s: \"0x4258671a55ca38500b350465f6c88c1ba1251c3c7b364ff12fd4a40f7e044eb8\", " + "messageHash: \"0x60505c83a54729c334d0192c9600d7e74a33b94cf213c70a73ca441ca21da555\", " + "message: \"1517431274\"}, assetId: \"250624\", username: \"George\", password: \"poop\"}"; await Task.Delay(MOCK_SERVICE_DELAY); } else { JObject jObject = new JObject(); jObject.Add("assetId", assetId); jObject.Add("username", username); jObject.Add("password", password); string payload = JsonConvert.SerializeObject(jObject); if (isDisposalAccept) { response = await CallWebService(Constants.acceptDisposalURL /*"activateDevice"*/, "POST", payload); } else { response = await CallWebService(Constants.acceptDeviceURL /*"activateDevice"*/, "POST", payload); } } return(response); }
//******************************************************* /// <summary> /// deactivateDevice /// </summary> /// <returns>Success/Error</returns> /// <param name="assetId">AssetId.</param> /// <param name="username">Username.</param> /// <param name="password">Password.</param> public async Task <WebServiceResponse> DeactivateDevice(string assetId, string username, string password) { WebServiceResponse response; if (CurrentEnvironment.IsMock) { response = new WebServiceResponse(); response.ResponseCode = 200; response.ResponseString = ""; await Task.Delay(MOCK_SERVICE_DELAY); } else { JObject jObject = new JObject(); jObject.Add("assetId", assetId); jObject.Add("username", username); jObject.Add("password", password); string payload = JsonConvert.SerializeObject(jObject); response = await CallWebService(Constants.disposeDeviceURL /*deactivateDeviceURL"deactivateDevice"*/, "POST", payload); } return(response); }
private static async Task ValidateService(string apiBaseUrl, PaginationResults paginationResults, dynamic service, WebServiceReader webServiceReader) { dynamic obj = service; try { WebServiceResponse result = await webServiceReader.ConvertToDynamic(apiBaseUrl + "/services/" + service.id); if (result != null) { obj = result.Data; paginationResults.HasAllowOrigin = result.HasAllowOrigin; } if (obj == null) { obj = service; paginationResults.MissingDetailIDs.Add(Convert.ToString(service.id)); } } catch { try { paginationResults.MissingDetailIDs.Add(Convert.ToString(service.id)); } catch { //bad data don't stop the test for this } } paginationResults.Items.Add(obj); }
/// <summary> /// Called to create the response. /// </summary> /// <param name="proposedResponse">The proposed response.</param> /// <returns>The response.</returns> protected override async Task <WebServiceResponse> CreateResponseAsync(WebServiceResponse proposedResponse) { HttpStatusCode statusCode = proposedResponse.StatusCode; HttpHeaders headers = proposedResponse.Headers; var content = proposedResponse.Content; // check for content if (content is object) { // check content type if (proposedResponse.HasJson()) { string responseJson = await proposedResponse.GetJsonAsync().ConfigureAwait(false); // success return(new JsonWebServiceResponse(this, statusCode, headers, JsonWebServiceContent.FromJson(responseJson))); } else { // got content with the wrong content type (HTML error information, perhaps; allowed for non-OK) string message = "Response content type is not JSON: {0}".FormatInvariant(content.Headers.ContentType); if (statusCode == HttpStatusCode.OK) { throw WebServiceResponseUtility.CreateWebServiceException(proposedResponse, message); } } } // missing or non-JSON content return(new JsonWebServiceResponse(this, statusCode, headers, content)); }
protected ActionResult Xml(WebServiceResponse response) { var stream = new MemoryStream(); response.WriteXml(stream); stream.Position = 0; return(Xml(stream)); }
/// <summary> /// Returns true if the response content uses the JSON content type. /// </summary> /// <param name="response">The response.</param> /// <returns>True if the response content uses the JSON content type ("application/json") and the content is not empty.</returns> public static bool HasJson(this WebServiceResponse response) { bool hasJson = response.Content?.Headers.ContentLength > 0; string contentType = response.Content?.Headers.ContentType?.ToString(); hasJson &= !string.IsNullOrEmpty(contentType) && contentType.Trim().StartsWith(JsonWebServiceContent.JsonContentType, StringComparison.Ordinal); return(hasJson); }
/// <summary> /// Returns true if the response content uses the JSON content type. /// </summary> /// <param name="response">The response.</param> /// <returns>True if the response content uses the JSON content type ("application/json" or "application/schema+json") and the content is not empty.</returns> public static bool HasJson(this WebServiceResponse response) { bool hasJson = response.Content?.Headers.ContentLength > 0; var contentType = response.Content?.Headers.ContentType?.ToString(); hasJson &= contentType is object && JsonResponseUtility.IsJsonContentType(contentType); return(hasJson); }
public static bool IsLoggedIn(WebServiceResponse response) { if (response == null) { return(false); } return(!string.IsNullOrEmpty(response.UserName)); }
/// <summary> /// Gets the JSON. /// </summary> /// <param name="response">The response.</param> /// <returns>The unverified JSON.</returns> /// <exception cref="WebServiceException">The response content does not use the JSON content type or the content is empty.</exception> public static Task <string> GetJsonAsync(this WebServiceResponse response) { if (!response.HasJson()) { throw WebServiceResponseUtility.CreateWebServiceException(response, "The response does not have JSON content."); } return(response.Content !.ReadAsStringAsync()); }
/// <summary> /// Returns true if the response content uses the JSON content type. /// </summary> /// <param name="response">The response.</param> /// <returns>True if the response content uses the JSON content type ("application/json") and the content is not empty.</returns> public static bool HasJson(this WebServiceResponse response) { bool hasJson = response.Content?.Headers.ContentLength > 0; var contentType = response.Content?.Headers.ContentType?.ToString(); hasJson &= contentType is object && contentType.Length >= JsonWebServiceContent.JsonContentType.Length && contentType.Trim().StartsWith(JsonWebServiceContent.JsonContentType, StringComparison.Ordinal); return(hasJson); }
protected void cmdConfirm_Click(object sender, EventArgs e) { WebServiceResponse rsp = null; try { switch (action) { case "delete-lane": Master.WebService.DeleteLane(Master.WebServiceLogin, lane_id); break; case "delete-host": Master.WebService.DeleteHost(Master.WebServiceLogin, host_id); break; case "delete-all-work-for-host": rsp = Master.WebService.DeleteAllWorkForHost(Master.WebServiceLogin, host_id); break; case "delete-all-work-for-lane": rsp = Master.WebService.DeleteAllWorkForLane(Master.WebServiceLogin, lane_id); break; case "delete-all-revisions-for-lane": rsp = Master.WebService.DeleteAllRevisionsForLane(Master.WebServiceLogin, lane_id); break; case "clear-all-work-for-host": rsp = Master.WebService.ClearAllWorkForHost(Master.WebServiceLogin, host_id); break; case "clear-all-work-for-lane": rsp = Master.WebService.ClearAllWorkForLane(Master.WebServiceLogin, lane_id); break; default: lblMessage.Text = "Invalid action"; return; } if (rsp != null && rsp.Exception != null) { cmdConfirm.Enabled = false; lblMessage.Text = Utils.FormatException(rsp.Exception.Message); } else { Redirect(); } } catch (Exception ex) { cmdConfirm.Enabled = false; cmdConfirm.Visible = false; lblMessage.Text = Utils.FormatException(ex, true); } }
protected void Page_Load(object sender, EventArgs e) { try { string action = Request ["action"]; int id; if (!string.IsNullOrEmpty(action)) { switch (action) { case "delete": if (int.TryParse(Request ["id"], out id)) { WebServiceResponse rsp = Master.WebService.DeleteUser(Master.WebServiceLogin, id); if (rsp.Exception != null) { lblMessage.Text = Utils.FormatException(response.Exception.Message); } else { Response.Redirect("Users.aspx", false); return; } } else { lblMessage.Text = "Invalid id"; } break; } } response = Master.WebService.GetUsers(Master.WebServiceLogin); if (response.Exception != null) { lblMessage.Text = Utils.FormatException(response.Exception.Message); } else if (response.Users != null) { foreach (DBPerson person in response.Users) { tblUsers.Rows.Add(Utils.CreateTableRow( string.Format("<a href='User.aspx?username={0}'>{0}</a>", HttpUtility.HtmlEncode(person.login)), HttpUtility.HtmlEncode(person.fullname), HttpUtility.HtmlEncode(person.roles), HttpUtility.HtmlEncode(person.password), string.Format("<a href='Users.aspx?id={0}&action=delete'>Delete</a>", person.id))); } } } catch (Exception ex) { lblMessage.Text = Utils.FormatException(ex); } }
public static void VerifyUserInRole(string remote_ip, DB db, WebServiceLogin login, string role, bool @readonly) { WebServiceResponse dummy = new WebServiceResponse(); Authenticate(remote_ip, db, login, dummy, @readonly); if (!dummy.IsInRole(role)) { log.InfoFormat("The user '{0}' has the roles '{1}', and requested role is: {2}", login.User, dummy.UserRoles == null ? "<null>" : string.Join(",", dummy.UserRoles), role); throw new UnauthorizedException("You don't have the required permissions."); } }
/// <summary> /// Processes the error /// </summary> /// <param name="response">Response document</param> /// <param name="responseModel">Response</param> private static bool HasFaultError(WebServiceResponse responseModel, XmlDocument response) { XmlNodeList xmlFault = response.GetElementsByTagName("faultstring"); if (xmlFault.Count > 0) { responseModel.Status = WebServiceResponseStatus.Error; responseModel.ErrorMessage = xmlFault.Item(0).InnerText; return(true); } return(false); }
public static void VerifyUserInRole(HttpContext Context, DB db, WebServiceLogin login, string role, bool @readonly) { WebServiceResponse dummy = new WebServiceResponse(); Authenticate(Context, db, login, dummy, @readonly); if (!dummy.IsInRole(role)) { Logger.Log(2, "The user '{0}' has the roles '{1}', and requested role is: {2}", login.User, dummy.UserRoles == null ? "<null>" : string.Join(",", dummy.UserRoles), role); throw new HttpException(403, "You don't have the required permissions."); } }
public static void ProcessLogin(Array rows) { LoginRow row = (LoginRow)rows[0]; jQuery.Post("/Services/AddUser?signed_request=" + Utility.GetSignedRequest(), new JsonObject("member", new JsonObject()), (AjaxRequestCallback <object>) delegate(object data, string textStatus, jQueryXmlHttpRequest <object> request) { WebServiceResponse response = (WebServiceResponse)data; AddUserResponse addUser = (AddUserResponse)response.Data; // } ); }
public void OnRequestStockHistoryCompleted(WebServiceResponse response) { var stocks = ReadStockHistory(response); var stockToken = response.UserState as StockDataToken; if (stockToken != null && stockToken.Callback != null) { SynchronizationContext.Current.Post(data => stockToken.Callback(stockToken.Symbol, (List <StockDataItem>)data), stocks); } }
public async Task PaginateServices(string apiBaseUrl, string id, ServiceProcessorAsync processor, WebServiceReader webServiceReader, string parameters = "", int?totalPagesOverride = null) { int pageNo = 0; int totalPages = totalPagesOverride ?? 1; while (pageNo < totalPages) { pageNo++; string serviceUrl = apiBaseUrl + "/services/"; serviceUrl += parameters; if (!serviceUrl.Contains("?")) { serviceUrl += "?"; } else { serviceUrl += "&"; } WebServiceResponse serviceList = await webServiceReader.ConvertToDynamic(serviceUrl + "page=" + pageNo); try { if (serviceList == null) { continue; } int tmp = Convert.ToInt32(serviceList.Data.totalPages); if (!totalPagesOverride.HasValue || tmp < totalPages) { totalPages = tmp; } } catch { //if this isn't here we will ignore it and just paginate the first page. This issue will be reported upon in pagination } if (!await processor(serviceList.Data, totalPages, serviceList.HashCode)) { break; } ProgressCache.Update(id, pageNo, totalPages); } }
/// <summary> /// Create a composite response model /// </summary> /// <param name="response">Xml response</param> /// <returns>Response model</returns> public static CompositeResponse CreateCompositeResponse(XmlDocument response) { CompositeResponse responseModel = new CompositeResponse(); if (HasFaultError(responseModel, response)) { return(responseModel); } responseModel.Status = WebServiceResponseStatus.Successful; XmlNodeList xmlResponses = response.GetElementsByTagName("StandardResponse"); for (int i = 0; i < xmlResponses.Count; i++) { XmlElement xmlTemp = (XmlElement)xmlResponses.Item(i); WebServiceResponse partialResponse = null; if (xmlTemp.GetElementsByTagName("WindowTabData").Count > 0) { XmlDocument xmlDocTemp = new XmlDocument(); xmlDocTemp.AppendChild(xmlDocTemp.ImportNode(xmlTemp.GetElementsByTagName("WindowTabData").Item(0), true)); partialResponse = CreateWindowTabDataResponse(xmlDocTemp); responseModel.AddResponse(partialResponse); } else if (xmlTemp.GetElementsByTagName("RunProcessResponse").Count > 0) { XmlDocument xmlDocTemp = new XmlDocument(); xmlDocTemp.AppendChild(xmlDocTemp.ImportNode(xmlTemp.GetElementsByTagName("RunProcessResponse").Item(0), true)); partialResponse = CreateRunProcessResponse(xmlDocTemp); responseModel.AddResponse(partialResponse); } else { XmlDocument xmlDocTemp = new XmlDocument(); xmlDocTemp.AppendChild(xmlDocTemp.ImportNode(xmlTemp, true)); partialResponse = CreateStandardResponse(xmlDocTemp); responseModel.AddResponse(partialResponse); } if (partialResponse != null && partialResponse.Status == WebServiceResponseStatus.Error) { responseModel.Status = WebServiceResponseStatus.Error; responseModel.ErrorMessage = partialResponse.ErrorMessage; } } return(responseModel); }
private static void HandleResetPasswordResponse(WebServiceResponse response, Action onFinish, Action <LoginManager.AuthErrorCode, string> onError) { if (!response.Success) { AppLog.LogError(string.Concat("ResetWassword was failed. Reason: ", response.Message), true); if (onError != null) { onError((AuthErrorCode)5, response.Message); } } else if (onFinish != null) { onFinish(); } }
private WebServiceResponse UnmarshallResponse(UnmarshallerContext context, IRequestContext requestContext) { var unmarshaller = requestContext.Unmarshaller; WebServiceResponse response = null; try { response = unmarshaller.UnmarshallResponse(context); } finally { } return(response); }
protected void btnCalculate_Click(object sender, EventArgs e) { //connect to web service SampleWebServiceSoapClient client = new SampleWebServiceSoapClient(); //call web service method based on user params and place result in string variable WebServiceResponse response = client.Calculator(Convert.ToInt32(txtFirstValue.Text), Convert.ToInt32(txtSecondValue.Text), txtOperation.Text); if (response.Result != string.Empty) { lblResult.Text = "Result: <b style ='color:Green'>" + response.Result + "</b>"; } else { lblResult.Text = "Exception: <b style ='color:Red'>" + response.ErrorMessage + "</b>"; } }
public override WebServiceResponse Unmarshall(UnmarshallerContext input) { XmlUnmarshallerContext context = input as XmlUnmarshallerContext; if (context == null) { throw new InvalidOperationException("Unsupported UnmarshallerContext"); } WebServiceResponse response = this.Unmarshall(context); foreach (var headerName in context.ResponseData.GetHeaderNames()) { response.Headers.Add(headerName, context.ResponseData.GetHeaderValue(headerName)); } return(response); }
public WebServiceResponse GetExcutableMethods() { var result = new WebServiceResponse(); result.Status = (int)0;// ErrorCodes.ALL_OK; result.Message = "Success"; try { result.Items = Tasks.GetExcutableMethods().ToArray <object>(); } catch (Exception ex) { result.Status = (int)1;// ErrorCodes.GENERAL_ERROR; result.Message = ex.Message; ServiceLogger.Error("ExecuteTask error: " + ex.Message); } return(result); }
public static bool IsInRole(WebServiceResponse response, string role) { bool result; if (response == null) { return(false); } if (response.UserRoles == null) { return(false); } result = Array.IndexOf(response.UserRoles, role) >= 0; return(result); }
public async Task <IActionResult> GetServiceById(GetServiceByIdRequest request) { var model = await _service.GetServiceByIdAsync(request.ServiceId); if (model == null) { return(BadRequest()); } var response = new WebServiceResponse { Code = "success", Message = "get.services.success", Data = model }; return(Ok(model)); }