/// <summary>
 /// Creates the appropriate PropertyMapper based on the BusinessObject and propertyName.
 /// </summary>
 /// <param name="businessObject"></param>
 /// <param name="propertyName"></param>
 /// <returns></returns>
 public static IBOPropertyMapper CreateMapper(IBusinessObject businessObject, string propertyName)
 {
     var originalPropertyName = propertyName;
     if (IsReflectiveProp(propertyName))
     {
         IBusinessObject relatedBo = businessObject;
         while (propertyName.Contains(RELATIONSHIP_SEPARATOR))
         {
             //Get the first property name
             string relationshipName = propertyName.Substring(0, propertyName.IndexOf("."));
             propertyName = propertyName.Remove(0, propertyName.IndexOf(".") + 1);
             var newRelatedBo = relatedBo.Relationships.GetRelatedObject(relationshipName);
             if (newRelatedBo == null)
             {
                 var invalidReason = string.Format("The '{0}' relationship of the '{1}' returned null, therefore the '{2}' property could not be accessed.", relationshipName, relatedBo.GetType().Name, propertyName);
                 return new NullBOPropertyMapper(originalPropertyName, invalidReason) { BusinessObject = businessObject };
             }
             relatedBo = newRelatedBo;
         }
         return new ReflectionPropertyMapper(propertyName) { BusinessObject = relatedBo };
     }
     try
     {
         return new BOPropertyMapper(propertyName) { BusinessObject = businessObject };
     }
     catch (InvalidPropertyException)
     {
         //If the BOProp is not found then try a ReflectiveProperty.
         return new ReflectionPropertyMapper(propertyName) { BusinessObject = businessObject };
     }
 }

 /// <summary>
 /// Constructor for <see cref="TransactionalSingleRelationship"/>
 /// </summary>
 /// <param name="relationship"></param>
 /// <param name="relatedBO"></param>
 protected TransactionalSingleRelationship(IRelationship relationship, IBusinessObject relatedBO)
 {
     if (relatedBO == null) throw new ArgumentNullException("relatedBO");
     _transactionID = Guid.NewGuid().ToString();
     _relationship = relationship;
     _relatedBO = relatedBO;
 }

 ///<summary>
 /// Deletes the given business object
 ///</summary>
 ///<param name="businessObject">The business object to delete</param>
 public void DeleteBusinessObject(IBusinessObject businessObject)
 {
     string message;
     if (CustomConfirmationMessageDelegate != null)
     {
         message = CustomConfirmationMessageDelegate(businessObject);
     }
     else
     {
         message = string.Format("Are you certain you want to delete the object '{0}'", businessObject);
     }
     Confirmer.Confirm(message, delegate(bool confirmed)
         {
             if (!confirmed) return;
             var defaultBODeletor = new DefaultBODeletor();
             try
             {
                 defaultBODeletor.DeleteBusinessObject(businessObject);
             }
             catch (Exception ex)
             {
                 GlobalRegistry.UIExceptionNotifier.Notify(ex, "", "Error Deleting");
             }
         });
 }

 /// <summary>
 /// Constructor for a new initialiser
 /// </summary>
 /// <param name="parentObject">The parent for the relationship</param>
 /// <param name="relationship">The relationship object</param>
 /// <param name="correspondingRelationshipName">The corresponding
 /// relationship name</param>
 public RelationshipObjectInitialiser(IBusinessObject parentObject, RelationshipDef relationship,
                                      string correspondingRelationshipName)
 {
     _parentObject = parentObject;
     _relationship = relationship;
     _correspondingRelationshipName = correspondingRelationshipName;
 }

 public void CancelEditsToBusinessObject(IBusinessObject bo)
 {
     bo.CancelEdits();
     if (bo.Status.IsNew)
     {
         bo.MarkForDelete();
     }
 }

 public AutorController(
     IBusinessObject<Autor> bo,
     IMapper<Autor, AutorModel> mapper,
     IMapper<AutorModel, Autor> modelMapper)
 {
     BO = bo;
     Mapper = mapper;
     ModelMapper = modelMapper;
 }

 public GeneroController(
     IBusinessObject<Genero> bo,
     IMapper<Genero, GeneroModel> mapper,
     IMapper<GeneroModel, Genero> modelMapper)
 {
     BO = bo;
     Mapper = mapper;
     ModelMapper = modelMapper;
 }

        /// <summary>
        /// Initialises the given object
        /// </summary>
        /// <param name="objToInitialise">The object to initialise</param>
        public void InitialiseObject(IBusinessObject objToInitialise)
        {
            BusinessObject newBo = (BusinessObject) objToInitialise;
			foreach (RelPropDef propDef in _relationship.RelKeyDef)
			{
                newBo.SetPropertyValue(propDef.OwnerPropertyName,
                                       _parentObject.GetPropertyValue(propDef.RelatedClassPropName));
            }
            newBo.Relationships.SetRelatedObject(_correspondingRelationshipName, _parentObject);
        }

 /// <summary>
 /// Constructs a DTO for a Business Object.
 /// </summary>
 /// <param name="businessObject"></param>
 public BusinessObjectDTO(IBusinessObject businessObject) {
     ClassDefName = businessObject.ClassDef.ClassName;
     ClassName = businessObject.ClassDef.ClassNameExcludingTypeParameter;
     AssemblyName = businessObject.ClassDef.AssemblyName;
     foreach (IBOProp boProp in businessObject.Props)
     {
         Props[boProp.PropertyName.ToUpper()] = boProp.Value;
     }
     ID = businessObject.ID.ToString();
 }

        internal static void TestUpdate(IBusinessObject busObject, object newValue, string columnName)
        {
            ObjectStateEntry stateEntry;
            BsoArchiveEntities.Current.ObjectStateManager.TryGetObjectStateEntry(busObject, out stateEntry);

            var createdProps = stateEntry.CurrentValues.DataRecordInfo.FieldMetadata;

            var prop = createdProps.FirstOrDefault(p => p.FieldType.Name.ToUpper() == columnName.ToUpper());
            stateEntry.CurrentValues.SetValue(prop.Ordinal, newValue);
        }

 /// <summary>
 /// Constructor to initialise the exception with details regarding the
 /// object whose record was deleted
 /// </summary>
 /// <param name="bo">The business object in question</param>
 /// <param name="message">Additional err message</param>
 public BusObjDeleteException(IBusinessObject bo, string message):
     base(String.IsNullOrEmpty(message) ? string.Format(
         "You cannot delete the '{0}', as the IsDeletable is set to false for the object. " +
         "ObjectID: {1}, also identified as {2}",
         bo.ClassDef.ClassName, bo.ID, bo) : message, 
         !String.IsNullOrEmpty(message) ? new Exception(
             string.Format(
                 "You cannot delete the '{0}', as the IsDeletable is set to false for the object. " +
                 "ObjectID: {1}, also identified as {2}",
                 bo.ClassDef.ClassName, bo.ID, bo)) : null)
 {
 }

 ///<summary>
 /// This constructor initialises this update log with the BusinessObject to be updated.
 /// This businessobject is then searched for the default UserLastUpdated and DateLastUpdated properties 
 /// that are to be updated when the BusinessObject is updated.
 ///</summary>
 ///<param name="businessObject">The BusinessObject to be updated</param>
 public BusinessObjectLastUpdatePropertiesLog(IBusinessObject businessObject)
 {
     IBOPropCol boPropCol = businessObject.Props;
     string propName = "UserLastUpdated";
     if (boPropCol.Contains(propName))
     {
         _userLastUpdatedBoProp = boPropCol[propName];
     }
     propName = "DateLastUpdated";
     if (boPropCol.Contains(propName))
     {
         _dateLastUpdatedBoProp = boPropCol[propName];
     }
 }

 ///<summary>
 /// Deletes the given business object
 ///</summary>
 ///<param name="businessObject">The business object to delete</param>
 public virtual void DeleteBusinessObject(IBusinessObject businessObject)
 {
     try
     {
         businessObject.MarkForDelete();
         var committer = BORegistry.DataAccessor.CreateTransactionCommitter();
         committer.AddBusinessObject(businessObject);
         committer.CommitTransaction();
     }
     catch (Exception)
     {
         businessObject.CancelEdits();
         throw;
     }
 }

        internal static void UpdateObject(IBusinessObject busObject, object newValue, string columnName)
        {
            ObjectStateEntry stateEntry;
            BsoArchiveEntities.Current.ObjectStateManager.TryGetObjectStateEntry(busObject, out stateEntry);

            var createdProps = stateEntry.CurrentValues.DataRecordInfo.FieldMetadata;

            var prop = createdProps.FirstOrDefault(p => p.FieldType.Name.ToUpper() == columnName.ToUpper());

            if (prop.FieldType == null)
                return;

            var value = EFUtility.MapType(newValue, prop.FieldType.TypeUsage.EdmType);

            stateEntry.CurrentValues.SetValue(prop.Ordinal, value);
        }

 ///<summary>
 /// Add an object of type business object to the transaction.
 /// The DBTransactionCommiter wraps this Business Object in the
 /// appropriate Transactional Business Object
 ///</summary>
 ///<param name="businessObject"></param>
 public void AddBusinessObject(IBusinessObject businessObject)
 {
     if (_myDataAccessor == null)
     {
         _myDataAccessor = GetDataAccessorForType(businessObject.GetType());
         _transactionCommitter = _myDataAccessor.CreateTransactionCommitter();
     } else
     {
         IDataAccessor dataAccessorToUseForType = GetDataAccessorForType(businessObject.GetType());
         if (dataAccessorToUseForType != _myDataAccessor)
         {
             throw new HabaneroDeveloperException("A problem occurred while trying to save, please see log for details", string.Format("A BusinessObject of type {0} was added to a TransactionCommitterMultiSource which has been set up with a different source to this type.", businessObject.GetType().FullName));
         }
     }
     _transactionCommitter.AddBusinessObject(businessObject);
 }

        public static void GetBrokenRulesString(IBusinessObject currentObj,
                List<IBusinessObject> checkEntities,
                List<string> errorMessages,
                System.Data.Objects.DataClasses.EntityObject parent)
        {
            if (checkEntities.Contains(currentObj))
                return;

            checkEntities.Add(currentObj);

            if (parent == null)
                errorMessages.Add(currentObj.GetCurrentBrokenRules());
            else
                errorMessages.Add(currentObj.GetCurrentBrokenRules());

            if (IsNew(currentObj))
                return;

            foreach (Adage.EF.Interfaces.RelatedObject eachObj in currentObj.RelatedObjects)
            {
                IRelatedEnd childColl;
                if (eachObj.RelatedType == RelatedEnum.Many)
                {
                    childColl = eachObj.GetRelatedEnd((EntityObject)currentObj);
                    if (childColl == null || childColl.IsLoaded == false)
                    {
                        continue;
                    }
                }
                else
                {
                    if (eachObj.GetReference((EntityObject)currentObj).IsLoaded == false)
                    {
                        continue;
                    }

                    childColl = eachObj.GetRelatedEnd((EntityObject)currentObj);
                }

                foreach (Adage.EF.Interfaces.IBusinessObject eachChild in childColl)
                {
                    eachChild.FindBrokenRules(checkEntities,
                        errorMessages, (EntityObject)currentObj);
                }
            }
        }

 /// <summary>
 /// Constructor to initialise the exception with a set of details
 /// regarding the editing of the object
 /// </summary>
 /// <param name="className">The class name</param>
 /// <param name="userName">The user name editing the record</param>
 /// <param name="machineName">The machine name editing the record</param>
 /// <param name="dateUpdated">The date that the editing took place</param>
 /// <param name="objectID">The object's ID</param>
 /// <param name="obj">The object in question</param>
 public BusObjBeginEditConcurrencyControlException(string className,
     string userName,
     string machineName,
     DateTime dateUpdated,
     string objectID,
     IBusinessObject obj)
     :
         base("You cannot Edit '" + className +
              "', as another user has edited this record. \n" +
              "UserName: " +
              (userName.Length > 0 ? userName : "[Unknown]") +
              " \nMachineName: " +
              (machineName.Length > 0 ? machineName : "[Unknown]") +
              " \nDateUpdated: " +
              dateUpdated.ToString("dd MMM yyyy HH:mm:ss:fff") +
              " \nObjectID: " + objectID, obj)
 {
 }

        public CloseBOEditorDialogResult ShowDialog(IBusinessObject businessObject)
        {
            if (businessObject == null)
            {
                BOEditorDialogResult = CloseBOEditorDialogResult.CloseWithoutSaving;
                this.Close();
                return BOEditorDialogResult;
            }


            var isInValidState = businessObject.Status.IsValid();
            var isDirty = businessObject.Status.IsDirty;
            SaveAndCloseBtn.Enabled = isInValidState;
            this.BOEditorDialogResult = CloseBOEditorDialogResult.CancelClose;


            if (!isDirty)
            {
                this.BOEditorDialogResult = CloseBOEditorDialogResult.CloseWithoutSaving;
                this.Close();
                return this.BOEditorDialogResult;
            }
            string isValidString;
            if (isInValidState)
            {
                isValidString = " and is in a valid state to be saved";
            }

            else
            {
                string isValidMessage = businessObject.Status.IsValidMessage;

                isValidString = " and is not in a valid state to be saved: " + Environment.NewLine +
                                isValidMessage + Environment.NewLine;
            }
            var fullDisplayName = businessObject.ClassDef.DisplayName
                    + " '" + businessObject.ToString() + "'";
            _label.Text = "The " + fullDisplayName + " is has been edited" + isValidString +
                          ". Please choose the appropriate action";
            this.SaveAndCloseBtn.Enabled = isInValidState;
            ShowForm();
            return this.BOEditorDialogResult;
        }

 /// <summary>
 /// Constructor to initialise the exception with a set of concurrency
 /// details
 /// </summary>
 /// <param name="className">The class name</param>
 /// <param name="userName">The user name that edited the record</param>
 /// <param name="machineName">The machine name that edited the record</param>
 /// <param name="dateUpdated">The date that the record was edited</param>
 /// <param name="objectID">The object ID</param>
 /// <param name="obj">The object whose record was edited</param>
 public BusObjOptimisticConcurrencyControlException(string className,
     string userName,
     string machineName,
     DateTime dateUpdated,
     string objectID,
     IBusinessObject obj) :
         base("You cannot save the changes to '" + className +
              "', as another user has edited this record. \n" +
              "UserName: " +
              (userName.Length > 0 ? userName : "[Unknown]") +
              " \nMachineName: " +
              (machineName.Length > 0 ? machineName : "[Unknown]") +
              " \nDateUpdated: " +
              dateUpdated.ToString("dd MMM yyyy HH:mm:ss:fff") +
              " \nObjectID: " + objectID, obj)
 {
     _userNameEdited = (userName.Length > 0 ? userName : "[Unknown]");
     _machineNameEdited = (machineName.Length > 0 ? machineName : "[Unknown]");
     _dateUpdated = dateUpdated;
     _objectID = objectID;
     _obj = obj;
     _className = className;
 }

        public static bool CheckIsValid(IBusinessObject currentObj,
                List<IBusinessObject> checkEntities)
        {
            if (checkEntities.Contains(currentObj))
                return true;

            checkEntities.Add(currentObj);
            foreach (Adage.EF.Interfaces.RelatedObject eachObj in currentObj.RelatedObjects)
            {
                IRelatedEnd childColl;
                if (eachObj.RelatedType == RelatedEnum.Many)
                {
                    childColl = eachObj.GetRelatedEnd((EntityObject)currentObj);
                    if (childColl == null || childColl.IsLoaded == false)
                    {
                        continue;
                    }
                }
                else
                {
                    if (eachObj.GetReference((EntityObject)currentObj).IsLoaded == false)
                    {
                        continue;
                    }

                    childColl = eachObj.GetRelatedEnd((EntityObject)currentObj);
                }

                foreach (IBusinessObject eachChild in childColl)
                {
                    if (eachChild.CheckIsValid(checkEntities) == false)
                        return false;
                }
            }

            return true;
        }