///////////////////////////////////////////////////////////
//  WorkorderItemOutsideService.cs
//  Implementation of Class WorkorderItemOutsideService
//  CSLA type: Editable Grand Child 
//  Created on: 07-Jun-2004 8:41:49 AM
//  Object design: Joyce       
//	Coded: John 21-July-2004
///////////////////////////////////////////////////////////

using System;
using System.Data;
using CSLA.Data;
using GZTW.Data;
using CSLA;
using System.Threading;
using CSLA.Security;
using System.ComponentModel;

namespace GZTW.AyaNova.BLL {
    /// <summary>
    /// Contains the record of Units sent out for service by a 3rd party.
    /// </summary>
	[Serializable]
	public class WorkorderItemOutsideService : BusinessBase {

		#region Attributes 

		private bool bReadOnly;
		private Guid mID;		
		private SmartDate mCreated;
		private SmartDate mModified;		
		private Guid mCreator;
		private Guid mModifier;				
		private Guid mWorkorderItemID;	
		

		/// <summary>
		/// General comments
		/// </summary>
		private string mNotes="";
		
		/// <summary>
		/// By default, displays list of vendors marked with enumeration of Manufactuer or
		/// ThirdpartyRepair - but can select to show all vendors to select from
		/// </summary>
		private Guid mVendorSentToID;

		/// <summary>
		/// By default, displays list of vendors marked with enumeration of Shipper - but
		/// can select to show all vendors to select from
		/// </summary>
		private Guid mVendorSentViaID;

		/// <summary>
		/// Referred to as RMA or repair number - usually provided by the repair center
		/// shipped to
		/// </summary>
		private string mRMANumber="";

		/// <summary>
		/// Number used to track the shipping number when sent
		/// </summary>
		private string mTrackingNumber="";

		/// <summary>
		/// Cost of repair
		/// </summary>
		private decimal mRepairCost=0m;

		/// <summary>
		/// Price charged to customer for repair.
		/// </summary>
		private decimal mRepairPrice=0m;

		/// <summary>
		/// Cost to ship
		/// </summary>
		private decimal mShippingCost=0m;

		/// <summary>
		/// Price charged to client for shipping
		/// </summary>
		private decimal mShippingPrice=0m;

		private SmartDate mDateSent;
		private Guid mSenderUserID;

		/// <summary>
		/// Date expected to be returned
		/// </summary>
		private SmartDate mDateETA;

		/// <summary>
		/// Actual date of return Derives from shipping/receiving screen or can be edited
		/// by user here
		/// </summary>
		private SmartDate mDateReturned;

		


		//Used by notification event Processing
		//a change in these fields will flage these
		//true triggering a notify event
		private bool mDateReturnedIsInteresting=false;
		private bool mDateETAIsInteresting=false;
		//used to get list of interested parties
		//to events
		[NotUndoable()]
		private WorkorderItem mWorkorderItem;
		


		#endregion

		#region Constructor

		/// <summary>
		/// Private constructor to prevent direct instantiation
		/// </summary>
		private WorkorderItemOutsideService()
		{
			//Set to read / write initially so that properties
			//can be set
			bReadOnly=false;
			
			//Child object
			MarkAsChild();

			//New ID
			mID = Guid.NewGuid();

			mDateETA=new SmartDate();
			mDateReturned=new SmartDate();
			mDateSent=new SmartDate();

			//Set record history to defaults
			mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
			mModified=new SmartDate();
			mCreator=Guid.Empty;
			mModifier=Guid.Empty;
			
			
			
		}

		#endregion

		#region Business properties	

		/// <summary>
		/// Get internal id number Read only property because it's set internally, not
		/// externally
		/// </summary>
		public Guid ID 
		{
			get
			{
				return mID;
			}
		}

		/// <summary>
		/// Get created date
		///
		/// 
		/// </summary>
		public string Created 
		{
			get
			{
				return mCreated.ToString();
			}
		}

