///////////////////////////////////////////////////////////
//  ClientNote.cs
//  Implementation of Class ClientNote
//  CSLA type: Editable Child 
//  Created on: 07-Jun-2004 8:41:15 AM
//  Object design: Joyce  
//	Coded: John July 9 2004
//	Re-coded: as editable child by John Nov 11 2004
///////////////////////////////////////////////////////////

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

namespace GZTW.AyaNova.BLL 
{
    /// <summary>
    /// Note for a <see cref="Client"/> object stored in the Client's <see cref="ClientNotes"/> collection
    /// </summary>
	[Serializable]
	public class ClientNote : BusinessBase {

		#region Attributes 

		private bool bReadOnly;
		private Guid mID;		
		private SmartDate mCreated;
		private SmartDate mModified;
		private Guid mCreator;
		private Guid mModifier;		
		private SmartDate mNoteDate;
		private string mNotes="";
		private Guid mClientNoteTypeID=Guid.Empty;
		private Guid mClientID;
		private Guid mRootObjectID;
		private RootObjectTypes mRootObjectType;

		#endregion

		#region Constructor	

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

			//New ID
			mID = Guid.NewGuid();
            mNoteDate = new SmartDate(DBUtil.CurrentWorkingDateTime);

			//Set record history to defaults
			mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
			mModified = new SmartDate();
			//Case 30
            //mCreator = Guid.Empty;
            mCreator = User.CurrentThreadUserID;

			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>
		/// 
		/// </summary>
		public string Notes 
		{
			get
			{
				return mNotes;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mNotes!=value)
					{
						mNotes = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// User selectable data and time of note
		/// </summary>
		public object NoteDate 
		{
			get
			{
				return mNoteDate.DBValue;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
                    if (!AyaBizUtils.SmartDateEquals(mNoteDate, value)) //Case 298
					{
						mNoteDate.DBValue = value;
						MarkDirty();
						
					}
				}
			}
		}

        /// <summary>
        /// <see cref="Client"/> ID
        /// </summary>
		public Guid ClientID 
		{
			get
			{
				return mClientID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mClientID!=value)
					{
						mClientID = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
        /// DEPRECATED: DO NOT USE 
		/// </summary>
		public RootObjectTypes RootObjectType 
		{
			get
			{
				return mRootObjectType;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRootObjectType!=value)
					{
						mRootObjectType = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
        /// DEPRECATED: DO NOT USE
		/// </summary>
		public Guid RootObjectID //NOTE: 2/19/2015 THIS IS NOT ACTUALLY USED, flagging as deprecated
		{
			get
			{
				return mRootObjectID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRootObjectID!=value)
					{
						mRootObjectID = value;
						MarkDirty();
						
					}
				}
			}
		}
        /// <summary>
        /// <see cref="ClientNoteType"/> ID
        /// </summary>
		public Guid ClientNoteTypeID 
		{
			get
			{
				return mClientNoteTypeID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mClientNoteTypeID!=value)
					{
						mClientNoteTypeID = 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("ClientNote.Label.List")
				)
				);
		}
		#endregion

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

		/// <summary>
		/// 
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public override bool Equals(Object obj)
		{
			if ( obj == null || GetType ( ) != obj.GetType ( ) ) return false;
			ClientNote c=(ClientNote)obj;
			return mID==c.mID;
		}
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public override int GetHashCode()
		{
			return ("ClientNote" + 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)
		{

			
			if(AyaBizUtils.Right("Object.Client")<(int)SecurityLevelTypes.ReadOnly)
				return new SearchResult();

			SearchResult sr=new SearchResult();
			System.Text.StringBuilder sb = new System.Text.StringBuilder();
			
			//=================================================================
				
			SafeDataReader dr = null;	
			try
			{
				dr=DBUtil.GetReaderFromSQLString(
					"SELECT aClientNote.aCreated, aClientNote.aModified, " +
					" aClientNote.aCreator, aClientNote.aModifier, " +
					" aClientNote.aNotes, aClient.aID AS aClientID, aClient.aRegionID, " +
					" aClient.aName FROM aClientNote LEFT JOIN " +
					"aClient ON aClientNote.aClientID = aClient.aID " +
					"WHERE (aClientNote.aID = @ID)",ID);

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

                if (!AyaBizUtils.InYourRegion(dr.GetGuid("aRegionID"))) return new SearchResult();//case 58
						
				sr.Description=dr.GetString("aName");
				sb.Append(dr.GetString("aNotes"));
				sr.AncestorRootObjectID=dr.GetGuid("aClientID");
				sr.AncestorRootObjectType=RootObjectTypes.Client;
							
				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;		
			
			return sr;

		}

		#endregion

		#region Static methods
		/// <summary>
		/// Get new object
		/// </summary>
		/// <returns></returns>
		internal static ClientNote NewItem()
		{
			
			if(AyaBizUtils.Right("Object.Client")>(int)SecurityLevelTypes.ReadOnly)			
				return new ClientNote();
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
					LocalizedTextTable.GetLocalizedTextDirect("ClientNote.Label.List")));
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="dr"></param>
		/// <returns></returns>
		public static ClientNote GetItem(SafeDataReader dr)
		{
			
			if(AyaBizUtils.Right("Object.Client")>(int)SecurityLevelTypes.NoAccess)			
			{
				ClientNote child = new ClientNote();
				child.Fetch(dr);
				return child;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
					LocalizedTextTable.GetLocalizedTextDirect("ClientNote.Label.List")));
		}

		
		#endregion

		#region DAL DATA ACCESS

		#region Fetch
		/// <summary>
		/// Populate this object from the values in the datareader passed to it
		/// </summary>
		/// <param name="dr"></param>
		private void Fetch(SafeDataReader dr)
		{				
			//Standard fields
			mID=dr.GetGuid("aID");
			mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
			mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
			mCreator=dr.GetGuid("aCreator");
			mModifier=dr.GetGuid("aModifier");
					
			//ClientNote fields							
			mClientID=dr.GetGuid("aClientID");
			mClientNoteTypeID=dr.GetGuid("aClientNoteTypeID");
			mNoteDate=DBUtil.ToLocal(dr.GetSmartDate("aNoteDate"));
			mNotes=dr.GetString("aNotes");
			mRootObjectID=dr.GetGuid("aRootObjectID");
			mRootObjectType=(RootObjectTypes)dr.GetInt16("aRootObjectType");			

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

			MarkOld();
		}
		#endregion fetch

		#region Update

		/// <summary>
		/// 
		/// </summary>
		/// <param name="tr"></param>
		internal void Update(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.CheckSafeToUpdate(this.mModified.Date,this.mID,"aClientNote");

			#region Delete
			if(IsDeleted)
			{
				if(!IsNew)
				{
					//Delete object and child objects
					DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aClientNote WHERE aID = @ID;");
					cmDelete.AddInParameter("@ID",DbType.Guid,this.mID);
					DBUtil.DB.ExecuteNonQuery(cmDelete, tr);
					DBUtil.RemoveKeywords(tr,RootObjectTypes.ClientNote,this.mID);
					//-----------------------------
				}
				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 aClientNote (aID, aNoteDate, aNotes, aClientNoteTypeID, " +
					"aClientID, aRootObjectID,aRootObjectType, " +
					"aCreated,aModified,aCreator,aModifier) VALUES (@ID,@NoteDate, " +
					"@Notes,@ClientNoteTypeID,@ClientID,@RootObjectID, " +
					"@RootObjectType,@Created,@Modified,@CurrentUserID,@CurrentUserID)"
					);
			else
				cm=DBUtil.GetCommandFromSQL(
					"UPDATE aClientNote SET aID=@ID, aNoteDate=@NoteDate, " +
					"aNotes=@Notes, aClientNoteTypeID=@ClientNoteTypeID, " +
					"aClientID=@ClientID, aRootObjectID=@RootObjectID, " +
					" aRootObjectType=@RootObjectType, aModifier=@CurrentUserID, " +
					" aModified=@Modified WHERE aID=@ID"
					);


			//ClientNote fields
			cm.AddInParameter("@NoteDate",DbType.DateTime,DBUtil.ToUTC(mNoteDate).DBValue);
			cm.AddLargeStringInParameter("@Notes",mNotes);
			cm.AddInParameter("@ClientNoteTypeID",DbType.Guid,mClientNoteTypeID);
			cm.AddInParameter("@ClientID",DbType.Guid,mClientID);
			cm.AddInParameter("@RootObjectID",DbType.Guid,mRootObjectID);
			cm.AddInParameter("@RootObjectType",DbType.Int16,(int)mRootObjectType);

			//Standard fields
			cm.AddInParameter("@ID",DbType.Guid,this.mID);							
			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.ClientNote,IsNew,AyaBizUtils.Break(false,
				mNotes
				));


			MarkOld();//db is now synched with object
			//Successful update so 
			//change modification time to match
			this.mModified.Date=dtModified;	
			#endregion						
			
			
		}
		#endregion update		
		
		#endregion	

		
		
	}//end ClientNote

}//end namespace GZTW.AyaNova.BLL