/// <summary>Retrieves in the calling AuditActionCollection object all AuditActionEntity objects which are related via a relation of type 'm:n' with the passed in RoleEntity.</summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="roleInstance">RoleEntity object to be used as a filter in the m:n relation</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 /// <returns>true if succeeded, false otherwise</returns>
 public bool GetMultiUsingRolesWithAuditAction(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity roleInstance, IPrefetchPath prefetchPathToUse, int pageNumber, int pageSize)
 {
     RelationCollection relations = new RelationCollection();
     relations.Add(AuditActionEntity.Relations.RoleAuditActionEntityUsingAuditActionID, "RoleAuditAction_");
     relations.Add(RoleAuditActionEntity.Relations.RoleEntityUsingRoleID, "RoleAuditAction_", string.Empty, JoinHint.None);
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(roleInstance.Fields[(int)RoleFieldIndex.RoleID], ComparisonOperator.Equal));
     return this.GetMulti(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, entityFactoryToUse, selectFilter, relations, prefetchPathToUse, pageNumber, pageSize);
 }

 /// <summary>CTor</summary>
 /// <param name="id">PK value for City which data should be fetched into this City object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public CityEntity(System.Int32 id, IPrefetchPath prefetchPathToUse)
 {
     InitClassFetch(id, null, prefetchPathToUse);
 }

        /// <summary> Initializes the the entity and fetches the data related to the entity in this entity.</summary>
        /// <param name="sectionID">PK value for Section which data should be fetched into this Section object</param>
        /// <param name="validator">The validator object for this SectionEntity</param>
        /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
        private void InitClassFetch(System.Int32 sectionID, IValidator validator, IPrefetchPath prefetchPathToUse)
        {
            OnInitializing();
            this.Validator = validator;
            this.Fields = CreateFields();
            InitClassMembers();
            Fetch(sectionID, prefetchPathToUse, null, null);

            // __LLBLGENPRO_USER_CODE_REGION_START InitClassFetch
            // __LLBLGENPRO_USER_CODE_REGION_END

            OnInitialized();
        }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="sectionID">PK value for Section which data should be fetched into this Section object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 sectionID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(sectionID, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary>
 /// Retrieves in the calling AccountCollection object all AccountEntity objects
 /// which are related via a relation of type 'm:n' with the passed in UserEntity. 
 /// </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. 
 /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="userInstance">UserEntity object to be used as a filter in the m:n relation</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <returns>true if succeeded, false otherwise</returns>
 public bool GetMultiUsingUserCollectionViaUser_(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity userInstance, IPrefetchPath prefetchPathToUse)
 {
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(Auction.Entities.EntityType.AccountEntity);
     RelationCollection relations = new RelationCollection();
     relations.Add(AccountEntity.Relations.UserEntityUsingAccountId, "User_");
     relations.Add(UserEntity.Relations.UserEntityUsingUpdatedBy, "User_", string.Empty, JoinHint.None);
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(userInstance.Fields[(int)UserFieldIndex.Id], ComparisonOperator.Equal));
     return GetMulti(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, entityFactoryToUse, selectFilter, relations, prefetchPathToUse);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="actionRightID">PK value for ActionRight which data should be fetched into this ActionRight object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 actionRightID, IPrefetchPath prefetchPathToUse)
 {
     return FetchUsingPK(actionRightID, prefetchPathToUse, null, null);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="id">PK value for Raffle which data should be fetched into this Raffle object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int64 id, IPrefetchPath prefetchPathToUse, Context contextToUse)
 {
     return Fetch(id, prefetchPathToUse, contextToUse, null);
 }

        /// <summary> Initializes the the entity and fetches the data related to the entity in this entity.</summary>
        /// <param name="id">PK value for Raffle which data should be fetched into this Raffle object</param>
        /// <param name="validator">The validator object for this RaffleEntity</param>
        /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
        protected virtual void InitClassFetch(System.Int64 id, IValidator validator, IPrefetchPath prefetchPathToUse)
        {
            OnInitializing();
            base.Validator = validator;
            InitClassMembers();
            base.Fields = CreateFields();
            bool wasSuccesful = Fetch(id, prefetchPathToUse, null, null);
            base.IsNew = !wasSuccesful;

            // __LLBLGENPRO_USER_CODE_REGION_START InitClassFetch
            // __LLBLGENPRO_USER_CODE_REGION_END

            OnInitialized();
        }

 /// <summary>CTor</summary>
 /// <param name="cIdHakAkses">PK value for MHakAkses which data should be fetched into this MHakAkses object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public MHakAksesEntity(System.String cIdHakAkses, IPrefetchPath prefetchPathToUse)
 {
     InitClassFetch(cIdHakAkses, null, prefetchPathToUse);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="cIdHakAkses">PK value for MHakAkses which data should be fetched into this MHakAkses object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.String cIdHakAkses, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(cIdHakAkses, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary>CTor</summary>
 /// <param name="id">PK value for ProductPhoto which data should be fetched into this ProductPhoto object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public ProductPhotoEntity(System.Int32 id, IPrefetchPath prefetchPathToUse)
 {
     InitClassFetch(id, null, prefetchPathToUse);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="id">PK value for ProductPhoto which data should be fetched into this ProductPhoto object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 id, IPrefetchPath prefetchPathToUse)
 {
     return FetchUsingPK(id, prefetchPathToUse, null, null);
 }

 /// <summary>CTor</summary>
 /// <param name="roleID">PK value for RoleSystemActionRight which data should be fetched into this RoleSystemActionRight object</param>
 /// <param name="actionRightID">PK value for RoleSystemActionRight which data should be fetched into this RoleSystemActionRight object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public RoleSystemActionRightEntity(System.Int32 roleID, System.Int32 actionRightID, IPrefetchPath prefetchPathToUse)
     : base(roleID, actionRightID, prefetchPathToUse)
 {
 }

 /// <summary>CTor</summary>
 /// <param name="queueID">PK value for SupportQueue which data should be fetched into this SupportQueue object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public SupportQueueEntity(System.Int32 queueID, IPrefetchPath prefetchPathToUse)
     : base(queueID, prefetchPathToUse)
 {
 }

 /// <summary>CTor</summary>
 /// <param name="queueID">PK value for SupportQueueThread which data should be fetched into this SupportQueueThread object</param>
 /// <param name="threadID">PK value for SupportQueueThread which data should be fetched into this SupportQueueThread object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 protected SupportQueueThreadEntityBase(System.Int32 queueID, System.Int32 threadID, IPrefetchPath prefetchPathToUse)
     : base("SupportQueueThreadEntity")
 {
     InitClassFetch(queueID, threadID, null, prefetchPathToUse);
 }

 /// <summary>Retrieves in the calling ForumCollection object all ForumEntity objects which are related via a relation of type 'm:n' with the passed in UserEntity.</summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="userInstance">UserEntity object to be used as a filter in the m:n relation</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 /// <returns>true if succeeded, false otherwise</returns>
 public bool GetMultiUsingUsersWhoStartedThreads(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity userInstance, IPrefetchPath prefetchPathToUse, int pageNumber, int pageSize)
 {
     RelationCollection relations = new RelationCollection();
     relations.Add(ForumEntity.Relations.ThreadEntityUsingForumID, "Thread_");
     relations.Add(ThreadEntity.Relations.UserEntityUsingStartedByUserID, "Thread_", string.Empty, JoinHint.None);
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(userInstance.Fields[(int)UserFieldIndex.UserID], ComparisonOperator.Equal));
     return this.GetMulti(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, entityFactoryToUse, selectFilter, relations, prefetchPathToUse, pageNumber, pageSize);
 }

 /// <summary>
 /// Retrieves in the calling EffectCollection object all EffectEntity objects
 /// which are related via a relation of type 'm:n' with the passed in PolicyEntity. 
 /// </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. 
 /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="policyInstance">PolicyEntity object to be used as a filter in the m:n relation</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <returns>true if succeeded, false otherwise</returns>
 public bool GetMultiUsingPolicyCollectionViaRule(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity policyInstance, IPrefetchPath prefetchPathToUse)
 {
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(policyDB.EntityType.EffectEntity);
     RelationCollection relations = new RelationCollection();
     relations.Add(EffectEntity.Relations.RuleEntityUsingEffectId, "Rule_");
     relations.Add(RuleEntity.Relations.PolicyEntityUsingPolicyId, "Rule_", string.Empty, JoinHint.None);
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(policyInstance.Fields[(int)PolicyFieldIndex.Id], ComparisonOperator.Equal));
     return GetMulti(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, entityFactoryToUse, selectFilter, relations, prefetchPathToUse);
 }

 /// <summary> Fetches the entity from the persistent storage. Fetch simply reads the entity into an EntityFields object. </summary>
 /// <param name="id">PK value for Raffle which data should be fetched into this Raffle object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 private bool Fetch(System.Int64 id, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     try
     {
         OnFetch();
         IDao dao = this.CreateDAOInstance();
         base.Fields[(int)RaffleFieldIndex.Id].ForcedCurrentValueWrite(id);
         dao.FetchExisting(this, base.Transaction, prefetchPathToUse, contextToUse, excludedIncludedFields);
         return (base.Fields.State == EntityState.Fetched);
     }
     finally
     {
         OnFetchComplete();
     }
 }

        /// <summary> Initializes the the entity and fetches the data related to the entity in this entity.</summary>
        /// <param name="auditDataID">PK value for AuditDataMessageRelated which data should be fetched into this AuditDataMessageRelated object</param>
        /// <param name="validator">The validator object for this AuditDataMessageRelatedEntity</param>
        /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
        private void InitClassFetch(System.Int32 auditDataID, IValidator validator, IPrefetchPath prefetchPathToUse)
        {
            InitClassMembers();

            // __LLBLGENPRO_USER_CODE_REGION_START InitClassFetch
            // __LLBLGENPRO_USER_CODE_REGION_END
        }

 /// <summary>CTor</summary>
 /// <param name="id">PK value for Raffle which data should be fetched into this Raffle object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 public RaffleEntity(System.Int64 id, IPrefetchPath prefetchPathToUse)
 {
     InitClassFetch(id, null, prefetchPathToUse);
 }