ServiceExtensions.cs

using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using ServiceStack.Auth;
using ServiceStack.Caching;
using ServiceStack.Host;
using ServiceStack.Logging;
using ServiceStack.Testing;
using ServiceStack.Text;
using ServiceStack.Web;

namespace ServiceStack
{
    public static class ServiceExtensions
    {
        public static ILog Log = LogManager.GetLogger(typeof(ServiceExtensions));

        public static IHttpResult Redirect(this IServiceBase service, string redirect) => 
            service.Redirect(redirect, HelpMessages.DefaultRedirectMessage);

        public static IHttpResult Redirect(this IServiceBase service, string redirect, string message) =>
            HostContext.AppHost.Redirect(service, redirect, message);

        public static IHttpResult LocalRedirect(this IServiceBase service, string redirect) =>
            service.LocalRedirect(redirect, HelpMessages.DefaultRedirectMessage);
        
        public static IHttpResult LocalRedirect(this IServiceBase service, string redirect, string message) =>
            HostContext.AppHost.LocalRedirect(service, redirect, message);

        public static IHttpResult AuthenticationRequired(this IServiceBase service) =>
            HostContext.AppHost.AuthenticationRequired(service);

        public static string GetSessionId(this IServiceBase service)
        {
            var req = service.Request;
            var sessionId = req.GetSessionId();
            if (sessionId == null)
                throw new ArgumentNullException(nameof(sessionId), ErrorMessages.SessionIdEmpty);

            return sessionId;
        }

        public static ICacheClient GetCacheClient(this IRequest request) => HostContext.AppHost.GetCacheClient(request);
        public static ICacheClientAsync GetCacheClientAsync(this IRequest request) => HostContext.AppHost.GetCacheClientAsync(request);

        public static ICacheClient GetMemoryCacheClient(this IRequest request) => HostContext.AppHost.GetMemoryCacheClient(request);

        [Obsolete("Use SaveSessionAsync")]
        public static void SaveSession(this IServiceBase service, IAuthSession session, TimeSpan? expiresIn = null)
        {
            if (service == null || session == null) return;

            service.Request.SaveSession(session, expiresIn);
        }

        public static async Task SaveSessionAsync(this IServiceBase service, IAuthSession session, TimeSpan? expiresIn = null, CancellationToken token=default)
        {
            if (service == null || session == null) return;

            await service.Request.SaveSessionAsync(session, expiresIn, token).ConfigAwait();
        }

        public static void RemoveSession(this IServiceBase service)
        {
            service?.Request.RemoveSession();
        }
        public static Task RemoveSessionAsync(this IServiceBase service, CancellationToken token=default)
        {
            return service?.Request.RemoveSessionAsync(token);
        }

        public static void RemoveSession(this Service service)
        {
            service?.Request.RemoveSession();
        }
        public static Task RemoveSessionAsync(this Service service, CancellationToken token=default)
        {
            return service?.Request.RemoveSessionAsync(token);
        }

        public static void CacheSet<T>(this ICacheClient cache, string key, T value, TimeSpan? expiresIn)
        {
            if (expiresIn.HasValue)
                cache.Set(key, value, expiresIn.Value);
            else
                cache.Set(key, value);
        }

        public static async Task CacheSetAsync<T>(this ICacheClientAsync cache, string key, T value, TimeSpan? expiresIn, CancellationToken token=default)
        {
            if (expiresIn.HasValue)
                await cache.SetAsync(key, value, expiresIn.Value, token).ConfigAwait();
            else
                await cache.SetAsync(key, value, token).ConfigAwait();
        }

        [Obsolete("Use SaveSessionAsync")]
        public static void SaveSession(this IRequest httpReq, IAuthSession session, TimeSpan? expiresIn = null)
        {
            HostContext.AppHost.OnSaveSession(httpReq, session, expiresIn);
        }

        public static Task SaveSessionAsync(this IRequest httpReq, IAuthSession session, TimeSpan? expiresIn = null, CancellationToken token=default)
        {
            return HostContext.AppHost.OnSaveSessionAsync(httpReq, session, expiresIn, token);
        }

        public static void RemoveSession(this IRequest httpReq)
        {
            RemoveSession(httpReq, httpReq.GetSessionId());
        }

