mschill
378653c536
The purpose of this upgrade is to improve the user experience when using the Admin tool to Update ROs. Currently for larger RO dbs (like Barakah) we can run up against memory constraints that do not allow all the ROs to be updated at one time. This is based upon some initial resource where some places were identified where we could improve memory usage. Some of these should benefit PROMS as a whole while others will be specific to the RO Update option in Admin Tools.
1287 lines
39 KiB
Org Mode
1287 lines
39 KiB
Org Mode
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, Folder = 3, Session = 4
|
|
}
|
|
#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
|
|
{
|
|
private Int64 _LastContentChange;
|
|
public Int64 LastContentChange
|
|
{
|
|
get { return _LastContentChange; }
|
|
set { _LastContentChange = value; }
|
|
}
|
|
private byte[] _LastChanged = new byte[8];
|
|
public byte[] LastChanged
|
|
{
|
|
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
|
|
get
|
|
{
|
|
return _LastChanged;
|
|
}
|
|
set { _LastChanged = value; }
|
|
}
|
|
public string LastChangedString
|
|
{
|
|
get { return ContentInfo.FormatByteArray(_LastChanged); }
|
|
}
|
|
public Int64 LastChangedInt64
|
|
{
|
|
get { return Convert.ToInt64(LastChangedString, 16); }
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
private Dictionary<int, Int64> _ChangedContents;
|
|
public Dictionary<int, Int64> ChangedContents
|
|
{
|
|
get { return _ChangedContents; }
|
|
set { _ChangedContents = value; }
|
|
}
|
|
private Dictionary<int, Int64> _ChangedItems;
|
|
public Dictionary<int, Int64> ChangedItems
|
|
{
|
|
get { return _ChangedItems; }
|
|
set { _ChangedItems = value; }
|
|
}
|
|
public List<int> PingSession()
|
|
{
|
|
List<int> myList = new List<int>();
|
|
SessionPing.Execute(this.SessionID);
|
|
ChangedContents = SessionChangedContents.Execute(this.LastContentChange);
|
|
ChangedItems = SessionChangedItems.Execute(this.LastContentChange);
|
|
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;
|
|
if (objectType == CheckOutType.Session)
|
|
{
|
|
if (sil.Count == 1)
|
|
{
|
|
OwnerInfoList oil = OwnerInfoList.GetBySessionID(sil[0].SessionID);
|
|
if (oil.Count == 0)
|
|
return true;
|
|
else
|
|
{
|
|
message = "Export Procedure Set and Import Procedure Set are not available because you have open procedures or documents";
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
message = "Export Procedure Set and Import Procedure Set are not available because there are other sessions open in the database";
|
|
return false;
|
|
}
|
|
}
|
|
bool rv = true;
|
|
foreach (SessionInfo si in sil)
|
|
{
|
|
//if (si.SessionID != this.SessionID && objectType == CheckOutType.Procedure)
|
|
if (si.ProcessID != this.ProcessID && 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)
|
|
else if (si.ProcessID != this.ProcessID && 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)
|
|
//else if (si.ProcessID != this.ProcessID && objectType == CheckOutType.DocVersion)
|
|
{
|
|
// gets here if other session has working draft open & click on sam working draft.
|
|
OwnerInfo oi = OwnerInfo.GetBySessionIDandVersionID(si.SessionID, objectID);
|
|
if (oi == null)
|
|
message = message + string.Format("The working draft is already checked out to {0}", si.UserID) + Environment.NewLine;
|
|
else 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;
|
|
}
|
|
else if (si.SessionID != this.SessionID && objectType == CheckOutType.Folder)
|
|
//else if (si.ProcessID != this.ProcessID && objectType == CheckOutType.Folder)
|
|
{
|
|
// gets here if other session has working draft open & click on folder above. Gets here
|
|
// if other session has wd open and click on top folder - query returns empty.
|
|
OwnerInfo oi = OwnerInfo.GetBySessionIDandFolderID(si.SessionID, objectID);
|
|
if (oi != null)
|
|
{
|
|
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);
|
|
else if (oi.OwnerType == 3)
|
|
message = message + string.Format("The folder 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 TurnChangeManagerOff : CommandBase
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
#region Factory Methods
|
|
public static void Execute()
|
|
{
|
|
TurnChangeManagerOff cmd = new TurnChangeManagerOff();
|
|
DataPortal.Execute<TurnChangeManagerOff>(cmd);
|
|
}
|
|
#endregion
|
|
#region Server-Side code
|
|
protected override void DataPortal_Execute()
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = new SqlCommand("vesp_TurnChangeManagerOFF", cn))
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandTimeout = 0;
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_MyLog.IsErrorEnabled) _MyLog.Error("TurnChangeManagerOff Error", ex);
|
|
throw new ApplicationException("Failure on TurnChangeManagerOff", ex);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
public class TurnChangeManagerOn : CommandBase
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
#region Factory Methods
|
|
public static void Execute()
|
|
{
|
|
TurnChangeManagerOn cmd = new TurnChangeManagerOn();
|
|
DataPortal.Execute<TurnChangeManagerOn>(cmd);
|
|
}
|
|
#endregion
|
|
#region Server-Side code
|
|
protected override void DataPortal_Execute()
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = new SqlCommand("vesp_TurnChangeManagerON", cn))
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandTimeout = 0;
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_MyLog.IsErrorEnabled) _MyLog.Error("TurnChangeManagerOn Error", ex);
|
|
throw new ApplicationException("Failure on TurnChangeManagerOn", ex);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
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
|
|
}
|
|
public class SessionChangedContents : CommandBase
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private Int64 _LastContentChange;
|
|
public Int64 LastContentChange
|
|
{
|
|
get { return _LastContentChange; }
|
|
set { _LastContentChange = value; }
|
|
}
|
|
private Dictionary<int,Int64> _ChangedContents;
|
|
public Dictionary<int, Int64> ChangedContents
|
|
{
|
|
get { return _ChangedContents; }
|
|
set { _ChangedContents = value; }
|
|
}
|
|
#region Factory Methods
|
|
public static Dictionary<int, Int64> Execute(Int64 lastContentChanged)
|
|
{
|
|
SessionChangedContents cmd = new SessionChangedContents();
|
|
cmd.LastContentChange = lastContentChanged;
|
|
cmd = DataPortal.Execute<SessionChangedContents>(cmd);
|
|
return cmd.ChangedContents;
|
|
}
|
|
#endregion
|
|
#region Server-Side Code
|
|
protected override void DataPortal_Execute()
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = new SqlCommand("vesp_ListContentsAfterLastChanged2", cn))
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandTimeout = 0;
|
|
cmd.Parameters.AddWithValue("@LastChanged", LastContentChange);
|
|
cmd.Parameters.AddWithValue("@UserID", Volian.Base.Library.VlnSettings.UserID);
|
|
SqlDataReader dr = cmd.ExecuteReader();
|
|
ChangedContents = new Dictionary<int, Int64>();
|
|
while (dr.Read())
|
|
ChangedContents.Add(dr.GetInt32(0), (Int64)dr.GetSqlInt64(1));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_MyLog.IsErrorEnabled) _MyLog.Error("SessionChangedContents Error", ex);
|
|
throw new ApplicationException("Failure on SessionChangedContents", ex);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
public class SessionChangedItems : CommandBase
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private Int64 _LastContentChange;
|
|
public Int64 LastContentChange
|
|
{
|
|
get { return _LastContentChange; }
|
|
set { _LastContentChange = value; }
|
|
}
|
|
private Dictionary<int, Int64> _ChangedItems;
|
|
public Dictionary<int, Int64> ChangedItems
|
|
{
|
|
get { return _ChangedItems; }
|
|
set { _ChangedItems = value; }
|
|
}
|
|
#region Factory Methods
|
|
public static Dictionary<int, Int64> Execute(Int64 lastContentChanged)
|
|
{
|
|
SessionChangedItems cmd = new SessionChangedItems();
|
|
cmd.LastContentChange = lastContentChanged;
|
|
cmd = DataPortal.Execute<SessionChangedItems>(cmd);
|
|
return cmd.ChangedItems;
|
|
}
|
|
#endregion
|
|
#region Server-Side Code
|
|
protected override void DataPortal_Execute()
|
|
{
|
|
try
|
|
{
|
|
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
|
|
{
|
|
using (SqlCommand cmd = new SqlCommand("vesp_ListItemsAfterLastChanged", cn))
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandTimeout = 0;
|
|
cmd.Parameters.AddWithValue("@LastChanged", LastContentChange);
|
|
cmd.Parameters.AddWithValue("@UserID", Volian.Base.Library.VlnSettings.UserID);
|
|
SqlDataReader dr = cmd.ExecuteReader();
|
|
ChangedItems = new Dictionary<int, Int64>();
|
|
while (dr.Read())
|
|
ChangedItems.Add(dr.GetInt32(0), (Int64)dr.GetSqlInt64(1));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_MyLog.IsErrorEnabled) _MyLog.Error("SessionChangedItems Error", ex);
|
|
throw new ApplicationException("Failure on SessionChangedItems", 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("OwnerInfoList.DataPortal_Fetch", ex);
|
|
}
|
|
this.RaiseListChangedEvents = true;
|
|
}
|
|
public static OwnerInfoList GetByVersionID(int versionID)
|
|
{
|
|
try
|
|
{
|
|
OwnerInfoList tmp = DataPortal.Fetch<OwnerInfoList>(new GetByVersionIDCriteria(versionID));
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (ex.Message.Contains("Could not find stored procedure"))
|
|
System.Windows.Forms.MessageBox.Show("Have your DBA run the latest version of PROMSFixes.SQL", "SQL code is not current", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Exclamation);
|
|
return null;
|
|
}
|
|
}
|
|
[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("OwnerInfoList.DataPortal_Fetch", ex);
|
|
}
|
|
this.RaiseListChangedEvents = true;
|
|
}
|
|
}
|
|
public partial class OwnerInfo
|
|
{
|
|
public static OwnerInfo GetBySessionIDandFolderID(int sessionID, int folderID)
|
|
{
|
|
try
|
|
{
|
|
OwnerInfo tmp = DataPortal.Fetch<OwnerInfo>(new GetBySessionIDandFolderIDCriteria(sessionID, folderID));
|
|
if (tmp.ErrorMessage == "No Record Found")
|
|
{
|
|
tmp.Dispose(); // Clean-up SessionInfo
|
|
tmp = null;
|
|
}
|
|
return tmp;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new DbCslaException("Error on OwnerInfo.GetBySessionIDandFolderID", ex);
|
|
}
|
|
}
|
|
[Serializable()]
|
|
protected class GetBySessionIDandFolderIDCriteria
|
|
{
|
|
private int _SessionID;
|
|
public int SessionID
|
|
{ get { return _SessionID; } }
|
|
private int _FolderID;
|
|
public int FolderID
|
|
{ get { return _FolderID; } }
|
|
public GetBySessionIDandFolderIDCriteria(int sessionID, int folderID)
|
|
{
|
|
_SessionID = sessionID;
|
|
_FolderID = folderID;
|
|
}
|
|
}
|
|
private void DataPortal_Fetch(GetBySessionIDandFolderIDCriteria 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 = "getOwnerBySessionIDandFolderID";
|
|
cm.Parameters.AddWithValue("@SessionID", criteria.SessionID);
|
|
cm.Parameters.AddWithValue("@FolderID", criteria.FolderID);
|
|
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 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 static bool CanEdit(UserInfo myUserInfo, DocVersionInfo myDVI)
|
|
{
|
|
return myUserInfo!=null && myDVI!=null && (myUserInfo.IsAdministrator() || myUserInfo.IsSetAdministrator(myDVI) || myUserInfo.IsWriter(myDVI));
|
|
}
|
|
public static bool CanEditROs(UserInfo myUserInfo, DocVersionInfo myDVI)
|
|
{
|
|
return myUserInfo != null && myDVI != null && myUserInfo.IsAdministrator() || myUserInfo.IsSetAdministrator(myDVI) || myUserInfo.IsROEditor(myDVI);
|
|
}
|
|
public static bool CanCreateFolders(UserInfo myUserInfo, DocVersionInfo myDVI)
|
|
{
|
|
return myUserInfo != null && myDVI != null && myUserInfo.IsAdministrator() || myUserInfo.IsSetAdministrator(myDVI);
|
|
}
|
|
public static bool CanCreateFolders(UserInfo myUserInfo, FolderInfo fi)
|
|
{
|
|
return myUserInfo != null && fi != null && myUserInfo.IsAdministrator() || myUserInfo.IsSetAdministrator(fi);
|
|
}
|
|
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
|
|
}
|