/// <summary>
/// Unifies the possible error messages
/// </summary>
/// <param name="parameter">Name of the parameter on which the error took place</param>
/// <param name="ret">Error type</param>
/// <returns>Hashtable that has to be returned to the client</returns>
public static Hashtable GenerateErrorHashtable(String parameter, ResponseErrorType ret)
{
Hashtable h = new Hashtable();
switch (ret)
{
case ResponseErrorType.ParameterConvertError:
h.Add("error", "Following parameter could not be converted: " + parameter + " to the right format (int, string, ...).");
break;
case ResponseErrorType.ParameterMissing:
h.Add("error", "Following parameter was not submitted: " + parameter + ". Please include it in your URL");
break;
case ResponseErrorType.InternalValueNotSet:
h.Add("error", "An internal error accured. Following value could not be set: " + parameter + ". Please check the requested method's source code");
break;
case ResponseErrorType.ParameterRangeException:
h.Add("error", "Following parameter was out of range: " + parameter + ".");
break;
case ResponseErrorType.InternalOperationError:
h.Add("error", "An internal error accured. Following code part threw the error: " + parameter + ". Please check the requested method's source code");
break;
}
return(h);
}
/// <summary>
/// UserInfoResponse
/// </summary>
/// <param name="exception">exception</param>
public UserInfoResponse(Exception exception)
{
IsError = true;
Error = exception.Message;
Exception = exception;
ErrorType = ResponseErrorType.Exception;
}
/// <summary>
/// Handles exception response from UserInfo api call
/// </summary>
/// <param name="statusCode">statusCode</param>
/// <param name="reason">reason</param>
public UserInfoResponse(HttpStatusCode statusCode, string httpErrorReason)
{
IsError = true;
HttpStatusCode = statusCode;
ErrorType = ResponseErrorType.Http;
Error = httpErrorReason;
}
public ErrorOut(HttpStatusCode code, string message, ResponseErrorType errorType, string errorProperty, string errorCode) : this()
{
this.ErrorMessage = message;
this.ErrorStatusCode = code;
this.ErrorProperty = errorProperty;
this.ErrorType = errorType;
this.ErrorCode = string.IsNullOrEmpty(errorCode) ? KRFConstants.DefaultErrorCode : errorCode;
}
static public Response DefineError(Request request, ResponseErrorType type)
{
return(new Response(status: ResponseStatus.Error, onRequest: request.Type, data: new Dictionary <string, string>
{
["Error Type"] = Mapper[type].Item1,
["Error Message"] = Mapper[type].Item2
}));
}
/// <summary>
/// Initializes a protocol response from an exception
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ex">The ex.</param>
/// <param name="errorType"></param>
/// <param name="errorMessage">The error message.</param>
/// <returns></returns>
public static T FromException <T>(Exception ex, ResponseErrorType errorType, string errorMessage = null) where T : ProtocolResponse <TV>, new()
{
var response = new T
{
Exception = ex,
ErrorType = errorType,
ErrorMessage = errorMessage
};
return(response);
}
private void GetMessage(string code)
{
Assembly assem = Assembly.GetExecutingAssembly();
using (Stream stream = assem.GetManifestResourceStream("TOP.Core.Facade.ErrorMessage.xml"))
{
XmlDocument doc = new XmlDocument();
doc.Load(stream);
XmlElement element = doc.DocumentElement;
foreach (XmlNode node in element.ChildNodes)
{
if (node.Name.Equals("error", StringComparison.OrdinalIgnoreCase))
{
XmlAttribute attrCode = node.Attributes["code"];
if (attrCode != null)
{
if (attrCode.Value == code)
{
XmlAttribute attrType = node.Attributes["type"];
XmlAttribute attrMsgEn = node.Attributes["description"];
XmlAttribute attrMsgCh = node.Attributes["message"];
if (attrType != null)
{
if (attrType.Value.Equals("system", StringComparison.OrdinalIgnoreCase))
{
errorType = ResponseErrorType.System;
}
else if (attrType.Value.Equals("business", StringComparison.OrdinalIgnoreCase))
{
errorType = ResponseErrorType.Business;
}
}
if (attrMsgEn != null)
{
errorMessageEn = attrMsgEn.Value;
}
if (attrMsgCh != null)
{
errorMessageCh = attrMsgCh.Value;
}
break;
}
}
}
}
}
}
/// <summary>
/// Handles successful raw response from UserInfo api call
/// </summary>
/// <param name="raw">raw</param>
public UserInfoResponse(string raw)
{
Raw = raw;
HttpStatusCode = HttpStatusCode.OK;
IsError = false;
try
{
Json = JObject.Parse(raw);
Claims = Json.ToClaims();
}
catch (Exception ex)
{
IsError = true;
Error = ex.Message;
Exception = ex;
ErrorType = ResponseErrorType.Exception;
}
}
public async Task Handle_ErrorMessageFromXmg_ShouldRejectCost(ResponseErrorType errorType)
{
// Arrange
var cost = MockCost();
var payload = new { errorMessages = new[] { new { type = ((int)errorType).ToString(), message = "Error messages" } } };
var message = new PurchaseOrderErrorResponse
{
ActivityType = "Error",
ClientName = BuType.Pg.ToString(),
EventTimeStamp = DateTime.Now,
CostNumber = cost.CostNumber,
Payload = JObject.Parse(JsonConvert.SerializeObject(payload))
};
var response = new ApprovalServiceActionResult {
Success = true, ApprovalType = "Brand"
};
var costUser = new CostUser {
GdamUserId = "alsjdnaljsdn"
};
var adminUser = new CostUser {
Email = ApprovalMemberModel.BrandApprovalUserEmail
};
var adminUserIdentity = new SystemAdminUserIdentity(adminUser);
var costUserSetMock = _efContextMock.MockAsyncQueryable(new List <CostUser> {
costUser, adminUser
}.AsQueryable(), context => context.CostUser);
costUserSetMock.Setup(u => u.FindAsync(It.IsAny <Guid>())).ReturnsAsync(costUser);
_approvalServiceMock.Setup(a => a.Reject(cost.Id, adminUserIdentity, BuType.Pg, "Error messages", SourceSystem.Coupa)).ReturnsAsync(response);
// Act
await _handler.Handle(message);
// Assert
_approvalServiceMock.Verify(s => s.Reject(cost.Id, adminUserIdentity, BuType.Pg, "Error messages", SourceSystem.Coupa));
}
public ErrorOut(HttpStatusCode code, string message, ResponseErrorType errorType, string errorCode)
: this(code, message, errorType, null, errorCode)
{
}
public void ErrorType_ReturnsCorrectEnumType(string errorMessage, ResponseErrorType expectedErrorType)
{
var errorResponse = new OMDBErrorResponse(errorMessage);
Assert.AreEqual(expectedErrorType, errorResponse.ErrorType);
}
public ErrorResponse(ResponseErrorType errotType, string message = null)
{
ErrotType = errotType;
Message = message;
}
