///////////////////////////////////////////////////////////
//  UserRight.cs
//  Implementation of Class UserRight
//  CSLA type: Editable Child 
//  Created on: 07-Jun-2004 8:41:43 AM
//  Object design: Joyce 
//	Coded: John July 12 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>
	/// Contains one user right and resides in <see cref="UserRights"/> collection.
	/// </summary>
	[Serializable]
	public class UserRight : BusinessBase
    {

#pragma warning disable 1591
        #region Attributes

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

		
		private Guid mSecurityGroupID;
		private string mRight="";
		private SecurityLevelTypes mSecurityLevel;

		#endregion

		#region Constructor	

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

			//Set as child object
			MarkAsChild();


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

			//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 securitygroup this right belongs to
		/// </summary>
		public Guid SecurityGroupID 
		{
			get
			{
				return mSecurityGroupID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mSecurityGroupID!=value)
					{
						mSecurityGroupID = value;
						MarkDirty();
						
					}
				}
			}
		}

		/// <summary>
		/// Get / Set the abbreviated right code for this UserRight.  Setting is validated
		/// to conform to list of potential rights.
		/// </summary>
		public string Right 
		{
			get
			{
				return mRight;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mRight!=value)
					{
						mRight = value;
						MarkDirty();
						
					}
				}
			}
		}

        /// <summary>
        /// <see cref="SecurityLevelTypes"/> level
        /// </summary>
		public SecurityLevelTypes SecurityLevel 
		{
			get
			{
				return mSecurityLevel;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mSecurityLevel!=value)
					{
						mSecurityLevel = 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.UserRight")
				)
				);
		}
		#endregion

		#region System.Object overrides
		public override string ToString()
		{
			return "UserRight" + mID.ToString();
		}

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

		public override int GetHashCode()
		{
			return ("UserRight" + mID).GetHashCode();
		}
		#endregion

		#region Static methods
		/// <summary>
		/// Get new object
		/// </summary>
		/// <returns></returns>
		internal static UserRight NewItem(SecurityGroup obj)
		{
			
			if(AyaBizUtils.Right("Object.SecurityGroup")>(int)SecurityLevelTypes.ReadOnly)
			{
				UserRight child=new UserRight();
				child.mSecurityGroupID=obj.ID;	
				return child;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
					LocalizedTextTable.GetLocalizedTextDirect("O.UserRight")));
		}

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

		
		#endregion

		#region DAL DATA ACCESS

		#region Fetch
		/// <summary>
		/// Fetch
		/// </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");
					
			//UserRight fields
			mRight=dr.GetString("aRight");
			mSecurityGroupID=dr.GetGuid("aSecurityGroupID");
			mSecurityLevel=(SecurityLevelTypes)dr.GetInt16("aSecurityLevel");									
			
			MarkOld();		

			//Get access rights level
			//make sure manager group rights can't be modified
			if(this.mSecurityGroupID==new Guid("{FF0DE42A-0EA0-429B-9643-64355703E8D1}"))
				bReadOnly=true;
			else
                bReadOnly = AyaBizUtils.Right("Object.SecurityGroup") < (int)SecurityLevelTypes.ReadWrite;//case 618 was userright security object
		}
		#endregion fetch

		#region Update

		/// <summary>
		/// Update
		/// </summary>
		/// <param name="obj"></param>
		/// <param name="tr"></param>
		internal void Update(SecurityGroup 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.CheckSafeToUpdate(this.mModified.Date,this.mID,"aUserRight");	
			
			#region Delete
			if(IsDeleted)
			{
				if(!IsNew)
				{
					//Delete object
					DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aUserRight WHERE aID = @ID;");
					cmDelete.AddInParameter("@ID",DbType.Guid,this.mID);
					DBUtil.DB.ExecuteNonQuery(cmDelete, 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 aUserRight (aID, aSecurityGroupID, aRight, " +
					"aSecurityLevel, aCreated,aModified,aCreator,aModifier) VALUES " +
					"(@ID,@SecurityGroupID,@Right,@SecurityLevel,@Created,@Modified,@CurrentUserID, " +
					"@CurrentUserID)"
					);
			else
				cm=DBUtil.GetCommandFromSQL(
					"UPDATE aUserRight SET aID=@ID, aSecurityGroupID=@SecurityGroupID, " +
					"aRight=@Right, aSecurityLevel=@SecurityLevel, " +
					"aModifier=@CurrentUserID, aModified=@Modified " +
					"WHERE aID=@ID"
					);


			//Purchase order item fields
			cm.AddInParameter("@ID",DbType.Guid,this.mID);
			cm.AddInParameter("@SecurityGroupID",DbType.Guid,mSecurityGroupID);
			cm.AddInParameter("@Right",DbType.String,mRight);
			cm.AddInParameter("@SecurityLevel",DbType.Int16,(int)mSecurityLevel);		
			
			//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);
			
			MarkOld();//db is now synched with object
			//Successful update so 
			//change modification time to match
			this.mModified.Date=dtModified;	
			#endregion			


			
			
		}
		#endregion update
		
		
		#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

#pragma warning restore 1591

    }//end UserRight

}//end namespace GZTW.AyaNova.BLL