public void ProcessRequest(HttpContext context)
{
LoginResponseDTO res;
LoginRequestDTO dto = new LoginRequestDTO()
{
PlatformId = HttpExtension.GetRequestParam("PlatformId"),
UserCode = HttpExtension.GetRequestParam("UserCode"),
UserPassword = HttpExtension.GetRequestParam("UserPassword")
};
if (dto.PlatformId.IsEmpty() || dto.UserCode.IsEmpty() || dto.UserPassword.IsEmpty())
{
res = new LoginResponseDTO()
{
Success = false,
ErrorMsg = "登陆信息不完整"
};
}
else
{
res = new CommonController().Login(dto);
}
context.Response.ContentType = "text/plain";
context.Response.Write(res.ToJson());
}
void Start()
{
HttpExtension httpExtension = new HttpExtension();
string source = httpExtension.GetHttpWebRequest(url);
Debug.Log(source);
}
public static SearchItem GetAllPram()
{
SearchItem item = new Results.SearchItem();
item.Values = HttpExtension.GetRequestParam <Dictionary <string, string> >("Data");
item.PageInfo = PageInfo.GetPageinfoFormUI();
return(item);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
UIResult res;
//异常处理
if (filterContext.Exception != null)
{
filterContext.ExceptionHandled = true;
if (filterContext.Exception.GetInnerException() is zExceptionBase)
{
zExceptionBase ex = filterContext.Exception.GetInnerException() as zExceptionBase;
res = new UIResult()
{
Flag = ex.Flag,
Msg = ex.Message
};
}
else
{
res = new UIResult()
{
Flag = -1,
Msg = filterContext.Exception.InnerMessage()
};
}
filterContext.Result = res;
}
if (filterContext.Result is EmptyResult)
{
filterContext.Result = new UIResult();
}
if (filterContext.Result is UIResult)
{
filterContext.Result = new UIResult()
{
Data = (filterContext.Result as UIResult).GetData()
};
}
}
else
{
filterContext.Controller.ViewBag.ControllerUrl =
IOExtension.MakeUri(
HttpExtension.GetWebBasePath(),
filterContext.RouteData.Values["area"].ToString(),
filterContext.RouteData.Values["controller"].ToString()) + "/";
filterContext.Controller.ViewBag.CommonControllerUrl =
IOExtension.MakeUri(
HttpExtension.GetWebBasePath(),
"Base",
"Common") + "/";
}
}
public void ProcessRequest(HttpContext context)
{
var res = new CommonController().Do(new RequestDTO()
{
SecretKey = HttpExtension.GetRequestParam("SecretKey"),
ServiceName = HttpExtension.GetRequestParam("ServiceName"),
Context = HttpExtension.GetRequestParam("Context")
});
context.Response.ContentType = "text/plain";
context.Response.Write(res.ToJson());
}
public IActionResult VerifyCode()
{
string codeValue = "";
var codeImg = ValidateCode.CreateImage(out codeValue, 6);
codeValue = codeValue.ToUpper();//验证码不分大小写
HttpExtension.SetSession(Consts.Session_ValidateCode, codeValue);
Response.Body.Dispose();
return(File(codeImg, @"image/png"));
}
/// <summary>
/// Gets the cookie values.
/// </summary>
/// <param name="cookieKey">The cookie key.</param>
/// <returns></returns>
public override IEnumerable <string> GetCookieValues(string cookieKey)
{
List <string> result = new List <string>();
if (!string.IsNullOrWhiteSpace(cookieKey))
{
var cookieString = Request.Headers.GetValue(HttpConstants.HttpHeader.Cookie);
var cookieMatrix = HttpExtension.ConvertCookieStringToMatrix(cookieString);
cookieMatrix.TryGetValue(cookieKey, out result);
}
return(result?.Select(x => x.ToUrlDecodedText()));
}
public static PageInfo GetPageinfoFormUI()
{
PageInfo p = new DbDomain.PageInfo();
if (string.IsNullOrEmpty(HttpExtension.GetRequestParam("page")))
{
p.PageIndex = p.PageSize = 0;
}
else
{
p.PageIndex = HttpExtension.GetRequestParam("page").ToInt() - 1;
p.PageSize = HttpExtension.GetRequestParam("rows").ToInt();
}
return(p);
}
/// <summary>
///
/// </summary>
/// <param name="purchase"></param>
/// <returns></returns>
/// <exception cref="DataConflictException">When product definition has changed on server</exception>
public async Task <PurchasedItem> AddPuchase(PurchaseOrder purchase)
{
return(await HttpExtension.AskRetryOnHttpStatusFail(
async() => {
try
{
return await _connectionService.PostJsonAuthorizedAsync <PurchaseOrder, PurchasedItem>(purchase, u => u.Shop.User);
}
catch (HttpStatusCodeException ex) when(ex.Status == HttpStatusCode.Conflict)
{
var proposal = JsonConvert.DeserializeObject <PurchaseOrder>(ex.Content);
throw new DataConflictException(proposal);
}
}));
}
public async Task <Urls> GetUrls()
{
if (_result != null)
{
return(_result);
}
var client = CreateHttpClient(x => x);
_result = await HttpExtension.AskRetryOnHttpStatusFail(
async() =>
{
var response = await client.GetAsync(Config.ApiConfigUrl);
return(await response.ParseJsonResponseBody <Urls>());
});
return(_result);
}
// searches for extension header in response
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public string GetExtension(HttpExtension extension, string header)
{
CheckDisposed();
return(GetResponseHeader(header));
}
public async Task <List <Product> > GetProducts()
{
return(await HttpExtension.AskRetryOnHttpStatusFail(
() => _connectionService.GetJsonAsync <List <Product> >(urls => urls.Shop.Products)
));
}
// searches for extension header in response
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public string GetExtension(HttpExtension extension, string header)
{
CheckDisposed();
return GetResponseHeader(header);
}
/// <summary>
/// Processes the route.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="doAuthentication">if set to <c>true</c> [do authentication].</param>
/// <returns></returns>
/// <exception cref="ResourceNotFoundException">
/// ResourceName
/// or
/// or
/// </exception>
internal virtual RuntimeContext ProcessRoute(HttpApiContextContainer <TRequest, TResponse> context, bool doAuthentication = true)
{
try
{
context.CheckNullObject(nameof(context));
var httpMethod = context.HttpMethod;
var uri = context.Url;
var rawFullUrl = string.Format("{0}: {1}", httpMethod, context.Url);
var result = InitializeRuntimeContext(uri);
result.CheckNullObjectAsInvalid("URL");
if (result.Version.Equals(ApiConstants.BuiltInFeatureVersionKeyword, StringComparison.OrdinalIgnoreCase))
{
return(result);
}
if (string.IsNullOrWhiteSpace(result.ResourceName))
{
throw new ResourceNotFoundException(rawFullUrl, nameof(result.ResourceName));
}
RuntimeRoute runtimeRoute;
var apiRouterIdentifier = new ApiRouteIdentifier(result.Realm, result.Version, result.ResourceName, httpMethod, result.Parameter1);
if (!RestApiRoutePool.Routes.TryGetValue(apiRouterIdentifier, out runtimeRoute))
{
apiRouterIdentifier = new ApiRouteIdentifier(result.Realm, result.Version, result.ResourceName, httpMethod, null);
RestApiRoutePool.Routes.TryGetValue(apiRouterIdentifier, out runtimeRoute);
}
else
{
if (runtimeRoute != null && (!string.IsNullOrWhiteSpace(result.Parameter1) && !runtimeRoute.IsActionUsed))
{
throw new ResourceNotFoundException(rawFullUrl);
}
}
if (runtimeRoute == null)
{
throw new ResourceNotFoundException(rawFullUrl);
}
result.ApiRouterIdentifier = apiRouterIdentifier;
// Override out parameters
result.OperationParameters = runtimeRoute.OperationParameters ?? new RuntimeApiOperationParameters();
result.ApiMethod = runtimeRoute.ApiMethod;
result.ApiInstance = runtimeRoute.ApiInstance;
result.IsActionUsed = runtimeRoute.IsActionUsed;
result.IsVoid = runtimeRoute.IsVoid;
context.Settings = result.Settings = runtimeRoute.Setting ?? RestApiSettingPool.DefaultRestApiSettings;
result.OmitApiEvent = runtimeRoute.OmitApiTracking?.Omit(ApiTrackingType.Event) ?? false;
if (runtimeRoute.ApiCacheAttribute != null)
{
result.ApiCacheIdentity = runtimeRoute.ApiRouteIdentifier.Clone() as ApiRouteIdentifier;
if (runtimeRoute.ApiCacheAttribute.CacheParameter.CachedByParameterizedIdentity)
{
result.ApiCacheIdentity.SetParameterizedIdentifier(uri.ToQueryString());
}
result.ApiCacheContainer = runtimeRoute.ApiCacheContainer;
if (result.ApiCacheContainer != null)
{
string cachedResponseBody;
if (result.ApiCacheContainer.GetCacheResult(result.ApiCacheIdentity, out cachedResponseBody))
{
result.CachedResponseBody = cachedResponseBody;
result.ApiCacheStatus = ApiCacheStatus.UseCache;
}
else
{
result.ApiCacheStatus = ApiCacheStatus.UpdateCache;
}
}
else
{
result.ApiCacheStatus = ApiCacheStatus.NoCache;
}
}
// Fill basic context info.
var userAgentHeaderKey = context.Settings?.OriginalUserAgentHeaderKey;
var token = context.TryGetRequestHeader((context.Settings?.TokenHeaderKey).SafeToString(HttpConstants.HttpHeader.TOKEN));
ContextHelper.ApiContext.IndicatedOperator = context.TryGetRequestHeader(HttpConstants.HttpHeader.OPERATOR);
ContextHelper.ConsistContext(
// TOKEN
token,
// Settings
context.Settings,
// IP Address
context.TryGetRequestHeader(context.Settings?.OriginalIpAddressHeaderKey.SafeToString(HttpConstants.HttpHeader.ORIGINAL)).SafeToString(context.ClientIpAddress),
// User Agent
string.IsNullOrWhiteSpace(userAgentHeaderKey) ? context.UserAgent : context.TryGetRequestHeader(userAgentHeaderKey).SafeToString(context.UserAgent),
// Culture Code
context.QueryString.Get(HttpConstants.QueryString.Language).SafeToString(context.UserLanguages.SafeFirstOrDefault()).EnsureCultureCode(),
// Current Uri
context.Url,
HttpExtension.GetBasicAuthentication(context.TryGetRequestHeader(HttpConstants.HttpHeader.Authorization).DecodeBase64()),
apiRouterIdentifier.ToApiUniqueIdentifier()
);
string userIdentifier = ContextHelper.ApiContext.CurrentCredential?.Name.SafeToString(token);
var authenticationException = doAuthentication ? Authorize(runtimeRoute, ContextHelper.ApiContext) : null;
if (authenticationException != null)
{
throw authenticationException.Handle(new { result.ApiMethod.Name, token });
}
return(result);
}
catch (Exception ex)
{
throw ex.Handle();
}
}
public async Task <AccountInfo> GetAccountInfo()
{
return(await HttpExtension.AskRetryOnHttpStatusFail(
() => _connectionService.GetJsonAuthorizedAsync <AccountInfo>(u => u.Shop.User, cache: false)
));
}