///////////////////////////////////////////////////////////
//  AssignedDoc.cs
//  Implementation of Class AssignedDoc
//  CSLA type: Editable Child 
//  Created on: 07-Jun-2004 8:41:13 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>
    /// AssignedDoc class
    /// This is the original method of attaching documents to various objects in AyaNova and is used to link a file location on disk to a business object.
    /// If you want to actually store the document itself in the AyaNova database (making it accessible from WBI and location independant) 
    /// you should use the <see cref="WikiPage"/> object instead to store documents in the database.
    /// 
    /// </summary>
	[Serializable]
	public class AssignedDoc : BusinessBase {

		
		#region Attributes 

		private bool bReadOnly;
		private Guid mID;
		private Guid mRootObjectID;
	
		private RootObjectTypes mRootObjectType;
		private SmartDate mCreated;
		private SmartDate mModified;
		private Guid mCreator;
		private Guid mModifier;		
		
		private string mDescription="";
		
		
		private string mURL=null;
        
        //case 1584
        private RootObjectTypes mExactObjectType;

		#endregion

		#region Constructor	

		/// <summary>
		/// Private constructor to prevent direct instantiation
		/// </summary>
		private AssignedDoc()
		{
			
			MarkAsChild();
			//Set to read / write initially so that properties
			//can be set
			bReadOnly=false;
			mID=Guid.NewGuid();
			//pre-break the rule
			this.URL="";

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

            //case 1584
            mExactObjectType = RootObjectTypes.Nothing;

		}
		
		#endregion

		#region Business properties

		/// <summary>
		/// ID of assigneddoc entry
		/// </summary>
		public Guid ID 
		{
			get
			{
				return mID;
			}
		}

		/// <summary>
		/// RootObject Type
		/// </summary>
		public RootObjectTypes RootObjectType 
		{
			get
			{
				return mRootObjectType;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRootObjectType!=value)
					{
						mRootObjectType = value;
											
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// RootObjectID
		/// </summary>
		public Guid RootObjectID 
		{
			get
			{
				return mRootObjectID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRootObjectID!=value)
					{
						mRootObjectID = value;
						MarkDirty();
                        
					}
				}
			}
		}

        /// <summary>
        /// AssignedDocs associated with any workorder type are saved attributed to rootobject type Workorder.
        /// Since version 7 that has been deprecated but to maintain backward compatibility wikipages are still
        /// associated with Workorder.
        /// 
        /// This properly shows the actual exact workorder type that retrieved this assigneddoc object.
        /// 
        /// It is not stored in the database but used on the fly internally by AyaNova to check exact rights.
        /// </summary>
        public RootObjectTypes ExactRootObjectType //case 1584
        {
            get
            {
                return mExactObjectType;
            }
            set
            {
                mExactObjectType = value;
            }
        }
			
		/// <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>
		/// Set/get Description of item
		/// 
		/// </summary>
		public string Description 
		{
			get
			{
				return mDescription;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mDescription!=value)
					{
						mDescription = value;

						
						BrokenRules.Assert("DescriptionLength",
							"Error.Object.FieldLengthExceeded255,AssignedDoc.Label.Description","Description",value.Length>255);
						
						MarkDirty();
						
					}
				}
			}
		}
		


		/// <summary>
		///URL for document
		///This could be an internet URL, a UNC path and file name or a 
		///drive letter path filename to the file in question
		///
		///Basically this is anything that is understood by the Windows Shell
		///Maximum of 4000 characters 
		/// </summary>
		public string URL 
		{
			get
			{
				return mURL;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mURL!=value)
					{
						mURL = value;

						BrokenRules.Assert("URLRequired",
							"Error.Object.RequiredFieldEmpty,AssignedDoc.Label.URL","URL",value.Length==0);

						BrokenRules.Assert("URLLength",
							"Error.Object.FieldLengthExceeded,AssignedDoc.Label.URL,3500","URL",value.Length>3500);
					
						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.AssignedDoc")
				)
				);
		}
		#endregion

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

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

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public override int GetHashCode()
		{
			return ("AssignedDoc"+ mID.ToString()).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)
		{

			SearchResult sr=new SearchResult();
			System.Text.StringBuilder sb = new System.Text.StringBuilder();

			SafeDataReader dr = null;	
				
			try
			{
				dr=DBUtil.GetReaderFromSQLString(
					"SELECT aCreated, aModified, aCreator, aModifier, aRootObjectID, " +
					"aRootObjectType, aURL, aDescription FROM AASSIGNEDDOC " +
					"WHERE (aID = @ID)",ID);

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

					
													
						
				//Get description for later adding to description string
				sr.Description=dr.GetString("aDescription");
				sb.Append(dr.GetString("aURL"));
				sb.Append(" ");
				sb.Append(sr.Description);
				sr.AncestorRootObjectID=dr.GetGuid("aRootObjectID");
				sr.AncestorRootObjectType=(RootObjectTypes)dr.GetInt16("aRootObjectType");
											

				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();
			}


            //Case 58
            //Is the document's ancestor within their region?
            if (
                !AyaBizUtils.InYourRegion(
                ObjectRegionIDFetcher.ObjectRegion(
                new TypeAndID(
                    sr.AncestorRootObjectType,sr.AncestorRootObjectID
                    )
                    )
                    )
                ) return new SearchResult();//case 58

			//Security check..do they have rights to the ancestor object?
			
			if(AyaBizUtils.Right("Object." + sr.AncestorRootObjectType.ToString())<(int)SecurityLevelTypes.ReadOnly)
				return new SearchResult();

			//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
		/// Parent is responsible for RootObjectID, RootObjectType and DocumentID
		/// </summary>
		/// <returns></returns>
        internal static AssignedDoc NewItem(RootObjectTypes ObjectType, RootObjectTypes ExactObjectType) //case 1584
		{            
			
			if(AyaBizUtils.Right(ExactObjectType)>(int)SecurityLevelTypes.ReadOnly)			
				return new AssignedDoc();
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
					LocalizedTextTable.GetLocalizedTextDirect("O.AssignedDoc")));
		}


        internal static AssignedDoc GetItem(SafeDataReader dr, RootObjectTypes ObjectType, RootObjectTypes ExactObjectType) //case 1584
		{

            if (AyaBizUtils.Right(ExactObjectType) > (int)SecurityLevelTypes.NoAccess)			
			{
				AssignedDoc child = new AssignedDoc();
				child.Fetch(dr,ExactObjectType);
				return child;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
					LocalizedTextTable.GetLocalizedTextDirect("O.AssignedDoc")));
		}

		
		#endregion

		#region DAL Data access
		/// <summary>
		/// Populate this object from the values in the datareader passed to it
		/// </summary>
		/// <param name="dr"></param>
        /// <param name="ExactObjectType"></param>
		private void Fetch(SafeDataReader dr, RootObjectTypes ExactObjectType)
		{				
					
			//Standard fields
			mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
			mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
			mCreator=dr.GetGuid("aCreator");
			mModifier=dr.GetGuid("aModifier");
									
					
			//AssignedDoc fields
			mID=dr.GetGuid("aID");
			mRootObjectID=dr.GetGuid("aRootObjectID");
			mRootObjectType=(RootObjectTypes)dr.GetInt16("aRootObjectType");
            mExactObjectType = ExactObjectType;//case 1584
			mDescription=dr.GetString("aDescription");
			
			URL=dr.GetString("aURL");
			
			//Get access rights level
			bReadOnly=AyaBizUtils.Right(ExactObjectType)<(int)SecurityLevelTypes.ReadWrite;//case 1584
			MarkOld();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="tr"></param>
		internal void Update(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.CheckSafeToUpdateInsideTransaction(this.mModified.Date, this.mID, "AASSIGNEDDOC", tr);//case 1960
	
			#region Delete
			if(IsDeleted)
			{
				if(!IsNew)
				{
					//Delete user and child objects
					DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM AASSIGNEDDOC WHERE aID = @ID;");
					cmDelete.AddInParameter("@ID",DbType.Guid,this.mID);															
					DBUtil.DB.ExecuteNonQuery(cmDelete, tr);							
					DBUtil.RemoveKeywords(tr,RootObjectTypes.AssignedDocument,this.ID);
					
				}
				MarkNew();
				return;
			}

			#endregion

			#region Add / Update			


			DBCommandWrapper cm = null;
			if(IsNew)//Add or update?
				cm=DBUtil.GetCommandFromSQL(
					"INSERT INTO AASSIGNEDDOC (aRootObjectID,aRootObjectType, aID, aURL, aDescription, aCreated,aModified,aCreator,aModifier) " +
					"VALUES (@RootObjectID,@RootObjectType, @ID, @URL,@Description, @Created, @Modified, @CurrentUserID,@CurrentUserID)"
					);
			else
				cm=DBUtil.GetCommandFromSQL(
					"UPDATE AASSIGNEDDOC SET aRootObjectID=@RootObjectID, " +
					"aRootObjectType=@RootObjectType, aID=@ID, aURL=@URL, " +
					"aDescription=@Description,aModified=@Modified, aModifier=@CurrentUserID " +
					"WHERE aID=@ID"
					);


			cm.AddInParameter("@ID",DbType.Guid,mID);
			cm.AddInParameter("@RootObjectID",DbType.Guid, mRootObjectID);
			cm.AddInParameter("@RootObjectType",DbType.Int16, mRootObjectType);
			cm.AddInParameter("@Description",DbType.String, mDescription);
			cm.AddInParameter("@URL",DbType.String, mURL);			
			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.AssignedDocument,IsNew,AyaBizUtils.Break(false,mDescription,mURL));

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

			#endregion

			
			
		}

		
		
		#endregion	

		#region Override IsValid / IsDirty
		//Override base class version if there are child objects 
		/*
			public override bool IsValid
			{
				get
				{
					return base.IsValid && ChildItem.IsValid;
				}
			}
			public override bool IsDirty
			{
				get
				{
					return base.IsDirty || ChildItem.IsDirty;
				}
			}
			*/
		#endregion

		#region criteria
//		/// <summary>
//		/// Criteria for identifying existing object
//		/// </summary>
//		[Serializable]
//			private class Criteria
//		{
//			public Guid RootObjectID;
//			public Guid DocumentID;
//			public RootObjectTypes RootObjectType;
//			public Criteria(Guid _RootObjectID, Guid _DocumentID, RootObjectTypes _RootObjectType )
//			{
//				RootObjectID=_RootObjectID;
//				DocumentID=_DocumentID;
//				RootObjectType=_RootObjectType;
//
//			}
//			
//		}
		#endregion
		
	}//end AssignedDoc

}//end namespace GZTW.AyaNova.BLL