public virtual ResponsePackage <T> CommonResult <T>(Func <T> handler, Action <ResponsePackage <T> > infoLog = null)
{
var result = new ResponsePackage <T>();
var extionData = new ResponseExtensionData
{
ModelValidateErrors = new List <ModelValidateError>(),
CallResult = CallResult.Success,
RetMsg = LanguageUtil.Translate("api_Controller_AppApi_CommonResult_RetMsg")
};
try
{
AssertUtil.IsNotNull(handler, LanguageUtil.Translate("api_Controller_AppApi_CommonResult_handler"));
var o = handler();
result.Data = o;
if (infoLog != null)
{
infoLog(result);
}
}
catch (AssertException ex)
{
extionData.CallResult = CallResult.BusinessError;
extionData.RetMsg = string.Format(LanguageUtil.Translate("api_Controller_AppApi_CommonResult_AssertException"), ex.Message);
result.Data = default(T);
}
catch (Exception ex)
{
extionData.CallResult = CallResult.BusinessError;
extionData.RetMsg = string.Format(LanguageUtil.Translate("api_Controller_AppApi_CommonResult_Exception"), ex.Message);
result.Data = default(T);
}
result.ExtensionData = extionData;
return(result);
}
private const string EncryptValue = "5bvv"; // TODO 可配置 AxOne
public override void OnActionExecuting(HttpActionContext filterContext)
{
var headers = filterContext.Request.Headers;
var data = new ResponseExtensionData
{
CallResult = CallResult.Unauthorized,
RetMsg = LanguageUtil.Translate("api_Filters_AuthCodeAttribute_CheckAppAttribute_OnActionExecuting_RetMsg"),
ModelValidateErrors = new List <ModelValidateError>()
};
if (headers.Contains("appkey"))
{
var appKeyStr = headers.GetValues("appkey").First();
var authKeys = ((IContainer)HttpRuntime.Cache["containerKey"]).Resolve <IAuthKeysBusiness>().GetAuthKeys(0, AuthUserType.Application);
if (string.IsNullOrEmpty(appKeyStr) || authKeys == null || string.IsNullOrWhiteSpace(authKeys.PrivateKey))
{
filterContext.Response = filterContext.ControllerContext.Request.CreateErrorResponseByReturnType(filterContext, data);
return;
}
var encryptValue = RSAHelper.DecryptString(appKeyStr, authKeys.PrivateKey);
if (string.IsNullOrWhiteSpace(encryptValue) || !string.Equals(encryptValue, EncryptValue))
{
filterContext.Response = filterContext.ControllerContext.Request.CreateErrorResponseByReturnType(filterContext, data);
return;
}
}
else
{
filterContext.Response = filterContext.ControllerContext.Request.CreateErrorResponseByReturnType(filterContext, data);
return;
}
base.OnActionExecuting(filterContext);
}
public virtual ResponsePackage <T> PackageActionResult <T>(T value, ResponseExtensionData extentionData)
{
if (extentionData == null)
{
extentionData = ResponseExtensionData;
}
return(new ResponsePackage <T> {
Data = value, ExtensionData = extentionData
});
}
public override void OnActionExecuting(HttpActionContext filterContext)
{
var headers = filterContext.Request.Headers;
var result = new ResponsePackage <object>();
var extionData = new ResponseExtensionData
{
ModelValidateErrors = new List <ModelValidateError>(),
CallResult = CallResult.Unauthorized,
RetMsg = LanguageUtil.Translate("api_Filters_AuthCodeAttribute_CheckAppLoginAttribute_OnActionExecuting_RetMsg")
};
if (!headers.Contains("uid"))
{
result.Data = null;
result.ExtensionData = extionData;
filterContext.Response = filterContext.Request.CreateResponse(HttpStatusCode.OK, result);
return;
}
var uid = Convert.ToInt32(headers.GetValues("uid").First());
if (headers.Contains("token") && uid > 0)
{
const AuthUserType userType = (AuthUserType)2;
var tokenEncryptStr = headers.GetValues("token").First();
var authKeys = ((IContainer)HttpRuntime.Cache["containerKey"]).Resolve <IAuthKeysBusiness>().GetAuthKeys(uid, userType);
if (string.IsNullOrEmpty(tokenEncryptStr) || authKeys == null || authKeys.PrivateKey == null)
{
result.Data = null;
result.ExtensionData = extionData;
filterContext.Response = filterContext.Request.CreateResponse(HttpStatusCode.OK, result);
return;
}
var tokenDecryptStr = RSAHelper.DecryptString(tokenEncryptStr, authKeys.PrivateKey);
if (string.IsNullOrWhiteSpace(tokenDecryptStr) || !string.Equals(tokenDecryptStr, uid.ToString()))
{
result.Data = null;
result.ExtensionData = extionData;
filterContext.Response = filterContext.Request.CreateResponse(HttpStatusCode.OK, result);
return;
}
}
else
{
result.Data = null;
result.ExtensionData = extionData;
filterContext.Response = filterContext.Request.CreateResponse(HttpStatusCode.OK, result);
return;
}
base.OnActionExecuting(filterContext);
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
var modelState = actionContext.ModelState;
if (modelState.IsValid &&
(actionContext.ActionArguments.Count != 1 || actionContext.ActionArguments.ElementAt(0).Value != null))
{
return;
}
IList <ModelValidateError> errors;
if (modelState.IsValid)
{
errors = new List <ModelValidateError> {
new ModelValidateError
{
Key = LanguageUtil.Translate("api_Filters_AuthCodeAttribute_ModelValidateAttribute_OnActionExecuting_Key"),
Value = LanguageUtil.Translate("api_Filters_AuthCodeAttribute_ModelValidateAttribute_OnActionExecuting_Value")
}
};
}
else
{
errors = modelState.Where(w => modelState[w.Key].Errors.Any()).Select(w => new ModelValidateError {
Key = w.Key, Value = string.Join(";", w.Value.Errors.Select(t => t.ErrorMessage))
}).ToList();
}
string msg;
if (errors.Any() && !string.IsNullOrWhiteSpace(errors.First().Value))
{
msg = errors.First().Value;
}
else
{
msg = LanguageUtil.Translate("api_Filters_AuthCodeAttribute_ModelValidateAttribute_OnActionExecuting_msg");
}
var data = new ResponseExtensionData
{
CallResult = CallResult.ModelError,
RetMsg = msg,
ModelValidateErrors = errors
};
actionContext.Response = actionContext.ControllerContext.Request.CreateErrorResponseByReturnType(actionContext, data);
}
/// <summary>
/// 根据Action的返回类型创建对应的错误响应信息
/// </summary>
/// <param name="request">request</param>
/// <param name="actionContext">actionContext</param>
/// <param name="extensionData">extensionData</param>
/// <param name="statusCode">statusCode</param>
/// <returns></returns>
public static HttpResponseMessage CreateErrorResponseByReturnType(this HttpRequestMessage request
, HttpActionContext actionContext, ResponseExtensionData extensionData, HttpStatusCode statusCode = HttpStatusCode.OK)
{
if (actionContext.ControllerContext.Controller is AppApiControllerBase)
{
return(CreateResponse(request, (object)null, actionContext.ControllerContext, statusCode, extensionData));
}
var returnType = actionContext.ActionDescriptor.ReturnType;
if (returnType.IsValueType || returnType == typeof(string))
{
return(request.CreateResponse(statusCode, (object)null));
}
if (!returnType.IsGenericType)
{
return(request.CreateResponse(statusCode, (object)null));
}
var genericType = returnType.GetGenericTypeDefinition();
if (genericType == typeof(ResponsePackage <>))
{
return(request.CreateResponse(statusCode
, new ResponsePackage <object> {
Data = null, ExtensionData = extensionData
}));
}
return(request.CreateResponse(statusCode, (object)null));
}
public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, T value, HttpControllerContext controllerContext, HttpStatusCode statusCode = HttpStatusCode.OK, ResponseExtensionData responseExtensionData = null)
{
var baseController = controllerContext.Controller as AppApiControllerBase;
if (baseController == null)
{
return(request.CreateResponse(statusCode, value, controllerContext.Configuration));
}
if (responseExtensionData == null && typeof(T).Name.Contains("ResponsePackage"))
{
return(request.CreateResponse(statusCode, baseController.PackageResult(value), controllerContext.Configuration));
}
return(request.CreateResponse(statusCode, baseController.PackageActionResult(value, responseExtensionData), controllerContext.Configuration));
}