		/// <summary>
		/// Get modified date
		///
		/// 
		/// </summary>
		public string Modified 
		{
			get
			{
				return mModified.ToString();
			}
		}

		/// <summary>
		/// Get user record ID of person who created this record
		///
		/// 
		/// </summary>
		public Guid Creator 
		{
			get
			{
				return mCreator;
			}
		}

		/// <summary>
		/// Get user ID of person who modified this record
		///
		/// 
		/// </summary>
		public Guid Modifier 
		{
			get
			{
				return mModifier;
			}
		}	
		
		

	

		/// <summary>
        /// Guid ID of parent <see cref="WorkorderItem"/> object
		/// </summary>
		public Guid WorkorderItemID 
		{
			get
			{
				return mWorkorderItemID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mWorkorderItemID!=value)
					{
						mWorkorderItemID = value;
						MarkDirty();
						
					}
				}
			}
		}
		/// <summary>
		/// Actual date of return derives from shipping / receiving screen or can be edited
		/// by user here
		/// </summary>
		public object DateReturned 
		{
			get
			{
				return mDateReturned.DBValue;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
                    if (!AyaBizUtils.SmartDateEquals(mDateReturned, value)) //Case 298
					{
						mDateReturnedIsInteresting=true;
						mDateReturned.DBValue = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Shipment tracking number
		/// </summary>
		public string TrackingNumber 
		{
			get
			{
				return mTrackingNumber;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mTrackingNumber!=value)
					{
						mTrackingNumber = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// ID of shipping <see cref="Vendor"/> unit sent by for repair
		/// </summary>
		public Guid VendorSentViaID 
		{
			get
			{
				return mVendorSentViaID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mVendorSentViaID!=value)
					{
						mVendorSentViaID = value;
						MarkDirty();
						
					}
				}
			}
		}
		/// <summary>
		/// Date expected to be returned
		/// </summary>
		public object DateETA 
		{
			get
			{
				return mDateETA.DBValue;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
                    if (!AyaBizUtils.SmartDateEquals(mDateETA, value)) //Case 298
					{
						//Record the user id of the person who set this so they can
						//be notified when it's overdue
						mSenderUserID=User.CurrentThreadUserID;
						mDateETAIsInteresting=true;
						mDateETA.DBValue = value;
						MarkDirty();
						
					}
				}
			}
		}
        /// <summary>
        /// Date unit was sent away for service
        /// </summary>
		public object DateSent 
		{
			get
			{
				return mDateSent.DBValue;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
                   
                    if (!AyaBizUtils.SmartDateEquals(mDateSent,value)) //Case 298
					{
						//Record the user id of the person who set this so they can
						//be notified when it's overdue
						mSenderUserID=User.CurrentThreadUserID;
						mDateSent.DBValue = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Cost of repair
		/// </summary>
		public decimal RepairCost 
		{
			get
			{
				return mRepairCost;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRepairCost!=value)
					{
						mRepairCost = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Price charged to customer for repair.
		/// </summary>
		public decimal RepairPrice 
		{
			get
			{
				return mRepairPrice;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRepairPrice!=value)
					{
						mRepairPrice = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Referred to as RMA or repair number - tracking number provided by the repair center		
		/// </summary>
		public string RMANumber 
		{
			get
			{
				return mRMANumber;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRMANumber!=value)
					{
						//Record the user id of the person who set this so they can
						//be notified when it's overdue
						mSenderUserID=User.CurrentThreadUserID;
						mRMANumber = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Cost to ship
		/// </summary>
		public decimal ShippingCost 
		{
			get
			{
				return mShippingCost;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mShippingCost!=value)
					{
						mShippingCost = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Price charged to client for shipping
		/// </summary>
		public decimal ShippingPrice 
		{
			get
			{
				return mShippingPrice;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mShippingPrice!=value)
					{
						mShippingPrice = value;
						MarkDirty();
						
					}
				}
			}
		}

        /// <summary>
        ///Optional notes about outside service 
        /// </summary>
		public string Notes 
		{
			get
			{
				return mNotes;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mNotes!=value)
					{
						mNotes = value;
						MarkDirty();
						
					}
				}
			}
		}
		

		

		/// <summary>
        /// ID of <see cref="Vendor"/> <see cref="Unit"/> sent to for repair
		/// </summary>
		public Guid VendorSentToID 
		{
			get
			{
				return mVendorSentToID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mVendorSentToID!=value)
					{
						mVendorSentToID = value;
						MarkDirty();
						
					}
				}
			}
		}
		

		/// <summary>
		/// Sets all to read / write status
		/// used by workorder object when it's closed or service completed is true
		/// </summary>
		/// <param name="RO">true=Set to read only explicitly, false=set to whatever rights allowed</param>
		public void SetReadOnly(bool RO)
		{
			
				if(RO==false)
					RO=AyaBizUtils.Right("Object.WorkorderItemOutsideService")<(int)SecurityLevelTypes.ReadWrite;

			bReadOnly=RO;
			
		}


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

		#endregion

		#region System.object overrides
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public override string ToString()
		{
			return "WorkorderItemOutsideService" + mID.ToString();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public override bool Equals(Object obj)
		{
			if ( obj == null || GetType ( ) != obj.GetType ( ) ) return false;
			WorkorderItemOutsideService c=(WorkorderItemOutsideService)obj;
			return mID==c.mID;
		}
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public override int GetHashCode()
		{
			return ("WorkorderItemOutsideService"+mID).GetHashCode();
		}
		#endregion

		#region Searching

		/// <summary>
		/// Returns a search result object based on search terms
		/// for the ID specified
		/// </summary>
		/// <param name="ID"></param>
		/// <param name="searchTerms"></param>
		/// <returns></returns>
		public static SearchResult GetSearchResult(Guid ID, string[]searchTerms)
		{
            //case 1387
            if (Workorder.RightsToWorkorder(WorkorderIDFetcher.GetWorkorderByRelative(RootObjectTypes.WorkorderItemOutsideService, ID)) < SecurityLevelTypes.ReadOnly)
                return new SearchResult();
            

			SearchResult sr=new SearchResult();

           

			System.Text.StringBuilder sb = new System.Text.StringBuilder();
				
				SafeDataReader dr = null;
				try
				{

                    //removed for Case 88
                    //"SELECT aID, aCreator, aModifier, aCreated, aModified, aNotes, " +
                    //    "aRMANumber, aTrackingNumber FROM aWorkorderItemOutsideService " +
                    //    "WHERE (aID = @ID)"

					dr=DBUtil.GetReaderFromSQLString(
                        "SELECT AWORKORDERITEMOUTSIDESERVICE.aID, AWORKORDERITEMOUTSIDESERVICE.aCreator, " +
                    " AWORKORDERITEMOUTSIDESERVICE.aModifier, AWORKORDERITEMOUTSIDESERVICE.aCreated, " +
                    " AWORKORDERITEMOUTSIDESERVICE.aModified, AWORKORDERITEMOUTSIDESERVICE.aNotes, " +
                    "AWORKORDERITEMOUTSIDESERVICE.aRMANumber, AWORKORDERITEMOUTSIDESERVICE.aTrackingNumber, " +
                    "AWORKORDERSERVICE.ASERVICENUMBER, " +
                    " AWORKORDERQUOTE.AQUOTENUMBER, AWORKORDERPREVENTIVEMAINTENANCE.APREVENTIVEMAINTENANCENUMBER, " +
                    " ACLIENT.ANAME AS ACLIENTNAME, aClient.aRegionID AS ACLIENTREGION, AWORKORDER.aWorkorderType " +
                    "FROM AWORKORDERITEMOUTSIDESERVICE INNER JOIN AWORKORDERITEM " +
                    "ON AWORKORDERITEMOUTSIDESERVICE.AWORKORDERITEMID = AWORKORDERITEM.AID " +
                    "LEFT OUTER " +
                    "JOIN AWORKORDER ON AWORKORDERITEM.AWORKORDERID = " +
                    "AWORKORDER.AID LEFT OUTER JOIN ACLIENT ON AWORKORDER.ACLIENTID " +
                    "= ACLIENT.AID LEFT OUTER JOIN AWORKORDERPREVENTIVEMAINTENANCE " +
                    "ON AWORKORDER.AID = " +
                    "AWORKORDERPREVENTIVEMAINTENANCE.AWORKORDERID LEFT OUTER JOIN " +
                    "AWORKORDERQUOTE ON AWORKORDER.AID = AWORKORDERQUOTE.AWORKORDERID " +
                    "LEFT OUTER JOIN AWORKORDERSERVICE " +
                    "ON AWORKORDER.AID = AWORKORDERSERVICE.AWORKORDERID " +
                    "WHERE (AWORKORDERITEMOUTSIDESERVICE.aID = @ID)"
						
						,ID);

					if(!dr.Read())
						return new SearchResult();//DBUtil.ThrowFetchError("SearchResult for WorkorderItemOutsideServiceID: " + ID.ToString());

                    if (!AyaBizUtils.InYourRegion(dr.GetGuid("ACLIENTREGION"))) return new SearchResult();//case 58

                    //Case 88 parse out workorder type and prepare description field accordingly

                    WorkorderTypes workorderType = (WorkorderTypes)dr.GetInt16("aWorkorderType");
                    switch (workorderType)
                    {
                        case WorkorderTypes.Service:
                            sr.Description = LocalizedTextTable.GetLocalizedTextDirect("O.WorkorderService") + " " + dr.GetInt32("aServiceNumber").ToString() + " " + dr.GetString("ACLIENTNAME");
                            break;
                        case WorkorderTypes.Quote:
                            sr.Description = LocalizedTextTable.GetLocalizedTextDirect("O.WorkorderQuote") + " " + dr.GetInt32("AQUOTENUMBER").ToString() + " " + dr.GetString("ACLIENTNAME");
                            break;
                        case WorkorderTypes.PreventiveMaintenance:
                            sr.Description = LocalizedTextTable.GetLocalizedTextDirect("O.WorkorderPreventiveMaintenance") + " " + dr.GetInt32("APREVENTIVEMAINTENANCENUMBER").ToString() + " " + dr.GetString("ACLIENTNAME");
                            break;
                    }
							//sr.Description="";						
							sb.Append(dr.GetString("aNotes"));
							sb.Append(" ");

							sb.Append(dr.GetString("aRMANumber"));
							sb.Append(" ");

							sb.Append(dr.GetString("aTrackingNumber"));
							sb.Append(" ");

							
							sr.Created=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
							sr.Modified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
							sr.Creator=dr.GetGuid("aCreator");
							sr.Modifier=dr.GetGuid("aModifier");
							
						
							

					}
					finally
					{
						if(dr!=null) dr.Close();
					}
			 

				

			//Formulate results
			ExtractAndRank er = new ExtractAndRank();
			er.Process(sb.ToString().Trim(),searchTerms);
			sr.Extract=er.Extract;
			sr.Rank=er.Ranking;
			sr.AncestorRootObjectID=ID;
			sr.AncestorRootObjectType=RootObjectTypes.WorkorderItemOutsideService;
			
			return sr;
//
		}

		#endregion

		#region Static methods
		

		/// <summary>
		/// New item
		/// (Note: requires rights to Workorder object
		/// *not* WorkorderItemOutsideService object)
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		internal static WorkorderItemOutsideService NewItem(WorkorderItem obj)
		{
			
			
			//wierd rights situation here because we *have* to allow a user to make a new 
			//outside service record whatever their rights to it if they are allowed to make a 
			//workorder so this checks the workorder instead of the outside service for
			//creation (we're really only worried about edit rights to the outside service object)

            //case 1387, same situation except now we check against the header object which is effectively the same thing
            if (AyaBizUtils.IsGenerator || (obj.mHeaderRights > SecurityLevelTypes.ReadOnly))			
			{
				WorkorderItemOutsideService child = new WorkorderItemOutsideService();
				child.mWorkorderItemID=obj.ID;
				child.mWorkorderItem=obj;
				return child;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
					LocalizedTextTable.GetLocalizedTextDirect("O.WorkorderItemOutsideService")));
			

			
		}

		/// <summary>
		/// Get item
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		internal static WorkorderItemOutsideService GetItem(WorkorderItem obj)
		{
			//case 1387
            if ((obj.mHeaderRights > SecurityLevelTypes.NoAccess))
			{
			
				WorkorderItemOutsideService child = new WorkorderItemOutsideService();

                //case 1317
                if (AyaBizUtils.Right(RootObjectTypes.WorkorderItemOutsideService) > (int)SecurityLevelTypes.NoAccess)
                    child.Fetch(obj);               

				return child;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
					LocalizedTextTable.GetLocalizedTextDirect("O.WorkorderItemOutsideService")));
		}

		

		#endregion

		#region Shared Notification Message Processor
        internal static NotifyMessage GetNotificationMessage(NotifyMessageRequestData d)
		{
			//string d.Language=User.GetUserLanguage(MessageForUserID);
			WorkorderDescriptionFetcher wdf = WorkorderDescriptionFetcher.GetItemFromWorkorderItemOutsideServiceID(d.RootObjectID);
            string sUnitDescription = UnitNameFetcher.GetUnitNameFromWorkorderItemOutsideServiceID(d.RootObjectID);
			string sEventDescription="";
            switch (d.EventType)
			{
				case (int)WorkorderItemOutsideServiceEvent.UnitBackFromService:
					sEventDescription=LocalizedTextTable.GetLocalizedTextDirect("WorkorderItemOutsideService.Label.Event.UnitBackFromService",d.Language);
					break;
				case (int)WorkorderItemOutsideServiceEvent.UnitNotBackFromServiceByETA:
					sEventDescription=LocalizedTextTable.GetLocalizedTextDirect("WorkorderItemOutsideService.Label.Event.UnitNotBackFromServiceByETA",d.Language);
					break;

			}
				
				
			string sMessage=sEventDescription;
			string sSubject=sEventDescription;
			NotifyMessage nm=null;
            if (d.Format == NotifyDeliveryMessageFormats.Brief)
			{
				sMessage+=" "+ sUnitDescription + " " + LocalizedTextTable.GetLocalizedTextDirect("WorkorderService.Label.ServiceNumber",d.Language)+" " + wdf.WorkorderNumber + " " + wdf.ClientName;
                if (d.MaxCharacters > 0 && sMessage.Length > d.MaxCharacters)
                    nm = new NotifyMessage("", sMessage.Substring(0, d.MaxCharacters));
				else
					nm=new NotifyMessage("", sMessage);

			}
			else
			{		
				sSubject+=": " +LocalizedTextTable.GetLocalizedTextDirect("WorkorderService.Label.ServiceNumber",d.Language) +" "+ wdf.WorkorderNumber;
				sMessage+=": "+ sUnitDescription + "\r\n"  + 
					LocalizedTextTable.GetLocalizedTextDirect("WorkorderService.Label.ServiceNumber",d.Language) +": "+ wdf.WorkorderNumber +"\r\n" + 
					LocalizedTextTable.GetLocalizedTextDirect("O.Client",d.Language) + ": " + wdf.ClientName + "\r\n";


				nm=new NotifyMessage(sSubject,sMessage);
				
			}
			return nm;
		}
		#endregion

		#region DAL DATA ACCESS
		
		#region Fetch
		/// <summary>
		/// Fetch
		/// </summary>
		/// <param name="obj"></param>
		protected void Fetch(WorkorderItem obj)
		{
			//Self loading grandchild specific 
			mWorkorderItemID=obj.ID;
			mWorkorderItem=obj;
			
			//set to false to load items initially
			bReadOnly=false;
			
			
			SafeDataReader dr = null;	
				
			try
			{
				dr=DBUtil.GetReaderFromSQLString("SELECT * FROM aWorkorderItemOutsideService WHERE aWorkorderItemID=@ID;",obj.ID);
				if(dr.Read())
				{
					//	DBUtil.ThrowFetchError("WorkorderItemOutsideService for WorkorderItem ID: " + obj.ID.ToString());

			
					//Standard fields
					mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
					mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
					mCreator=dr.GetGuid("aCreator");
					mModifier=dr.GetGuid("aModifier");
					mID=dr.GetGuid("aID");
						
					
					//WorkorderItemOutsideService fields					
					mNotes=dr.GetString("aNotes");		
					mDateETA=DBUtil.ToLocal(dr.GetSmartDate("aDateETA"));
					mDateReturned=DBUtil.ToLocal(dr.GetSmartDate("aDateReturned"));
					mDateSent=DBUtil.ToLocal(dr.GetSmartDate("aDateSent"));
					mSenderUserID=dr.GetGuid("aSenderUserID");
					
					mRepairCost=dr.GetDecimal("aRepairCost");
					mRepairPrice=dr.GetDecimal("aRepairPrice");
					mRMANumber=dr.GetString("aRMANumber");
					mShippingCost=dr.GetDecimal("aShippingCost");
					mShippingPrice=dr.GetDecimal("aShippingPrice");
					mTrackingNumber=dr.GetString("aTrackingNumber");
					mVendorSentToID=dr.GetGuid("aVendorSentToID");
					mVendorSentViaID=dr.GetGuid("aVendorSentViaID");
				}

			}
			finally
			{
				if(dr!=null) dr.Close();
			}
			MarkOld();

				
				
			
			//Get access rights level
			bReadOnly=AyaBizUtils.Right("Object.WorkorderItemOutsideService")<(int)SecurityLevelTypes.ReadWrite;

			MarkOld();

		}
		#endregion fetch

		#region Add / Update

		/// <summary>
		/// Update Grandchild
		/// </summary>
		/// <param name="obj"></param>
		/// <param name="tr"></param>
		internal void Update(WorkorderItem obj,IDbTransaction tr)
		{
			//No need to update if there is nothing changed
			if(!this.IsDirty) return;

			// If not a new record, check if record was modified 
			//by another user since original retrieval:
			if(!IsNew)
                DBUtil.CheckSafeToUpdateInsideTransaction(this.mModified.Date, this.mID, "aWorkorderItemOutsideService", tr);//case 1960	
			
			#region Delete
			if(IsDeleted)
			{
				if(!IsNew)
				{
					

					DeleteItem(obj.ID,tr);	
					

					//-----------------------------
				}
				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 aWorkorderItemOutsideService (aWorkorderItemID, " +
					"aID, aNotes, aVendorSentToID, aVendorSentViaID, " +
					"aRMANumber,  aTrackingNumber, aRepairCost, aRepairPrice, " +
					"aShippingCost, aShippingPrice,  aDateSent, aSenderUserID, " +
					"aDateETA, aDateReturned, aCreated,aModified,aCreator, " +
					"aModifier) VALUES (@WorkorderItemID,@ID,@Notes, " +
					"@VendorSentToID,@VendorSentViaID,@RMANumber, @TrackingNumber, " +
					"@RepairCost,@RepairPrice,@ShippingCost, " +
					"@ShippingPrice, @DateSent,@SenderUserID, @DateETA,@DateReturned, " +
					"@Created,@Modified,@CurrentUserID,@CurrentUserID)"
					);
				
			else
				cm=DBUtil.GetCommandFromSQL(
					"UPDATE aWorkorderItemOutsideService SET aWorkorderItemID=@WorkorderItemID, " +
					"aID=@ID, aNotes=@Notes, " +
					"aVendorSentToID=@VendorSentToID, aVendorSentViaID=@VendorSentViaID, " +
					"aRMANumber=@RMANumber, aTrackingNumber=@TrackingNumber, " +
					"aRepairCost=@RepairCost, " +
					"aRepairPrice=@RepairPrice, aShippingCost=@ShippingCost, " +
					"aShippingPrice=@ShippingPrice, aDateSent=@DateSent, aSenderUserID=@SenderUserID, " +
					"aDateETA=@DateETA, aDateReturned=@DateReturned, " +
					"aModifier=@CurrentUserID, " +
					"aModified=@Modified WHERE " +
					"aID=@ID"
					);

			//WorkorderItemOutsideService specific
			cm.AddInParameter("@ID",DbType.Guid,mID);
			cm.AddInParameter("@WorkorderItemID",DbType.Guid,mWorkorderItemID);	
			cm.AddLargeStringInParameter("@Notes",mNotes);				
			cm.AddInParameter("@DateETA",DbType.DateTime,DBUtil.ToUTC(mDateETA).DBValue);
			cm.AddInParameter("@DateReturned",DbType.DateTime,DBUtil.ToUTC(mDateReturned).DBValue);
			cm.AddInParameter("@DateSent",DbType.DateTime,DBUtil.ToUTC(mDateSent).DBValue);
			cm.AddInParameter("@SenderUserID",DbType.Guid,mSenderUserID);
			cm.AddInParameter("@RepairCost",DbType.Decimal,mRepairCost);
			cm.AddInParameter("@RepairPrice",DbType.Decimal,mRepairPrice);
			cm.AddInParameter("@RMANumber",DbType.String,mRMANumber);
			cm.AddInParameter("@ShippingCost",DbType.Decimal,mShippingCost);
			cm.AddInParameter("@ShippingPrice",DbType.Decimal,mShippingPrice);
			cm.AddInParameter("@TrackingNumber",DbType.String,mTrackingNumber);
			cm.AddInParameter("@VendorSentToID",DbType.Guid,mVendorSentToID);
			cm.AddInParameter("@VendorSentViaID",DbType.Guid,mVendorSentViaID);
			
			
			//standard parameters				
			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);	

			//Process keywords
			DBUtil.ProcessKeywords(tr,this.mID,RootObjectTypes.WorkorderItemOutsideService,IsNew,AyaBizUtils.Break(false,
				mNotes,mRMANumber,mTrackingNumber
				));

			MarkOld();//db is now synched with object

			//Successful update so 
			//change modification time to match
			this.mModified.Date=dtModified;

			#region Process events
			//Process events as necessary
            if (AyaBizUtils.GlobalSettings.UseNotification)//Case 510
			{
				
				//there are two types of events that might be of interest

				//Has the eta date changed?
				if(this.mDateETAIsInteresting)
				{
					//this is the unit not received back by eta 
					//it's going to the person who set the shipped date/eta date .

					//User removed any date of ETA? (can't notify if late if there's no date)
					if(this.mDateETA.IsEmpty)
						NotifyEvent.RemoveSpecificEventForObject(mID,(int)WorkorderItemOutsideServiceEvent.UnitNotBackFromServiceByETA);
					else
						NotifyEvent.AddOrUpdateEvent(RootObjectTypes.WorkorderItemOutsideService,this.mID,
							(int)WorkorderItemOutsideServiceEvent.UnitNotBackFromServiceByETA,
							this.mSenderUserID,this.mDateETA,Guid.Empty);

				}
					
				//This goes to the woitem creator, sched techs and labor techs on this workorder item 
				if(this.mDateReturnedIsInteresting)
				{
					//User removed date returned? (remove any old date returned events if so)
					if(this.mDateReturned.IsEmpty)
						NotifyEvent.RemoveSpecificEventForObject(mID,(int)WorkorderItemOutsideServiceEvent.UnitBackFromService);
					else
					{
						//User indicated unit is returned
						//remove UnitNotBackFromService event as it's now no longer required
						NotifyEvent.RemoveSpecificEventForObject(mID,(int)WorkorderItemOutsideServiceEvent.UnitNotBackFromServiceByETA);

						//Notify the workorderitem creator
						NotifyEvent.AddOrUpdateEvent(RootObjectTypes.WorkorderItemOutsideService,this.mID,
							(int)WorkorderItemOutsideServiceEvent.UnitBackFromService,
							mWorkorderItem.Creator,new SmartDate(),Guid.Empty);

						//Loop through all potentially interested parties and generate a notification for it
						
						//Sched techs
						foreach(WorkorderItemScheduledUser u in mWorkorderItem.ScheduledUsers)
						{
							NotifyEvent.AddOrUpdateEvent(RootObjectTypes.WorkorderItemOutsideService,this.mID,
							(int)WorkorderItemOutsideServiceEvent.UnitBackFromService,
							u.UserID,new SmartDate(),Guid.Empty);

						}
						//Labor techs
						foreach(WorkorderItemLabor l in mWorkorderItem.Labors)
						{
							NotifyEvent.AddOrUpdateEvent(RootObjectTypes.WorkorderItemOutsideService,this.mID,
								(int)WorkorderItemOutsideServiceEvent.UnitBackFromService,
								l.UserID,new SmartDate(),Guid.Empty);
						}

					}
				}
				

						
				
							
			}
			#endregion


			#endregion			



			


		}
		#endregion add/update

		#region Shared delete method
		/// <summary>
		/// Given a workorder item ID deletes this item for that ID
		/// 
		/// Called by workorderitems delete
		/// </summary>
		/// <param name="WorkorderItemID">ID of parent workorder item</param>
		/// <param name="transaction">Database transaction from ascendant item</param>
		internal static void DeleteItem( Guid WorkorderItemID,IDbTransaction transaction)
		{

			//Get ID of workorderItemOutsideService for passed in WorkorderItemID

			//let's see if the user in question is subscribed to the event in question

            //Added:30-Aug-2006 added transaction parameter to call to getscalar method below
            //was freezing at this point when deleting a second workorder item with MSSQL
			Guid id=DBUtil.ToGuid(DBUtil.GetScalarFromSQLString(
				"SELECT aID FROM aWorkorderItemOutsideService WHERE (aWorkorderItemID = @ID)"
				,WorkorderItemID,transaction));
			if(id==Guid.Empty)
				return;//BAIL OUT, No matching record 
				
			Guid WorkorderItemOutsideServiceID=id;

			DBUtil.RemoveKeywords(transaction,RootObjectTypes.WorkorderItemOutsideService,WorkorderItemOutsideServiceID);


			//Remove any events for this object
			if(AyaBizUtils.GlobalSettings.UseNotification)
			{
				NotifyEvent.RemoveAllEventsForObject(WorkorderItemOutsideServiceID);
			}

			//Now remove this object			
			DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aWorkorderItemOutsideService WHERE aWorkorderItemID=@ID;");
			cmDelete.AddInParameter("@ID",DbType.Guid,WorkorderItemID);													
			DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
	
		}

		#endregion

		#endregion

        #region Override IsValid / IsDirty
        //Override base class version for case 1317
        /// <summary>
        /// 
        /// </summary>
        public override bool IsValid
        {
            get
            {
                return base.IsValid;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        public override bool IsDirty
        {
            get
            {
                //case 1317
                if (AyaBizUtils.Right(RootObjectTypes.WorkorderItemOutsideService) < (int)SecurityLevelTypes.ReadOnly) return false;
                return base.IsDirty;

            }
        }

        #endregion
	}//end WorkorderItemOutsideService

	#region Notification events
#pragma warning disable 1591

    public  enum WorkorderItemOutsideServiceEvent : int 
	{
			
		[Description("LT:WorkorderItemOutsideService.Label.Event.UnitBackFromService")] UnitBackFromService=1,
		[Description("LT:WorkorderItemOutsideService.Label.Event.UnitNotBackFromServiceByETA")] UnitNotBackFromServiceByETA=2

	}
#pragma warning restore 1591
	#endregion

}//end namespace GZTW.AyaNova.BLL