public static T ConvertToModel <T>(Microsoft.AspNetCore.Http.HttpContext context) where T : new() { return(Bind <T>(str => { return WebRequestHelper.RequestValue(str, context);// context.Request[str]; })); }
public static bool IsMobilePhone(ref Microsoft.AspNetCore.Http.HttpContext context) { Debug.Assert(context != null); HttpRequest request = context.Request; if (request.Cookies["View"] != null && request.Cookies["View"].FirstOrDefault().ToString() == "MOBILE") { return(true); } if (request.Cookies["View"] != null && request.Cookies["View"].FirstOrDefault().ToString() == "DESKTOP") { return(false); } if (request != null && request.Headers["User-Agent"].ToString() != null) { var u = request.Headers["User-Agent"].ToString().ToString(); if (u.Length < 4) { context.Response.Cookies.Append("View", "DESKTOP"); return(false); } if (MobileCheck.IsMatch(u) || MobileVersionCheck.IsMatch(u.Substring(0, 4))) { context.Response.Cookies.Append("View", "MOBILE"); return(true); } } context.Response.Cookies.Append("View", "DESKTOP"); return(false); }
public void RequestEnd(ProtoContext httpContext, Exception exception, HostingApplication.Context context) { // Local cache items resolved multiple items, in order of use so they are primed in cpu pipeline when used var startTimestamp = context.StartTimestamp; var currentTimestamp = 0L; // If startTimestamp was 0, then Information logging wasn't enabled at for this request (and calcuated time will be wildly wrong) // Is used as proxy to reduce calls to virtual: _logger.IsEnabled(LogLevel.Information) if (startTimestamp != 0) { currentTimestamp = Stopwatch.GetTimestamp(); // Non-inline LogRequestFinished(httpContext, startTimestamp, currentTimestamp); } if (_diagnosticListener.IsEnabled()) { if (currentTimestamp == 0) { currentTimestamp = Stopwatch.GetTimestamp(); } if (exception == null) { // No exception was thrown, request was sucessful if (_diagnosticListener.IsEnabled(DeprecatedDiagnosticsEndRequestKey)) { // Diagnostics is enabled for EndRequest, but it may not be for BeginRequest // so call GetTimestamp if currentTimestamp is zero (from above) RecordEndRequestDiagnostics(httpContext, currentTimestamp); } } else { // Exception was thrown from request if (_diagnosticListener.IsEnabled(DiagnosticsUnhandledExceptionKey)) { // Diagnostics is enabled for UnhandledException, but it may not be for BeginRequest // so call GetTimestamp if currentTimestamp is zero (from above) RecordUnhandledExceptionDiagnostics(httpContext, currentTimestamp, exception); } } var activity = context.Activity; // Always stop activity if it was started if (activity != null) { StopActivity(httpContext, activity); } } if (context.EventLogEnabled && exception != null) { // Non-inline HostingEventSource.Log.UnhandledException(); } // Logging Scope is finshed with context.Scope?.Dispose(); }
public static async Task DoSomething(Microsoft.AspNetCore.Http.HttpContext c) { string message = @"<!DOCTYPE html> <html> <head> <meta http-equiv=""X-UA-Compatible"" content=""IE=edge""> <meta charset=""utf-8"" /> <meta name=""viewport"" content=""width=device-width, initial-scale=1"" /> <title>LoL</title> </head> <body> <h1>howdy</h1> </body> </html> "; // message = "howdy dude"; // c.Response.StatusCode = 200; c.Response.ContentType = "text/plain"; // var ba = System.Text.Encoding.UTF8.GetBytes(message); // c.Response.Body.Write(ba, 0, ba.Length); // return Task.CompletedTask; await c.Response.WriteAsync(message); await Sleeper(c); // await c.Response.WriteAsync(message); }
public override Task Invoke(HttpContext httpContext) { var context = GetDashboardContext(httpContext); var findResult = _routes.FindDispatcher(httpContext.Request.Path.Value); if (findResult == null) { return(_next.Invoke(httpContext)); } // ReSharper disable once LoopCanBeConvertedToQuery foreach (var filter in _authorization) { if (!filter.Authorize(context)) { #if NETSTANDARD var isAuthenticated = httpContext.User?.Identity?.IsAuthenticated; #else var isAuthenticated = httpContext.Request?.User?.Identity?.IsAuthenticated; #endif httpContext.Response.StatusCode = isAuthenticated == true ? (int)System.Net.HttpStatusCode.Forbidden : (int)System.Net.HttpStatusCode.Unauthorized; return(Task.CompletedTask); } } context.UriMatch = findResult.Item2; var r = findResult.Item1.DispatchAsync(context); return(context.NextInvoke ? _next.Invoke(httpContext) : r); }
public async Task Invoke(Microsoft.AspNetCore.Http.HttpContext context) { HttpContext.Set(context); await _next(context); HttpContext.Flush(); }
private async Task ProcessMetaFromFile(Microsoft.AspNetCore.Http.HttpContext httpContext) { Meta.MetaFromFile meta = new Meta.MetaFromFile(); if (!string.IsNullOrEmpty(_options.WsdlFileOptions.VirtualPath)) { meta.CurrentWebServer = _options.WsdlFileOptions.VirtualPath + "/"; } meta.CurrentWebService = httpContext.Request.Path.Value.Replace("/", string.Empty); WebServiceWSDLMapping mapping = _options.WsdlFileOptions.WebServiceWSDLMapping[meta.CurrentWebService]; meta.XsdFolder = mapping.SchemaFolder; meta.WSDLFolder = mapping.WSDLFolder; if (_options.WsdlFileOptions.UrlOverride != string.Empty) { meta.ServerUrl = _options.WsdlFileOptions.UrlOverride; } else { meta.ServerUrl = httpContext.Request.Scheme + "://" + httpContext.Request.Host + "/"; } string wsdlfile = mapping.WsdlFile; string path = _options.WsdlFileOptions.AppPath; string wsdl = meta.ReadLocalFile(path + Path.AltDirectorySeparatorChar + meta.WSDLFolder + Path.AltDirectorySeparatorChar + wsdlfile); string modifiedWsdl = meta.ModifyWSDLAddRightSchemaPath(wsdl); //we should use text/xml in wsdl page for browser compability. httpContext.Response.ContentType = "text/xml;charset=UTF-8"; byte[] data = System.Text.Encoding.UTF8.GetBytes(modifiedWsdl); await httpContext.Response.Body.WriteAsync(data, 0, data.Length); }
private void LogException(Exception error, Microsoft.AspNetCore.Http.HttpContext context) { try { // var connectionStr = Configuration.GetConnectionString("DefaultConnection"); // using (var connection = new System.Data.SqlClient.SqlConnection(connectionStr)) // { // var command = connection.CreateCommand(); // command.CommandText = @"INSERT INTO ErrorLog (ErrorId, Application, Host, Type, Source, Method, Message, StackTrace, [User], TimeUtc) //VALUES (@ErrorId, @Application, @Host, @Type, @Source, @Method, @Message, @StackTrace, @User, @TimeUtc)"; // connection.Open(); // if (error.InnerException != null) // error = error.InnerException; // command.Parameters.AddWithValue("@ErrorId", Guid.Parse(context.TraceIdentifier)); // command.Parameters.AddWithValue("@Application", this.GetType().Namespace); // command.Parameters.AddWithValue("@Host", Environment.MachineName); // command.Parameters.AddWithValue("@Type", error.GetType().FullName); // command.Parameters.AddWithValue("@Source", error.Source); // command.Parameters.AddWithValue("@Method", context.Request.Method); // command.Parameters.AddWithValue("@Message", error.Message); // command.Parameters.AddWithValue("@StackTrace", error.StackTrace); // var user = context.User.Identity?.Name; // if (user == null) // command.Parameters.AddWithValue("@User", DBNull.Value); // else // command.Parameters.AddWithValue("@User", user); // command.Parameters.AddWithValue("@TimeUtc", DateTime.Now); // command.ExecuteNonQuery(); // } } catch (Exception exp) { } }
public JsonResult Create(string bookId) { JsonResult json = new JsonResult("Request Failed"); if (string.IsNullOrEmpty(bookId)) { json = new JsonResult("bad request"); } else { Microsoft.AspNetCore.Http.HttpContext currentHttpContext = HttpContext; string userid = HttpContext.Session.GetString("UserID"); int result = 0; if (!string.IsNullOrEmpty(userid)) { Random rnd = new Random(); int requestCode = rnd.Next(10000000, 99999999); result = _context.Database. ExecuteSqlCommand( "[dbo].[RequestBook] @bookId = {0}, @userId = {1}, @RCode = {2}", Convert.ToInt32(bookId), Convert.ToInt32(userid), requestCode.ToString()); if (result.Equals(2)) { json = new JsonResult(requestCode); } } } return(json); }
public static async Task OnEndRequest(Microsoft.AspNetCore.Http.HttpContext e) { //Get preflight token string state = e.Request.Query["state"]; DbPreflightToken session = await Program.connection.GetPreflightTokenByTokenAsync(state); if (session == null) { await Program.QuickWriteToDoc(e, "Failed to sign in, you might have taken too long.", "text/plain", 400); //TODO: REDIRECT BACK TO LOGIN return; } //Do auth DbUser user = await SteamAuth.SteamOpenID.Finish(e); if (user == null) { await Program.QuickWriteToDoc(e, "Failed to sign in. Try again.", "text/plain", 400); //TODO: REDIRECT BACK TO LOGIN return; } //Update await session.SetUser(Program.connection, user); //Redirect to final endpoint string url = PREFLIGHT_OUT_URLS[session.redirect_type].Replace("{STATE}", state); e.Response.Headers.Add("Location", url); await Program.QuickWriteToDoc(e, "Redirecting...", "text/plain", 302); }
/// <summary>调用</summary> /// <param name="ctx"></param> /// <returns></returns> public async Task Invoke(HttpContext ctx) { // APM跟踪 //var span = Tracer?.NewSpan(ctx.Request.Path); ISpan span = null; if (Tracer != null) { var action = GetAction(ctx); if (!action.IsNullOrEmpty()) { span = Tracer.NewSpan(action); span.Tag = ctx.Request.GetRawUrl() + ""; span.Detach(ctx.Request.Headers.ToDictionary(e => e.Key, e => (Object)e.Value)); } } try { await _next.Invoke(ctx); } catch (Exception ex) { span?.SetError(ex, null); throw; } finally { span?.Dispose(); } }
private void attachUserToContext(Microsoft.AspNetCore.Http.HttpContext context, IUserService userService, string token) { try { var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_appSettings.Secret); tokenHandler.ValidateToken(token, new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(key), ValidateIssuer = false, ValidateAudience = false, // set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later) ClockSkew = TimeSpan.Zero }, out SecurityToken validatedToken); var jwtToken = (JwtSecurityToken)validatedToken; var userModel = new UserLoginModel(); var claim = jwtToken.Claims.First(x => x.Type == ClaimTypes.UserData); if (claim != null) { userModel = JsonConvert.DeserializeObject <UserLoginModel>(claim.Value); } //var userInfo = int.Parse(jwtToken.Claims.First(x => x.Type == ClaimTypes.UserData).Value); // attach user to context on successful jwt validation context.Items["User"] = userModel; } catch { // do nothing if jwt validation fails // user is not attached to context so request won't have access to secure routes } }
protected TestInvolvingAspNetHttpContext() { HttpContext = SetupFakeHttpContext(); #if !ASP_NET_CORE HttpContext.Current = HttpContext; #endif }
//异常错误信息捕获,将错误信息用Json方式返回 private static Task HandleExceptionAsync(Microsoft.AspNetCore.Http.HttpContext context, Exception ex, int statusCode) { StringBuilder builder = new StringBuilder(ex.Message); ErrorHandlingMiddleware.GetExceptionMessage(ex, builder); ApiResult apiResult = new ApiResult() { Success = false, Data = new ApiResultData() { Message = builder.ToString(), RequestUrl = context.Request.Path, ExceptionCode = statusCode } }; if (ex is BusinessException) { apiResult.Data.ExceptionCode = (ex as BusinessException).ExceptionCode; } var result = JsonConvert.SerializeObject(apiResult); context.Response.ContentType = "application/json;charset=utf-8"; GlobalConstants.DefaultLogger.Error(result); GlobalConstants.DefaultLogger.Error(ex.StackTrace); return(context.Response.WriteAsync(result)); }
public async System.Threading.Tasks.Task SlowTaskStatusCode(Microsoft.AspNetCore.Http.HttpContext httpContext) { var handler = new Samples.MyHandler(); var result = await handler.SlowTaskStatusCode(); await result.ExecuteAsync(httpContext); }
private static async Task WriteExceptionAsync(HttpContext context, Exception exception) { //记录日志 var logger = LogManager.GetCurrentClassLogger(); logger.Log(LogLevel.Error, exception.Message); //返回友好的提示 var response = context.Response; //状态码 if (exception is UnauthorizedAccessException) { response.StatusCode = (int)HttpStatusCode.Unauthorized; } else { response.StatusCode = (int)HttpStatusCode.BadRequest; } response.ContentType = context.Request.Headers["Accept"]; var result = new Result(StateCode.Fail, exception.Message); if (response.ContentType.ToLower() == "application/xml") { await response.WriteAsync(Object2XmlString(result)).ConfigureAwait(false); } response.ContentType = "application/json"; await response.WriteAsync(JsonConvert.SerializeObject(result)).ConfigureAwait(false); }
public System.Threading.Tasks.Task Authed(Microsoft.AspNetCore.Http.HttpContext httpContext) { var handler = new Samples.MyHandler(); handler.Authed(); return(System.Threading.Tasks.Task.CompletedTask); }
public System.Threading.Tasks.Task Blah(Microsoft.AspNetCore.Http.HttpContext httpContext) { var handler = new Samples.MyHandler(); var result = handler.Blah(); return(httpContext.Response.WriteAsJsonAsync(result)); }
public async System.Threading.Tasks.Task PostAForm(Microsoft.AspNetCore.Http.HttpContext httpContext) { var handler = new Samples.MyHandler(); var arg_form = await httpContext.Request.ReadFormAsync(); handler.PostAForm(arg_form); }
public async System.Threading.Tasks.Task Hello(Microsoft.AspNetCore.Http.HttpContext httpContext) { var handler = new Samples.MyHandler(); var formCollection = await httpContext.Request.ReadFormAsync(); var arg_s = formCollection["foo"].ToString(); var arg_id = httpContext.Request.Headers["X-Id"].ToString(); var arg_page_Value = httpContext.Request.Query["page"].ToString(); System.Nullable <int> arg_page; if (arg_page_Value != null && int.TryParse(arg_page_Value, out var arg_page_Temp)) { arg_page = arg_page_Temp; } else { arg_page = default; } var arg_pageSize_Value = httpContext.Request.Query["pageSize"].ToString(); System.Nullable <int> arg_pageSize; if (arg_pageSize_Value != null && int.TryParse(arg_pageSize_Value, out var arg_pageSize_Temp)) { arg_pageSize = arg_pageSize_Temp; } else { arg_pageSize = default; } var result = handler.Hello(arg_s, arg_id, arg_page, arg_pageSize); await httpContext.Response.WriteAsync(result); }
private async Task HandleErrorAsync(Microsoft.AspNetCore.Http.HttpContext context, Exception exception) { //await _exceptionLogService.AddExceptionAsync(new ExceptionLogModel() //{ // ClassName = nameof(exception), // Message = exception.Message, // Source = exception.Source, // StackTrace = exception.StackTrace // .Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries).ToList() //}); //Console.WriteLine(exception.Message); //if (Debugger.IsAttached) //{ // Debugger.Break(); //} Console.WriteLine($"ErrorHandler:{exception.Message}"); ApiResult apiResult; if (exception is PermissionAuthorizeFailException) { apiResult = ApiResult.GetRequestError("权限验证失败"); } else { apiResult = ApiResult.GetServerError(exception.Message); } var response = context.Response; response.ContentType = "application/json"; await response.WriteAsync(JsonSerializerHelper.SerializeObject(apiResult)); }
public static async Task OnTokenRequest(Microsoft.AspNetCore.Http.HttpContext e) { //Get preflight token string state = e.Request.Query["state"]; DbPreflightToken session = await Program.connection.GetPreflightTokenByTokenAsync(state); if (session == null) { await Program.QuickWriteToDoc(e, "Failed to sign in, you might have taken too long.", "text/plain", 400); //TODO: REDIRECT BACK TO LOGIN return; } //Verify if (!session.auth) { await Program.QuickWriteToDoc(e, "Token is not yet valid.", "text/plain", 400); return; } //Create output data TokenResponseData d = new TokenResponseData { token = session.final_token, next = session.next, nonce = session.nonce }; await Program.QuickWriteJsonToDoc(e, d); }
public static HttpContext GetHttpContext() { object factory = CPAppContext.GetService(typeof(Microsoft.AspNetCore.Http.IHttpContextAccessor)); Microsoft.AspNetCore.Http.HttpContext context = ((Microsoft.AspNetCore.Http.HttpContextAccessor)factory).HttpContext; return(context); }
public static void SetResponseCookie(this Microsoft.AspNetCore.Http.HttpContext context, string key, string value, DateTime expires, string subdomain = null, string path = "/", bool httpOnly = false, bool secure = false) { var cookieOptions = new CookieOptions { Expires = expires, Domain = subdomain, Path = path, Secure = secure, HttpOnly = httpOnly }; if (string.IsNullOrWhiteSpace(value)) { context.Response.Cookies.Delete(key); } else { context.Response.Cookies.Append(key, value, cookieOptions); } }
/// <summary> /// Read UserID from HttpContext /// </summary> /// <param name="context"></param> /// <returns></returns> public static int GetUserID(this Microsoft.AspNetCore.Http.HttpContext context) { var claimsIdentity = context.User; var claim = claimsIdentity.Claims.FirstOrDefault(cl => cl.Type == ClaimTypes.PrimarySid); return(Convert.ToInt32(claim.Value)); }
public async Task Invoke(Microsoft.AspNetCore.Http.HttpContext context) { var httpContextAccessor = context.RequestServices.GetService <IHttpContextAccessor>(); HttpContext.Configure(httpContextAccessor); await _next.Invoke(context); }
/// <summary> /// Invoke middleware actions /// </summary> /// <param name="context">HTTP context</param> /// <param name="webHelper">Web helper</param> /// <param name="workContext">Work context</param> /// <returns>Task</returns> public Task Invoke(Microsoft.AspNetCore.Http.HttpContext context) { CommonHelper.SetTelerikCulture(); //call the next middleware in the request pipeline return(_next(context)); }
/// <summary> /// 写cookie值 /// </summary> /// <param name="strName">名称</param> /// <param name="strValue">值</param> /// <param name="strValue">过期时间(分钟)</param> public static void WriteCookie(Microsoft.AspNetCore.Http.HttpContext context, string strName, string strValue, int expires, string domain = "", string path = "/", bool httponly = true, bool secure = false) { #if !NET45 context.Response.Cookies.Append(strName, strValue, new CookieOptions() { Domain = domain, Path = path, HttpOnly = httponly, Secure = secure, Expires = new DateTimeOffset(DateTime.Now.AddMinutes(expires)) }); #else HttpCookie cookie = context.Request.Cookies[strName]; if (cookie == null) { cookie = new HttpCookie(strName); } cookie.Value = strValue; cookie.Expires = DateTime.Now.AddMinutes(expires); cookie.HttpOnly = httponly; cookie.Secure = secure; cookie.Path = path; if (domain != null) { cookie.Domain = domain; } context.Response.AppendCookie(cookie); #endif }
public static Microsoft.AspNetCore.Http.HttpContext Current() { object factory = ServiceProvider.GetService(typeof(Microsoft.AspNetCore.Http.IHttpContextAccessor)); Microsoft.AspNetCore.Http.HttpContext context = ((IHttpContextAccessor)factory).HttpContext; return(context); }
public async Task Invoke(Microsoft.AspNetCore.Http.HttpContext context) { try { await next(context); } catch (Exception ex) { var statusCode = context.Response.StatusCode; if (ex is ArgumentException) { statusCode = 200; } try { await HandleExceptionAsync(context, ex, statusCode); } catch { } } finally { var statusCode = context.Response.StatusCode; if (statusCode != 101) { await ProcessError(context, statusCode); } } }
protected override SharePointContext LoadSharePointContext(HttpContext httpContext) { byte[] value; httpContext.Session.TryGetValue(SPContextKey, out value); if (value == null) { return null; } char[] chars = new char[value.Length / sizeof(char)]; System.Buffer.BlockCopy(value, 0, chars, 0, value.Length); string acsSessionContext = new string(chars); var dto = JsonConvert.DeserializeObject<SharePointSessionData>(acsSessionContext); var contextTokenObj = TokenHandler.ReadAndValidateContextToken(dto.ContextToken, httpContext.Request.Host.Value); return new SharePointAcsContext(dto.SpHostUrl, dto.SpAppWebUrl, dto.SpLanguage, dto.SpClientTag, dto.SpProductNumber, dto.ContextToken, contextTokenObj, Configuration); }
/// <summary> /// Saves the specified SharePointContext instance associated with the specified HTTP context. /// <c>null</c> is accepted for clearing the SharePointContext instance associated with the HTTP context. /// </summary> /// <param name="spContext">The SharePointContext instance to be saved, or <c>null</c>.</param> /// <param name="httpContext">The HTTP context.</param> protected abstract void SaveSharePointContext(SharePointContext spContext, HttpContext httpContext);
protected override void SaveSharePointContext(SharePointContext spContext, HttpContext httpContext) { SharePointAcsContext spAcsContext = spContext as SharePointAcsContext; //creates a cookie to store the SPCacheKey if (spAcsContext != null) { //The following code generates a cookie in the response with the SPCacheKey as a value var options = new CookieOptions() { HttpOnly = true, Secure = true }; httpContext.Response.Cookies.Append(SPCacheKeyKey, spAcsContext.CacheKey, options); } string output = JsonConvert.SerializeObject(spAcsContext); byte[] bytes = new byte[output.Length * sizeof(char)]; System.Buffer.BlockCopy(output.ToCharArray(), 0, bytes, 0, bytes.Length); httpContext.Session.Set(SPContextKey, bytes); }
/// <summary> /// Validates if the given SharePointContext can be used with the specified HTTP context. /// </summary> /// <param name="spContext">The SharePointContext.</param> /// <param name="httpContext">The HTTP context.</param> /// <returns>True if the given SharePointContext can be used with the specified HTTP context.</returns> protected abstract bool ValidateSharePointContext(SharePointContext spContext, HttpContext httpContext);
protected override bool ValidateSharePointContext(SharePointContext spContext, HttpContext httpContext) { SharePointAcsContext spAcsContext = spContext as SharePointAcsContext; //Checks for the SPCacheKey cookie and gets the value if (spAcsContext != null) { //Uri spHostUrl = SharePointContext.GetUriFromQueryStringParameter // (httpContext.Request, SharePointContext.SPHostUrlKey); string contextToken = TokenHandler.GetContextTokenFromRequest(httpContext.Request); //read the cookie value var cookieCollection = httpContext.Request.Cookies; if (!cookieCollection.ContainsKey(SPCacheKeyKey)) return false; var spCacheKeyCookieValue = httpContext.Request.Cookies[SPCacheKeyKey]; string spCacheKey = spCacheKeyCookieValue != null ? spCacheKeyCookieValue : null; //return spHostUrl == spAcsContext.SPHostUrl && (taken out) return !string.IsNullOrEmpty(spAcsContext.CacheKey) && spCacheKey == spAcsContext.CacheKey && !string.IsNullOrEmpty(spAcsContext.ContextToken) && (string.IsNullOrEmpty(contextToken) || contextToken == spAcsContext.ContextToken); } return false; }
/// <summary> /// Getting the correct url with the correct url scheme since httpContext.Request.GetDisplayUrl() /// provides incorrect 'http' scheme even we are running on 'https'. It needs to be double checked until /// better solution has been found. /// </summary> /// <param name="httpContext"></param> /// <returns></returns> private static string GetCurrentUrl(HttpContext httpContext) { var url = httpContext.Request.GetDisplayUrl(); return url; }
/// <summary> /// Loads the SharePointContext instance associated with the specified HTTP context. /// </summary> /// <param name="httpContext">The HTTP context.</param> /// <returns>The SharePointContext instance. Returns <c>null</c> if not found.</returns> protected abstract SharePointContext LoadSharePointContext(HttpContext httpContext);
/// <summary> /// Checks if it is necessary to redirect to SharePoint for user to authenticate. /// </summary> /// <param name="httpContext">The HTTP context.</param> /// <param name="redirectUrl">The redirect url to SharePoint if the status is ShouldRedirect. <c>Null</c> if the status is Ok or CanNotRedirect.</param> /// <returns>Redirection status.</returns> public static RedirectionStatus CheckRedirectionStatus(HttpContext httpContext, out Uri redirectUrl) { if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } redirectUrl = null; bool contextTokenExpired = false; try { if (Current.GetSharePointContext(httpContext) != null) { return RedirectionStatus.Ok; } } catch (SecurityTokenExpiredException) { contextTokenExpired = true; } const string SPHasRedirectedToSharePointKey = "SPHasRedirectedToSharePoint"; if (!string.IsNullOrEmpty(httpContext.Request.Query[SPHasRedirectedToSharePointKey]) && !contextTokenExpired) { return RedirectionStatus.CanNotRedirect; } Uri spHostUrl = SharePointContext.GetUriFromQueryStringParameter (httpContext.Request, SharePointContext.SPHostUrlKey); if (spHostUrl == null) { return RedirectionStatus.CanNotRedirect; } if (StringComparer.OrdinalIgnoreCase.Equals(httpContext.Request.Method, "POST")) { return RedirectionStatus.CanNotRedirect; } var uri = GetCurrentUrl(httpContext); var queryNameValueCollection = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(uri); // Removes the values that are included in {StandardTokens}, as {StandardTokens} will be inserted at the beginning of the query string. queryNameValueCollection.Remove(SharePointContext.SPHostUrlKey); queryNameValueCollection.Remove(SharePointContext.SPAppWebUrlKey); queryNameValueCollection.Remove(SharePointContext.SPLanguageKey); queryNameValueCollection.Remove(SharePointContext.SPClientTagKey); queryNameValueCollection.Remove(SharePointContext.SPProductNumberKey); // Adds SPHasRedirectedToSharePoint=1. queryNameValueCollection.Add(SPHasRedirectedToSharePointKey, "1"); UriBuilder returnUrlBuilder = new UriBuilder(uri); returnUrlBuilder.Query = queryNameValueCollection.ToString(); // Inserts StandardTokens. const string StandardTokens = "{StandardTokens}"; string returnUrlString = returnUrlBuilder.Uri.AbsoluteUri; returnUrlString = returnUrlString.Insert(returnUrlString.IndexOf("?") + 1, StandardTokens + "&"); // Constructs redirect url. string redirectUrlString = TokenHandler.GetAppContextTokenRequestUrl(spHostUrl.AbsoluteUri, Uri.EscapeDataString(returnUrlString)); redirectUrl = new Uri(redirectUrlString, UriKind.Absolute); return RedirectionStatus.ShouldRedirect; }
/// <summary> /// Gets a SharePointContext instance associated with the specified HTTP context. /// </summary> /// <param name="httpContext">The HTTP context.</param> /// <returns>The SharePointContext instance. Returns <c>null</c> if not found and a new instance can't be created.</returns> public SharePointContext GetSharePointContext(HttpContext httpContext) { if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } SharePointContext spContext = LoadSharePointContext(httpContext); if (spContext == null || !ValidateSharePointContext(spContext, httpContext)) { spContext = CreateSharePointContext(httpContext.Request); if (spContext != null) { SaveSharePointContext(spContext, httpContext); } } return spContext; }