///////////////////////////////////////////////////////////
//  PartInventoryAdjustmentItem.cs
//  Implementation of Class PartInventoryAdjustmentItem
//  CSLA type: Editable Child 
//  Created on: 15-Nov-2004 8:41:17 AM
//  Object design: Joyce  
//	Coded: John 15-Nov-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>
	/// PartInventoryAdjustmentItem item
	/// </summary>
	[Serializable]
	public class PartInventoryAdjustmentItem : BusinessBase 
	{
		//CustomFields

		#region Attributes
 		
		private bool bReadOnly;

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

		private Guid mPartInventoryAdjustmentID;
		private Guid mPartID;
		
		private PartSerials mSerialNumbers;
		private Guid mPartWarehouseID;

		private decimal mQuantityAdjustment;

		//read only from parent
		//used to set date in partserial objects
		//when they are updated
		internal SmartDate mDateAdjusted;
		
		#endregion

		#region Constructor

		private PartInventoryAdjustmentItem()
		{
			//Child object
			MarkAsChild();

			//Set to read / write initially so that properties
			//can be set
			bReadOnly=false;			
			//New ID
			mID = Guid.NewGuid();	
			mSerialNumbers=PartSerials.NewItems();
			//Default warehouse
			mPartWarehouseID=PartWarehouse.DefaultWarehouseID;

			//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>
		/// Parent
		/// </summary>
		public Guid PartInventoryAdjustmentID 
		{
			get
			{
				return mPartInventoryAdjustmentID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mPartInventoryAdjustmentID!=value)
					{
						mPartInventoryAdjustmentID = value;
						MarkDirty();
					}
				}
			}
		}

		/// <summary>
		/// PartID
		/// </summary>
		public Guid PartID 
		{
			get
			{
				return mPartID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mPartID!=value)
					{
						mPartID = value;
						
						SetSerialNumberCollection(true);
						VerifyQuantity();
						MarkDirty();
					}
				}
			}
		}

		
		
		/// <summary>
		///Ensures that serial number collection
		///has as many elements as absolute value of
		///Quantity adjustment
		///And also ensures that all serial number items have correct part ID
		///and Adjustment item ID set
		///
		///This function tries to preserve existing serial number entries as much
		///as possible unless a Major change is indicated. 
		///this is important because user may have just selected wrong part initially,
		///but *had* correctly entered all serial numbers
		/// </summary>
		/// <param name="MajorChange">If true, then wipe all serial numbers previously entered</param>
		private void SetSerialNumberCollection(bool MajorChange)
		{
			if(MajorChange)
				mSerialNumbers.Clear();

			//Is there a part selected?
			if(mPartID==Guid.Empty) return;

			//Is current part serialized?
			BoolFetcher b = BoolFetcher.GetItem("aPart","aTrackSerialNumber",mPartID);
			if(b.BoolValue)
			{
				//Yes, current part is serialized, so
				//adjust the number of serial numbers collection

				//More serial numbers than adjustment calls for?
				if(mSerialNumbers.Count > System.Math.Abs(mQuantityAdjustment))
				{
					//add more
					decimal dRemove=mSerialNumbers.Count-(decimal)System.Math.Abs(mQuantityAdjustment);
					for(int x=0;x<dRemove;x++)
					{
						//remove the last one in the list
						mSerialNumbers.RemoveAt(mSerialNumbers.Count-1);
						
					}							
				}

				//Less serials than adjustment total?
				if(mSerialNumbers.Count < System.Math.Abs(mQuantityAdjustment))
				{
					//Need to add some serials
					decimal AddAmount=(decimal)System.Math.Abs(mQuantityAdjustment)-mSerialNumbers.Count;
					for(int x=0;x<AddAmount;x++)
					{						
						PartSerial ps=mSerialNumbers.Add(RootObjectTypes.PartInventoryAdjustment);
						
					}													
				}				
			}
			else
			{
				//Not serialized so make sure count is zero
				if(mSerialNumbers.Count>0)
					mSerialNumbers.Clear();
				return;
			}

			//ensure all serial number items have correct
			//part ID and adjustment ID
			foreach(PartSerial ps in mSerialNumbers)
			{
				ps.AdjustmentID=mID;
				ps.PurchaseOrderReceiptItemID=Guid.Empty;
				ps.PartWarehouseID=mPartWarehouseID;
				ps.WorkorderItemPartID=Guid.Empty;
				ps.PartID=mPartID;
				
				
			}

		}


		/// <summary>
		/// Sets broken rule if quantity of adjustment is unacceptible
		/// (negative quantity but no accompanying stock available)
		/// Safe to call from anywhere
		/// </summary>
		/// <returns></returns>
		private void VerifyQuantity()
		{

			//Is there a part selected?
			if(mPartID==Guid.Empty) return;
			
			//Is there a warehouse selected?
			if(mPartWarehouseID==Guid.Empty) return;

            //reset potential broken rule if previously tried to remove a quantity that 
			//isn't present
			if(mQuantityAdjustment>-1)
			{
				//ensure any previously broken rule is removed
				BrokenRules.Assert("QuantityAdjustmentInvalid",
				"PartInventoryAdjustmentItem.Label.Error.NegativeQuantityInvalid",
					"QuantityAdjustment",false);						
				
			}

			//Check if inventory sufficient when REMOVING inventory by adjustment:
			if(mQuantityAdjustment <0)
			{			
				decimal dOnHand=PartByWarehouseInventoryValuesFetcher.GetItem(mPartID,mPartWarehouseID).QuantityOnHand;
							
				//trying to remove more than exist?
				BrokenRules.Assert(
					"QuantityAdjustmentInvalid",
					LocalizedTextTable.GetLocalizedTextDirect("PartInventoryAdjustmentItem.Label.Error.NegativeQuantityInvalid"),
					"QuantityAdjustment",
					dOnHand<Math.Abs(mQuantityAdjustment));	
			}

			//A zero quantity adjustment is always invalid
			//ensure any previously broken rule is removed
			BrokenRules.Assert("ZeroQuantityAdjustmentInvalid",
				"PartInventoryAdjustmentItem.Label.Error.ZeroQuantityInvalid",
				"ZeroQuantityAdjustmentInvalid",mQuantityAdjustment==0);


			
			
			

		}

		/// <summary>
		/// set by collection if this item
		/// is a duplicate of another in the collection
		/// so that broken rule will be set
		/// 
		/// (duplicate meaning same part id and warehouse)
		/// </summary>
		internal bool DuplicatePart
		{
			set
			{
				BrokenRules.Assert("PartDuplicate","PartInventoryAdjustmentItem.Label.Error.PartNotUnique",
					"PartNumber",value);
			}


		}


		/// <summary>
		/// User ID who created this PartInventoryAdjustmentItem record 
		/// </summary>
		public Guid Creator 
		{
			get
			{
				return mCreator;
			}
		}

		/// <summary>
		/// Date this PartInventoryAdjustmentItem was created 
		/// </summary>
		public string Created 
		{
			get
			{
				return mCreated.ToString();
			}
		}

		/// <summary>
		/// User ID who last modified this record 
		/// </summary>
		public Guid Modifier 
		{
			get
			{
				return mModifier;
			}
		}

		/// <summary>
		/// Last date this PartInventoryAdjustmentItem was modified 
		/// </summary>
		public string Modified 
		{
			get
			{
				return mModified.ToString();
			}
		}

		
		
		/// <summary>
		/// Serial numbers collection for adjusted part, 0 to many
        /// NOTE: if this is a negative quantity adjustment (remove from inventory)
        /// and the part is serialized then the serial number should be set to the Guid
        /// value of the existing PartSerial record ID value as a string.
		/// </summary>
		public PartSerials SerialNumbers
		{
			get
			{
				return mSerialNumbers;
			}
		}

		/// <summary>
		/// GUID of Warehouse this adjustment is for
		/// (Defaults to "default" warehouse in any case)
		/// </summary>
		public Guid PartWarehouseID 
		{
			get
			{
				return mPartWarehouseID;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mPartWarehouseID!=value)
					{
						mPartWarehouseID = value;
						SetSerialNumberCollection(true);
						//change of warehouse can affect quantity
						//validity
						VerifyQuantity();
						BrokenRules.Assert("WarehouseRequired","Error.Object.RequiredFieldEmpty,O.PartWarehouse","PartWarehouseID",value==Guid.Empty);

						MarkDirty();
						
					}
				}
			}
		}
		

		/// <summary>
		/// Quantity change
		/// </summary>
		public decimal QuantityAdjustment 
		{
			get
			{
				return mQuantityAdjustment;
			}
			set
			{
				if(bReadOnly)
					ThrowSetError();
				else
				{
					if(mQuantityAdjustment!=value)
					{
						mQuantityAdjustment = value;
						SetSerialNumberCollection(false);
						VerifyQuantity();
						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.PartInventoryAdjustmentItem")
				)
				);
		}
		

		#endregion 

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

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

		#region Static methods
		/// <summary>
		/// Create new PartInventoryAdjustmentItem
		/// Sets RootObjectID, RootObjectType 
		/// </summary>
		internal static PartInventoryAdjustmentItem NewItem(Guid ParentID)
		{
			
			if(AyaBizUtils.Right("Object.PartInventoryAdjustment")>(int)SecurityLevelTypes.ReadOnly)
			{
				PartInventoryAdjustmentItem c= new PartInventoryAdjustmentItem();
				c.mPartInventoryAdjustmentID=ParentID;
				
				return c;
			}
			else
				throw new System.Security.SecurityException(
					string.Format(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
					LocalizedTextTable.GetLocalizedTextDirect("O.PartInventoryAdjustmentItem")));

			
		}

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

			
		}

		

		#endregion 

		#region DAL DATA ACCESS

		#region Update
		/// <summary>
		/// Update
		/// </summary>
		/// <param name="ParentID"></param>
		/// <param name="tr"></param>
		internal void Update( Guid ParentID, IDbTransaction tr)
		{
			//PartInventoryAdjustmentItem is unchangeable once saved, add only:
			if(!IsNew)
				throw new System.ApplicationException
					(
					string.Format
					(
					LocalizedTextTable.GetLocalizedTextDirect("Error.Object.NotChangeable"),
					LocalizedTextTable.GetLocalizedTextDirect("O.PartInventoryAdjustmentItem")
					)
					);

			#region Delete (Is new so allowed here)
			if(IsDeleted)
			{
				//This is a little different than normal because
				//this is always a new object at this point. We check for that at the 
				//top of this update method (see above if you don't believe me! <grin>).
				this.mSerialNumbers.Clear();
				MarkNew();
				return;
			}

			#endregion
		
			//get modification time temporarily, if update succeeds then
			//set to this time
			System.DateTime dtModified = DBUtil.CurrentWorkingDateTime;

			#region Add part inventory adjustment item to database
			
			

			DBCommandWrapper cm = null;
			//It's always an add, there can be no updates for this object once it's been saved
			//so normal rules don't applyh here for updating
			
			cm=DBUtil.GetCommandFromSQL(
				"INSERT INTO aPartInventoryAdjustmentItem ( " +
				"aID, aPartInventoryAdjustmentID, aPartID, aPartWarehouseID, " +
				"aQuantityAdjustment, aCreated,aModified,aCreator,aModifier) values " +
				"(@ID,@PartInventoryAdjustmentID,@PartID,@PartWarehouseID, " +
				"@QuantityAdjustment,@Created,@Modified,@CurrentUserID,@CurrentUserID)"
				);



			//PartInventoryAdjustmentItem fields
			cm.AddInParameter("@PartInventoryAdjustmentID",DbType.Guid, mPartInventoryAdjustmentID);
			cm.AddInParameter("@PartID",DbType.Guid, mPartID);					
			cm.AddInParameter("@QuantityAdjustment",DbType.Decimal,mQuantityAdjustment);
			cm.AddInParameter("@PartWarehouseID",DbType.Guid, mPartWarehouseID);

			//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);	

			
			#endregion	

			#region serial numbers update
		//Update Serial numbers, either removing availability of existing ones if negative adjustment
			//by doing a direct update query
			//or if positive adjustment then setting data in the serial number collection
			//correctly and saving the collection as normal
			foreach(PartSerial ps in mSerialNumbers)
			{
				//Removing?
				if(this.mQuantityAdjustment<0)
				{
					DBCommandWrapper cmSerialUpdate = null;
					//removing, so fire off a query to set available 
					//to false, adjustmentid to this id etc//AAVAILABLE

                    //Changed: 31-Aug-2006 when selecting a pre-existing serial
                    //number for a negative adjustment, the info form is
                    //putting the partserial record ID value in the SerialNumber field
                    //instead of the actual serial number as it is when it's entered manually
                    //for a positive adjustment, no idea why, but it was causing serial
                    //numbers to not be set to available=false
					cmSerialUpdate=DBUtil.GetCommandFromSQL(
						"UPDATE aPartSerial SET " +
						"AADJUSTMENTID=@AdjustmentID, aModified=@Modified, aModifier=@CurrentUserID, " +
						" AAVAILABLE=@False "+
						" WHERE aID = @ID ");

					cmSerialUpdate.AddInParameter("@AdjustmentID",DbType.Guid, this.mID);	
					cmSerialUpdate.AddInParameter("@False",DbType.Boolean, false);
					cmSerialUpdate.AddInParameter("@ID",DbType.Guid, new Guid(ps.SerialNumber));
					
					cmSerialUpdate.AddInParameter("@CurrentUserID",DbType.Guid, CurrentUserID);
					cmSerialUpdate.AddInParameter("@Modified",DbType.DateTime, DBUtil.ToUTC(dtModified));
					DBUtil.DB.ExecuteNonQuery(cmSerialUpdate, tr);

                   
                }
				else
				{
					//Adding
					ps.Available=true;
					ps.sdDateReceived=this.mDateAdjusted;
					ps.PartID=this.mPartID;
					ps.PurchaseOrderReceiptItemID=Guid.Empty;
					ps.PartWarehouseID=this.mPartWarehouseID;
					ps.WorkorderItemPartID=Guid.Empty;
					ps.AdjustmentID=this.mID;
					
				}
			}

			//SerialNumbers is a grandchild collection
			//it must be called to update regardless of whether
			//the receipt item record is dirty or not, otherwise it would never get saved
			//(But only if there is a positive adjustment happening (adding more))
			if(this.mQuantityAdjustment>0)
				mSerialNumbers.Update(tr);

			#endregion		

			#region adjust inventory

            //v8port: Why is this done in code instead of in the query itself avoiding the fetch?
			//Get current quantity on hand for this item
			decimal newQuantity=PartByWarehouseInventoryValuesFetcher.GetItem(mPartID,mPartWarehouseID,tr).QuantityOnHand;


			//adjust...
			newQuantity=newQuantity+mQuantityAdjustment;

			//Update...
			DBCommandWrapper cmUpdateInventory = null;
            cmUpdateInventory = DBUtil.GetCommandFromSQL(
				"UPDATE aPartByWarehouseInventory SET aQuantityOnHand=@NewQuantity, " +
				"aModifier=@CurrentUserID, aModified=@Modified " +
				"WHERE (aPartID = @PartID) AND (aPartWarehouseID " +
				"= @PartWarehouseID)"
				);
			cmUpdateInventory.AddInParameter("@PartID",DbType.Guid,mPartID);
			cmUpdateInventory.AddInParameter("@PartWarehouseID",DbType.Guid,mPartWarehouseID);
			cmUpdateInventory.AddInParameter("@CurrentUserID",DbType.Guid, CurrentUserID);
			cmUpdateInventory.AddInParameter("@Modified",DbType.DateTime, DBUtil.ToUTC(dtModified));
			cmUpdateInventory.AddInParameter("@NewQuantity",DbType.Decimal,newQuantity);
			DBUtil.DB.ExecuteNonQuery(cmUpdateInventory, tr);	

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

		#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 items
			mCreated=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
			mCreator=dr.GetGuid("aCreator");
			mModified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
			mModifier=dr.GetGuid("aModifier");

			//PartInventoryAdjustmentItem specific items
			mID=dr.GetGuid("aID");
			mPartInventoryAdjustmentID=dr.GetGuid("aPartInventoryAdjustmentID");
			mPartID=dr.GetGuid("aPartID");
			
			mQuantityAdjustment=dr.GetDecimal("aQuantityAdjustment");
			mPartWarehouseID=dr.GetGuid("aPartWarehouseID");

			//Populate child serial numbers collection
			//Since SerialNumbers is a grandchild collection
			//will be loaded by the SerialNumbers collection
			//object who will do the database call based on 
			//the ID of this object  and it's root object type
			mSerialNumbers=PartSerials.GetItems(RootObjectTypes.PartInventoryAdjustment,mID);
			
			//Get access rights level
			bReadOnly=AyaBizUtils.Right("Object.PartInventoryAdjustment")<(int)SecurityLevelTypes.ReadWrite;
	
			MarkOld();
		}
		#endregion fetch

		#endregion 		

		
	}//end PartInventoryAdjustmentItem

}//end namespace GZTW.AyaNova.BLL