/// <summary> /// Builds the DbCommand that returns the list of dependent tasks /// and their dependent tasks for a given WaitTaskQueueCode /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <returns>DbCommand Object with DbNull Parameter values</returns> static DbCommand GetDependentTasksCmd(DataAccessMgr daMgr) { StringBuilder sb = new StringBuilder(); // we do not have any helper functions to build a recursive query; so we // are building this manually. sb.AppendFormat("WITH Dependencies ({0}, {1}, Level){2} AS{2} ({2}" , TaskProcessing.Constants.TaskQueueCode , TaskProcessing.Constants.WaitTaskQueueCode , Environment.NewLine); sb.AppendFormat("SELECT tpq.{0}, {1}, 1 AS Level{2}" , TaskProcessing.Constants.TaskQueueCode , TaskProcessing.Constants.WaitTaskQueueCode , Environment.NewLine); sb.AppendFormat("FROM {0}.{1} tpq{2}" , DataAccess.Constants.SCHEMA_CORE , TaskProcessing.Constants.TaskProcessingQueue , Environment.NewLine); sb.AppendFormat("INNER JOIN {0}.{1} td{2}" , DataAccess.Constants.SCHEMA_CORE , TaskProcessing.Constants.TaskDependencies , Environment.NewLine); sb.AppendFormat("ON tpq.{0} = td.{0}{1}UNION ALL{1}" , TaskProcessing.Constants.TaskQueueCode , Environment.NewLine); sb.AppendFormat("SELECT d.{0}, td.{1}, Level + 1{2}" , TaskProcessing.Constants.TaskQueueCode , TaskProcessing.Constants.WaitTaskQueueCode , Environment.NewLine); sb.AppendFormat("FROM Dependencies d{0}" , Environment.NewLine); sb.AppendFormat("INNER JOIN {0}.{1} td{2}" , DataAccess.Constants.SCHEMA_CORE , TaskProcessing.Constants.TaskDependencies , Environment.NewLine); sb.AppendFormat("ON d.{0} = td.{1}{2})" , TaskProcessing.Constants.WaitTaskQueueCode , TaskProcessing.Constants.TaskQueueCode , Environment.NewLine); sb.AppendFormat("SELECT {0}, {1}, Level{2}" , TaskProcessing.Constants.TaskQueueCode , TaskProcessing.Constants.WaitTaskQueueCode , Environment.NewLine); sb.AppendFormat("FROM Dependencies d{0}" , Environment.NewLine); sb.AppendFormat("WHERE {0} = {1}{2};" , TaskProcessing.Constants.WaitTaskQueueCode , daMgr.BuildBindVariableName(TaskProcessing.Constants.WaitTaskQueueCode) , Environment.NewLine); DbCommand dbCmd = daMgr.BuildSelectDbCommand(sb.ToString(), null); daMgr.AddNewParameterToCollection(dbCmd.Parameters, TaskProcessing.Constants.WaitTaskQueueCode , DbType.Int32 , null , 0 , ParameterDirection.Input , DBNull.Value); return(dbCmd); }
/// <summary> /// Returns the list of registered tasks as a datatable /// </summary> /// <param name="daMgr">DataAccess manager object</param> /// <returns></returns> public static DataTable GetRegisteredTasks(DataAccessMgr daMgr) { DbCommand dbCmd = daMgr.DbCmdCacheGetOrAdd(Constants.TaskRegistrationList , BuildCmdGetRegisteredTasksList); return(daMgr.ExecuteDataSet(dbCmd, null, null).Tables[0]); }
/// <summary> /// Builds the DbCommand to delete the task dependency(s) for the given taskQueueCode. /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="taskQueueItem">Datarow containing the parameter values</param> /// <param name="deleteAll">Indicates whether or not to delete all dependencies.</param> /// <returns>DbCommand Object with DbNull Parameter values</returns> public static DbCommand GetDeleteQueueItemCmd(DataAccessMgr daMgr, DataRow taskQueueItem, bool deleteAll) { if (taskQueueItem == null || !taskQueueItem.Table.Columns.Contains(TaskProcessing.Constants.TaskQueueCode)) { throw new ExceptionEvent(enumExceptionEventCodes.NullOrEmptyParameter , "DataRow (taskQueueItem) containing TaskDependency data was empty"); } DbTableDmlMgr dmlMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , TaskProcessing.Constants.TaskDependencies); dmlMgr.SetWhereCondition(w => w.Column(TaskProcessing.Constants.TaskQueueCode) == w.Parameter(TaskProcessing.Constants.TaskQueueCode)); if (!deleteAll) { System.Linq.Expressions.Expression waitTaskExp = DbPredicate.CreatePredicatePart(w => w.Column(TaskProcessing.Constants.WaitTaskQueueCode) == w.Parameter(TaskProcessing.Constants.WaitTaskQueueCode)); dmlMgr.AddToWhereCondition(System.Linq.Expressions.ExpressionType.AndAlso, waitTaskExp); } DbCommand dbCmd = daMgr.BuildDeleteDbCommand(dmlMgr); dbCmd.Parameters[daMgr.BuildParamName(TaskProcessing.Constants.TaskQueueCode)].Value = Convert.ToInt32(taskQueueItem[TaskProcessing.Constants.TaskQueueCode]); if (!deleteAll) { dbCmd.Parameters[daMgr.BuildParamName(TaskProcessing.Constants.WaitTaskQueueCode)].Value = Convert.ToInt32(taskQueueItem[TaskProcessing.Constants.WaitTaskQueueCode]); } return(dbCmd); }
static DbCommand BuildCmdGetAllUserSessionsList(DataAccessMgr daMgr) { DbTableDmlMgr dmlSelectMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserSessions); return(daMgr.BuildSelectDbCommand(dmlSelectMgr, null)); }
#pragma warning restore 1591 // restore the xmlComments warning /// <summary> /// Returns the entire data table of application session records in the /// database based on the given enumeration. /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="tpqList">Enumeration indicating what type of session records to return</param> /// <returns>DataTable of Task Processing Queue records</returns> public static DataTable TaskProcessingQueueList(DataAccessMgr daMgr, ListEnum tpqList) { DbCommand dbCmd; switch (tpqList) { case ListEnum.Queued: dbCmd = daMgr.DbCmdCacheGetOrAdd("BuildCmdGetTPQListByWaitDateTime" , BuildCmdGetTPQListByWaitDateTime); dbCmd.Parameters[daMgr.BuildParamName(Constants.StatusCode)].Value = Convert.ToByte(tpqList); break; case ListEnum.Failed: case ListEnum.Succeeded: case ListEnum.InProcess: case ListEnum.NotQueued: dbCmd = daMgr.DbCmdCacheGetOrAdd("BuildCmdGetTPQListByStatusDateTime" , BuildCmdGetTPQListByStatusDateTime); dbCmd.Parameters[daMgr.BuildParamName(Constants.StatusCode)].Value = Convert.ToByte(tpqList); break; default: dbCmd = daMgr.DbCmdCacheGetOrAdd("BuildCmdGetTPQListByTaskId", BuildCmdGetTPQListByTaskId); break; } return(daMgr.ExecuteDataSet(dbCmd, null, null).Tables[0]); }
/// <summary> /// Constructor for the dependency tasks dialog /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="taskQueueCode">The task's unique code that has the dependency</param> /// <param name="taskQueueItem">DataRow object containing all the dependency tasks details</param> public DependentTaskAdmin(DataAccessMgr daMgr, string taskQueueCode, DataRow taskQueueItem) { InitializeComponent(); _daMgr = daMgr; _taskQueueCode = taskQueueCode; _taskQueueItem = taskQueueItem; PopulateForm(); }
/// <summary> /// Builds the DbCommand to get a list of the given task's dependency records /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="taskQueueCode">Unique identifier of the task whose dependencies will be returned</param> /// <returns>DateTable of the given task's dependencies</returns> public static DataTable TaskDependenciesList(DataAccessMgr daMgr, Int32 taskQueueCode) { DbCommand dbCmd = daMgr.DbCmdCacheGetOrAdd("BuildCmdGetTaskDependencies" , BuildCmdGetTaskDependencies); dbCmd.Parameters[daMgr.BuildParamName(Constants.TaskQueueCode)].Value = taskQueueCode; return(daMgr.ExecuteDataSet(dbCmd, null, null).Tables[0]); }
/// <summary> /// Returns the DbCommand to get this list of registered tasks. /// </summary> /// <param name="daMgr">DataAccess manager object</param> /// <returns></returns> static DbCommand BuildCmdGetRegisteredTasksList(DataAccessMgr daMgr) { // get all the columns and all the rows DbTableDmlMgr dmlSelectMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.TaskRegistrations); // return the DbCommand object return(daMgr.BuildSelectDbCommand(dmlSelectMgr, null)); }
/// <summary> /// The only constructor. /// </summary> /// <param name="daMgr">DataAccessMgr object</param> internal SignonControl(DataAccessMgr daMgr) { _daMgr = daMgr; DataTable dt = _daMgr.ExecuteDataSet(_daMgr.BuildSelectDbCommand( "select * from " + DataAccess.Constants.SCHEMA_CORE + "." + Constants.SignonControl , null), null, null).Tables[0]; Refresh(dt); }
public SampleTaskRun1Minute(DataAccessMgr daMgr , string taskId , int taskQueueCode , string parameters , TaskCompletedDelegate taskCompletedHandler , string engineId) : base(daMgr, taskId, taskQueueCode, parameters, taskCompletedHandler, engineId) { }
public ActionResult Users2() { DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); B1SampleEntities entities = new B1SampleEntities(); var query = from a in entities.UserMasters select new { a.UserCode, a.UserId, a.FirstName, "Edit" }; PagingMgr testSequenceMgr = new PagingMgr(daMgr, query, DataAccess.Constants.PageSize, 5); return(PartialView(Constants._Page_PagingMgrView, testSequenceMgr)); }
public ActionResult Users() { DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); B1SampleEntities entities = new B1SampleEntities(); var query = from a in entities.UserMasters select new { a.UserCode, a.UserId, a.FirstName }; DbCommand dbCmd = daMgr.BuildSelectDbCommand(query, null); return(PartialView("_Users", daMgr.ExecuteCollection <UserMaster>(dbCmd, null))); }
/// <summary> /// Returns the set of dependency relationships where the given task is the dependent task /// </summary> /// <param name="daMgr">DbAccessMgr object instance</param> /// <param name="waitTaskQueueCode">The taskQueueCode that other tasks may be dependent on</param> /// <returns>The DataTable of dependency relationhips</returns> public static DataTable GetDependentTasks(DataAccessMgr daMgr , Int32 waitTaskQueueCode) { DbCommand dbCmd = daMgr.DbCmdCacheGetOrAdd("GetDependentTasksCmd", GetDependentTasksCmd); dbCmd.Parameters[daMgr.BuildParamName(TaskProcessing.Constants.WaitTaskQueueCode)].Value = waitTaskQueueCode; return(daMgr.ExecuteDataSet(dbCmd, null, null).Tables[0]); }
private void TestSequenceButton_Click(object sender, RoutedEventArgs e) { DataAccessMgr daMgr = new DataAccessMgr(ConfigurationManager.AppSettings["ConnectionKey"]); B1SampleEntities entities = new B1SampleEntities(); var query = from a in entities.TestSequences orderby new { a.AppSequenceName, a.AppSequenceId } select new { a.AppSequenceId, a.AppSequenceName, a.DbSequenceId }; MainGridControl.PagingMgr = new PagingMgr(daMgr, query, DataAccess.Constants.PageSize, 10); MainGridControl.SetPage(PagingMgr.PagingDbCmdEnum.First); }
static DbCommand BuildCmdGetUpdateUserSession(DataAccessMgr daMgr) { DbTableDmlMgr dmlUpdateMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserSessions); dmlUpdateMgr.AddColumn(Constants.SessionDateTime, EnumDateTimeLocale.UTC); dmlUpdateMgr.SetWhereCondition(j => j.Column(Constants.SessionCode) == j.Parameter(Constants.UserSessions, Constants.SessionCode , daMgr.BuildParamName(Constants.SessionCode))); return(daMgr.BuildUpdateDbCommand(dmlUpdateMgr)); }
/// <summary> /// Constructor to create a UserSession instance for the given user signon meta data /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="userSignon">Meta data about the user's sucessful signon; including session code</param> internal UserSession(DataAccessMgr daMgr, UserSignonSessionStructure userSignon) { _daMgr = daMgr; _userSignon.DefaultAccessGroupCode = userSignon.DefaultAccessGroupCode; _userSignon.SessionCode = userSignon.SessionCode; _userSignon.SignonApp = userSignon.SignonApp; _userSignon.UserCode = userSignon.UserCode; _userSignon.UserId = userSignon.UserId; _userSignon.PasswordHash = userSignon.PasswordHash; _accessControlData = LoadAccessControl(); }
public ActionResult TestSequences2() { DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); B1SampleEntities entities = new B1SampleEntities(); var query = from a in entities.TestSequences orderby new { a.AppSequenceName, a.AppSequenceId } select new { a.AppSequenceId, a.AppSequenceName, a.DbSequenceId }; PagingMgr testSequenceMgr = new PagingMgr(daMgr, query, DataAccess.Constants.PageSize, 10); return(PartialView(Constants._Page_PagingMgrView, testSequenceMgr)); }
protected void Session_OnEnd() { System.Threading.Interlocked.Decrement(ref _userSessionCount); if (Session[SessionManagement.Constants.UserSessionMgr] != null) { UserSession userSessionMgr = (UserSession)Session[SessionManagement.Constants.UserSessionMgr]; DataAccessMgr daMgr = (DataAccessMgr)Application[DataAccess.Constants.DataAccessMgr]; UserSignon.Signoff(daMgr, userSessionMgr.SessionCode); Session.Remove(SessionManagement.Constants.UserSessionMgr); } }
public string TestSequences() { DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); B1SampleEntities entities = new B1SampleEntities(); var query = from a in entities.TestSequences orderby new { a.AppSequenceName, a.AppSequenceId } select new { a.AppSequenceId, a.AppSequenceName, a.DbSequenceId }; PagingMgr testSequenceMgr = new PagingMgr(daMgr, query, DataAccess.Constants.PageSize, 20); return(testSequenceMgr.ToHtmlString(this)); }
static DbCommand BuildGetUserMasterCmd(DataAccessMgr daMgr) { DbTableDmlMgr dmlMgr = new DbTableDmlMgr(daMgr, Constants.Schema_UserMaster, Constants.Table_UserMaster); dmlMgr.SetWhereCondition(w => ((w.Parameter(Constants.UserId) == null) || w.Column(Constants.UserId) == w.Parameter(Constants.UserId)) && ((w.Parameter(Constants.UserCode) == null) || w.Column(Constants.UserCode) == w.Parameter(Constants.UserCode))); DbCommand dbCmd = daMgr.BuildSelectDbCommand(dmlMgr, null); return(dbCmd); }
/// <summary> /// Main Window for Application /// </summary> public MainWindow() { try { InitializeComponent(); _configSettings = LoadConfigurationSettings(); _loggingMgr = new LoggingMgr(_loggingKey); _loggingMgr.TraceToWindow = true; _daMgr = new DataAccessMgr(_connectionKey, _loggingMgr); // This host requires an app session object _appSession = new AppSession(_daMgr , _engineId , _assemblyVersion , _assemblyName , Status); // create paging manager for task processing queue PagingMgr tpq = new PagingMgr(_daMgr , string.Format("{0}.{1}", DataAccess.Constants.SCHEMA_CORE, TaskProcessing.Constants.TaskProcessingQueue) , null, 1, null); // pass paging manager to paging controll pagingTableTPQ.Source = tpq; pagingTableTPQ.Title = "Task Processing Queue"; // set the status control for the local TPE localTpeStatus.SetContext(this, null, OnPlusMinusClick); // pass in the configuration settings localTpeStatus.Display(TraceLevelChanged , MaxTasksChanged , _connectionKey , _loggingKey , _configId , _engineId , _taskAssemblyPath , _hostEndpointAddress , _maxTasks , _loggingMgr.TraceLevel); // right now we cannot connect to any remote host remoteTpeStatus.IsEnabled = false; } catch (Exception e) { string errorFileName = "TaskProcessingEngine.Exception.txt"; string msg = "Will attempt to write exception details to file: " + errorFileName + Environment.NewLine + e.Message + Environment.NewLine + e.StackTrace + Environment.NewLine; MessageBox.Show(msg, "Fatal Error - Look for file: " + errorFileName); FileManagement.FileMgr.WriteTextToFile(errorFileName, msg, false, true); Exit(); } }
/// <summary> /// Adds a record to the session database table /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="userId">Unique user identifier</param> /// <param name="userCode">Unique numeric user identifier</param> /// <param name="userEnv">MetaData about the user's environment</param> /// <returns>A unique session code</returns> static Int64 AddSession(DataAccessMgr daMgr, string userId, Int32 userCode, UserEnvironmentStructure userEnv) { Int64 sessionCode = daMgr.GetNextSequenceNumber(Constants.SessionCode); DbTableDmlMgr dmlInsert = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserSessions); dmlInsert.AddColumn(Constants.SessionCode, daMgr.BuildParamName(Constants.SessionCode)); dmlInsert.AddColumn(Constants.UserCode, daMgr.BuildParamName(Constants.UserCode)); dmlInsert.AddColumn(Constants.UserId, daMgr.BuildParamName(Constants.UserId)); dmlInsert.AddColumn(Constants.AppCode, daMgr.BuildParamName(Constants.AppCode)); dmlInsert.AddColumn(Constants.AppId, daMgr.BuildParamName(Constants.AppId)); dmlInsert.AddColumn(Constants.AppMachine, daMgr.BuildParamName(Constants.AppMachine)); dmlInsert.AddColumn(Constants.AppVersion, daMgr.BuildParamName(Constants.AppVersion)); dmlInsert.AddColumn(Constants.RemoteAddress, daMgr.BuildParamName(Constants.RemoteAddress)); DbCommand cmdInsert = daMgr.BuildInsertDbCommand(dmlInsert); cmdInsert.Parameters[daMgr.BuildParamName(Constants.SessionCode)].Value = sessionCode; cmdInsert.Parameters[daMgr.BuildParamName(Constants.UserId)].Value = userId; cmdInsert.Parameters[daMgr.BuildParamName(Constants.UserCode)].Value = userCode; cmdInsert.Parameters[daMgr.BuildParamName(Constants.AppId)].Value = userEnv.AppId; cmdInsert.Parameters[daMgr.BuildParamName(Constants.AppCode)].Value = userEnv.AppCode; cmdInsert.Parameters[daMgr.BuildParamName(Constants.AppVersion)].Value = userEnv.AppVersion; cmdInsert.Parameters[daMgr.BuildParamName(Constants.RemoteAddress)].Value = userEnv.RemoteAddress; cmdInsert.Parameters[daMgr.BuildParamName(Constants.AppMachine)].Value = Environment.MachineName; DbTableDmlMgr dmlUpdate = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserMaster); dmlUpdate.AddColumn(Constants.FailedSignonAttempts , daMgr.BuildParamName(Constants.FailedSignonAttempts)); dmlUpdate.AddColumn(Constants.LastSignonDateTime , EnumDateTimeLocale.Default); dmlUpdate.SetWhereCondition((j) => j.Column(Constants.UserId) == j.Parameter(dmlUpdate.MainTable.SchemaName , dmlUpdate.MainTable.TableName , Constants.UserId , daMgr.BuildParamName(Constants.UserId))); DbCommand cmdUpdate = daMgr.BuildUpdateDbCommand(dmlUpdate); cmdUpdate.Parameters[daMgr.BuildParamName(Constants.UserId)].Value = userId; cmdUpdate.Parameters[daMgr.BuildParamName(Constants.FailedSignonAttempts)].Value = 0; DbCommandMgr cmdMgr = new DbCommandMgr(daMgr); cmdMgr.AddDbCommand(cmdInsert); cmdMgr.AddDbCommand(cmdUpdate); cmdMgr.ExecuteNonQuery(); return(sessionCode); }
public ActionResult UserEditForm(int userCode) { B1SampleEntities entities = new B1SampleEntities(); DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); var query = from a in entities.UserMasters where a.UserCode == userCode select new { a.UserCode, a.UserId, a.FirstName }; DbCommand dbCmd = daMgr.BuildSelectDbCommand(query, null); return(PartialView(Constants._Page_UserEdit, daMgr.ExecuteCollection <UserMaster>(dbCmd, null).First())); }
/// <summary> /// Constructor for the TaskProcessingQueue's dialog form /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="taskQueueItem">DataRow containing the task queue record data</param> /// <param name="userCode">The current user's unique code</param> public TaskProcessingQueueAdmin(DataAccessMgr daMgr, DataRow taskQueueItem, Int32?userCode) { InitializeComponent(); dtpStatusDateTime.Format = dtpCompletedDateTime.Format = dtpStartedDateTime.Format = dtpWaitForDateTime.Format = DateTimePickerFormat.Custom; dtpStatusDateTime.CustomFormat = dtpCompletedDateTime.CustomFormat = dtpStartedDateTime.CustomFormat = dtpWaitForDateTime.CustomFormat = "yyyy/MM/dd hh:mm:ss"; _daMgr = daMgr; _taskQueueItem = taskQueueItem; _userCode = userCode; PopulateForm(); }
/// <summary> /// Changes the given user's password to the new password and resets any account restrictions /// depending on given parameter. /// <para>The method assumes the caller has verified the spelling of the new password.</para> /// <para>The method also assumes the caller has verified the existing password if applicable.</para> /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <param name="userId">Unique user identifier</param> /// <param name="newPassword">The new password (unhashed) plain text</param> /// <param name="resetSignonRestrictions">Indicates whether the accounts restrictions will be reset</param> public static void ChangePassword(DataAccessMgr daMgr , string userId , string newPassword , bool resetSignonRestrictions) { string salt = Cryptography.HashOperation.CreateRandomSalt(Cryptography.HashAlgorithmTypeEnum.SHA512HashAlgorithm); string hash = Cryptography.HashOperation.ComputeHash(Cryptography.HashAlgorithmTypeEnum.SHA512HashAlgorithm , newPassword , salt); DbTableDmlMgr dmlUpdate = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserMaster); dmlUpdate.AddColumn(Constants.UserPassword , daMgr.BuildParamName(Constants.UserPassword)); dmlUpdate.AddColumn(Constants.PasswordSalt , daMgr.BuildParamName(Constants.PasswordSalt)); dmlUpdate.AddColumn(Constants.FailedSignonAttempts , daMgr.BuildParamName(Constants.FailedSignonAttempts)); dmlUpdate.AddColumn(Constants.ForcePasswordChange , daMgr.BuildParamName(Constants.ForcePasswordChange)); if (resetSignonRestrictions) { dmlUpdate.AddColumn(Constants.SignonRestricted , daMgr.BuildParamName(Constants.SignonRestricted)); } dmlUpdate.SetWhereCondition((j) => j.Column(Constants.UserId) == j.Parameter(dmlUpdate.MainTable.SchemaName , dmlUpdate.MainTable.TableName , Constants.UserId , daMgr.BuildParamName(Constants.UserId))); DbCommand cmdUpdate = daMgr.BuildUpdateDbCommand(dmlUpdate); cmdUpdate.Parameters[daMgr.BuildParamName(Constants.UserId)].Value = userId; cmdUpdate.Parameters[daMgr.BuildParamName(Constants.UserPassword)].Value = hash; cmdUpdate.Parameters[daMgr.BuildParamName(Constants.PasswordSalt)].Value = salt; if (resetSignonRestrictions) { cmdUpdate.Parameters[daMgr.BuildParamName(Constants.SignonRestricted)].Value = 0; } cmdUpdate.Parameters[daMgr.BuildParamName(Constants.FailedSignonAttempts)].Value = 0; cmdUpdate.Parameters[daMgr.BuildParamName(Constants.ForcePasswordChange)].Value = 0; daMgr.ExecuteNonQuery(cmdUpdate, null, null); }
// ************************************** // URL: /Account/SignOff // ************************************** public ActionResult SignOff() { if (Session[SessionManagement.Constants.UserSessionMgr] != null) { UserSession userSessionMgr = (UserSession)Session[SessionManagement.Constants.UserSessionMgr]; DataAccessMgr daMgr = (DataAccessMgr)Global.GetDataAccessMgr(this.HttpContext); UserSignon.Signoff(daMgr, userSessionMgr.SessionCode); Session.Remove(SessionManagement.Constants.UserSessionMgr); } FormsService.SignOut(); Session.Abandon(); return(RedirectToAction(Constants.Index, Constants.Home)); }
/// <summary> /// Default constructor for the DbCommand Manager class. /// It expects a DataAccessMgr class instance in the constructor. /// </summary> /// <param name="dataAccessManager">string entry in configuration file for connection string</param> public DbCommandMgr(DataAccessMgr dataAccessManager) { _daMgr = dataAccessManager; _database = dataAccessManager.Database; _loggingMgr = dataAccessManager.loggingMgr; _noOpDbCommandText = _daMgr.NoOpDbCommandText; _paramAliases = new Dictionary <string, List <DbParameter> >(StringComparer.CurrentCultureIgnoreCase); _dbCommand = _daMgr.BuildNoOpDbCommand(); if (_daMgr.DatabaseType == DataAccessMgr.EnumDbType.Oracle) { _commandBlockReady = false; } }
static DbCommand BuildCmdDelInActiveUserSessionsList(DataAccessMgr daMgr) { DbTableDmlMgr dmlDeleteMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.UserSessions); string joinTable = dmlDeleteMgr.AddJoin(DataAccess.Constants.SCHEMA_CORE , Constants.SignonControl, DbTableJoinType.Cross, null); string dateAdd = daMgr.FormatDateMathSql(EnumDateDiffInterval.Second , dmlDeleteMgr.AliasedColumn(joinTable, Constants.StatusSeconds), dmlDeleteMgr.Column(Constants.SessionDateTime)); dmlDeleteMgr.SetWhereCondition(j => j.Function(dateAdd) < j.Function(daMgr.GetDbTimeAs(EnumDateTimeLocale.UTC, null))); return(daMgr.BuildDeleteDbCommand(dmlDeleteMgr)); }
//?? public ActionResult AppSessions() public string AppSessions() { B1SampleEntities entities = new B1SampleEntities(); DataAccessMgr daMgr = Global.GetDataAccessMgr(this.HttpContext); var query = from a in entities.AppSessions orderby new { a.AppCode, a.MultipleSessionCode } select new { a.AppCode, a.AppId, a.MultipleSessionCode }; PagingMgr testSequenceMgr = new PagingMgr(daMgr, query, DataAccess.Constants.PageSize, 20); return(testSequenceMgr.ToHtmlString <AppSession>(PagingMgr.PagingDbCmdEnum.First).ToHtmlString()); //DbCommand dbCmd = daMgr.BuildSelectDbCommand(query, null); //return PartialView("_AppSessions", daMgr.ExecuteCollection<AppSession>(dbCmd, null)); }
/// <summary> /// Builds the DbCommand to get a list of task processing queue records /// sorted by taskId. /// </summary> /// <param name="daMgr">DataAccessMgr object</param> /// <returns>DbCommand Object with DbNull Parameter values</returns> static DbCommand BuildCmdGetTPQListByTaskId(DataAccessMgr daMgr) { DbTableDmlMgr dmlSelectMgr = daMgr.DbCatalogGetTableDmlMgr(DataAccess.Constants.SCHEMA_CORE , Constants.TaskProcessingQueue); string joinTable = dmlSelectMgr.AddJoin(DataAccess.Constants.SCHEMA_CORE , Constants.TaskStatusCodes , DbTableJoinType.Inner , j => j.AliasedColumn(Constants.StatusCode) == j.JoinAliasedColumn(Constants.StatusCode) , Constants.StatusName); dmlSelectMgr.AddOrderByColumnAscending(Constants.TaskId); return(daMgr.BuildSelectDbCommand(dmlSelectMgr, null)); }