        public static Task RemoveSessionAsync(this IRequest httpReq, CancellationToken token=default)
        {
            return RemoveSessionAsync(httpReq, httpReq.GetSessionId(), token);
        }

        public static void RemoveSession(this IRequest httpReq, string sessionId)
        {
            if (httpReq == null) return;
            if (sessionId == null)
                throw new ArgumentNullException(nameof(sessionId));

            var sessionKey = SessionFeature.GetSessionKey(sessionId);
            httpReq.GetCacheClient().Remove(sessionKey);

            httpReq.Items.Remove(Keywords.Session);
        }

        public static async Task RemoveSessionAsync(this IRequest httpReq, string sessionId, CancellationToken token=default)
        {
            if (httpReq == null) return;
            if (sessionId == null)
                throw new ArgumentNullException(nameof(sessionId));

            var sessionKey = SessionFeature.GetSessionKey(sessionId);
            await httpReq.GetCacheClientAsync().RemoveAsync(sessionKey, token).ConfigAwait();

            httpReq.Items.Remove(Keywords.Session);
        }

        public static IAuthSession GetSession(this IServiceBase service, bool reload = false)
        {
            return service.Request.GetSession(reload);
        }

        public static Task<IAuthSession> GetSessionAsync(this IServiceBase service, bool reload = false, CancellationToken token=default)
        {
            return service.Request.GetSessionAsync(reload, token);
        }

        public static TUserSession SessionAs<TUserSession>(this IRequest req)
        {
            if (HostContext.TestMode)
            {
                var mockSession = req.TryResolve<TUserSession>();
                if (!Equals(mockSession, default(TUserSession)))
                    mockSession = req.TryResolve<IAuthSession>() is TUserSession
                        ? (TUserSession)req.TryResolve<IAuthSession>()
                        : default;

                if (!Equals(mockSession, default(TUserSession)))
                    return mockSession;
            }

            return SessionFeature.GetOrCreateSession<TUserSession>(req.GetCacheClient(), req, req.Response);
        }

        public static async Task<TUserSession> SessionAsAsync<TUserSession>(this IRequest req, CancellationToken token=default)
        {
            if (HostContext.TestMode)
            {
                var mockSession = req.TryResolve<TUserSession>();
                if (!Equals(mockSession, default(TUserSession)))
                    mockSession = req.TryResolve<IAuthSession>() is TUserSession
                        ? (TUserSession)req.TryResolve<IAuthSession>()
                        : default;

                if (!Equals(mockSession, default(TUserSession)))
                    return mockSession;
            }

            return await SessionFeature.GetOrCreateSessionAsync<TUserSession>(req.GetCacheClientAsync(), req, req.Response, token).ConfigAwait();
        }

        [Obsolete("Use IsAuthenticatedAsync")]
        public static bool IsAuthenticated(this IRequest req) => AuthenticateAttribute.Authenticate(req, req.Dto);

        public static Task<bool> IsAuthenticatedAsync(this IRequest req) => AuthenticateAttribute.AuthenticateAsync(req, req.Dto);

        public static IAuthSession AssertAuthenticatedSession(this IRequest req, bool reload = false) 
            => HostContext.AppHost.HasValidAuthSecret(req)
                ? HostContext.GetAuthSecretSession()
                : HostContext.AppHost.AssertAuthenticated(req.GetSession(), req);

        public static async Task<IAuthSession> AssertAuthenticatedSessionAsync(this IRequest req, bool reload=false, CancellationToken token=default) 
            => HostContext.AppHost.HasValidAuthSecret(req)
                ? HostContext.GetAuthSecretSession()
                : HostContext.AppHost.AssertAuthenticated(await req.GetSessionAsync(token: token).ConfigAwait(), req);

        public static IAuthSession GetSession(this IRequest httpReq, bool reload = false)
        {
            var task = GetSessionInternalAsync(httpReq, reload, async: false);
            var ret = task.GetResult();
            return ret;
        }

        public static Task<IAuthSession> GetSessionAsync(this IRequest httpReq, bool reload = false, CancellationToken token=default)
        {
            return GetSessionInternalAsync(httpReq, reload, async: true, token);
        }

