/// <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));
}
