891 lines
26 KiB
C#
891 lines
26 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)
|
|
{
|
|
SessionPing cmd = new SessionPing();
|
|
cmd.SessionID = sessionID;
|
|
DataPortal.Execute<SessionPing>(cmd);
|
|
}
|
|
#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 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
|
|
}
|