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