public static IList<ISearchJobDto> getRecentSearchJobs(HttpSessionState session)
 {
     SessionKey key = SessionKey.SearchJobs;
     if(get(key, session) == null)
         set(key, session, new List<ISearchJobDto>());
     return get(key, session) as IList<ISearchJobDto>;
 }

 public void Invoke(HttpSessionState session, DataInputStream input)
 {
     _result = HttpProcessor.GetClient<CommentServiceSoapClient>(session).GetComment(
         input.ReadString(),
         input.ReadString(),
         input.ReadInt32());
 }

 internal static HttpSessionStateWrapper CreateSessionWrapper(HttpSessionState httpSessionState)
 {
     HttpSessionStateWrapper httpSessionStateWrapper = new HttpSessionStateWrapper(httpSessionState);
     //if (httpSessionState.IsNewSession)
     //    httpSessionStateWrapper.NotifyCreated();
     return httpSessionStateWrapper;
 }

        /// <summary>
        /// Invokes the appropriate service handler (registered using a ServiceAttribute)
        /// </summary>
        public void InvokeServiceHandler(Message request, Message response, HttpSessionState session, HttpResponse httpresponse)
        {
            if (request.Type.Equals(this.Request))
            {
                try
                {
                    Message temp_response = response;
                    Object[] parameters = new Object[] { request, temp_response };
                    Object declaringTypeInstance = Activator.CreateInstance(this.MethodInfo.DeclaringType);
                    this.MethodInfo.Invoke(declaringTypeInstance, parameters);
                    temp_response = (Message)parameters[1];
                    temp_response.Type = this.Response;
                    temp_response.Scope = request.Scope;
                    temp_response.Version = request.Version;
                    temp_response.RequestDetails = request.RequestDetails;

                    Logger.Instance.Debug("Invoked service for request: " + request.Type);
                    Dispatcher.Instance.EnqueueOutgoingMessage(temp_response, session.SessionID);
                }
                catch (Exception e)
                {
                    String err = "";
                    err+="Exception while invoking service handler - " + this.MethodInfo.Name + " in " + this.MethodInfo.DeclaringType.Name + "\n";
                    err += "Request Message - " + request.Type + "\n";
                    err += "Response Message - " + response.Type + "\n";
                    err += "Message - " + e.Message + "\n";
                    err += "Stacktrace - " + e.StackTrace + "\n";
                    Logger.Instance.Error(err);
                }
            }
        }

 public List<Node> Dump(HttpSessionState session)
 {
     return session.Keys.Cast<string>()
         .OrderBy(x => x)
         .Select(x => Process("item", x, session[x], 0))
         .ToList();
 }

 public void Invoke(HttpSessionState session, DataInputStream input)
 {
     HttpProcessor.GetClient<AskServiceSoapClient>(session).CompleteQuestion(
        input.ReadString(),
        input.ReadString(),
        input.ReadString());
 }

        /// <summary>
        /// Handles the id PSSO request.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="request">The request.</param>
        /// <param name="response">The response.</param>
        /// <param name="session">The session.</param>
        private void HandleIdPSSORequest(HttpContext context, HttpRequest request, HttpResponse response, HttpSessionState session)
        {
            if (request.Cookies[FormsAuthentication.FormsCookieName] == null) return;
              var cookiestr = request.Cookies[FormsAuthentication.FormsCookieName].Value;
              var tkt = FormsAuthentication.Decrypt(cookiestr);
              if (tkt == null) return;
              var attributes = new MultiStringDictionary
            {
              {Constants.SUBJECT, tkt.Name},
              {"NickName", "defaultNickName"},
              {"Role", "Admin"}
            };
              if (request[Constants.RESUME_PATH] == null) return;
              var attributesToSend = new MultiStringDictionary();
              foreach (var pair in attributes)
              {
            var key = pair.Key;

            foreach (string value in pair.Value)
            {
              attributesToSend.Add(key, value);
            }
              }

              var strRedirect = "https://" + ConfigurationManager.AppSettings["PFHost"] + request[Constants.RESUME_PATH];
              strRedirect = SetOpenToken(context, strRedirect, attributesToSend);
              response.Redirect(strRedirect, true);
        }

 public void Invoke(HttpSessionState session, DataInputStream input)
 {
     _result = HttpProcessor.GetClient<PhotoServiceSoapClient>(session).GetPhotosForCollection(
         input.ReadString(),
         input.ReadString(),
         input.ReadInt32());
 }

 public HttpSessionStateWrapper(HttpSessionState httpSessionState)
 {
     if (httpSessionState == null) {
         throw new ArgumentNullException("httpSessionState");
     }
     _session = httpSessionState;
 }

 public void Invoke(HttpSessionState session, DataInputStream input)
 {
     _result = HttpProcessor.GetClient<TagServiceSoapClient>(session).UploadTags(
         input.ReadString(),
         input.ReadString(),
         input.ReadTagUpdate());
 }

        public void CarregarValores(HttpSessionState Session, string sWhere = "")
        {
            if (this.DataSource == null)
            {
                string sDataTable = "DataTable" + this.ID;
                DataTable dtValores = (DataTable)Session[sDataTable];
                //if (dtValores == null)
                {
                    Tabela oTabelas = ((UsuarioWeb)Session["ObjetoUsuario"]).oTabelas;
                    StringBuilder strExpressao = new StringBuilder();
                    strExpressao.Append(sExpressaoSqlDadosConsulta);
                    strExpressao.Replace("<CD_EMPRESA>", "'" + oTabelas.sEmpresa + "'");
                    strExpressao.Replace("<CD_VEND>", "'" + oTabelas.CdVendedorAtual + "'");
                    if (sWhere != "")
                    {
                        strExpressao.Append(" Where " + sWhere);
                    }

                    dtValores = oTabelas.hlpDbFuncoes.qrySeekRet(strExpressao.ToString());
                    Session[sDataTable] = dtValores;
                }
                this.DataSource = dtValores;
                this.DataBind();
            }
        }

 public void Invoke(HttpSessionState session, DataInputStream input)
 {
     _result = HttpProcessor.GetClient<DashboardServiceSoapClient>(session).GetThumbnail(
         input.ReadString(),
         input.ReadString(),
         input.ReadString());
 }

        internal void RaiseOnEnd(HttpSessionState sessionState) {
            Debug.Trace("SessionOnEnd", "Firing OnSessionEnd for " + sessionState.SessionID);

            if (_sessionEndEventHandlerCount > 0) {
                HttpApplicationFactory.EndSession(sessionState, this, EventArgs.Empty);
            }
        }

 public static string GetMessageForUser(HttpSessionState session)
 {
     if (UserHaveMessage(session))
         return session[USER_MESSAGE].ToString();
     else
         return string.Empty;
 }

        internal static void FCKClearTempStore(HttpSessionState session)
        {
            if (session == null)
                return;

            var uploads = session["tempFCKUploads"] as List<FCKTempUploadsInfo>;
            if (uploads == null) return;

            IDataStore store = null;
            foreach (var u in uploads.Where(u => u.Files.Count > 0))
            {
                if (store == null)
                    store = StorageFactory.GetStorage(u.TenantID.ToString(), "fckuploaders");

                if (u.IsEdit)
                {
                    foreach (var fileName in u.Files)
                        store.DeleteFiles(u.StoreDomain, u.FolderID, fileName.ToLower(), false);
                }
                else
                {
                    store.DeleteFiles(u.StoreDomain, u.FolderID, "*", false);
                }
            }
        }

 public static Bubis.Andika.DAL.EF.Users GetUser(HttpSessionState session)
 {
     if (UserIsAuthenticated(session))
         return session[SESSION_USER] as Bubis.Andika.DAL.EF.Users;
     else
         throw new Bubis.Andika.Core.Exceptions.SessionExpiredException();
 }

        /// <summary>
        /// A constructor.
        /// </summary>
        /// <param name="e_game_type">A type of a game</param>
        /// <param name="queryString">URL query string</param>
        /// <param name="userSessionID">User's session ID from Session object</param>
        /// <param name="gameSessionID">Game session ID</param>
        public GameServiceProxy(EGameType e_game_type, string queryString, string userSessionID, string gameSessionID, HttpSessionState Session)
        {
            if (GS == null)
            {
                GS = new com.sanuko.www.GameService();
            }

            if (gameSessionID == null)
            {
                this.gameSessionID = "";
            }
            else
            {
                this.gameSessionID = gameSessionID;
            }

            this.Session = Session;

            this.e_game_type = e_game_type;
            this.queryString = queryString.Replace("?", "").Replace("&", ";");
            if (userSessionID == null)
            {
                this.userSessionID = "";
            }
            else
            {
                this.userSessionID = userSessionID;
            }
        }

 public static void SaveIntegrationSession(HttpSessionState session, string endpointUri, string apiKey, string dataServiceEndpoint, string activeUserName)
 {
     session[Constants.SessionApiKey] = apiKey;
     session[Constants.SessionLodEndpoint] = endpointUri;
     session[Constants.SessionDataServiceEndpoint] = dataServiceEndpoint;
     session[Constants.SessionActiveUserName] = activeUserName;
 }

 public void NotifyObserver(HttpSessionState currentSession, bool isFinised)
 {
     const string message = "finished.";
     if (NotifyLogger != null) NotifyLogger(message); //+ "\n"
     var args = new NotificationEventArgs(currentSession, message, isFinised);
     OnAsyncNotificationEvent(args);//for web
 }

 internal void RaiseOnEnd(HttpSessionState sessionState)
 {
     if (this._sessionEndEventHandlerCount > 0)
     {
         HttpApplicationFactory.EndSession(sessionState, this, EventArgs.Empty);
     }
 }