public HttpApplicationStateWrapper(HttpApplicationState httpApplicationState)
 {
     if (httpApplicationState == null) {
         throw new ArgumentNullException("httpApplicationState");
     }
     _application = httpApplicationState;
 }

 // 12/22/2007 Paul.  Inside the timer event, there is no current context, so we need to pass the application.
 public static DataTable Parent(HttpApplicationState Application, string sPARENT_TYPE, Guid gPARENT_ID)
 {
     DataTable dt = new DataTable();
     string sTABLE_NAME = Sql.ToString(Application["Modules." + sPARENT_TYPE + ".TableName"]);
     if ( !Sql.IsEmptyString(sTABLE_NAME) )
     {
         DbProviderFactory dbf = DbProviderFactories.GetFactory(Application);
         using ( IDbConnection con = dbf.CreateConnection() )
         {
             con.Open();
             string sSQL;
             sSQL = "select *"                + ControlChars.CrLf
                  + "  from vw" + sTABLE_NAME + ControlChars.CrLf
                  + " where ID = @ID"         + ControlChars.CrLf;
             using ( IDbCommand cmd = con.CreateCommand() )
             {
                 cmd.CommandText = sSQL;
                 Sql.AddParameter(cmd, "@ID", gPARENT_ID);
                 using ( DbDataAdapter da = dbf.CreateDataAdapter() )
                 {
                     ((IDbDataAdapter)da).SelectCommand = cmd;
                     da.Fill(dt);
                 }
             }
         }
     }
     return dt;
 }

        public static List<Bubis.Andika.DAL.EF.Roles> GetRoles(HttpApplicationState application)
        {
            if (!RolesIsLoaded(application))
                LoadRoles(application);

            return application[ROLES_PAGES] as List<Bubis.Andika.DAL.EF.Roles>;
        }

        public Broker(HttpApplicationState app)
        {
            this._app = app;
            LogUtil.Setup();
            StartSuperWebSocketByConfig();

        }

 public HttpApplicationStateWrapper(System.Web.HttpApplicationState httpApplicationState)
 {
     if (httpApplicationState == null)
     {
         throw new ArgumentNullException("httpApplicationState");
     }
     this._application = httpApplicationState;
 }

 public static void OnStart( HttpApplicationState appState )
 {
     // Uncomment to debug bootstrapping process.
     // Note: IIS 7 starts up far too fast for Visual Studio to attach.  If you need to
     //       Debug the bootstrapping process then you need to uncomment this line of code,
     //       connect to Rem through the browser.  This statement will force a debugger to
     //       attach to the worker process and enable you to debug.
     //System.Diagnostics.Debugger.Launch();
     new Bootstrapper().Run ( appState );
 }

 private string GetSessionId(HttpApplicationState Application)
 {
     if (Application["sessionId"] == null)
     {
         Application.Lock();
         Application["sessionId"] = opentok.CreateSession().Id;
         Application.UnLock();
     }
     return (string)Application["sessionId"];
 }

 // todo: serialize access to this method
 private SingularAssociationManager initAssociationManager(HttpApplicationState application)
 {
     SingularAssociationManager returnValue = (SingularAssociationManager)application["dossia.openid.associationManager"];
     if (returnValue == null)
     {
         returnValue = new SingularAssociationManager();
         application["dossia.openid.associationManager"] = returnValue;
     }
     return returnValue;
 }

		// 08/17/2005   Special Term function that helps with a list. 
		public static object Term(HttpApplicationState Application, string sCultureName, string sListName, object oField)
		{
			// 01/11/2008   Protect against uninitialized variables. 
			if ( String.IsNullOrEmpty(sListName) )
				return String.Empty;

			if ( oField == null || oField == DBNull.Value )
				return oField;
			// 11/28/2005   Convert field to string instead of cast.  Cast will not work for integer fields. 
			return Term(Application, sCultureName, sListName + oField.ToString());
		}

        public BootcampCore([NotNull] HttpServerUtility server, [NotNull] HttpApplicationState application, [CanBeNull] HttpResponse response, BootcampMode mode, bool noisy)
        {
            Assert.ArgumentNotNull(server, "server");
              Assert.ArgumentNotNull(application, "application");

              this.Server = server;
              this.Application = application;
              this.Response = response;
              this.Mode = mode;
              this.Noisy = noisy;
        }

        public static void Process(HttpApplicationState Application)
        {
            if ( !bInsideWorkflow )
            {
                bInsideWorkflow = true;
                try
                {
                    //SplendidError.SystemMessage(Application, "Warning", new StackTrace(true).GetFrame(0), "WorkflowUtils.Process Begin");

                    spWORKFLOW_EVENTS_ProcessAll(Application);
                    /*
                    DbProviderFactory dbf = DbProviderFactories.GetFactory(Application);
                    using ( IDbConnection con = dbf.CreateConnection() )
                    {
                        string sSQL ;
                        sSQL = "select *                " + ControlChars.CrLf
                             + "  from vwWORKFLOW_EVENTS" + ControlChars.CrLf
                             + " order by AUDIT_VERSION " + ControlChars.CrLf;
                        using ( IDbCommand cmd = con.CreateCommand() )
                        {
                            cmd.CommandText = sSQL;
                            con.Open();

                            using ( DbDataAdapter da = dbf.CreateDataAdapter() )
                            {
                                ((IDbDataAdapter)da).SelectCommand = cmd;
                                using ( DataTable dt = new DataTable() )
                                {
                                    da.Fill(dt);
                                    if ( dt.Rows.Count > 0 )
                                        SplendidError.SystemMessage(Application, "Warning", new StackTrace(true).GetFrame(0), "Processing " + dt.Rows.Count.ToString() + " workflow events");
                                    foreach ( DataRow row in dt.Rows )
                                    {
                                        Guid gID = Sql.ToGuid(row["ID"]);
                                        // 12/30/2007 Paul.  We are not going to do anything yet, but we do need to clean up the table.
                                        spWORKFLOW_EVENTS_Delete(Application, gID);
                                    }
                                }
                            }
                        }
                    }
                    */
                }
                catch(Exception ex)
                {
                    SplendidError.SystemMessage(Application, "Error", new StackTrace(true).GetFrame(0), Utils.ExpandException(ex));
                }
                finally
                {
                    bInsideWorkflow = false;
                }
            }
        }

 // 12/22/2007 Paul.  Inside the timer event, there is no current context, so we need to pass the application.
 public static string Culture(HttpApplicationState Application)
 {
     string sCulture = Sql.ToString(Application["CONFIG.default_language"]);
     // 12/22/2007 Paul.  The cache is not available when we are inside the timer event.
     if ( HttpContext.Current != null && HttpContext.Current.Cache != null )
     {
         DataView vwLanguages = new DataView(SplendidCache.Languages());
         vwLanguages.RowFilter = "NAME = '" + sCulture +"'";
         if ( vwLanguages.Count > 0 )
             sCulture = Sql.ToString(vwLanguages[0]["NAME"]);
     }
     if ( Sql.IsEmptyString(sCulture) )
         sCulture = "en-US";
     return L10N.NormalizeCulture(sCulture);
 }

		// 12/22/2007   Inside the timer event, there is no current context, so we need to pass the application. 
		public static string Culture(HttpApplicationState Application)
		{
			string sCulture = Sql.ToString(Application["CONFIG.default_language"]);
			// 12/22/2007   The cache is not available when we are inside the timer event. 
			// 02/18/2008   The Languages function is now thread safe, so it can be called from the timer. 
			//if ( HttpContext.Current != null && HttpContext.Current.Cache != null )
			{
				DataView vwLanguages = new DataView(SplendidCache.Languages(Application));
				// 05/20/2008   Normalize culture before lookup. 
				vwLanguages.RowFilter = "NAME = '" + L10N.NormalizeCulture(sCulture) +"'";
				if ( vwLanguages.Count > 0 )
					sCulture = Sql.ToString(vwLanguages[0]["NAME"]);
			}
			if ( Sql.IsEmptyString(sCulture) )
				sCulture = "en-US";
			return L10N.NormalizeCulture(sCulture);
		}

 private void CompileApplication()
 {
     this._theApplicationType = BuildManager.GetGlobalAsaxType();
     BuildResultCompiledGlobalAsaxType globalAsaxBuildResult = BuildManager.GetGlobalAsaxBuildResult();
     if (globalAsaxBuildResult != null)
     {
         if (globalAsaxBuildResult.HasAppOrSessionObjects)
         {
             this.GetAppStateByParsingGlobalAsax();
         }
         this._fileDependencies = globalAsaxBuildResult.VirtualPathDependencies;
     }
     if (this._state == null)
     {
         this._state = new HttpApplicationState();
     }
     this.ReflectOnApplicationType();
 }

        internal static async void CheckForUpdates(HttpApplicationState application)
        {
            bool autoSuggestUpdate =
                Conversion.TryCastBoolean(ConfigurationHelper.GetUpdaterParameter("AutoSuggestUpdate"));

            if (autoSuggestUpdate)
            {
                try
                {
                    Updater.UpdateManager updater = new Updater.UpdateManager();
                    Release release = await updater.GetLatestReleaseAsync();

                    if (release != null)
                    {
                        application["UpdateAvailable"] = true;
                    }
                }
                catch (Exception ex)
                {
                    Log.Error("Exception occurred. {Exception}.", ex);
                }
            }
        }

        //
        //
        //

        internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers) {
            Debug.Assert(context != null, "context != null");

            // Remember state
            _state = state;

            PerfCounters.IncrementCounter(AppPerfCounter.PIPELINES);

            try {
                try {
                    // Remember context for config lookups
                    _initContext = context;
                    _initContext.ApplicationInstance = this;

                    // Set config path to be application path for the application initialization
                    context.ConfigurationPath = context.Request.ApplicationPathObject;

                    // keep HttpContext.Current working while running user code
                    using (new DisposableHttpContextWrapper(context)) {

                        // Build module list from config
                        if (HttpRuntime.UseIntegratedPipeline) {

                            Debug.Assert(_moduleConfigInfo != null, "_moduleConfigInfo != null");
                            Debug.Assert(_moduleConfigInfo.Count >= 0, "_moduleConfigInfo.Count >= 0");

                            try {
                                context.HideRequestResponse = true;
                                _hideRequestResponse = true;
                                InitIntegratedModules();
                            }
                            finally {
                                context.HideRequestResponse = false;
                                _hideRequestResponse = false;
                            }
                        }
                        else {
                            InitModules();

                            // this is used exclusively for integrated mode
                            Debug.Assert(null == _moduleContainers, "null == _moduleContainers");
                        }

                        // Hookup event handlers via reflection
                        if (handlers != null)
                            HookupEventHandlersForApplicationAndModules(handlers);

                        // Initialization of the derived class
                        _context = context;
                        if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                            _context.HideRequestResponse = true;
                        }
                        _hideRequestResponse = true;

                        try {
                            Init();
                        }
                        catch (Exception e) {
                            RecordError(e);
                        }
                    }

                    if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                        _context.HideRequestResponse = false;
                    }
                    _hideRequestResponse = false;
                    _context = null;
                    _resumeStepsWaitCallback= new WaitCallback(this.ResumeStepsWaitCallback);

                    // Construct the execution steps array
                    if (HttpRuntime.UseIntegratedPipeline) {
                        _stepManager = new PipelineStepManager(this);
                    }
                    else {
                        _stepManager = new ApplicationStepManager(this);
                    }

                    _stepManager.BuildSteps(_resumeStepsWaitCallback);
                }
                finally {
                    _initInternalCompleted = true;

                    // Reset config path
                    context.ConfigurationPath = null;

                    // don't hold on to the context
                    _initContext.ApplicationInstance = null;
                    _initContext = null;
                }
            }
            catch { // Protect against exception filters
                throw;
            }
        }

 /// <summary>
 /// spWORKFLOW_EVENTS_ProcessAll
 /// </summary>
 public static void spWORKFLOW_EVENTS_ProcessAll(HttpApplicationState Application)
 {
     if ( HttpContext.Current != null && HttpContext.Current.Application != null )
     {
         // 12/22/2007 Paul.  By calling the SqlProcs version, we will ensure a compile-time error if the parameters change.
         SqlProcs.spWORKFLOW_EVENTS_ProcessAll();
     }
     else
     {
         DbProviderFactory dbf = DbProviderFactories.GetFactory(Application);
         using ( IDbConnection con = dbf.CreateConnection() )
         {
             con.Open();
             using ( IDbTransaction trn = con.BeginTransaction() )
             {
                 try
                 {
                     using ( IDbCommand cmd = con.CreateCommand() )
                     {
                         cmd.Transaction = trn;
                         cmd.CommandType = CommandType.StoredProcedure;
                         cmd.CommandText = "spWORKFLOW_EVENTS_ProcessAll";
                         cmd.ExecuteNonQuery();
                     }
                     trn.Commit();
                 }
                 catch(Exception ex)
                 {
                     trn.Rollback();
                     throw(new Exception(ex.Message, ex.InnerException));
                 }
             }
         }
     }
 }

 /// <summary>
 /// Dumps the values found in the application state
 /// </summary>
 /// <param name="Input">Application state variable</param>
 /// <returns>A string containing the application state information</returns>
 public static string DumpApplicationState(HttpApplicationState Input)
 {
     StringBuilder String = new StringBuilder();
     foreach (string Key in Input.Keys)
     {
         String.Append(Key).Append(": ")
             .Append(Input[Key].ToString())
             .Append("<br />Properties<br />")
             .Append(Reflection.Reflection.DumpProperties(Input[Key]))
             .Append("<br />");
     }
     return String.ToString();
 }

 public HttpApplicationStateAdapter(HttpApplicationState app)
 {
     this.app = app;
 }

        internal void InitSpecial(HttpApplicationState state, MethodInfo[] handlers, IntPtr appContext, HttpContext context) {
            // Remember state
            _state = state;

            try {
                //  Remember the context for the initialization
                if (context != null) {
                    _initContext = context;
                    _initContext.ApplicationInstance = this;
                }

                // if we're doing integrated pipeline wireup, then appContext is non-null and we need to init modules and register event subscriptions with IIS
                if (appContext != IntPtr.Zero) {
                    // 1694356: app_offline.htm and <httpRuntime enabled=/> require that we make this check here for integrated mode
                    using (new ApplicationImpersonationContext()) {
                        HttpRuntime.CheckApplicationEnabled();
                    }

                    // retrieve app level culture
                    InitAppLevelCulture();

                    Debug.Trace("PipelineRuntime", "InitSpecial for " + appContext.ToString() + "\n");
                    RegisterEventSubscriptionsWithIIS(appContext, context, handlers);
                }
                else {
                    // retrieve app level culture
                    InitAppLevelCulture();

                    // Hookup event handlers via reflection
                    if (handlers != null) {
                        HookupEventHandlersForApplicationAndModules(handlers);
                    }
                }

                // if we're doing integrated pipeline wireup, then appContext is non-null and we need to register the application (global.asax) event handlers
                if (appContext != IntPtr.Zero) {
                    if (_appPostNotifications != 0 || _appRequestNotifications != 0) {
                        RegisterIntegratedEvent(appContext,
                                                HttpApplicationFactory.applicationFileName,
                                                _appRequestNotifications,
                                                _appPostNotifications,
                                                this.GetType().FullName,
                                                MANAGED_PRECONDITION,
                                                false);
                    }
                }
            }
            finally  {
                _initSpecialCompleted = true;

                //  Do not hold on to the context
                if (_initContext != null) {
                    _initContext.ApplicationInstance = null;
                    _initContext = null;
                }
            }
        }