Rich 9e059a37f5 Modified vesp_SessionBegin to delete inactive owner records and inactive session records for current user after 5 minutes of inactivity and for all other users after 15 minutes of inactivity during start of new session.
Added new stored procedure getOwnersByVersionID.
Added method to OwnerInfoList class named GetByVersionID
Utilized OwnerInfoList.GetByVersionID method
2014-05-30 01:13:55 +00:00

942 lines
27 KiB
C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using Csla;
using Csla.Data;
namespace VEPROMS.CSLA.Library
{
#region Enum stuff
public enum CheckOutType : int
{
Procedure = 0, Document = 1, DocVersion = 2
}
#endregion
#region SessionInfoList stuff
public partial class SessionInfoList
{
[Serializable()]
public class CanCheckOutItemCriteria
{
private int _ObjectID;
public int ObjectID
{ get { return _ObjectID; } }
private CheckOutType _ObjectType;
public CheckOutType ObjectType
{ get { return _ObjectType; } }
public CanCheckOutItemCriteria(int objectID, CheckOutType objectType)
{
_ObjectID = objectID;
_ObjectType = objectType;
}
}
private void DataPortal_Fetch(CanCheckOutItemCriteria criteria)
{
this.RaiseListChangedEvents = false;
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] SessionInfoList.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SessionCanCheckOutItem";
cm.Parameters.AddWithValue("@ObjectID", criteria.ObjectID);
cm.Parameters.AddWithValue("@ObjectType", criteria.ObjectType);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
IsReadOnly = false;
while (dr.Read()) this.Add(new SessionInfo(dr));
IsReadOnly = true;
}
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("SessionInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("SessionInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
}
#endregion
#region SessionInfo stuff
public partial class SessionInfo
{
public static SessionInfo BeginSession(string machineName, int processID)
{
try
{
SessionInfo tmp = DataPortal.Fetch<SessionInfo>(new BeginSessionCriteria(Volian.Base.Library.VlnSettings.UserID, machineName, processID));
if (tmp.ErrorMessage == "No Record Found")
{
tmp.Dispose(); // Clean-up SessionInfo
tmp = null;
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on SessionInfo.BeginSession", ex);
}
}
public List<int> PingSession()
{
List<int> myList = new List<int>();
SessionPing.Execute(this.SessionID);
OwnerInfoList oil = OwnerInfoList.GetBySessionID(this.SessionID);
foreach (OwnerInfo oi in oil)
myList.Add(oi.OwnerID);
return myList;
}
public void EndSession()
{
SessionEnd.Execute(this.SessionID);
}
public bool CanCheckOutItem(int objectID, CheckOutType objectType, ref string message)
{
try
{
SessionInfoList sil = DataPortal.Fetch<SessionInfoList>(new SessionInfoList.CanCheckOutItemCriteria(objectID, objectType));
if (sil.Count == 0)
return true;
bool rv = true;
foreach (SessionInfo si in sil)
{
if (si.SessionID != this.SessionID && objectType == CheckOutType.Procedure)
{
message = string.Format("The procedure {0} is already checked out to {1}", ItemInfo.Get(objectID).MyProcedure.DisplayNumber, si.UserID);
rv = rv && false;
}
else if (si.SessionID != this.SessionID && objectType == CheckOutType.Document)
{
message = string.Format("The document {0} is already checked out to {1}", DocumentInfo.Get(objectID).DocumentEntries[0].MyContent.Text, si.UserID);
rv = rv && false;
}
else if (si.SessionID != this.SessionID && objectType == CheckOutType.DocVersion)
{
OwnerInfo oi = OwnerInfo.GetBySessionIDandVersionID(si.SessionID, objectID);
if(oi.OwnerType == 0)
message = message + string.Format("The procedure {0} is already checked out to {1}", ItemInfo.Get(oi.OwnerItemID).MyProcedure.DisplayNumber, si.UserID) + Environment.NewLine;
else if (oi.OwnerType == 1)
message = message + string.Format("The document {0} is already checked out to {1}", DocumentInfo.Get(oi.OwnerItemID).DocumentEntries[0].MyContent.Text, si.UserID) + Environment.NewLine;
else if (oi.OwnerType == 2)
message = message + string.Format("The working draft is already checked out to {0}", si.UserID);
rv = rv && false;
}
}
return rv;
}
catch (Exception ex)
{
throw new DbCslaException("Error on SessionInfo.Get", ex);
}
}
public int CheckOutItem(int itemID, CheckOutType itemType)
{
int ownerID = SessionCheckOutItem.Execute(this.SessionID, itemID, itemType);
return ownerID;
}
public void CheckInItem(int ownerID)
{
SessionCheckInItem.Execute(ownerID);
}
private void DataPortal_Fetch(BeginSessionCriteria criteria)
{
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] SessionInfo.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
ApplicationContext.LocalContext["cn"] = cn;
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SessionBegin";
cm.Parameters.AddWithValue("@UserID", criteria.UserID);
cm.Parameters.AddWithValue("@MachineName", criteria.MachineName);
cm.Parameters.AddWithValue("@ProcessID", criteria.ProcessID);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (!dr.Read())
{
_ErrorMessage = "No Record Found";
return;
}
ReadData(dr);
}
}
// removing of item only needed for local data portal
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
ApplicationContext.LocalContext.Remove("cn");
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("SessionInfo.DataPortal_Fetch", ex);
_ErrorMessage = ex.Message;
throw new DbCslaException("SessionInfo.DataPortal_Fetch", ex);
}
}
//private void DataPortal_Fetch(CanCheckOutItemCriteria criteria)
//{
// if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] SessionInfo.DataPortal_Fetch", GetHashCode());
// try
// {
// using (SqlConnection cn = Database.VEPROMS_SqlConnection)
// {
// ApplicationContext.LocalContext["cn"] = cn;
// using (SqlCommand cm = cn.CreateCommand())
// {
// cm.CommandType = CommandType.StoredProcedure;
// cm.CommandText = "vesp_SessionCanCheckOutItem";
// cm.Parameters.AddWithValue("@ObjectID", criteria.ObjectID);
// cm.Parameters.AddWithValue("@ObjectType", criteria.ObjectType);
// using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
// {
// while(dr.Read())
// if (!dr.Read())
// {
// _ErrorMessage = "No Record Found";
// return;
// }
// ReadData(dr);
// }
// }
// // removing of item only needed for local data portal
// if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
// ApplicationContext.LocalContext.Remove("cn");
// }
// }
// catch (Exception ex)
// {
// if (_MyLog.IsErrorEnabled) _MyLog.Error("SessionInfo.DataPortal_Fetch", ex);
// _ErrorMessage = ex.Message;
// throw new DbCslaException("SessionInfo.DataPortal_Fetch", ex);
// }
//}
[Serializable()]
protected class BeginSessionCriteria
{
private string _UserID;
public string UserID
{ get { return _UserID; } }
private string _MachineName;
public string MachineName
{ get { return _MachineName; } }
private int _ProcessID;
public int ProcessID
{ get { return _ProcessID; } }
public BeginSessionCriteria(string userID, string machineName, int processID)
{
_UserID = userID;
_MachineName = machineName;
_ProcessID = processID;
}
}
//[Serializable()]
//protected class CanCheckOutItemCriteria
//{
// private int _ObjectID;
// public int ObjectID
// { get { return _ObjectID; } }
// private CheckOutType _ObjectType;
// public CheckOutType ObjectType
// { get { return _ObjectType; } }
// public CanCheckOutItemCriteria(int objectID, CheckOutType objectType)
// {
// _ObjectID = objectID;
// _ObjectType = objectType;
// }
//}
}
public class ResetSecurity : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#region Factory Methods
public static void Execute()
{
ResetSecurity cmd = new ResetSecurity();
DataPortal.Execute<ResetSecurity>(cmd);
}
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_ResetSecurity", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = 0;
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("Reset Security Error", ex);
throw new ApplicationException("Failure on Reset Security", ex);
}
}
#endregion
}
public class SessionPing : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private int _SessionID;
public int SessionID
{
get { return _SessionID; }
set { _SessionID = value; }
}
#region Factory Methods
public static void Execute(int sessionID)
{
try
{
SessionPing cmd = new SessionPing();
cmd.SessionID = sessionID;
DataPortal.Execute<SessionPing>(cmd);
}
catch (Exception ex)
{
_MyLog.Warn("Session Ping Failure", ex);
}
}
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_SessionPing", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = 0;
cmd.Parameters.AddWithValue("@SessionID", SessionID);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("Session Ping Error", ex);
throw new ApplicationException("Failure on Session Ping", ex);
}
}
#endregion
}
public class SessionEnd : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private int _SessionID;
public int SessionID
{
get { return _SessionID; }
set { _SessionID = value; }
}
#region Factory Methods
public static void Execute(int sessionID)
{
SessionEnd cmd = new SessionEnd();
cmd.SessionID = sessionID;
DataPortal.Execute<SessionEnd>(cmd);
}
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_SessionEnd", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = 0;
cmd.Parameters.AddWithValue("@SessionID", SessionID);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("Session End Error", ex);
throw new ApplicationException("Failure on Session End", ex);
}
}
#endregion
}
public class SessionCheckOutItem : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private int _SessionID;
public int SessionID
{
get { return _SessionID; }
set { _SessionID = value; }
}
private int _ItemID;
public int ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int _ItemType;
public int ItemType
{
get { return _ItemType; }
set { _ItemType = value; }
}
private int _OwnerID;
public int OwnerID
{
get { return _OwnerID; }
set { _OwnerID = value; }
}
#region Factory Methods
public static int Execute(int sessionID, int itemID, CheckOutType itemType)
{
SessionCheckOutItem cmd = new SessionCheckOutItem();
cmd.SessionID = sessionID;
cmd.ItemID = itemID;
cmd.ItemType = (int)itemType;
cmd = DataPortal.Execute<SessionCheckOutItem>(cmd);
return cmd.OwnerID;
}
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_SessionCheckOutItem", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = 0;
cmd.Parameters.AddWithValue("@SessionID", SessionID);
cmd.Parameters.AddWithValue("@ItemID", ItemID);
cmd.Parameters.AddWithValue("@ItemType", ItemType);
SqlParameter parm = cmd.Parameters.AddWithValue("@OwnerID", 0);
parm.Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
OwnerID = (int)cmd.Parameters["@OwnerID"].Value;
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("Session End Error", ex);
throw new ApplicationException("Failure on Session End", ex);
}
}
#endregion
}
public class SessionCheckInItem : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private int _OwnerID;
public int OwnerID
{
get { return _OwnerID; }
set { _OwnerID = value; }
}
private int _ItemID;
#region Factory Methods
public static void Execute(int ownerID)
{
SessionCheckInItem cmd = new SessionCheckInItem();
cmd.OwnerID = ownerID;
DataPortal.Execute<SessionCheckInItem>(cmd);
}
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_SessionCheckInItem", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = 0;
cmd.Parameters.AddWithValue("@OwnerID", OwnerID);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("Session End Error", ex);
throw new ApplicationException("Failure on Session End", ex);
}
}
#endregion
}
#endregion
#region OwnerInfo stuff
public partial class OwnerInfoList
{
public static OwnerInfoList GetBySessionID(int sessionID)
{
OwnerInfoList tmp = DataPortal.Fetch<OwnerInfoList>(new GetBySessionIDCriteria(sessionID));
return tmp;
}
[Serializable()]
protected class GetBySessionIDCriteria
{
private int _SessionID;
public int SessionID { get { return _SessionID; } }
public GetBySessionIDCriteria(int sessionID)
{
_SessionID = sessionID;
}
}
private void DataPortal_Fetch(GetBySessionIDCriteria criteria)
{
this.RaiseListChangedEvents = false;
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] OwnerInfoList.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getOwnersBySessionID";
cm.Parameters.AddWithValue("@SessionID", criteria.SessionID);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
IsReadOnly = false;
while (dr.Read()) this.Add(new OwnerInfo(dr));
IsReadOnly = true;
}
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("OwnerInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("OwberInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
public static OwnerInfoList GetByVersionID(int versionID)
{
OwnerInfoList tmp = DataPortal.Fetch<OwnerInfoList>(new GetByVersionIDCriteria(versionID));
return tmp;
}
[Serializable()]
protected class GetByVersionIDCriteria
{
private int _VersionID;
public int VersionID { get { return _VersionID; } }
public GetByVersionIDCriteria(int versionID)
{
_VersionID = versionID;
}
}
private void DataPortal_Fetch(GetByVersionIDCriteria criteria)
{
this.RaiseListChangedEvents = false;
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] OwnerInfoList.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getOwnersByVersionID";
cm.Parameters.AddWithValue("@VersionID", criteria.VersionID);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
IsReadOnly = false;
while (dr.Read()) this.Add(new OwnerInfo(dr));
IsReadOnly = true;
}
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("OwnerInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("OwberInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
}
public partial class OwnerInfo
{
public static OwnerInfo GetBySessionIDandVersionID(int sessionID, int versionID)
{
try
{
OwnerInfo tmp = DataPortal.Fetch<OwnerInfo>(new GetBySessionIDandVersionIDCriteria(sessionID, versionID));
if (tmp.ErrorMessage == "No Record Found")
{
tmp.Dispose(); // Clean-up SessionInfo
tmp = null;
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on OwnerInfo.GetBySessionIDandVersionID", ex);
}
}
[Serializable()]
protected class GetBySessionIDandVersionIDCriteria
{
private int _SessionID;
public int SessionID
{ get { return _SessionID; } }
private int _VersionID;
public int VersionID
{ get { return _VersionID; } }
public GetBySessionIDandVersionIDCriteria(int sessionID, int versionID)
{
_SessionID = sessionID;
_VersionID = versionID;
}
}
private void DataPortal_Fetch(GetBySessionIDandVersionIDCriteria criteria)
{
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] OwnerInfo.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
ApplicationContext.LocalContext["cn"] = cn;
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getOwnerBySessionIDandVersionID";
cm.Parameters.AddWithValue("@SessionID", criteria.SessionID);
cm.Parameters.AddWithValue("@VersionID", criteria.VersionID);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (!dr.Read())
{
_ErrorMessage = "No Record Found";
return;
}
ReadData(dr);
}
}
// removing of item only needed for local data portal
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
ApplicationContext.LocalContext.Remove("cn");
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("OwnerInfo.DataPortal_Fetch", ex);
_ErrorMessage = ex.Message;
throw new DbCslaException("OwnerInfo.DataPortal_Fetch", ex);
}
}
public static OwnerInfo GetByItemID(int itemID, CheckOutType itemType)
{
try
{
OwnerInfo tmp = DataPortal.Fetch<OwnerInfo>(new GetByItemIDCriteria(itemID, itemType));
if (tmp.ErrorMessage == "No Record Found")
{
tmp.Dispose(); // Clean-up SessionInfo
tmp = null;
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on OwnerInfo.GetByItemID", ex);
}
}
[Serializable()]
protected class GetByItemIDCriteria
{
private int _ItemID;
public int ItemID
{ get { return _ItemID; } }
private CheckOutType _ItemType;
public CheckOutType ItemType
{ get { return _ItemType; } }
public GetByItemIDCriteria(int itemID, CheckOutType itemType)
{
_ItemID = itemID;
_ItemType = itemType;
}
}
private void DataPortal_Fetch(GetByItemIDCriteria criteria)
{
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] OwnerInfo.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
ApplicationContext.LocalContext["cn"] = cn;
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getOwnerByItemID";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@ItemType", (int)criteria.ItemType);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (!dr.Read())
{
_ErrorMessage = "No Record Found";
return;
}
ReadData(dr);
}
}
// removing of item only needed for local data portal
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
ApplicationContext.LocalContext.Remove("cn");
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("OwnerInfo.DataPortal_Fetch", ex);
_ErrorMessage = ex.Message;
throw new DbCslaException("OwnerInfo.DataPortal_Fetch", ex);
}
}
public string SessionUserID
{
get
{
SessionInfo si = SessionInfo.Get(this.SessionID);
return si.UserID;
}
}
}
#endregion
#region UserInfo stuff
public partial class UserInfo
{
public bool IsAdministrator()
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (ai.FolderID == 1 && ai.MyRole.Name == "Administrator")
return true;
}
}
}
return false;
}
public bool IsSetAdministrator(FolderInfo fi)
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
Dictionary<int, int> folders = new Dictionary<int, int>();
//FolderInfo fi = FolderInfo.Get(dv.MyFolder.FolderID);
while (fi.FolderID > 1)
{
folders.Add(fi.FolderID, fi.FolderID);
fi = fi.MyParent;
}
folders.Add(1, 1);
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (folders.ContainsKey(ai.FolderID) && ai.MyRole.Name == "Set Administrator")
return true;
}
}
}
return false;
}
public bool IsSetAdministrator(DocVersionInfo dv)
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
Dictionary<int, int> folders = new Dictionary<int, int>();
FolderInfo fi = FolderInfo.Get(dv.MyFolder.FolderID);
while (fi.FolderID > 1)
{
folders.Add(fi.FolderID, fi.FolderID);
fi = fi.MyParent;
}
folders.Add(1, 1);
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (folders.ContainsKey(ai.FolderID) && ai.MyRole.Name == "Set Administrator")
return true;
}
}
}
return false;
}
public bool IsWriter(DocVersionInfo dv)
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
Dictionary<int, int> folders = new Dictionary<int, int>();
FolderInfo fi = FolderInfo.Get(dv.MyFolder.FolderID);
while (fi.FolderID > 1)
{
folders.Add(fi.FolderID, fi.FolderID);
fi = fi.MyParent;
}
folders.Add(1, 1);
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (folders.ContainsKey(ai.FolderID) && ai.MyRole.Name == "Writer")
return true;
}
}
}
return false;
}
public bool IsReviewer(DocVersionInfo dv)
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
Dictionary<int, int> folders = new Dictionary<int, int>();
FolderInfo fi = FolderInfo.Get(dv.MyFolder.FolderID);
while (fi.FolderID > 1)
{
folders.Add(fi.FolderID, fi.FolderID);
fi = fi.MyParent;
}
folders.Add(1, 1);
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (folders.ContainsKey(ai.FolderID) && ai.MyRole.Name == "Reviewer")
return true;
}
}
}
return false;
}
public bool IsROEditor(DocVersionInfo dv)
{
if (this.UserMembershipCount == 0)
return false;
foreach (MembershipInfo mi in this.UserMemberships)
{
if (mi.EndDate == string.Empty)
{
Dictionary<int, int> folders = new Dictionary<int, int>();
FolderInfo fi = FolderInfo.Get(dv.MyFolder.FolderID);
while (fi.FolderID > 1)
{
folders.Add(fi.FolderID, fi.FolderID);
fi = fi.MyParent;
}
folders.Add(1, 1);
foreach (AssignmentInfo ai in mi.MyGroup.GroupAssignments)
{
if (folders.ContainsKey(ai.FolderID) && ai.MyRole.Name == "RO Editor")
return true;
}
}
}
return false;
}
public static UserInfo GetByUserID(string userID)
{
try
{
UserInfo tmp = DataPortal.Fetch<UserInfo>(new GetByUserIDCriteria(userID));
if (tmp.ErrorMessage == "No Record Found")
{
tmp.Dispose(); // Clean-up SessionInfo
tmp = null;
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on UserInfo.GetByUserID", ex);
}
}
[Serializable()]
protected class GetByUserIDCriteria
{
private string _UserID;
public string UserID
{ get { return _UserID; } }
public GetByUserIDCriteria(string userID)
{
_UserID = userID;
}
}
private void DataPortal_Fetch(GetByUserIDCriteria criteria)
{
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] UserInfo.DataPortal_Fetch", GetHashCode());
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
ApplicationContext.LocalContext["cn"] = cn;
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getUserByUserID";
cm.Parameters.AddWithValue("@UserID", criteria.UserID);
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (!dr.Read())
{
_ErrorMessage = "No Record Found";
return;
}
ReadData(dr);
}
}
// removing of item only needed for local data portal
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
ApplicationContext.LocalContext.Remove("cn");
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("UserInfo.DataPortal_Fetch", ex);
_ErrorMessage = ex.Message;
throw new DbCslaException("UserInfo.DataPortal_Fetch", ex);
}
}
}
#endregion
}