/// <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> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="territoryId">PK value for Territory which data should be fetched into this Territory 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 territoryId, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
return(Fetch(territoryId, prefetchPathToUse, contextToUse, excludedIncludedFields));
}
/// <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> 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> 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> Method which will try to fetch the contents for this entity using a unique constraint. </summary>
/// <remarks>All contents of the entity is lost.</remarks>
/// <param name="threadID">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</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 and the contents is read, false otherwise</returns>
public bool FetchUsingUCThreadID(System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return FetchUsingUCThreadID( threadID, prefetchPathToUse, contextToUse, null);
}
/// <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> 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>
/// <returns>True if succeeded, false otherwise.</returns>
public bool FetchUsingPK(System.String cIdHakAkses, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return Fetch(cIdHakAkses, prefetchPathToUse, contextToUse, null);
}
/// <summary>CTor</summary>
/// <param name="shipperId">PK value for Shipper which data should be fetched into this Shipper object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public ShipperEntity(System.Int32 shipperId, IPrefetchPath prefetchPathToUse)
{
InitClassFetch(shipperId, null, prefetchPathToUse);
}
/// <summary>CTor</summary>
/// <param name="transactionID">PK value for TransactionHistoryArchive which data should be fetched into this TransactionHistoryArchive object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public TransactionHistoryArchiveEntityBase(System.Int32 transactionID, IPrefetchPath prefetchPathToUse)
{
InitClassFetch(transactionID, null, prefetchPathToUse);
}
/// <summary> Initializes the the entity and fetches the data related to the entity in this entity.</summary>
/// <param name="transactionID">PK value for TransactionHistoryArchive which data should be fetched into this TransactionHistoryArchive object</param>
/// <param name="validator">The validator object for this TransactionHistoryArchiveEntity</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
protected virtual void InitClassFetch(System.Int32 transactionID, IValidator validator, IPrefetchPath prefetchPathToUse)
{
OnInitializing();
base.Validator = validator;
InitClassMembers();
base.Fields = CreateFields();
bool wasSuccesful = Fetch(transactionID, prefetchPathToUse, null, null);
base.IsNew = !wasSuccesful;
// __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="transactionID">PK value for TransactionHistoryArchive which data should be fetched into this TransactionHistoryArchive 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 transactionID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
return(Fetch(transactionID, prefetchPathToUse, contextToUse, excludedIncludedFields));
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="transactionID">PK value for TransactionHistoryArchive which data should be fetched into this TransactionHistoryArchive 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.Int32 transactionID, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return(Fetch(transactionID, prefetchPathToUse, contextToUse, null));
}
/// <summary>CTor</summary>
/// <param name="regionId">PK value for Region which data should be fetched into this Region object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public RegionEntity(System.Int32 regionId, IPrefetchPath prefetchPathToUse) : base("RegionEntity")
{
InitClassFetch(regionId, null, prefetchPathToUse);
}
/// <summary>CTor</summary>
/// <param name="territoryId">PK value for Territory which data should be fetched into this Territory object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public TerritoryEntity(System.String territoryId, IPrefetchPath prefetchPathToUse) : base("TerritoryEntity")
{
InitClassFetch(territoryId, null, 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> 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> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="id">PK value for Group which data should be fetched into this Group 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="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>CTor</summary>
/// <param name="id">PK value for Group which data should be fetched into this Group object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public GroupEntity(System.Int32 id, IPrefetchPath prefetchPathToUse) : base("GroupEntity")
{
InitClassFetch(id, null, prefetchPathToUse);
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</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>
/// <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.Int32 queueID, System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return FetchUsingPK(queueID, threadID, prefetchPathToUse, contextToUse, null);
}
/// <summary>
/// CTor
/// </summary>
/// <param name="customerID">PK value for Store which data should be fetched into this Store object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public StoreEntity(System.Int32 customerID, IPrefetchPath prefetchPathToUse) :
base(customerID, 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 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> 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>Reads an entity based on a unique constraint. Which entity is read is determined from the passed in fields for the UniqueConstraint.</summary>
/// <param name="entityToFetch">The entity to fetch. Contained data will be overwritten.</param>
/// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
/// <param name="companyName">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
/// <param name="contextToUse">The context to fetch the prefetch path with.</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>
public void FetchCustomerUsingUCCompanyName(IEntity entityToFetch, ITransaction containingTransaction, System.String companyName, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
var selectFilter = new PredicateExpression();
selectFilter.Add(new FieldCompareValuePredicate(entityToFetch.Fields[(int)CustomerFieldIndex.CompanyName], ComparisonOperator.Equal, companyName));
this.PerformFetchEntityAction(entityToFetch, containingTransaction, selectFilter, 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>CTor</summary>
/// <param name="auditDataID">PK value for AuditDataThreadRelated which data should be fetched into this AuditDataThreadRelated object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
protected AuditDataThreadRelatedEntityBase(System.Int32 auditDataID, IPrefetchPath prefetchPathToUse) : base(auditDataID, prefetchPathToUse)
{
InitClassFetch(auditDataID, null, prefetchPathToUse);
SetName("AuditDataThreadRelatedEntity");
}
/// <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>Retrieves in the calling CustomerCollection object all CustomerEntity objects which are related via a relation of type 'm:n' with the passed in CustomerDemographyEntity.</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="customerDemographyInstance">CustomerDemographyEntity 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 GetMultiUsingCustomerDemographicsCollectionViaCustomerCustomerDemo(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity customerDemographyInstance, IPrefetchPath prefetchPathToUse, int pageNumber, int pageSize)
{
RelationCollection relations = new RelationCollection();
relations.Add(CustomerEntity.Relations.CustomerCustomerDemoEntityUsingCustomerId, "CustomerCustomerDemo_");
relations.Add(CustomerCustomerDemoEntity.Relations.CustomerDemographyEntityUsingCustomerTypeId, "CustomerCustomerDemo_", string.Empty, JoinHint.None);
IPredicateExpression selectFilter = new PredicateExpression();
selectFilter.Add(new FieldCompareValuePredicate(customerDemographyInstance.Fields[(int)CustomerDemographyFieldIndex.CustomerTypeId], 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>
/// CTor
/// </summary>
/// <param name="productID">PK value for Product which data should be fetched into this Product object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public ProductEntity(System.Int32 productID, IPrefetchPath prefetchPathToUse) :
base(productID, prefetchPathToUse)
{
}
/// <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="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="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>Retrieves in the calling ProductCollection object all ProductEntity objects which are related via a relation of type 'm:n' with the passed in OrderEntity.</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="orderInstance">OrderEntity 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 GetMultiUsingOrdersCollectionViaOrderDetails(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IEntity orderInstance, IPrefetchPath prefetchPathToUse, int pageNumber, int pageSize)
{
RelationCollection relations = new RelationCollection();
relations.Add(ProductEntity.Relations.OrderDetailEntityUsingProductId, "OrderDetail_");
relations.Add(OrderDetailEntity.Relations.OrderEntityUsingOrderId, "OrderDetail_", string.Empty, JoinHint.None);
IPredicateExpression selectFilter = new PredicateExpression();
selectFilter.Add(new FieldCompareValuePredicate(orderInstance.Fields[(int)OrderFieldIndex.OrderId], ComparisonOperator.Equal));
return(this.GetMulti(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, entityFactoryToUse, selectFilter, relations, prefetchPathToUse, pageNumber, pageSize));
}
/// <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>Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="userId">PK value for User which data should be fetched into this User 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.String userId, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return(FetchUsingPK(userId, prefetchPathToUse, contextToUse, null));
}
/// <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>CTor</summary>
/// <param name="userId">PK value for User which data should be fetched into this User object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public UserEntity(System.String userId, IPrefetchPath prefetchPathToUse)
{
InitClassFetch(userId, null, prefetchPathToUse);
}
/// <summary>CTor</summary>
/// <param name="auditDataID">PK value for AuditDataMessageRelated which data should be fetched into this AuditDataMessageRelated object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
protected AuditDataMessageRelatedEntityBase(System.Int32 auditDataID, IPrefetchPath prefetchPathToUse)
: base(auditDataID, prefetchPathToUse)
{
InitClassFetch(auditDataID, null, prefetchPathToUse);
SetName("AuditDataMessageRelatedEntity");
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="channelTypeId">PK value for ChannelType which data should be fetched into this ChannelType 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.Int32 channelTypeId, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return(FetchUsingPK(channelTypeId, prefetchPathToUse, contextToUse, null));
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</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>
/// <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 queueID, System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
return Fetch(queueID, threadID, prefetchPathToUse, contextToUse, excludedIncludedFields);
}
/// <summary> Initializes the the entity and fetches the data related to the entity in this entity.</summary>
/// <param name="channelTypeId">PK value for ChannelType which data should be fetched into this ChannelType object</param>
/// <param name="validator">The validator object for this ChannelTypeEntity</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
private void InitClassFetch(System.Int32 channelTypeId, IValidator validator, IPrefetchPath prefetchPathToUse)
{
OnInitializing();
this.Validator = validator;
this.Fields = CreateFields();
InitClassMembers();
Fetch(channelTypeId, prefetchPathToUse, null, null);
// __LLBLGENPRO_USER_CODE_REGION_START InitClassFetch
// __LLBLGENPRO_USER_CODE_REGION_END
OnInitialized();
}
/// <summary> Method which will try to fetch the contents for this entity using a unique constraint. </summary>
/// <remarks>All contents of the entity is lost.</remarks>
/// <param name="threadID">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</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 and the contents is read, false otherwise</returns>
public bool FetchUsingUCThreadID(System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
try
{
OnFetch();
((SupportQueueThreadDAO)CreateDAOInstance()).FetchSupportQueueThreadUsingUCThreadID(this, this.Transaction, threadID, prefetchPathToUse, contextToUse, excludedIncludedFields);
return (this.Fields.State == EntityState.Fetched);
}
finally
{
OnFetchComplete();
}
}
/// <summary>CTor</summary>
/// <param name="channelTypeId">PK value for ChannelType which data should be fetched into this ChannelType object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public ChannelTypeEntity(System.Int32 channelTypeId, IPrefetchPath prefetchPathToUse) : base("ChannelTypeEntity")
{
InitClassFetch(channelTypeId, 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 this ShipperCollection object all ShipperEntity objects which are related via a relation of type 'm:n' with the passed in EmployeeEntity. All current elements in the collection are removed from the collection.</summary>
/// <param name="employeeInstance">EmployeeEntity object to be used as a filter in the m:n relation</param>
/// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query.</param>
/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
/// <returns>true if the retrieval succeeded, false otherwise</returns>
public bool GetMultiManyToManyUsingEmployeesCollectionViaOrders(IEntity employeeInstance, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IPrefetchPath prefetchPathToUse)
{
if (!this.SuppressClearInGetMulti)
{
this.Clear();
}
return(DAOFactory.CreateShipperDAO().GetMultiUsingEmployeesCollectionViaOrders(this.Transaction, this, maxNumberOfItemsToReturn, sortClauses, this.EntityFactoryToUse, employeeInstance, prefetchPathToUse, 0, 0));
}
/// <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> Retrieves in this ShipperCollection object all ShipperEntity objects which are related via a Relation of type 'm:n' with the passed in CustomerEntity. All current elements in the collection are removed from the collection.</summary>
/// <param name="customerInstance">CustomerEntity 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 the retrieval succeeded, false otherwise</returns>
public bool GetMultiManyToManyUsingCustomersCollectionViaOrders(IEntity customerInstance, IPrefetchPath prefetchPathToUse)
{
return(GetMultiManyToManyUsingCustomersCollectionViaOrders(customerInstance, this.MaxNumberOfItemsToReturn, this.SortClauses, prefetchPathToUse));
}
/// <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);
}
/// <summary>Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="orderId">PK value for Order which data should be fetched into this Order 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.Int32 orderId, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return(FetchUsingPK(orderId, prefetchPathToUse, contextToUse, null));
}
/// <summary>CTor</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>
protected ActionRightEntityBase(System.Int32 actionRightID, IPrefetchPath prefetchPathToUse)
: base("ActionRightEntity")
{
InitClassFetch(actionRightID, null, prefetchPathToUse);
}
/// <summary>Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="orderId">PK value for Order which data should be fetched into this Order 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 orderId, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
return(Fetch(orderId, prefetchPathToUse, contextToUse, excludedIncludedFields));
}
/// <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>
/// <returns>True if succeeded, false otherwise.</returns>
public bool FetchUsingPK(System.Int32 sectionID, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return FetchUsingPK(sectionID, prefetchPathToUse, contextToUse, null);
}
/// <summary>CTor</summary>
/// <param name="orderId">PK value for Order which data should be fetched into this Order object</param>
/// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
public OrderEntity(System.Int32 orderId, IPrefetchPath prefetchPathToUse)
{
InitClassFetch(orderId, null, prefetchPathToUse);
}
/// <summary> Fetches the entity from the persistent storage. Fetch simply reads the entity into an EntityFields object. </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>
private bool Fetch(System.Int32 sectionID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
{
try
{
OnFetch();
this.Fields[(int)SectionFieldIndex.SectionID].ForcedCurrentValueWrite(sectionID);
CreateDAOInstance().FetchExisting(this, this.Transaction, prefetchPathToUse, contextToUse, excludedIncludedFields);
return (this.Fields.State == EntityState.Fetched);
}
finally
{
OnFetchComplete();
}
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="employeeId">PK value for EmployeeTerritory which data should be fetched into this EmployeeTerritory object</param>
/// <param name="territoryId">PK value for EmployeeTerritory which data should be fetched into this EmployeeTerritory 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.Int32 employeeId, System.String territoryId, IPrefetchPath prefetchPathToUse, Context contextToUse)
{
return(FetchUsingPK(employeeId, territoryId, prefetchPathToUse, contextToUse, null));
}
/// <summary>CTor</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>
protected SectionEntityBase(System.Int32 sectionID, IPrefetchPath prefetchPathToUse)
: base("SectionEntity")
{
InitClassFetch(sectionID, null, prefetchPathToUse);
}
/// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
/// <param name="territoryId">PK value for Territory which data should be fetched into this Territory 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.String territoryId, IPrefetchPath prefetchPathToUse)
{
return(FetchUsingPK(territoryId, prefetchPathToUse, null, null));
}