public dynamic Post(GameCreateRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
dynamic response;
if (!string.IsNullOrEmpty(request.Type) && request.Type == "Load")
{
response = GameLoad(request, appId);
}
else
{
response = GameCreate(request, appId);
}
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public ErrorSignalEventArgs(string message)
{
this.message = message;
this.response = ErrorResponse.Abort;
this.canskip = false;
this.canignore = false;
}
public dynamic Post(GameLeaveRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.IsInactive)
{
if (request.ActorNr > 0)
{
WebApiApplication.DataAccess.GameInsert(appId, request.UserId, request.GameId, request.ActorNr);
}
}
else
{
WebApiApplication.DataAccess.GameDelete(appId, request.UserId, request.GameId);
}
var okResponse = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(okResponse));
return okResponse;
}
public void ProcessRequest(HttpContext context)
{
var request = context.Request;
string method = request.QueryString["method"];
//string format = context.Request.QueryString["format"] ?? "json";
string body;
try
{
var type = GetParamsRequest(method);
var rsp = request.GetTopResponse(type);
body = rsp.ToJson();
}
catch (TopException ex)
{
LogException(ex);
body = new ErrorResponse(ex.ErrorCode, ex.ErrorMsg).ToJson();
}
catch (Exception ex)
{
LogException(ex);
body = new ErrorResponse(1, ex.Message).ToJson();
}
context.Response.ContentType = "application/json;charset=utf-8";
context.Response.Write(body);
context.Response.End();
}
/// <summary>
/// Initializes a new instance of the <see cref="KudosException"/>
/// class.
/// </summary>
/// <param name="errorResult">Error result set from Kudos API.</param>
/// <param name="message">Error message.</param>
public KudosException(ErrorResponse errorResult, string message)
: base(message)
{
if (errorResult.Errors != null)
{
Errors = errorResult.Errors;
}
}
/// <summary>
/// Creates a new <see cref="NutritionixException"/> from a error response
/// </summary>
internal NutritionixException(ErrorResponse response)
: base("The Nutritionix API returned an error response.")
{
if(response != null)
{
Errors = response.Errors;
}
}
public override void OnException(HttpActionExecutedContext context)
{
log.Error(context.Exception);
var response = new ErrorResponse {Message = context.Exception.Message};
if(log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
context.Response = context.Request.CreateResponse(HttpStatusCode.OK, response);
}
public static void CallBack(Action<ErrorResponse> callback, ErrorResponse errorResponse)
{
if (callback != null) {
try {
callback(errorResponse);
}
catch (Exception e) {
Program.PlaygroundKeeperLogSource.LogError(string.Format("RemovePlayground callback exception, {0}", e.ToString()));
}
}
}
public dynamic Post(GamePropertiesRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.State != null)
{
var state = (string)JsonConvert.SerializeObject(request.State);
WebApiApplication.DataAccess.StateSet(appId, request.GameId, state);
var properties = request.Properties;
object actorNrNext = null;
if (properties != null)
{
properties.TryGetValue("turn", out actorNrNext);
}
var userNextInTurn = string.Empty;
foreach (var actor in request.State.ActorList)
{
if (actorNrNext != null)
{
if (actor.ActorNr == actorNrNext)
{
userNextInTurn = (string)actor.UserId;
}
}
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
if (!string.IsNullOrEmpty(userNextInTurn))
{
var notificationContent = new Dictionary<string, string>
{
{ "en", "{USERNAME} finished. It's your turn." },
{ "de", "{USERNAME} hat seinen Zug gemacht. Du bist dran." },
};
pushWoosh.RequestPushNotification(notificationContent, request.Username, "UID2", userNextInTurn, appId);
}
}
var response = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public dynamic Post(GameCloseRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.State == null)
{
if (request.ActorCount > 0)
{
var errorResponse = new ErrorResponse { Message = "Missing State." };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
WebApiApplication.DataAccess.StateDelete(appId, request.GameId);
var okResponse = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(okResponse));
return okResponse;
}
foreach (var actor in request.State.ActorList)
{
//var listProperties = new ListProperties() { ActorNr = (int)actor.ActorNr, Properties = request.State.CustomProperties };
//WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (string)JsonConvert.SerializeObject(listProperties));
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
//deprecated
if (request.State2 != null)
{
foreach (var actor in request.State2.ActorList)
{
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
}
var state = (string)JsonConvert.SerializeObject(request.State);
WebApiApplication.DataAccess.StateSet(appId, request.GameId, state);
var response = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public async Task HandleAsync()
{
log.ErrorException(exception);
var wardenException = exception as WardenException;
if (wardenException != null)
{
var response = new ErrorResponse
{
Message = wardenException.ResponseMessage + "\n",
Data = wardenException.StackTrace
};
await messageWriter.WriteAsync(response);
}
}
/// <summary>
///
/// </summary>
/// <param name="errorResponse"></param>
/// <returns></returns>
public static string ErrorResponsToString(ErrorResponse errorResponse)
{
//TODO: check null values
string result = errorResponse.Text;
if (string.IsNullOrEmpty(errorResponse.StackTrace)) {
result += Environment.NewLine + " Stacktrace:" + errorResponse.StackTrace;
}
if (string.IsNullOrEmpty(errorResponse.Helplink)) {
result += Environment.NewLine + "Helplink:" + errorResponse.Helplink;
}
result += Environment.NewLine + "StatusCode:" + errorResponse.StatusCode;
return result;
}
public dynamic Post(GameCreateRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
dynamic response = GameCreateController.GameLoad(request, appId);
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public IErrorResponse SendEnhancedNotification(IEnhancedNotification enhancedNotification)
{
this.connection.Connect();
this.connection.Write(enhancedNotification.ToByteArray());
var response = new byte[6];
this.connection.Read(response, 0, response.Length);
this.connection.Disconnect();
IErrorResponse errorResponse = null;
if (response[0] == 0x08)
{
// we received an error response...
errorResponse = new ErrorResponse(BitConverter.ToInt32(response, 2), (ErrorResponseStatusCode) response[1]);
}
return errorResponse;
}
public HttpResponseMessage LoginPost(LoginPostRequest model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
try
{
BaseResponse response = null;
HttpStatusCode code = HttpStatusCode.OK;
ApplicationUser user = UserService.Signin(model.UserName, model.Password);
if (user != null)
{
response = new SuccessResponse();
HttpResponseMessage resp = Request.CreateResponse(response);
//ResetClientState(user.Id, resp);
return resp;
}
else
{
response = new ErrorResponse("Unable to Log in");
code = HttpStatusCode.BadRequest;
}
return Request.CreateResponse(code, response);
}
catch (Exception e)
{
ErrorResponse er = new ErrorResponse(e.Message);
//sabio.layout.showMessage(er);
return Request.CreateResponse(HttpStatusCode.InternalServerError, er);
}
}
public byte[] Process(byte[] data)
{
object result;
try {
var requestName = _requestParser.GetRequestName(data);
var command = _commandLocator.GetCommand(requestName);
if (command == null) {
throw new ProcessException(string.Format("The request '{0}' is unknown.", requestName));
}
result = ExecuteCommand(command, data);
}
catch (TargetInvocationException ex) {
result = new ErrorResponse {Error = ex.InnerException.Message};
}
catch (Exception ex) {
result = new ErrorResponse {Error = ex.Message};
}
return _requestParser.ConvertToBytes(result);
}
// Goes through the error response and inner exception, trying to find a message to use for this exception
private static string GetMessage(ErrorResponse response, WebException innerException)
{
// list of candidates for the message
var possibleMessages = new List<string>();
// add candidates from the error response
if(response != null)
{
possibleMessages.Add(response.message);
possibleMessages.Add(response.error_description);
possibleMessages.Add(response.error);
}
// add candidates from the inner exception
if(innerException != null)
possibleMessages.Add(innerException.Message);
// return the first candidate that's not empty
return possibleMessages.FirstOrDefault(message => !string.IsNullOrEmpty(message));
}
public dynamic Post(GetGameListRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
var list = new Dictionary<string, object>();
foreach (var pair in WebApiApplication.DataAccess.GameGetAll(appId, request.UserId))
{
// exists - save result in list
//if (WebApiApplication.DataAccess.StateExists(appId, pair.Key))
var stateJson = WebApiApplication.DataAccess.StateGet(appId, pair.Key);
if (stateJson != null)
{
dynamic customProperties = null;
if (stateJson != string.Empty)
{
var state = JsonConvert.DeserializeObject<dynamic>(stateJson);
customProperties = state.CustomProperties;
}
var gameListItem = new GameListItem(){ ActorNr = int.Parse(pair.Value), Properties = customProperties };
list.Add(pair.Key, gameListItem);
}
// not exists - delete
else
{
WebApiApplication.DataAccess.GameDelete(appId, request.UserId, pair.Key);
}
}
var getGameListResponse = new GetGameListResponse { Data = list };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(getGameListResponse));
return getGameListResponse;
}
private static dynamic GameCreate(GameCreateRequest request, string appId)
{
dynamic response;
if (WebApiApplication.DataAccess.StateExists(appId, request.GameId))
{
response = new ErrorResponse { Message = "Game already exists." };
return response;
}
if (request.CreateOptions == null)
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, string.Empty);
}
else
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, (string)JsonConvert.SerializeObject(request.CreateOptions));
}
response = new OkResponse();
return response;
}
public override void OnException(HttpActionExecutedContext filterContext)
{
var warning = filterContext.Exception as Warning;
if (warning != null)
{
var response = new ErrorResponse(warning);
filterContext.Response = filterContext.Request.CreateResponse(response);
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append("|Url:");
sb.Append(filterContext.ActionContext.Request.RequestUri.AbsoluteUri);
sb.Append("\r\n");
sb.Append(filterContext.Exception.Message.Replace("<", string.Empty).Replace(">", string.Empty));
sb.Append("\r\n");
sb.Append(filterContext.Exception.Source);
sb.Append("\r\n");
sb.Append(filterContext.Exception.StackTrace);
sb.Append("\r\n");
Exception ex = filterContext.Exception.InnerException;
while (ex != null)
{
sb.Append("\r\n-----------------------");
sb.Append(filterContext.Exception.Message.Replace("<", string.Empty).Replace(">", string.Empty));
sb.Append("\r\n");
sb.Append(filterContext.Exception.Source);
sb.Append("\r\n");
sb.Append(filterContext.Exception.StackTrace);
ex = ex.InnerException;
}
LogHelper.WriteLog(sb.ToString());
var response = new ErrorResponse(0, "系统错误,请联系管理员");
filterContext.Response = filterContext.Request.CreateResponse(response);
}
base.OnException(filterContext);
}
/// <summary>
/// Handle an message
/// </summary>
/// <param name="context">Context unique for this handler instance</param>
/// <param name="message">Message to process</param>
public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message)
{
var headerMsg = message as ReceivedHeader;
if (headerMsg != null)
{
_header = headerMsg.Header;
if (_header.Length > 65535)
{
var error = new ErrorResponse("-9999", new RpcError
{
Code = RpcErrorCode.InvalidRequest,
Message =
"Support requests which is at most 655355 bytes.",
});
context.SendDownstream(new SendResponse(error));
}
return;
}
var received = message as Received;
if (received != null)
{
var count = Math.Min(received.BufferReader.Count, _header.Length);
received.BufferReader.CopyTo(_stream, count);
if (_stream.Length == _header.Length)
{
_stream.Position = 0;
var request = DeserializeRequest(_stream);
context.SendUpstream(new ReceivedRequest(request));
}
return;
}
context.SendUpstream(message);
}
public override AmazonServiceException UnmarshallException(XmlUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = ErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("BucketPermissionException"))
{
return(new BucketPermissionException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("CanceledJobIdException"))
{
return(new CanceledJobIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ExpiredJobIdException"))
{
return(new ExpiredJobIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidAccessKeyIdException"))
{
return(new InvalidAccessKeyIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidAddressException"))
{
return(new InvalidAddressException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidCustomsException"))
{
return(new InvalidCustomsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidFileSystemException"))
{
return(new InvalidFileSystemException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidJobIdException"))
{
return(new InvalidJobIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidManifestFieldException"))
{
return(new InvalidManifestFieldException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidParameterException"))
{
return(new InvalidParameterException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MalformedManifestException"))
{
return(new MalformedManifestException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MissingCustomsException"))
{
return(new MissingCustomsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MissingManifestFieldException"))
{
return(new MissingManifestFieldException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MissingParameterException"))
{
return(new MissingParameterException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MultipleRegionsException"))
{
return(new MultipleRegionsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NoSuchBucketException"))
{
return(new NoSuchBucketException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
return(new AmazonImportExportException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Gets a list of workflow trigger histories.
/// </summary>
/// <param name='resourceGroupName'>
/// The resource group name.
/// </param>
/// <param name='workflowName'>
/// The workflow name.
/// </param>
/// <param name='triggerName'>
/// The workflow trigger name.
/// </param>
/// <param name='odataQuery'>
/// OData parameters to apply to the operation.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <IPage <WorkflowTriggerHistory> > > ListWithHttpMessagesAsync(string resourceGroupName, string workflowName, string triggerName, ODataQuery <WorkflowTriggerHistoryFilter> odataQuery = default(ODataQuery <WorkflowTriggerHistoryFilter>), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
if (resourceGroupName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
}
if (workflowName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "workflowName");
}
if (triggerName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "triggerName");
}
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("odataQuery", odataQuery);
tracingParameters.Add("resourceGroupName", resourceGroupName);
tracingParameters.Add("workflowName", workflowName);
tracingParameters.Add("triggerName", triggerName);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "List", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Logic/workflows/{workflowName}/triggers/{triggerName}/histories").ToString();
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
_url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
_url = _url.Replace("{workflowName}", System.Uri.EscapeDataString(workflowName));
_url = _url.Replace("{triggerName}", System.Uri.EscapeDataString(triggerName));
List <string> _queryParameters = new List <string>();
if (odataQuery != null)
{
var _odataFilter = odataQuery.ToString();
if (!string.IsNullOrEmpty(_odataFilter))
{
_queryParameters.Add(_odataFilter);
}
}
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("GET");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <IPage <WorkflowTriggerHistory> >();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <Page <WorkflowTriggerHistory> >(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
static void Main(string[] args)
{
Transaction transaction = new Transaction();
transaction.Environment = "TEST";
ResponseBase response = transaction.Sale(
"100", // 'merchantId' - REQUIRED: Merchant ID assigned by maxiPago! //
"merchant-key", // 'merchantKey' - REQUIRED: Merchant Key assigned by maxiPago! //
"ORD937393483", // 'referenceNum' - REQUIRED: Merchant internal order number //
133.45, // 'chargeTotal' - REQUIRED: Transaction amount in US format //
"4111111111111111", // 'creditCardNumber' - REQUIRED: Full credit card number //
"03", // 'expMonth' - REQUIRED: Credit card expiration month with 2 digits //
"2015", // 'expYear' - REQUIRED: Credit card expiration year with 4 digits //
null, // 'cvvInd' - Optional: Indicator of absense of CVV code //
"123", // 'cvvNumber' - RECOMMENDED: Credit card verification number //
null, // 'authentication' - Optional: Valid only for Cielo. Please see full documentation for more info //
"1", // 'processorId' - REQUIRED: Acquirer code for transaction routing Use '1' for testing. //
"2", // 'numberOfInstallments' - Optional: Number of installments for credit card purchases ("parcelas") //
// Send 'null' if no installments are used //
"N", // 'chargeInterest' - Optional: Charge interest flag (Y/N) for installment purchase ("com" e "sem" juros) //
"1270.0.1", // 'ipAddress' - Optional //
"999", // 'customerToken' - REQUIRED: Customer ID replied by maxiPago! after creating a customer profile //
null, //'onFileEndDate' - Optional: Date the credit card token will no longer be available for use //
null, // 'onFilePermission' - Optional: Sets period of use of token: 'ongoing' or 'use_once' //
null, // 'onFileComment' - Optional //
"2000.00", // 'onFileMaxChargeAmount' - Optional: Maximum amount this card can be charged //
"John Smith", // 'billingName' - RECOMMENDED: Customer name //
"Rua de Teste, 123", // 'billingAddress' - Optional: Customer address //
null, // 'billingAddress2' - Optional: Customer address //
"Rio de Janeiro", // 'billingCity' - Optional: Customer city //
"RJ", // 'billingState' - Optional: Customer state with 2 characters //
"20030000", // 'billingPostalCode' - Optional: Customer zip code //
"BR", // 'billingCountry' - Optional: Customer country per ISO 3166-2 //
null, // 'billingPhone' - Optional: Customer phone number //
"*****@*****.**", // 'billingEmail' - Optional: Customer email addres //
"Jane Smith", // 'shippingName' - Optional: Shipping name //
null, // 'shippingAddress' - Optional: Shipping address //
null, // 'shippingAddress2' - Optional: Shipping address //
null, // 'shippingCity' - Optional: Shipping city //
null, // 'shippingState' - Optional: Shipping state with 2 characters //
null, // 'shippingPostalCode' - Optional: Shipping zip code //
null, // 'shippingCountry' - Optional: Shipping country per ISO 3166-2 //
null, // 'shippingPhone' - Optional: Shipping phone number //
null, // 'shippingEmail' - Optional: Shipping email address //
null, // 'currencyCode' - Optional: Currency code. Valid only for ChasePaymentech. Please see full documentation for more info //
null, // 'softDescriptor' - Optional
null // 'iataFee' - Optional
);
if (response.IsTransactionResponse)
{
TransactionResponse result = response as TransactionResponse;
if (result.ResponseCode == "0")
{
// Success
}
else
{
// Decline
}
}
else if (response.IsErrorResponse)
{
ErrorResponse result = response as ErrorResponse;
// Fail
}
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("AliasExistsException"))
{
return(new AliasExistsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("CodeMismatchException"))
{
return(new CodeMismatchException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ExpiredCodeException"))
{
return(new ExpiredCodeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InternalErrorException"))
{
return(new InternalErrorException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidLambdaResponseException"))
{
return(new InvalidLambdaResponseException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidParameterException"))
{
return(new InvalidParameterException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidSmsRoleAccessPolicyException"))
{
return(new InvalidSmsRoleAccessPolicyException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidSmsRoleTrustRelationshipException"))
{
return(new InvalidSmsRoleTrustRelationshipException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidUserPoolConfigurationException"))
{
return(new InvalidUserPoolConfigurationException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MFAMethodNotFoundException"))
{
return(new MFAMethodNotFoundException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NotAuthorizedException"))
{
return(new NotAuthorizedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PasswordResetRequiredException"))
{
return(new PasswordResetRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ResourceNotFoundException"))
{
return(new ResourceNotFoundException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyRequestsException"))
{
return(new TooManyRequestsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("UnexpectedLambdaException"))
{
return(new UnexpectedLambdaException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("UserLambdaValidationException"))
{
return(new UserLambdaValidationException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("UserNotConfirmedException"))
{
return(new UserNotConfirmedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("UserNotFoundException"))
{
return(new UserNotFoundException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
return(new AmazonCognitoIdentityProviderException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public OverrideStatusRequiredException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
OverrideStatusRequiredException unmarshalledObject = new OverrideStatusRequiredException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return unmarshalledObject;
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("CommitMessageLengthExceededException"))
{
return(new CommitMessageLengthExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ConcurrentReferenceUpdateException"))
{
return(new ConcurrentReferenceUpdateException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("EncryptionIntegrityChecksFailedException"))
{
return(new EncryptionIntegrityChecksFailedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("EncryptionKeyAccessDeniedException"))
{
return(new EncryptionKeyAccessDeniedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("EncryptionKeyDisabledException"))
{
return(new EncryptionKeyDisabledException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("EncryptionKeyNotFoundException"))
{
return(new EncryptionKeyNotFoundException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("EncryptionKeyUnavailableException"))
{
return(new EncryptionKeyUnavailableException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("FileContentSizeLimitExceededException"))
{
return(new FileContentSizeLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("FolderContentSizeLimitExceededException"))
{
return(new FolderContentSizeLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidCommitIdException"))
{
return(new InvalidCommitIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidConflictDetailLevelException"))
{
return(new InvalidConflictDetailLevelException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidConflictResolutionException"))
{
return(new InvalidConflictResolutionException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidConflictResolutionStrategyException"))
{
return(new InvalidConflictResolutionStrategyException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidEmailException"))
{
return(new InvalidEmailException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidFileModeException"))
{
return(new InvalidFileModeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidPathException"))
{
return(new InvalidPathException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidPullRequestIdException"))
{
return(new InvalidPullRequestIdException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidReplacementContentException"))
{
return(new InvalidReplacementContentException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidReplacementTypeException"))
{
return(new InvalidReplacementTypeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRepositoryNameException"))
{
return(new InvalidRepositoryNameException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ManualMergeRequiredException"))
{
return(new ManualMergeRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MaximumConflictResolutionEntriesExceededException"))
{
return(new MaximumConflictResolutionEntriesExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MaximumFileContentToLoadExceededException"))
{
return(new MaximumFileContentToLoadExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MaximumItemsToCompareExceededException"))
{
return(new MaximumItemsToCompareExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MultipleConflictResolutionEntriesException"))
{
return(new MultipleConflictResolutionEntriesException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NameLengthExceededException"))
{
return(new NameLengthExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PathRequiredException"))
{
return(new PathRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PullRequestAlreadyClosedException"))
{
return(new PullRequestAlreadyClosedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PullRequestDoesNotExistException"))
{
return(new PullRequestDoesNotExistException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PullRequestIdRequiredException"))
{
return(new PullRequestIdRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ReplacementContentRequiredException"))
{
return(new ReplacementContentRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ReplacementTypeRequiredException"))
{
return(new ReplacementTypeRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("RepositoryDoesNotExistException"))
{
return(new RepositoryDoesNotExistException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("RepositoryNameRequiredException"))
{
return(new RepositoryNameRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("RepositoryNotAssociatedWithPullRequestException"))
{
return(new RepositoryNotAssociatedWithPullRequestException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TipOfSourceReferenceIsDifferentException"))
{
return(new TipOfSourceReferenceIsDifferentException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TipsDivergenceExceededException"))
{
return(new TipsDivergenceExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
return(new AmazonCodeCommitException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
return(new AmazonIoTSecureTunnelingException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public InvalidDBInstanceAutomatedBackupStateException Unmarshall(XmlUnmarshallerContext context, ErrorResponse errorResponse)
{
InvalidDBInstanceAutomatedBackupStateException response = new InvalidDBInstanceAutomatedBackupStateException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
}
}
return(response);
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("AlarmsLimitExceededException"))
{
return(new AlarmsLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ApplicationDoesNotExistException"))
{
return(new ApplicationDoesNotExistException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("ApplicationNameRequiredException"))
{
return(new ApplicationNameRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DeploymentConfigDoesNotExistException"))
{
return(new DeploymentConfigDoesNotExistException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DeploymentGroupAlreadyExistsException"))
{
return(new DeploymentGroupAlreadyExistsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DeploymentGroupLimitExceededException"))
{
return(new DeploymentGroupLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DeploymentGroupNameRequiredException"))
{
return(new DeploymentGroupNameRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidAlarmConfigException"))
{
return(new InvalidAlarmConfigException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidApplicationNameException"))
{
return(new InvalidApplicationNameException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidAutoRollbackConfigException"))
{
return(new InvalidAutoRollbackConfigException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidAutoScalingGroupException"))
{
return(new InvalidAutoScalingGroupException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidBlueGreenDeploymentConfigurationException"))
{
return(new InvalidBlueGreenDeploymentConfigurationException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDeploymentConfigNameException"))
{
return(new InvalidDeploymentConfigNameException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDeploymentGroupNameException"))
{
return(new InvalidDeploymentGroupNameException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDeploymentStyleException"))
{
return(new InvalidDeploymentStyleException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidEC2TagCombinationException"))
{
return(new InvalidEC2TagCombinationException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidEC2TagException"))
{
return(new InvalidEC2TagException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidLoadBalancerInfoException"))
{
return(new InvalidLoadBalancerInfoException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidOnPremisesTagCombinationException"))
{
return(new InvalidOnPremisesTagCombinationException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRoleException"))
{
return(new InvalidRoleException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidTagException"))
{
return(new InvalidTagException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidTriggerConfigException"))
{
return(new InvalidTriggerConfigException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("LifecycleHookLimitExceededException"))
{
return(new LifecycleHookLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("RoleRequiredException"))
{
return(new RoleRequiredException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TagSetListLimitExceededException"))
{
return(new TagSetListLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TriggerTargetsLimitExceededException"))
{
return(new TriggerTargetsLimitExceededException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
return(new AmazonCodeDeployException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public AssociatedInstancesException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
AssociatedInstancesException unmarshalledObject = new AssociatedInstancesException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
internal DeploymentScriptsError(ErrorResponse error)
{
Error = error;
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public InvalidLambdaFunctionAssociationException Unmarshall(XmlUnmarshallerContext context, ErrorResponse errorResponse)
{
InvalidLambdaFunctionAssociationException response = new InvalidLambdaFunctionAssociationException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
while (context.Read())
{
if (context.IsStartElement || context.IsAttribute)
{
}
}
return(response);
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public TrackingOptionsDoesNotExistException Unmarshall(XmlUnmarshallerContext context, ErrorResponse errorResponse)
{
TrackingOptionsDoesNotExistException response = new TrackingOptionsDoesNotExistException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("ConfigurationSetName", targetDepth))
{
response.ConfigurationSetName = StringUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public TooManyAccessPointsException Unmarshall(XmlUnmarshallerContext context, ErrorResponse errorResponse)
{
TooManyAccessPointsException response = new TooManyAccessPointsException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
}
}
return(response);
}
public void ShouldWriteErrorResponseCorrectly()
{
var errorMessage = "TEST123";
var output = new MemoryStream();
var converter = new MessageConverter();
var errorResponse = new ErrorResponse { Code = -10, Message = errorMessage };
var errorReader = new MessageReader(errorResponse);
converter.Convert(errorReader, new HmBinaryMessageWriter(output));
output.Seek(0, SeekOrigin.Begin);
var jsonOutput = new StringWriter();
converter.Convert(new HmBinaryMessageReader(output), new JsonMessageBuilder(jsonOutput));
var expected = "{\"faultCode\":-10,\"faultString\":\"" + errorMessage + "\"}";
jsonOutput.ToString().ShouldBe(expected);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public InvalidDeliveryChannelNameException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
InvalidDeliveryChannelNameException unmarshalledObject = new InvalidDeliveryChannelNameException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
/// <summary>
/// Invoked by the framework when a user cannot be created in the community
/// </summary>
/// <param name="username"></param>
/// <param name="emailAddress"></param>
/// <param name="userData"></param>
/// <param name="message"></param>
/// <param name="errorResponse"></param>
public virtual void UserCreationFailed(string username, string emailAddress, IDictionary<string, string> userData, string message, ErrorResponse errorResponse)
{
if (this.CommunityUserCreationFailed != null)
CommunityUserCreationFailed(this, errorResponse, new UserCreationFailedArgs(GetCurrentHttpContext())
{
UserName = username,
EmailAddress = emailAddress,
AdditionalData = userData,
Message = message
});
else
LogError(errorResponse.ToString() + ":" + message,
new ApplicationException(String.Format("Failed to create account for {0},{1}:{2}", username,
emailAddress, errorResponse)));
}
public AmazonServiceException UnmarshallException(UnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = ErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
return(new AmazonCloudWatchException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
public static void HandleError(Exception ex, HttpListenerContext context)
{
try
{
Log.ErrorFormat("Error this.ProcessRequest(context): [{0}]: {1}", ex.GetType().GetComplexTypeName(), ex.Message);
var errorResponse = new ErrorResponse
{
ResponseStatus = new ResponseStatus
{
ErrorCode = ex.GetType().GetComplexTypeName(),
Message = ex.Message,
StackTrace = ex.StackTrace,
}
};
var operationName = context.Request.GetOperationName();
var httpReq = context.ToRequest(operationName);
var httpRes = httpReq.Response;
var contentType = httpReq.ResponseContentType;
var serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
if (serializer == null)
{
contentType = HostContext.Config.DefaultContentType;
serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
}
var httpError = ex as IHttpError;
if (httpError != null)
{
httpRes.StatusCode = httpError.Status;
httpRes.StatusDescription = httpError.StatusDescription;
}
else
{
httpRes.StatusCode = 500;
}
httpRes.ContentType = contentType;
serializer(httpReq, errorResponse, httpRes);
httpRes.Close();
}
catch (Exception errorEx)
{
var error = "Error this.ProcessRequest(context)(Exception while writing error to the response): [{0}]: {1}"
.Fmt(errorEx.GetType().GetComplexTypeName(), errorEx.Message);
Log.ErrorFormat(error);
}
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public OrganizationNotInAllFeaturesModeException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
OrganizationNotInAllFeaturesModeException unmarshalledObject = new OrganizationNotInAllFeaturesModeException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
public ConvenienceModule()
{
/*
*
* First Version:
* Does not Check the rights concerning the device code.
* This will be implemented later
*
*/
// Configure Logging for this Application
Logger.Output = new ConsoleOutput();
Logger.IsActive = true;
//Logger.IsActive = false;
Before += ctx =>
{
Logger.Log("Request from: " + ctx.Request.UserHostAddress);
List<string> validAddresses = backend.GetValidIPs().Result;
// Debugging
/*List<string> validAddresses = new List<string>();
validAddresses.Add("127.0.0.1");
validAddresses.Add("localhost");
validAddresses.Add("77.182.174.215");*/
if (matchIPs(validAddresses, ctx.Request.UserHostAddress))
{
// valid
return null;
}
/*ErrorResponse err = new ErrorResponse();
err.error = "Unauthorized Source";
err.message = "This client/device/source is not authorized to use this service";
err.status = false;*/
//Response resp = new Nancy.Response();
//return JsonConvert.SerializeObject(err);
//return Response.AsText(JsonConvert.SerializeObject(err), "application/json; charset=utf-8");
Logger.Log("Rejected Connection from " + ctx.Request.UserHostAddress);
throw new Exception("This client/device/source is not authorized to use this service");
};
// Enable utf-8 for answers
After += ctx =>
{
ctx.Response.ContentType = "application/json; charset=utf-8";
};
OnError += (ctx, ex) =>
{
// maybe create specialized errors based on exception in future
var err = new ErrorResponse();
if (!(ex is Exception))
{
err.error = "unknown";
err.message = "Unknown Error occured";
return JsonConvert.SerializeObject(err);
}
Exception exx = (Exception)ex;
err.error = exx.GetType().ToString();
err.message = exx.Message;
return JsonConvert.SerializeObject(err);
};
// Base Index - Hello World or other status indication should be set
Get["/"] = parameters =>
{
Logger.Log("Server", "/ called");
return "Hello World";
};
// Status indicator
Get["/status", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/status called");
// Basic Idea: Just call somethin. If this fails, the backend server may be down/corrupted (e.g. MySQL Driver problem likely to happn..)
try
{
await backend.GetActiveUsersAsync("Foo");
return "True";
}
catch (Exception ex)
{
Logger.Log("Server", "Exception caught: " + ex.Message);
return "False: "+ex.Message;
}
};
Get["/restart.token={token}"] = parameters =>
{
Logger.Log("Server", "/restart called");
// Idea: restart the backend in case of problems
backend = null;
backend = new ConvenienceServer();
return "Backend restarted";
};
// Just testing around
Post["/"] = parameters =>
{
Logger.Log("Server (POST)", "/ called");
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
BaseResponse f = JsonConvert.DeserializeObject<BaseResponse>(b);
return f;
}
catch
{
return "please provide valid JSON";
}
};
/*Get["/viewAllUsers/{token}", runAsync:true] = async (parameters,CancelToken) =>
{
return parameters.token;
};*/
#region Basic Get/View Calls
Get["/viewAllUsers.token={token}", runAsync:true] = async (parameters,cancelToken) =>
{
/*string test = parameters.token;
return test;*/
Logger.Log("Server", "/viewAllUsers called");
UsersResponse response = new UsersResponse();
try
{
var users = await backend.GetAllUsersAsync((string)parameters.token);
response.dataSet = users;
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: "+ex.Message);
}
return response;
/*string test = parameters.token;
return test;*/
};
Get["/viewActiveUsers.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewActiveUsers called");
UsersResponse response = new UsersResponse();
try
{
var users = await backend.GetActiveUsersAsync((string)parameters.token);
response.dataSet = users;
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewAllProducts.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewAllProducts called");
ProductsResponse response = new ProductsResponse();
try
{
response.dataSet = await backend.GetFullProductsAsync((string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewAllDebtSinceKeyDate.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewAllDebtSinceKeyDate called");
var response = new UsersResponse();
try
{
response.dataSet = await backend.GetDebtSinceKeyDateAsync((string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewAccountingCountSince.date={date}.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewAccountingCountSince called");
var response = new ProductsCountResponse();
try
{
string c = parameters.date;
response.dataSet = await backend.GetAccountingCountSince((string)parameters.token, c);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewLastActivity.count={count}.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewLastActivity called");
var response = new AccountingElementsResponse();
try
{
string c = parameters.count;
int count;
if (int.TryParse(c,out count))
response.dataSet = await backend.GetLastActivityAsync((string)parameters.token,count);
else
response.dataSet = await backend.GetLastActivityAsync((string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewProductsCountForUser.user={user}.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewProductsCountForUser called");
var response = new ProductsCountResponse();
try
{
string c = parameters.user;
response.dataSet = await backend.GetProductsCountForUserAsync(c, (string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewKeyDates.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewKeyDates called");
var response = new KeyDatesResponse();
try
{
response.dataSet = await backend.GetKeyDatesAsync((string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewMails.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewMails called");
var response = new MailsResponse();
try
{
response.dataSet = await backend.GetMailsAsync((string)parameters.token);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Get["/viewAccountingForUser.user={user}.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server", "/viewAccountingForUser called");
var response = new AccountingElementsResponse();
try
{
response.dataSet = await backend.GetAccountingForUserAsync((string)parameters.token, (string)parameters.user);
response.status = true;
}
catch (Exception ex)
{
response.errorDescription = ex.Message;
response.status = false;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
#endregion
Post["/verifyWebUser.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (Post)", "/verifyWebUser called");
var response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
WebLoginRequest request = JsonConvert.DeserializeObject<WebLoginRequest>(b);
response.status = await backend.VerifyWebUser(request.username,request.password,(string)parameters.token);
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/revert.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (Post)", "/revert called");
var response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
RevertRequest request = JsonConvert.DeserializeObject<RevertRequest>(b);
int id = 0;
if (int.TryParse(request.id, out id))
{
// id is of type integer, so try performing the action
bool succ = await backend.RevertAccounting((string)parameters.token, id);
response.status = succ;
}
else
{
throw new Exception("id needs to be an integer value.");
}
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/emptyMail.token={token}"] = parameters =>
{
Logger.Log("Server (Post)", "/emptyMail called");
var response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
EmptyMailRequest request = JsonConvert.DeserializeObject<EmptyMailRequest>(b);
backend.SendEmptyMail(request.message);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/insertKeyDate.token={token}", runAsync:true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/insertKeyDate called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
InsertKeyDateRequest request = JsonConvert.DeserializeObject<InsertKeyDateRequest>(b);
// do stuff
await backend.InsertKeyDateAsync((string)parameters.token,comment: request.comment);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/addUser.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/addUser called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
CreateuserRequest request = JsonConvert.DeserializeObject<CreateuserRequest>(b);
// do stuff
await backend.AddUserAsync((string)parameters.token, request.user, request.comment, request.state);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/updateUser.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/updateUser called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
UpdateUsersRequest request = JsonConvert.DeserializeObject<UpdateUsersRequest>(b);
// do stuff
response.dataset = await backend.UpdateUsersAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/deleteUser.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/deleteUser called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
DeleteRequest request = JsonConvert.DeserializeObject<DeleteRequest>(b);
// do stuff
response.dataset = await backend.DeleteUsersAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/updateMails.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/updateMails called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
UpdateMailRequest request = JsonConvert.DeserializeObject<UpdateMailRequest>(b);
// do stuff
await backend.UpdateMailsAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/deleteMails.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/deleteMails called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
DeleteMailRequest request = JsonConvert.DeserializeObject<DeleteMailRequest>(b);
// do stuff
await backend.DeleteMailsAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/addMail.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/addMail called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
CreateMailRequest request = JsonConvert.DeserializeObject<CreateMailRequest>(b);
// do stuff
await backend.AddMailAsync((string)parameters.token, request.username, request.adress);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/updateProduct.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/updateProduct called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
UpdateProductsRequest request = JsonConvert.DeserializeObject<UpdateProductsRequest>(b);
// do stuff
response.dataset = await backend.UpdateProductsAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/deleteProduct.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/deleteProduct called");
UpdateResponse response = new UpdateResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
DeleteRequest request = JsonConvert.DeserializeObject<DeleteRequest>(b);
// do stuff
response.dataset = await backend.DeleteProductsAsync((string)parameters.token, request.dataSet);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/addProduct.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/addProduct called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
CreateProductRequest request = JsonConvert.DeserializeObject<CreateProductRequest>(b);
// do stuff
await backend.AddProductAsync((string)parameters.token, request.product, request.comment, request.price);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/buyProducts.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/buyProducts called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
BuyProductsRequest request = JsonConvert.DeserializeObject<BuyProductsRequest>(b);
// do stuff
await backend.BuyAsync((string)parameters.token, request.username, request.products);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
Post["/buyDirectly.token={token}", runAsync: true] = async (parameters, cancelToken) =>
{
Logger.Log("Server (POST)", "/buyDirectly called");
BaseResponse response = new BaseResponse();
try
{
byte[] array = new byte[Request.Body.Length];
var a = Request.Body.Read(array, 0, array.Length);
//return parameters;
var b = Encoding.UTF8.GetString(array);
BuyDirectlyRequest request = JsonConvert.DeserializeObject<BuyDirectlyRequest>(b);
// do stuff
await backend.BuyDirectlyAsync((string)parameters.token, request.username, request.comment, request.price);
//await backend.BuyAsync((string)parameters.token, request.username, request.products);
response.status = true;
}
catch (Exception ex)
{
response.status = false;
response.errorDescription = ex.Message;
Logger.Log("Server", "Error occured: " + ex.Message);
}
return response;
};
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(XmlUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = ErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
errorResponse.InnerException = innerException;
errorResponse.StatusCode = statusCode;
var responseBodyBytes = context.GetResponseBodyBytes();
using (var streamCopy = new MemoryStream(responseBodyBytes))
using (var contextCopy = new XmlUnmarshallerContext(streamCopy, false, null))
{
if (errorResponse.Code != null && errorResponse.Code.Equals("DBClusterAlreadyExistsFault"))
{
return(DBClusterAlreadyExistsExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DBClusterNotFoundFault"))
{
return(DBClusterNotFoundExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DBClusterQuotaExceededFault"))
{
return(DBClusterQuotaExceededExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DBClusterSnapshotNotFoundFault"))
{
return(DBClusterSnapshotNotFoundExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("DBSubnetGroupNotFoundFault"))
{
return(DBSubnetGroupNotFoundExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InsufficientDBClusterCapacityFault"))
{
return(InsufficientDBClusterCapacityExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InsufficientStorageClusterCapacity"))
{
return(InsufficientStorageClusterCapacityExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDBClusterSnapshotStateFault"))
{
return(InvalidDBClusterSnapshotStateExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDBClusterStateFault"))
{
return(InvalidDBClusterStateExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDBSnapshotState"))
{
return(InvalidDBSnapshotStateExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRestoreFault"))
{
return(InvalidRestoreExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidSubnet"))
{
return(InvalidSubnetExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidVPCNetworkStateFault"))
{
return(InvalidVPCNetworkStateExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("KMSKeyNotAccessibleFault"))
{
return(KMSKeyNotAccessibleExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("StorageQuotaExceeded"))
{
return(StorageQuotaExceededExceptionUnmarshaller.Instance.Unmarshall(contextCopy, errorResponse));
}
}
return(new AmazonDocDBException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public IncompatibleRegionForMultiAZException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
IncompatibleRegionForMultiAZException unmarshalledObject = new IncompatibleRegionForMultiAZException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public LifecyclePolicyPreviewNotFoundException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
LifecyclePolicyPreviewNotFoundException unmarshalledObject = new LifecyclePolicyPreviewNotFoundException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public FieldLevelEncryptionProfileAlreadyExistsException Unmarshall(XmlUnmarshallerContext context, ErrorResponse errorResponse)
{
FieldLevelEncryptionProfileAlreadyExistsException response = new FieldLevelEncryptionProfileAlreadyExistsException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
while (context.Read())
{
if (context.IsStartElement || context.IsAttribute)
{
}
}
return(response);
}
public static void WriteUnhandledErrorResponse(IRequest httpReq, Exception ex)
{
var errorResponse = new ErrorResponse
{
ResponseStatus = new ResponseStatus
{
ErrorCode = ex.GetType().GetOperationName(),
Message = ex.Message,
StackTrace = ex.StackTrace,
}
};
var httpRes = httpReq.Response;
var contentType = httpReq.ResponseContentType;
var serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
if (serializer == null)
{
contentType = HostContext.Config.DefaultContentType;
serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
}
var httpError = ex as IHttpError;
if (httpError != null)
{
httpRes.StatusCode = httpError.Status;
httpRes.StatusDescription = httpError.StatusDescription;
}
else
{
httpRes.StatusCode = 500;
}
httpRes.ContentType = contentType;
serializer(httpReq, errorResponse, httpRes);
httpRes.Close();
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public UnsupportedGrantTypeException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
UnsupportedGrantTypeException unmarshalledObject = new UnsupportedGrantTypeException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("error", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
unmarshalledObject.Error = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("error_description", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
unmarshalledObject.Error_description = unmarshaller.Unmarshall(context);
continue;
}
}
return(unmarshalledObject);
}
/// <summary>
/// On Error
/// </summary>
/// <param name="errorResponse"></param>
public void OnError(ErrorResponse errorResponse)
{
ErrorMessagePage page = new ErrorMessagePage();
page.Heading = String.IsNullOrEmpty(errorResponse.StackTrace) ? "Opps! Something went wrong" : "Internal Server Error";
page.Text = errorResponse.Text;
page.StackTrace = errorResponse.StackTrace;
this.Partial = page;
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public ResourceAlreadyExistsException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
ResourceAlreadyExistsException unmarshalledObject = new ResourceAlreadyExistsException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("resourceArn", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
unmarshalledObject.ResourceArn = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("resourceId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
unmarshalledObject.ResourceId = unmarshaller.Unmarshall(context);
continue;
}
}
return(unmarshalledObject);
}
public static Response AsErrorResponse(this IResponseFormatter source, ErrorResponse error, string redirectUri)
{
return source.AsRedirect(string.Concat(redirectUri, error.AsQueryString()));
}
/// <summary>
/// Unmarshaller error response to exception.
/// </summary>
/// <param name="context"></param>
/// <param name="innerException"></param>
/// <param name="statusCode"></param>
/// <returns></returns>
public override AmazonServiceException UnmarshallException(XmlUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = ErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
return new AmazonEC2Exception(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public ServiceUnavailableException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
ServiceUnavailableException unmarshalledObject = new ServiceUnavailableException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
}
return(unmarshalledObject);
}
public override AmazonServiceException UnmarshallException(XmlUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = ErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("AccessDenied"))
{
return(new AccessDeniedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("CNAMEAlreadyExists"))
{
return(new CNAMEAlreadyExistsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("IllegalUpdate"))
{
return(new IllegalUpdateException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InconsistentQuantities"))
{
return(new InconsistentQuantitiesException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidArgument"))
{
return(new InvalidArgumentException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidDefaultRootObject"))
{
return(new InvalidDefaultRootObjectException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidErrorCode"))
{
return(new InvalidErrorCodeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidForwardCookies"))
{
return(new InvalidForwardCookiesException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidGeoRestrictionParameter"))
{
return(new InvalidGeoRestrictionParameterException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidHeadersForS3Origin"))
{
return(new InvalidHeadersForS3OriginException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidIfMatchVersion"))
{
return(new InvalidIfMatchVersionException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidLocationCode"))
{
return(new InvalidLocationCodeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidOriginAccessIdentity"))
{
return(new InvalidOriginAccessIdentityException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRelativePath"))
{
return(new InvalidRelativePathException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidRequiredProtocol"))
{
return(new InvalidRequiredProtocolException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidResponseCode"))
{
return(new InvalidResponseCodeException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("InvalidViewerCertificate"))
{
return(new InvalidViewerCertificateException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("MissingBody"))
{
return(new MissingBodyException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NoSuchDistribution"))
{
return(new NoSuchDistributionException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("NoSuchOrigin"))
{
return(new NoSuchOriginException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("PreconditionFailed"))
{
return(new PreconditionFailedException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyCacheBehaviors"))
{
return(new TooManyCacheBehaviorsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyCertificates"))
{
return(new TooManyCertificatesException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyCookieNamesInWhiteList"))
{
return(new TooManyCookieNamesInWhiteListException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyDistributionCNAMEs"))
{
return(new TooManyDistributionCNAMEsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyHeadersInForwardedValues"))
{
return(new TooManyHeadersInForwardedValuesException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyOrigins"))
{
return(new TooManyOriginsException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TooManyTrustedSigners"))
{
return(new TooManyTrustedSignersException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
if (errorResponse.Code != null && errorResponse.Code.Equals("TrustedSignerDoesNotExist"))
{
return(new TrustedSignerDoesNotExistException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
return(new AmazonCloudFrontException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
public static void HandleError(Exception ex, HttpListenerContext context)
{
try
{
var errorResponse = new ErrorResponse
{
ResponseStatus = new ResponseStatus
{
ErrorCode = ex.GetType().Name,
Message = ex.Message,
StackTrace = ex.StackTrace,
}
};
var operationName = context.Request.GetOperationName();
var httpReq = new ListenerRequest(operationName, context.Request);
var httpRes = new ListenerResponse(context.Response);
var requestCtx = new HttpRequestContext(httpReq, httpRes, errorResponse);
var contentType = requestCtx.ResponseContentType;
var serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
if (serializer == null)
{
contentType = HostContext.Config.DefaultContentType;
serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
}
httpRes.StatusCode = 500;
httpRes.ContentType = contentType;
serializer(requestCtx, errorResponse, httpRes);
httpRes.Close();
}
catch (Exception errorEx)
{
var error = "Error this.ProcessRequest(context)(Exception while writing error to the response): [{0}]: {1}"
.Fmt(errorEx.GetType().Name, errorEx.Message);
Log.ErrorFormat(error);
}
}
/// <summary>
/// Gets a list of workflow trigger histories.
/// </summary>
/// <param name='nextPageLink'>
/// The NextLink from the previous successful call to List operation.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <IPage <WorkflowTriggerHistory> > > ListNextWithHttpMessagesAsync(string nextPageLink, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (nextPageLink == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "nextPageLink");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("nextPageLink", nextPageLink);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "ListNext", tracingParameters);
}
// Construct URL
string _url = "{nextLink}";
_url = _url.Replace("{nextLink}", nextPageLink);
List <string> _queryParameters = new List <string>();
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("GET");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <IPage <WorkflowTriggerHistory> >();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <Page <WorkflowTriggerHistory> >(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public LoginResponseDTO(bool success = false, ErrorResponse errorResponse = null) : base(success, errorResponse)
{
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <param name="errorResponse"></param>
/// <returns></returns>
public AssessmentRunInProgressException Unmarshall(JsonUnmarshallerContext context, ErrorResponse errorResponse)
{
context.Read();
AssessmentRunInProgressException unmarshalledObject = new AssessmentRunInProgressException(errorResponse.Message, errorResponse.InnerException,
errorResponse.Type, errorResponse.Code, errorResponse.RequestId, errorResponse.StatusCode);
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("assessmentRunArns", targetDepth))
{
var unmarshaller = new ListUnmarshaller <string, StringUnmarshaller>(StringUnmarshaller.Instance);
unmarshalledObject.AssessmentRunArns = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("assessmentRunArnsTruncated", targetDepth))
{
var unmarshaller = BoolUnmarshaller.Instance;
unmarshalledObject.AssessmentRunArnsTruncated = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("canRetry", targetDepth))
{
var unmarshaller = BoolUnmarshaller.Instance;
unmarshalledObject.CanRetry = unmarshaller.Unmarshall(context);
continue;
}
}
return(unmarshalledObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientException"/> class.
/// </summary>
/// <param name="error">The error entity.</param>
/// <param name="httpStatus">The http status.</param>
public ClientException(ErrorResponse error, HttpStatusCode httpStatus)
{
this.Error = error;
this.HttpStatus = httpStatus;
}
/// <summary>
/// Updates the billing property of a subscription. Currently, cost center can
/// be updated. The operation is supported only for billing accounts with
/// agreement type Microsoft Customer Agreement.
/// </summary>
/// <param name='parameters'>
/// Request parameters that are provided to the update billing property
/// operation.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <BillingProperty> > UpdateWithHttpMessagesAsync(BillingProperty parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
if (parameters == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("parameters", parameters);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "Update", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/providers/Microsoft.Billing/billingProperty/default").ToString();
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
List <string> _queryParameters = new List <string>();
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PATCH");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (parameters != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <BillingProperty>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <BillingProperty>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
