1051 lines
26 KiB
C#
1051 lines
26 KiB
C#
///////////////////////////////////////////////////////////
|
|
// NotifySubscription.cs
|
|
// Implementation of Class NotifySubscription
|
|
// CSLA type: Switchable
|
|
// Created on: 04-Oct-2005
|
|
// Object design: John
|
|
// Coded: John 04-Oct-2005
|
|
///////////////////////////////////////////////////////////
|
|
|
|
using System;
|
|
using System.Data;
|
|
using CSLA.Data;
|
|
using GZTW.Data;
|
|
using CSLA;
|
|
using System.Threading;
|
|
using CSLA.Security;
|
|
|
|
namespace GZTW.AyaNova.BLL
|
|
{
|
|
#pragma warning disable 1591
|
|
|
|
/// <summary>
|
|
/// Switchable (child or root), As child it is part of collection under NotifySubscriber
|
|
/// User's selection of events they want to subscribe to being notified about
|
|
/// </summary>
|
|
[Serializable]
|
|
public class NotifySubscription : BusinessBase
|
|
{
|
|
|
|
#region Attributes
|
|
|
|
private bool bReadOnly;
|
|
|
|
private Guid mID;
|
|
private Guid mCreator;
|
|
private Guid mModifier;
|
|
private SmartDate mCreated;
|
|
private SmartDate mModified;
|
|
/// <summary>
|
|
/// Guid ID of root object (UserID from Subscriber parent object)
|
|
/// </summary>
|
|
private Guid mUserID;
|
|
private RootObjectTypes mRootObjectType;
|
|
private int mEventType;
|
|
private int mPendingSpan;
|
|
private AyaUnitsOfTime mPendingSpanUnit;
|
|
|
|
private NotifySubscriptionDeliveries mDeliveries;
|
|
|
|
//used by events that require user specify an int value
|
|
//(Like WorkorderEvent.Status for example)
|
|
private Guid mGuidValue=Guid.Empty;
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
private NotifySubscription()
|
|
{
|
|
|
|
|
|
//Set to read / write initially so that properties
|
|
//can be set
|
|
bReadOnly=false;
|
|
|
|
|
|
|
|
//New ID
|
|
mID = Guid.NewGuid();
|
|
|
|
//Set record history to defaults
|
|
mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
|
|
mModified=new SmartDate();
|
|
mCreator=Guid.Empty;
|
|
mModifier=Guid.Empty;
|
|
//break the event to indicate unsettedness
|
|
EventType=0;
|
|
|
|
mPendingSpanUnit=AyaUnitsOfTime.Days;
|
|
mPendingSpan=10;
|
|
mDeliveries = NotifySubscriptionDeliveries.NewItems();
|
|
|
|
mGuidValue=Guid.Empty;
|
|
}
|
|
#endregion
|
|
|
|
#region Business Properties
|
|
|
|
//---Common properties
|
|
/// <summary>
|
|
/// Initial created date of this object
|
|
/// </summary>
|
|
public string Created
|
|
{
|
|
get
|
|
{
|
|
return mCreated.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initial created date of this object
|
|
/// as SmartDate (used by display list)
|
|
/// </summary>
|
|
public SmartDate CreatedSD
|
|
{
|
|
get
|
|
{
|
|
return mCreated;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// User ID of who initially created this object
|
|
/// </summary>
|
|
public Guid Creator
|
|
{
|
|
get
|
|
{
|
|
return mCreator;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Last modified date of this object
|
|
/// </summary>
|
|
public string Modified
|
|
{
|
|
get
|
|
{
|
|
return mModified.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// User ID of who last modified this object
|
|
/// </summary>
|
|
public Guid Modifier
|
|
{
|
|
get
|
|
{
|
|
return mModifier;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unique ID of this object
|
|
/// </summary>
|
|
public Guid ID
|
|
{
|
|
get
|
|
{
|
|
return mID;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// UserID (parent SubscriberID) of this object
|
|
/// </summary>
|
|
public Guid UserID
|
|
{
|
|
get
|
|
{
|
|
return mUserID;
|
|
}
|
|
}
|
|
|
|
|
|
//--------
|
|
|
|
/// <summary>
|
|
/// Get /set event publisher root object type
|
|
/// Read only once saved
|
|
/// </summary>
|
|
public RootObjectTypes RootObjectType
|
|
{
|
|
get
|
|
{
|
|
return mRootObjectType;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly || !IsNew)//Only pending minutes can be changed on an existing record
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mRootObjectType!=value)
|
|
{
|
|
mRootObjectType = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get /set event publisher's particulare event type subscribed to
|
|
/// Read only once saved
|
|
/// </summary>
|
|
public int EventType
|
|
{
|
|
get
|
|
{
|
|
return mEventType;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly || !IsNew)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mEventType!=value)
|
|
{
|
|
//TODO: Bizrule required here for being invalid
|
|
//if set to zero
|
|
mEventType = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get /set time span units of SpanRange for calculating
|
|
/// event date with pending type events
|
|
///
|
|
/// Can be changed after saving
|
|
/// </summary>
|
|
public int PendingSpan
|
|
{
|
|
get
|
|
{
|
|
return mPendingSpan;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mPendingSpan!=value)
|
|
{
|
|
mPendingSpan = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get /set time span unit of time for calculating
|
|
/// event date with pending type events
|
|
///
|
|
/// Can be changed after saving
|
|
/// </summary>
|
|
public AyaUnitsOfTime PendingSpanUnit
|
|
{
|
|
get
|
|
{
|
|
return mPendingSpanUnit;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mPendingSpanUnit!=value)
|
|
{
|
|
mPendingSpanUnit = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// TAkes the date of an event and returns true
|
|
/// if it's within the range the user set in this subscription
|
|
/// Used by the NotificationList object for dated type
|
|
/// events when generating
|
|
/// notifications to send out to users
|
|
/// </summary>
|
|
/// <param name="EventDate"></param>
|
|
/// <returns></returns>
|
|
public bool EventDateIsWithinDeliverableRange(System.DateTime EventDate)
|
|
{
|
|
//Firstly, if it's a user selectable timeframe advance
|
|
//notice type event then account for the fact that
|
|
//we may not yet have reached the actual event date
|
|
//but we may be deliverable anyway due to user set
|
|
//to warn in advance of the actual event date
|
|
if(IsUserTimeFrameSelectableEvent && mPendingSpan!=0)
|
|
{
|
|
//Use the PendingSpanUnit and PendingSpan value to subtract from the event date
|
|
//then compare with current date to see if it's within range
|
|
switch(PendingSpanUnit)
|
|
{
|
|
case AyaUnitsOfTime.Minutes:
|
|
EventDate=EventDate.AddMinutes(-mPendingSpan);
|
|
break;
|
|
case AyaUnitsOfTime.Hours:
|
|
EventDate=EventDate.AddHours(-mPendingSpan);
|
|
break;
|
|
case AyaUnitsOfTime.Days:
|
|
EventDate=EventDate.AddDays(-mPendingSpan);
|
|
break;
|
|
case AyaUnitsOfTime.Months:
|
|
EventDate=EventDate.AddMonths(-mPendingSpan);
|
|
break;
|
|
case AyaUnitsOfTime.Years:
|
|
EventDate=EventDate.AddYears(-mPendingSpan);
|
|
break;
|
|
|
|
default:
|
|
throw(new ApplicationException("INTERNAL ERROR: [" +PendingSpanUnit.ToString() + "] Is an invalid unit of time in: NotifySubscription.EventDateIsWithinPendingDateRange "));
|
|
//hours, days months years anything else is invalid and should barf
|
|
}
|
|
}
|
|
|
|
if (DBUtil.CurrentWorkingDateTime >= EventDate) return true;//case 1163
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
public NotifySubscriptionDeliveries Deliveries
|
|
{
|
|
get
|
|
{
|
|
return mDeliveries;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the localized text key describing the
|
|
/// currently set notification event
|
|
/// </summary>
|
|
public string EventDescriptionLocalizedTextKey
|
|
{
|
|
get
|
|
{
|
|
if( this.mEventType>0)//zero indicates it isn't valid yet
|
|
return NotifyEventUIHelper.GetEventLocalizedTextKey(this.mRootObjectType,this.EventType);
|
|
else
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the event associated with this subscription
|
|
/// is a type of event that the user can select a time
|
|
/// frame for (most pending type events, but not all)
|
|
///
|
|
///
|
|
/// </summary>
|
|
public bool IsUserTimeFrameSelectableEvent
|
|
{
|
|
get
|
|
{
|
|
//(User selectable time frame events all start at internal value 256 or higher)
|
|
if(mEventType > 255) return true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// If the event associated with this subscription
|
|
/// uses the GuidValue property then returns true.
|
|
///
|
|
///
|
|
/// </summary>
|
|
public bool IsWorkorderStatusEvent
|
|
{
|
|
get
|
|
{
|
|
if(this.mRootObjectType==RootObjectTypes.Workorder && mEventType==(int)WorkorderEvent.Status) return true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Used by some events where an additional Int value
|
|
/// needs to be specified in the subscription
|
|
///
|
|
/// can *not* be changed after saving
|
|
/// </summary>
|
|
public Guid GuidValue
|
|
{
|
|
get
|
|
{
|
|
return this.mGuidValue ;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly || !IsNew)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mGuidValue!=value)
|
|
{
|
|
|
|
mGuidValue = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--------------
|
|
|
|
/// <summary>
|
|
/// Throw an error when a read only user
|
|
/// tries to set a property
|
|
/// (this should normally never be called unless someone is using the developer api since the UI
|
|
/// should prevent it from happening initially)
|
|
/// </summary>
|
|
private void ThrowSetError()
|
|
{
|
|
throw new System.Security.SecurityException
|
|
(
|
|
string.Format
|
|
(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToChange"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")
|
|
)
|
|
);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region System.object overrides
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
return "NotifySubscription" + mID.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <returns></returns>
|
|
public override bool Equals(Object obj)
|
|
{
|
|
if ( obj == null || GetType ( ) != obj.GetType ( ) ) return false;
|
|
NotifySubscription c=(NotifySubscription)obj;
|
|
return mID==c.mID;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return ("NotifySubscription" + mID).GetHashCode();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used by UI code to weed out already selected
|
|
/// delivery methods in delivery method selector forms
|
|
/// </summary>
|
|
/// <param name="DeliverySettingID"></param>
|
|
/// <returns></returns>
|
|
public bool ContainsDelivery(Guid DeliverySettingID)
|
|
{
|
|
return this.mDeliveries.Contains(this.ID,DeliverySettingID);
|
|
}
|
|
#endregion
|
|
|
|
#region Static methods
|
|
#region Editable root versions
|
|
/// <summary>
|
|
/// Create item standalone editable root version
|
|
/// </summary>
|
|
/// <param name="UserID">Subscriber ID</param>
|
|
/// <returns>New Item</returns>
|
|
public static NotifySubscription NewItem(Guid UserID)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Notification")>(int)SecurityLevelTypes.ReadOnly)
|
|
{
|
|
NotifySubscription child=new NotifySubscription();
|
|
child.mUserID=UserID;
|
|
return child;
|
|
}
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")));
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve item - Editable root version
|
|
/// </summary>
|
|
/// <param name="NotifySubscriptionID"></param>
|
|
/// <returns></returns>
|
|
public static NotifySubscription GetItem(Guid NotifySubscriptionID)
|
|
{
|
|
|
|
|
|
if(AyaBizUtils.Right("Object.Notification")>(int)SecurityLevelTypes.NoAccess || AyaBizUtils.IsGenerator)
|
|
{
|
|
return (NotifySubscription)DataPortal.Fetch(new Criteria(NotifySubscriptionID));
|
|
}
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete NotifySubscription Item
|
|
/// </summary>
|
|
/// <param name="NotifySubscriptionID"></param>
|
|
public static void DeleteItem(Guid NotifySubscriptionID)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Notification")>(int)SecurityLevelTypes.ReadWrite)
|
|
DataPortal.Delete(new Criteria(NotifySubscriptionID));
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToDelete"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")));
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Child versions
|
|
/// <summary>
|
|
/// Create item Child version
|
|
/// </summary>
|
|
/// <param name="obj">Parent subscriber object</param>
|
|
/// <returns>New Item</returns>
|
|
internal static NotifySubscription NewItemChild(NotifySubscriber obj)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Notification")>(int)SecurityLevelTypes.ReadOnly)
|
|
{
|
|
NotifySubscription child=new NotifySubscription();
|
|
child.MarkAsChild();
|
|
child.mUserID=obj.UserID;
|
|
return child;
|
|
}
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")));
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve item
|
|
/// </summary>
|
|
/// <param name="dr">Data reader</param>
|
|
/// <returns>item from database</returns>
|
|
internal static NotifySubscription GetItemChild(SafeDataReader dr)
|
|
{
|
|
|
|
|
|
if(AyaBizUtils.Right("Object.Notification")>(int)SecurityLevelTypes.NoAccess)
|
|
{
|
|
NotifySubscription child = new NotifySubscription();
|
|
child.Fetch(dr);
|
|
return child;
|
|
}
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Notification")));
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DAL DATA ACCESS
|
|
|
|
#region Child versions
|
|
|
|
#region Fetch
|
|
/// <summary>
|
|
/// Fetch from db
|
|
/// </summary>
|
|
/// <param name="dr"></param>
|
|
private void Fetch(SafeDataReader dr)
|
|
{
|
|
MarkAsChild();
|
|
//Standard items
|
|
mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
|
|
mCreator=dr.GetGuid("aCreator");
|
|
mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
|
|
mModifier=dr.GetGuid("aModifier");
|
|
|
|
//NotifySubscription specific parameters
|
|
mID=dr.GetGuid("aID");
|
|
mUserID=dr.GetGuid("aUserID");
|
|
mRootObjectType=(RootObjectTypes)dr.GetInt16("aRootObjectType");
|
|
mEventType=dr.GetInt16("aEventType");
|
|
mPendingSpan=dr.GetInt32("aPendingSpan");
|
|
mPendingSpanUnit=(AyaUnitsOfTime)dr.GetInt16("aPendingSpanUnit");
|
|
|
|
this.mGuidValue=dr.GetGuid("aGuidValue");
|
|
|
|
|
|
//Deliveries
|
|
mDeliveries=NotifySubscriptionDeliveries.GetItems(this);
|
|
|
|
//Get access rights level
|
|
bReadOnly=AyaBizUtils.Right("Object.Notification")<(int)SecurityLevelTypes.ReadWrite;
|
|
|
|
MarkOld();
|
|
|
|
}
|
|
#endregion child fetch
|
|
|
|
#region Update child
|
|
|
|
/// <summary>
|
|
/// Persist object to database
|
|
/// </summary>
|
|
/// <param name="obj">Parent object</param>
|
|
/// <param name="tr">Parents transaction object</param>
|
|
internal void Update(NotifySubscriber obj,IDbTransaction tr)
|
|
{
|
|
|
|
//No need to update if there is nothing changed
|
|
if(!this.IsDirty) return;
|
|
|
|
//get modification time temporarily, if update succeeds then
|
|
//set to this time
|
|
System.DateTime dtModified = DBUtil.CurrentWorkingDateTime;
|
|
|
|
// If not a new record, check if record was modified
|
|
//by another user since original retrieval:
|
|
if(!IsNew)
|
|
DBUtil.CheckSafeToUpdate(this.mModified.Date,this.mID,"aNotifySubscription");
|
|
|
|
#region Delete
|
|
if(IsDeleted)
|
|
{
|
|
if(!IsNew)
|
|
{
|
|
//call static shared deleteItem method below
|
|
DeleteItem(this.mID,this.mRootObjectType,this.mEventType,this.mGuidValue,this.mUserID, tr);
|
|
|
|
}
|
|
MarkNew();
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Add / Update
|
|
|
|
|
|
DBCommandWrapper cm = null;
|
|
if(IsNew)//Add or update?
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"INSERT INTO aNotifySubscription (aID, aUserID, aRootObjectType, aEventType, aPendingSpan, aPendingSpanUnit, " +
|
|
"aGuidValue, aCreated, aModified, aCreator,aModifier) " +
|
|
"VALUES (@ID, @UserID,@RootObjectType,@EventType,@PendingSpan, @PendingSpanUnit, " +
|
|
"@GuidValue, @Created, @Modified, @CurrentUserID,@CurrentUserID)"
|
|
);
|
|
else
|
|
//Only pending minutes can be changed on a non new record
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"UPDATE aNotifySubscription SET aID=@ID, aUserID=@UserID, aPendingSpan=@PendingSpan, aPendingSpanUnit=@PendingSpanUnit, " +
|
|
"aGuidValue=@GuidValue, aModifier=@CurrentUserID, " +
|
|
"aModified=@Modified WHERE aID=@ID"
|
|
);
|
|
|
|
//NotifySubscription fields
|
|
cm.AddInParameter("@ID",DbType.Guid,mID);
|
|
cm.AddInParameter("@UserID",DbType.Guid,mUserID);
|
|
cm.AddInParameter("@RootObjectType",DbType.Int16,(int)mRootObjectType);
|
|
cm.AddInParameter("@EventType",DbType.Int16,mEventType);
|
|
cm.AddInParameter("@PendingSpan",DbType.Int32,mPendingSpan);
|
|
cm.AddInParameter("@PendingSpanUnit",DbType.Int16,(int)mPendingSpanUnit);
|
|
cm.AddInParameter("@GuidValue",DbType.Guid,mGuidValue);
|
|
|
|
|
|
//Standard fields
|
|
cm.AddInParameter("@CurrentUserID",DbType.Guid, CurrentUserID);
|
|
cm.AddInParameter("@Created",DbType.DateTime, DBUtil.ToUTC(mCreated.Date));
|
|
cm.AddInParameter("@Modified",DbType.DateTime, DBUtil.ToUTC(dtModified));
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cm, tr);
|
|
|
|
if(IsNew)
|
|
{
|
|
//Increment subscriber count to this event
|
|
NotifyEventOfInterestFetcher.Subscribe(this.RootObjectType,this.EventType,this.mGuidValue, true);
|
|
}
|
|
|
|
//Deliveries
|
|
mDeliveries.Update(tr);
|
|
|
|
MarkOld();//db is now synched with object
|
|
|
|
//Successful update so
|
|
//change modification time to match
|
|
this.mModified.Date=dtModified;
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
#endregion update child version
|
|
|
|
#endregion
|
|
|
|
#region Editable root versions
|
|
|
|
#region Fetch - Editable root style
|
|
///
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Fetch(object Criteria)
|
|
{
|
|
Criteria crit = (Criteria)Criteria;
|
|
SafeDataReader dr = null;
|
|
|
|
try
|
|
{
|
|
|
|
DBCommandWrapper dbCommandWrapper = DBUtil.DB.GetSqlStringCommandWrapper(
|
|
"SELECT * FROM aNotifySubscription WHERE aID=@ID"
|
|
);
|
|
dbCommandWrapper.AddInParameter("@ID",DbType.Guid,crit.ID);
|
|
|
|
dr = new SafeDataReader(DBUtil.DB.ExecuteReader(dbCommandWrapper));
|
|
|
|
if(!dr.Read())
|
|
DBUtil.ThrowFetchError("NotifySubscription: " + crit.ID.ToString());
|
|
|
|
//Standard items
|
|
mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
|
|
mCreator=dr.GetGuid("aCreator");
|
|
mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
|
|
mModifier=dr.GetGuid("aModifier");
|
|
|
|
//NotifySubscription specific parameters
|
|
mID=dr.GetGuid("aID");
|
|
mUserID=dr.GetGuid("aUserID");
|
|
mRootObjectType=(RootObjectTypes)dr.GetInt16("aRootObjectType");
|
|
mEventType=dr.GetInt16("aEventType");
|
|
mPendingSpan=dr.GetInt32("aPendingSpan");
|
|
mPendingSpanUnit=(AyaUnitsOfTime)dr.GetInt16("aPendingSpanUnit");
|
|
this.mGuidValue=dr.GetGuid("aGuidValue");
|
|
|
|
//Deliveries
|
|
mDeliveries=NotifySubscriptionDeliveries.GetItems(this);
|
|
|
|
|
|
}
|
|
finally
|
|
{
|
|
if(dr!=null) dr.Close();
|
|
}
|
|
MarkOld();
|
|
|
|
|
|
//Get access rights level
|
|
bReadOnly=AyaBizUtils.Right("Object.Notification")<(int)SecurityLevelTypes.ReadWrite;
|
|
|
|
}
|
|
#endregion fetch editable root style
|
|
|
|
#region Update - Editable Root Version
|
|
/// <summary>
|
|
/// Called by DataPortal to delete/add/update data into the database
|
|
/// Editable root version
|
|
/// </summary>
|
|
protected override void DataPortal_Update()
|
|
{
|
|
|
|
// If not a new record, check if record was modified
|
|
//by another user since original retrieval:
|
|
if(!IsNew)
|
|
DBUtil.CheckSafeToUpdate(this.mModified.Date,this.mID,"aNotifySubscription");
|
|
|
|
#region Delete
|
|
if(IsDeleted)
|
|
{
|
|
if(!IsNew)
|
|
{
|
|
//Delete object
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
try
|
|
{
|
|
//call static shared deleteItem method below
|
|
DeleteItem(this.mID,this.mRootObjectType,this.mEventType,this.mGuidValue,this.mUserID, transaction);
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
|
|
//-----------------------------
|
|
}
|
|
MarkNew();
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Add / Update
|
|
|
|
//get modification time temporarily, if update succeeds then
|
|
//set to this time
|
|
System.DateTime dtModified = DBUtil.CurrentWorkingDateTime;
|
|
|
|
DBCommandWrapper cm = null;
|
|
if(IsNew)//Add or update?
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"INSERT INTO aNotifySubscription (aID, aUserID, aRootObjectType, aEventType, aPendingSpan, aPendingSpanUnit, " +
|
|
"aGuidValue, aCreated, aModified, aCreator,aModifier) " +
|
|
"VALUES (@ID, @UserID,@RootObjectType,@EventType,@PendingSpan, @PendingSpanUnit, " +
|
|
"@Created, @Modified, @CurrentUserID,@CurrentUserID)"
|
|
);
|
|
else
|
|
//Only pending minutes can be changed on a non new record
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"UPDATE aNotifySubscription SET aID=@ID, aUserID=@UserID, aPendingSpan=@PendingSpan, aPendingSpanUnit=@PendingSpanUnit, " +
|
|
"aGuidValue=@GuidValue, aModifier=@CurrentUserID, " +
|
|
"aModified=@Modified WHERE aID=@ID"
|
|
);
|
|
|
|
//NotifySubscription fields
|
|
cm.AddInParameter("@ID",DbType.Guid,mID);
|
|
cm.AddInParameter("@UserID",DbType.Guid,mUserID);
|
|
cm.AddInParameter("@RootObjectType",DbType.Int16,(int)mRootObjectType);
|
|
cm.AddInParameter("@EventType",DbType.Int16,mEventType);
|
|
cm.AddInParameter("@PendingSpan",DbType.Int32,mPendingSpan);
|
|
cm.AddInParameter("@PendingSpanUnit",DbType.Int16,(int)mPendingSpanUnit);
|
|
cm.AddInParameter("@GuidValue",DbType.Guid,mGuidValue);
|
|
|
|
|
|
//Standard fields
|
|
cm.AddInParameter("@CurrentUserID",DbType.Guid, CurrentUserID);
|
|
cm.AddInParameter("@Created",DbType.DateTime, DBUtil.ToUTC(mCreated.Date));
|
|
cm.AddInParameter("@Modified",DbType.DateTime, DBUtil.ToUTC(dtModified));
|
|
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cm, transaction);
|
|
|
|
if(IsNew)
|
|
{
|
|
//Increment subscriber count to this event
|
|
NotifyEventOfInterestFetcher.Subscribe(this.RootObjectType,this.EventType,this.GuidValue, true);
|
|
}
|
|
|
|
//Deliveries
|
|
mDeliveries.Update(transaction);
|
|
|
|
MarkOld();//db is now synched with object
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
//Successful update so
|
|
//change modification time to match
|
|
this.mModified.Date=dtModified;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
}
|
|
|
|
#endregion Update editable root version
|
|
|
|
#region Delete - editable root version
|
|
|
|
/// <summary>
|
|
/// Remove a record from the database
|
|
/// </summary>
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Delete(object Criteria)
|
|
{
|
|
|
|
Criteria crit = (Criteria)Criteria;
|
|
NotifySubscription ns=NotifySubscription.GetItem(crit.ID);
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
try
|
|
{
|
|
//call static shared deleteItem method below
|
|
DeleteItem(crit.ID,ns.RootObjectType,ns.EventType, ns.GuidValue,ns.UserID, transaction);
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
#endregion Delete editable root style
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DeleteItem
|
|
/// <summary>
|
|
/// This handles deleting a subscription record and updating notifyeventofinterest accordingly
|
|
/// It's called internally here and also by the parent collection
|
|
///
|
|
/// It also removes any events that might be present in the NotifyEvent queue
|
|
/// </summary>
|
|
/// <param name="NotifySubscriptionID"></param>
|
|
/// <param name="RootObjectType"></param>
|
|
/// <param name="EventType"></param>
|
|
/// <param name="GuidValue"></param>
|
|
/// <param name="UserID"></param>
|
|
/// <param name="transaction"></param>
|
|
internal static void DeleteItem(Guid NotifySubscriptionID, RootObjectTypes RootObjectType,
|
|
int EventType, Guid GuidValue, Guid UserID, IDbTransaction transaction)
|
|
{
|
|
|
|
//Delete subscription and update notifyeventofinterest
|
|
|
|
//Delete deliveries
|
|
NotifySubscriptionDeliveries.DeleteItems(NotifySubscriptionID,transaction);
|
|
|
|
//Delete events that may be in queue for this particular subscription and user
|
|
NotifyEvent.RemoveSpecificEventForUser(RootObjectType,EventType,UserID,GuidValue);
|
|
|
|
//Delete subscription
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aNotifySubscription WHERE aID = @ID;");
|
|
cmDelete.AddInParameter("@ID",DbType.Guid,NotifySubscriptionID);
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
|
|
//decrement subscriber count to this event
|
|
NotifyEventOfInterestFetcher.Subscribe(RootObjectType,EventType,GuidValue, false);
|
|
|
|
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Override IsValid / IsDirty
|
|
//Override base class version if there are child objects
|
|
|
|
public override bool IsValid
|
|
{
|
|
get
|
|
{
|
|
return base.IsValid && mDeliveries.IsValid;
|
|
}
|
|
}
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return base.IsDirty || mDeliveries.IsDirty;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region criteria
|
|
/// <summary>
|
|
/// Criteria for identifying existing object
|
|
/// </summary>
|
|
[Serializable]
|
|
private class Criteria
|
|
{
|
|
|
|
public Guid ID;
|
|
|
|
|
|
public Criteria( Guid _ID)
|
|
{
|
|
ID=_ID;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}//end NotifySubscription
|
|
#pragma warning restore 1591
|
|
}//end namespace GZTW.AyaNova.BLL |