public string GetLogOnUrl(WorkContext context)
 {
     var urlHelper = new UrlHelper(context.HttpContext.Request.RequestContext);
     var returnUrl = context.HttpContext.Request.Url;
     var redirectUrl = urlHelper.Action("RequestToken", "TwitterOAuth", new { Area = "RM.QuickLogOn.OAuth", ReturnUrl = returnUrl });
     return redirectUrl;
 }

      protected sealed override void DoFilterWork(WorkContext work, IList<WorkFilter> filters, int thisFilterIndex)
      {     
         if (m_BeforeMatches.Count>0)
          foreach(var match in m_BeforeMatches.OrderedValues)
          {
            var matched = match.Make(work);
            if (matched!=null)
            {
              DoBeforeWork(work, matched);
              break;
            }
          }

         this.InvokeNextWorker(work, filters, thisFilterIndex);

         if (m_AfterMatches.Count>0)
          foreach(var match in m_AfterMatches.OrderedValues)
          {
            var matched = match.Make(work);
            if (matched!=null)
            {
              DoAfterWork(work, matched);
              break;
            }
          }
      }

        public DataMigrationNotificationProvider(IDataMigrationManager dataMigrationManager, WorkContext workContext)
        {
            _dataMigrationManager = dataMigrationManager;
            _workContext = workContext;

            T = NullLocalizer.Instance;
        }

        public MissingSettingsBanner(IOrchardServices orchardServices, IWorkContextAccessor workContextAccessor)
        {
            _orchardServices = orchardServices;
            _workContext = workContextAccessor.GetContext();

            T = NullLocalizer.Instance;
        }

 public ThemedViewResultFilter(IThemeManager themeManager, WorkContext workContext, ILayoutAwareViewEngine layoutAwareViewEngine)
 {
     _themeManager = themeManager;
     _workContext = workContext;
     _layoutAwareViewEngine = layoutAwareViewEngine;
     Logger = NullLogger.Instance;
 }

        public string GetAccessToken(WorkContext wc, string code, string returnUrl)
        {
            try
            {
                var part = wc.CurrentSite.As<FacebookSettingsPart>();
                var clientId = part.ClientId;
                var clientSecret = _oauthHelper.Decrypt(part.Record.EncryptedClientSecret);

                var urlHelper = new UrlHelper(wc.HttpContext.Request.RequestContext);
                var redirectUrl =
                    new Uri(wc.HttpContext.Request.Url,
                            urlHelper.Action("Auth", "FacebookOAuth", new { Area = "RM.QuickLogOn.OAuth" })).ToString();//, returnUrl = returnUrl
                var url = string.Format(TokenRequestUrl, urlHelper.Encode(clientId), urlHelper.Encode(redirectUrl), urlHelper.Encode(clientSecret), urlHelper.Encode(code));
                var wr = WebRequest.Create(url);
                wr.Proxy = OAuthHelper.GetProxy();
                wr.Method = "GET";
                var wres = wr.GetResponse();
                using (var stream = wres.GetResponseStream())
                using (var sr = new StreamReader(stream))
                {
                    var result = HttpUtility.ParseQueryString(sr.ReadToEnd());
                    return result["access_token"];
                }
                }
            catch (Exception ex)
            {
                string error = OAuthHelper.ReadWebExceptionMessage(ex);
                Logger.Error(ex, string.IsNullOrEmpty(error) ? ex.Message : error);
            }
            
            return null;
        }

 public ProfilerFilter(WorkContext workContext, IAuthorizer authorizer, IShapeFactory shapeFactory, IProfilerService profiler)
 {
     this.workContext = workContext;
     this.shapeFactory = shapeFactory;
     this.authorizer = authorizer;
     this.profiler = profiler;
 }

        public LayoutAwareViewEngine(IThemeAwareViewEngine themeAwareViewEngine, WorkContext workContext, IDisplayHelperFactory displayHelperFactory)
        {
            _themeAwareViewEngine = themeAwareViewEngine;
            _workContext = workContext.AsMvcWorkContext();
            _displayHelperFactory = displayHelperFactory;

            Logger = NullLogger.Instance;
        }

 public TemplatesFilter(
     WorkContext workContext, 
     IAuthorizer authorizer,
     IShapeFactory shapeFactory) {
     _workContext = workContext;
     _authorizer = authorizer;
     _shapeFactory = shapeFactory;
 }

 public AdminCultureSelectorFactory(
     IWorkContextAccessor workContextAccessor, 
     IShapeFactory shapeFactory,
     ICultureManager cultureManager) {
     _cultureManager = cultureManager;
     _workContext = workContextAccessor.GetContext();
     Shape = shapeFactory;
 }

 protected override void DoAfterWork(WorkContext work, JSONDataMap matched)
 {
   var txt = matched[VAR_ERROR].AsString();
   if (txt.IsNotNullOrWhiteSpace())
       throw new WaveException(txt);
   else
    work.Aborted = true;
 }

		public bool SetAuthenticatedUserForRequest(HttpRequestMessage request, WorkContext workContext)
		{
			var membershipService = workContext.Resolve<IMembershipService>();
			var authenticationService = workContext.Resolve<IAuthenticationService>();

			var credentials = this.GetCredentials(request.Headers.Authorization);
			var user = this.GetUserForCredentials(credentials, membershipService);
			return this.SetAuthenticatedUserForRequest(user, authenticationService);
		}

 public string GetLogOnUrl(WorkContext context)
 {
     var urlHelper = new UrlHelper(context.HttpContext.Request.RequestContext);
     var part = context.CurrentSite.As<FacebookSettingsPart>();
     var clientId = part.ClientId;
     var returnUrl = context.HttpContext.Request.Url;
     var redirectUrl = new Uri(returnUrl, urlHelper.Action("Auth", "FacebookOAuth", new { Area = "RM.QuickLogOn.OAuth" })).ToString();//, returnUrl = returnUrl
     return string.Format(Url, clientId, urlHelper.Encode(redirectUrl), urlHelper.Encode(returnUrl.ToString()));
 }

 protected override void DoBeforeWork(WorkContext work, JSONDataMap matched)
 {
     work.Log(
        matched[VAR_TYPE].AsEnum<MessageType>(MessageType.Info),
        matched[VAR_TEXT].AsString(work.About),
        matched[VAR_FROM].AsString("{0}.Before".Args(GetType().FullName)),
        pars: matched.ToJSON(JSONWritingOptions.CompactASCII)
        );
 }

 public InlineShapeFactory(IAuthorizer authorizer, 
     IWorkContextAccessor workContextAccessor,
     IShapeTableManager shapeTableManager,
     IThemeManager themeManager) {
     _authorizer = authorizer;
     _shapeTableManager = shapeTableManager;
     _themeManager = themeManager;
     _workContext = workContextAccessor.GetContext();
 }

      protected sealed override void DoFilterWork(WorkContext work, IList<WorkFilter> filters, int thisFilterIndex)
      {     
        if (work.m_PortalFilter==null)
        {
          try
          {
            work.m_PortalFilter = this;
            
            foreach(var match in m_PortalMatches.OrderedValues)
            {
              var matched = match.Make(work);
              if (matched!=null)
              {
                var portalName = matched[VAR_PORTAL_NAME].AsString();
                if (portalName.IsNotNullOrWhiteSpace())
                {
                  var portal = PortalHub.Instance.Portals[portalName];
                  if (portal!=null && !portal.Offline)
                  {
                    work.m_Portal = portal;
                    work.m_PortalMatch = match;
                    work.m_PortalMatchedVars = matched;
                  }
                  break;
                }
              }
            }

            if (work.m_Portal==null)
            {
              var defaultPortal = PortalHub.Instance.DefaultOnline;
              if (defaultPortal!=null)
              {
                 work.m_Portal = defaultPortal;
              } 
            }

            if (Server.m_InstrumentationEnabled &&
                work.m_Portal!=null && 
                work.m_Portal.InstrumentationEnabled)
            {
              Server.m_Stat_PortalRequest.IncrementLong(work.m_Portal.Name);
            }

            this.InvokeNextWorker(work, filters, thisFilterIndex);
          }
          finally
          {
            work.m_PortalFilter = null;
            work.m_Portal = null;
            work.m_PortalMatch = null;
            work.m_PortalMatchedVars = null;
            work.PortalTheme = null;
          }
        }
        else this.InvokeNextWorker(work, filters, thisFilterIndex);
      }

 public TinyMceShapeDisplayEvent(
     ICacheManager cacheManager,
     IVirtualPathProvider virtualPathProvider,
     IWorkContextAccessor workContextAccessor,
     ISignals signals) {
     _signals = signals;
     _cacheManager = cacheManager;
     _virtualPathProvider = virtualPathProvider;
     _workContext = workContextAccessor.GetContext();
 }

        public ThemeAwareViewEngine(
            WorkContext workContext,
            IEnumerable<IViewEngineProvider> viewEngineProviders,
            IConfiguredEnginesCache configuredEnginesCache) {
            _workContext = workContext;
            _viewEngineProviders = viewEngineProviders;
            _configuredEnginesCache = configuredEnginesCache;

            Logger = NullLogger.Instance;
        }

 public string GetLogOnUrl(WorkContext context)
 {
     var urlHelper = new UrlHelper(context.HttpContext.Request.RequestContext);
     var part = context.CurrentSite.As<LinkedInSettingsPart>();
     var clientId = part.ClientId;
     var returnUrl = context.HttpContext.Request.Url;
     var redirectUrl = new Uri(returnUrl, urlHelper.Action("Auth", "LinkedInOAuth", new { Area = "RM.QuickLogOn.OAuth", ReturnUrl = returnUrl })).ToString();//
     var state = Guid.NewGuid().ToString().Trim('{', '}');
     return string.Format(Url, clientId, urlHelper.Encode(redirectUrl), state);
 }

 public void Init() {
     var builder = new ContainerBuilder();
     _workContext = new StubWorkContext();
     builder.RegisterInstance(new StubCultureSelector("fr-CA")).As<ICultureSelector>();
     builder.RegisterInstance(new StubHttpContext("~/"));
     builder.RegisterInstance(_workContext);
     builder.RegisterType<StubHttpContextAccessor>().As<IHttpContextAccessor>();
     builder.RegisterType<CurrentCultureWorkContext>().As<IWorkContextStateProvider>();
     _container = builder.Build();
     _currentCultureStateProvider = _container.Resolve<IWorkContextStateProvider>();
 }