        internal static async Task<IAuthSession> GetSessionInternalAsync(this IRequest httpReq, bool reload, bool async, CancellationToken token=default)
        {
            if (httpReq == null)
                return null;

            if (HostContext.TestMode)
            {
                var mockSession = httpReq.TryResolve<IAuthSession>(); //testing
                if (mockSession != null)
                    return mockSession;
            }

            httpReq.Items.TryGetValue(Keywords.Session, out var oSession);
            if (reload && (oSession as IAuthSession)?.FromToken != true) // can't reload FromToken sessions from cache
                oSession = null;

            var appHost = HostContext.AppHost;
            if (oSession == null && !httpReq.Items.ContainsKey(Keywords.HasPreAuthenticated))
            {
                try
                {
                    await appHost.ApplyPreAuthenticateFiltersAsync(httpReq, httpReq.Response).ConfigAwait();
                    httpReq.Items.TryGetValue(Keywords.Session, out oSession);
                }
                catch (Exception ex)
                {
                    Log.Error("Error in GetSession() when ApplyPreAuthenticateFilters", ex);
                    /*treat errors as non-existing session*/
                }
            }

            var sessionId = httpReq.GetSessionId();
            var session = oSession as IAuthSession;
            if (session != null)
                session = appHost.OnSessionFilter(httpReq, session, sessionId);
            if (session != null)
                return session;

            if (appHost.HasValidAuthSecret(httpReq))
            {
                session = HostContext.GetAuthSecretSession();
                if (session != null)
                    return session;
            }

            var sessionKey = SessionFeature.GetSessionKey(sessionId);
            if (sessionKey != null)
            {
                // If changing global JsConfig configuration to use snake_case serialization convention
                session = async
                    ? await httpReq.GetCacheClientAsync().GetAsync<IAuthSession>(sessionKey, token).ConfigAwait()
                    : httpReq.GetCacheClient().Get<IAuthSession>(sessionKey);

                if (session != null)
                    session = appHost.OnSessionFilter(httpReq, session, sessionId);
            }

            if (session == null)
            {
                var newSession = SessionFeature.CreateNewSession(httpReq, sessionId);
                session = appHost.OnSessionFilter(httpReq, newSession, sessionId) ?? newSession;
            }

            httpReq.Items[Keywords.Session] = session;
            return session;
        }

        public static TimeSpan? GetSessionTimeToLive(this ICacheClient cache, string sessionId)
        {
            var sessionKey = SessionFeature.GetSessionKey(sessionId);
            return cache.GetTimeToLive(sessionKey);
        }

        public static async Task<TimeSpan?> GetSessionTimeToLiveAsync(this ICacheClientAsync cache, string sessionId, CancellationToken token=default)
        {
            var sessionKey = SessionFeature.GetSessionKey(sessionId);
            return await cache.GetTimeToLiveAsync(sessionKey, token).ConfigAwait();
        }

        public static TimeSpan? GetSessionTimeToLive(this IRequest httpReq)
        {
            return httpReq.GetCacheClient().GetSessionTimeToLive(httpReq.GetSessionId());
        }

        public static Task<TimeSpan?> GetSessionTimeToLiveAsync(this IRequest httpReq, CancellationToken token=default)
        {
            return httpReq.GetCacheClientAsync().GetSessionTimeToLiveAsync(httpReq.GetSessionId(), token);
        }

        public static object RunAction<TService, TRequest>(
            this TService service, TRequest request, Func<TService, TRequest, object> invokeAction,
            IRequest requestContext = null)
            where TService : IService
        {
            var actionCtx = new ActionContext
            {
                RequestFilters = TypeConstants<IRequestFilterBase>.EmptyArray,
                ResponseFilters = TypeConstants<IResponseFilterBase>.EmptyArray,
                ServiceType = typeof(TService),
                RequestType = typeof(TRequest),
                ServiceAction = (instance, req) => invokeAction(service, request)
            };

            requestContext ??= new MockHttpRequest();
            ServiceController.InjectRequestContext(service, requestContext);
            var runner = HostContext.CreateServiceRunner<TRequest>(actionCtx);
            var responseTask = runner.ExecuteAsync(requestContext, service, request);
            var response = responseTask.Result;
            return response;
        }
    }
}