public static IEnumerable<ArtworkEntity> GetToDownload()
{
var bucket = new RelationPredicateBucket();
bucket.Relations.Add(ArtworkEntity.Relations.ArtworkToEpisodeEntityUsingArtworkId, JoinHint.Left);
bucket.Relations.Add(ArtworkToEpisodeEntity.Relations.EpisodeEntityUsingEpisodeId, JoinHint.Left);
bucket.Relations.Add(EpisodeEntity.Relations.SeasonEntityUsingSeasonId,JoinHint.Left);
bucket.Relations.Add(SeasonEntity.Relations.SeriesEntityUsingSeriesId, JoinHint.Left);
bucket.Relations.Add(ArtworkEntity.Relations.ArtworkToPersonEntityUsingArtworkId, JoinHint.Left);
bucket.Relations.Add(ArtworkEntity.Relations.ArtworkToRoleEntityUsingArtworkId, JoinHint.Left);
bucket.Relations.Add(ArtworkToRoleEntity.Relations.RoleEntityUsingRoleId, JoinHint.Left);
bucket.Relations.Add(RoleEntity.Relations.RoleToSeriesEntityUsingRoleId, JoinHint.Left);
bucket.Relations.Add(RoleToSeriesEntity.Relations.SeriesEntityUsingSeriesId, JoinHint.Left);
bucket.Relations.Add(ArtworkEntity.Relations.ArtworkToSeasonEntityUsingArtworkId, JoinHint.Left);
bucket.Relations.Add(ArtworkToSeasonEntity.Relations.SeasonEntityUsingSeasonId, JoinHint.Left);
bucket.Relations.Add(SeasonEntity.Relations.SeriesEntityUsingSeriesId, JoinHint.Left);
bucket.Relations.Add(ArtworkEntity.Relations.ArtworkToSeriesEntityUsingArtworkId, JoinHint.Left);
bucket.Relations.Add(ArtworkToSeriesEntity.Relations.SeriesEntityUsingSeriesId, JoinHint.Left);
bucket.PredicateExpression.Add(ArtworkFields.IsDownloadedOnMaster == false);
var prefetchPath = new PrefetchPath2(EntityType.ArtworkEntity);
prefetchPath.Add(ArtworkEntity.PrefetchPathArtworkToEpisodes).SubPath.Add(ArtworkToEpisodeEntity.PrefetchPathEpisode).SubPath.Add(EpisodeEntity.PrefetchPathSeason).SubPath.Add(SeasonEntity.PrefetchPathSeries);
prefetchPath.Add(ArtworkEntity.PrefetchPathArtworkToPeople);
prefetchPath.Add(ArtworkEntity.PrefetchPathArtworkToRoles).SubPath.Add(ArtworkToRoleEntity.PrefetchPathRole).SubPath.Add(RoleEntity.PrefetchPathRoleToSeries).SubPath.Add(RoleToSeriesEntity.PrefetchPathSeries);
prefetchPath.Add(ArtworkEntity.PrefetchPathArtworkToSeasons).SubPath.Add(ArtworkToSeasonEntity.PrefetchPathSeason).SubPath.Add(SeasonEntity.PrefetchPathSeries);
prefetchPath.Add(ArtworkEntity.PrefetchPathArtworkToSeries).SubPath.Add(ArtworkToSeriesEntity.PrefetchPathSeries);
return Database.GetEntityCollection<ArtworkEntity>(bucket, prefetchPath);
}
public static RepoAukcijaEntity FetchRepoAukcija(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, DateTime datumAukcije)
{
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(RepoAukcijaFields.DatumAukcije == datumAukcije);
return FetchRepoAukcijaCollection(adapter, bucket, prefetchPath).SingleOrDefault();
}
public static UserEntity FetchUser(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long UserId)
{
UserEntity _UserEntity = new UserEntity(UserId);
adapter.FetchEntity(_UserEntity, prefetchPath);
return(_UserEntity);
}
public ActionResult GetArtiklCollectionForPaging(string sidx, string sord, string filters, int page = 1)
{
using (DataAccessAdapterBase adapter = Helper.GetDataAccessAdapter())
{
RelationPredicateBucket bucket = new RelationPredicateBucket();
long firmaId = UserEntity.GetFirmaId(adapter, User.Identity.Name);
bucket.PredicateExpression.Add(ArtiklFields.FirmaId == firmaId);
if (filters != null)
{
bucket.Relations.Add(ArtiklEntity.Relations.PdvEntityUsingPdvId);
bucket.PredicateExpression.Add(PredicateHelper.CreatePredicateFromJqGridFilterString(filters, typeof(ArtiklFields), DbGenericHelper.GetDbGenericTypeByName));
}
bool?isSortAscending = PagerBase.IsJqgridSortAscending(sord);
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.ArtiklEntity);
prefetchPath.Add(ArtiklEntity.PrefetchPathPdv);
ArtiklPager artiklPager = new ArtiklPager();
artiklPager.LoadData(adapter, bucket, page, Common.Config.JqGridPageSize, sidx, isSortAscending);
return(CreateJsonResponse(artiklPager.CreateJqGridRespose()));
}
}
public static FirmaEntity FetchFirma(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long FirmaId)
{
FirmaEntity _FirmaEntity = new FirmaEntity(FirmaId);
adapter.FetchEntity(_FirmaEntity, prefetchPath);
return(_FirmaEntity);
}
private List <MedicalVendorInvoiceStatistic> FetchInvoiceStatistics(IRelationPredicateBucket bucket)
{
var physicianInvoiceEntities = new EntityCollection <PhysicianInvoiceEntity>();
var medicalVendorInvoiceItemStatistics = new DataTable("MedicalVendorInvoiceItemStatisticsDataTable");
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
IPrefetchPath2 path = new PrefetchPath2(EntityType.PhysicianInvoiceEntity);
path.Add(PhysicianInvoiceEntity.PrefetchPathPhysicianProfile);
myAdapter.FetchEntityCollection(physicianInvoiceEntities, bucket, path);
long[] medicalVendorInvoiceIds = physicianInvoiceEntities.Select(i => i.PhysicianInvoiceId).ToArray();
if (!medicalVendorInvoiceIds.IsEmpty())
{
IRelationPredicateBucket medicalVendorInvoiceItemBucket = new RelationPredicateBucket
(PhysicianInvoiceItemFields.PhysicianInvoiceId == medicalVendorInvoiceIds);
OrderedPair <ResultsetFields, GroupByCollection> resultsetFieldsAndGroupByCollection = _medicalVendorInvoiceStatisticFactory.
CreateMedicalVendorInvoiceStatisticFieldsAndGroupByClause();
myAdapter.FetchTypedList(resultsetFieldsAndGroupByCollection.FirstValue, medicalVendorInvoiceItemStatistics,
medicalVendorInvoiceItemBucket, 0, null, true, resultsetFieldsAndGroupByCollection.SecondValue);
}
}
return(_medicalVendorInvoiceStatisticFactory.CreateMedicalVendorInvoiceStatistics(physicianInvoiceEntities,
medicalVendorInvoiceItemStatistics));
}
private MatchEntity GetMatchWithDateRelatedEntities(IPredicate filter, long tournamentId)
{
var prefetchPathMatch = new PrefetchPath2(EntityType.MatchEntity);
prefetchPathMatch.Add(MatchEntity.PrefetchPathHomeTeam);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(TeamEntity.PrefetchPathVenue);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(TeamEntity.PrefetchPathManagerOfTeams);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath[1].SubPath.Add(ManagerOfTeamEntity.PrefetchPathUser);
prefetchPathMatch.Add(MatchEntity.PrefetchPathGuestTeam);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(TeamEntity.PrefetchPathVenue);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(TeamEntity.PrefetchPathManagerOfTeams);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath[1].SubPath.Add(ManagerOfTeamEntity.PrefetchPathUser);
prefetchPathMatch.Add(MatchEntity.PrefetchPathSets);
prefetchPathMatch.Add(MatchEntity.PrefetchPathVenue);
prefetchPathMatch.Add(MatchEntity.PrefetchPathOrigVenue);
prefetchPathMatch.Add(MatchEntity.PrefetchPathRound);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(RoundEntity.PrefetchPathRoundLegs);
prefetchPathMatch[prefetchPathMatch.Count - 1].SubPath.Add(RoundEntity.PrefetchPathTournament);
MatchEntity match;
using (var da = _dbContext.GetNewAdapter())
{
// filter based for MatchEntity
var bucket = new RelationPredicateBucket(filter);
// filter based relation to RoundEntity
bucket.Relations.Add(MatchEntity.Relations.RoundEntityUsingRoundId);
bucket.PredicateExpression.AddWithAnd(RoundFields.TournamentId == tournamentId);
match = da.FetchNewEntity <MatchEntity>(bucket, prefetchPathMatch);
da.CloseConnection();
}
return(match);
}
public static RoleRoEntity FetchRoleRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long RoleRoId)
{
RoleRoEntity _RoleRoEntity = new RoleRoEntity(RoleRoId);
adapter.FetchEntity(_RoleRoEntity, prefetchPath);
return(_RoleRoEntity);
}
public static PartnerEntity FetchPartner(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long PartnerId)
{
PartnerEntity _PartnerEntity = new PartnerEntity(PartnerId);
adapter.FetchEntity(_PartnerEntity, prefetchPath);
return(_PartnerEntity);
}
public static AuditInfoEntity FetchAuditInfo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long AuditInfoId)
{
AuditInfoEntity _AuditInfoEntity = new AuditInfoEntity(AuditInfoId);
adapter.FetchEntity(_AuditInfoEntity, prefetchPath);
return(_AuditInfoEntity);
}
public static ConfigEntity FetchConfig(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ConfigId)
{
ConfigEntity _ConfigEntity = new ConfigEntity(ConfigId);
adapter.FetchEntity(_ConfigEntity, prefetchPath);
return(_ConfigEntity);
}
public static PdvEntity FetchPdv(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long PdvId)
{
PdvEntity _PdvEntity = new PdvEntity(PdvId);
adapter.FetchEntity(_PdvEntity, prefetchPath);
return(_PdvEntity);
}
/// <summary>
/// Efficient pageing for grid.
/// </summary>
/// <param name="pageNumber">Must be greater than zero.</param>
/// <param name="sortDirection">Validne vrijednosti su 'asc' i 'desc'.</param>
public static EntityCollection <ArtiklEntity> FetchArtiklCollectionForPaging(DataAccessAdapterBase adapter,
RelationPredicateBucket bucket,
PrefetchPath2 prefetchPath,
int pageNumber,
int pageSize,
string sortField,
bool isSortAscending)
{
string sortDirection = isSortAscending ? "asc" : "desc";
Type sortEntityFieldType = typeof(ArtiklFields);
string sortEntityFieldTypeName = SortHelper.GetEntityFieldTypeNameForSorting(sortField, sortEntityFieldType);
if (!string.IsNullOrWhiteSpace(sortEntityFieldTypeName))
{
sortEntityFieldType = Type.GetType(sortEntityFieldTypeName);
}
sortField = SortHelper.GetSortField(sortField);
SortExpression sort = SortHelper.GetSortExpression(sortField, sortDirection, sortEntityFieldType);
EntityCollection <ArtiklEntity> toReturn = new EntityCollection <ArtiklEntity>(new ArtiklEntityFactory());
adapter.FetchEntityCollection(toReturn, bucket, pageSize, sort, prefetchPath, pageNumber, pageSize);
return(toReturn);
}
public virtual async Task <TournamentEntity> GetTournamentEntityForMatchPlannerAsync(long tournamentId, CancellationToken cancellationToken)
{
var bucket = new RelationPredicateBucket(TournamentFields.Id == tournamentId);
bucket.Relations.Add(TournamentEntity.Relations.RoundEntityUsingTournamentId);
bucket.Relations.Add(RoundEntity.Relations.TeamInRoundEntityUsingRoundId);
bucket.Relations.Add(TeamInRoundEntity.Relations.TeamEntityUsingTeamId);
bucket.Relations.Add(TeamEntity.Relations.VenueEntityUsingVenueId);
var prefetchPathTournament = new PrefetchPath2(EntityType.TournamentEntity);
prefetchPathTournament.Add(TournamentEntity.PrefetchPathRounds);
prefetchPathTournament[0].SubPath.Add(RoundEntity.PrefetchPathRoundLegs);
prefetchPathTournament[0].SubPath.Add(RoundEntity.PrefetchPathTeamCollectionViaTeamInRound).SubPath
.Add(TeamEntity.PrefetchPathVenue);
var t = new EntityCollection <TournamentEntity>();
using var da = _dbContext.GetNewAdapter();
var qp = new QueryParameters(0, 0, 0, bucket)
{
CollectionToFetch = t,
PrefetchPathToUse = prefetchPathTournament
};
await da.FetchEntityCollectionAsync(qp, cancellationToken);
return(t.FirstOrDefault());
}
public static BrojacEntity FetchBrojac(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long BrojacId)
{
BrojacEntity _BrojacEntity = new BrojacEntity(BrojacId);
adapter.FetchEntity(_BrojacEntity, prefetchPath);
return(_BrojacEntity);
}
/// <summary>
/// İlgili manager'ın entity'lerine ulaşmak için gereken path'i, parametre kullanarak oluşturmalı.
/// </summary>
/// <param name="p">Parametre</param>
/// <param name="path">PathElement, rootPath değil. Bu metod başka manager'dan çağırıldığından, rootPath başka manager'da olacaktır. Bu metod pathElement üretir.</param>
/// <returns></returns>
public IPrefetchPathElement2 GetPathElement(TParameter p, IPrefetchPathElement2 path)
{
IPredicateExpression filterPredicateExpression = new PredicateExpression();
//Filtering
PrepareFilter(p, ref filterPredicateExpression);
path.Filter = filterPredicateExpression;
//Relations
//PrepareRelations(p, path.FilterRelations);
//Sort
ISortExpression sortExpression = new SortExpression();
PrepareSortExpression(p, ref sortExpression);
path.Sorter = sortExpression;
//SubPaths
var subPath = new PrefetchPath2(EntityTypeEnumValue);
if (p.PathsFunc != null)
{
p.PathsFunc.Invoke(subPath);
}
//PrepareSubPaths(p, ref subPath);
path.SubPath = subPath;
return(path);
}
public static EntityRoEntity FetchEntityRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long EntityRoId)
{
EntityRoEntity _EntityRoEntity = new EntityRoEntity(EntityRoId);
adapter.FetchEntity(_EntityRoEntity, prefetchPath);
return(_EntityRoEntity);
}
public static TarifaEntity FetchTarifa(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long TarifaId)
{
TarifaEntity _TarifaEntity = new TarifaEntity(TarifaId);
adapter.FetchEntity(_TarifaEntity, prefetchPath);
return(_TarifaEntity);
}
/// <summary>
/// Efficient pageing for grid.
/// </summary>
/// <param name="pageNumber">Must be greater than zero.</param>
/// <param name="sortDirection">Validne vrijednosti su 'asc' i 'desc'.</param>
public static EntityCollection<ArtiklEntity> FetchArtiklCollectionForPaging(DataAccessAdapterBase adapter,
RelationPredicateBucket bucket,
PrefetchPath2 prefetchPath,
int pageNumber,
int pageSize,
string sortField,
bool isSortAscending)
{
string sortDirection = isSortAscending ? "asc" : "desc";
Type sortEntityFieldType = typeof(ArtiklFields);
string sortEntityFieldTypeName = SortHelper.GetEntityFieldTypeNameForSorting(sortField, sortEntityFieldType);
if (!string.IsNullOrWhiteSpace(sortEntityFieldTypeName))
{
sortEntityFieldType = Type.GetType(sortEntityFieldTypeName);
}
sortField = SortHelper.GetSortField(sortField);
SortExpression sort = SortHelper.GetSortExpression(sortField, sortDirection, sortEntityFieldType);
EntityCollection<ArtiklEntity> toReturn = new EntityCollection<ArtiklEntity>(new ArtiklEntityFactory());
adapter.FetchEntityCollection(toReturn, bucket, pageSize, sort, prefetchPath, pageNumber, pageSize);
return toReturn;
}
public static ErrorEntity FetchError(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ErrorId)
{
ErrorEntity _ErrorEntity = new ErrorEntity(ErrorId);
adapter.FetchEntity(_ErrorEntity, prefetchPath);
return(_ErrorEntity);
}
public static StatusRoEntity FetchStatusRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long StatusRoId)
{
StatusRoEntity _StatusRoEntity = new StatusRoEntity(StatusRoId);
adapter.FetchEntity(_StatusRoEntity, prefetchPath);
return(_StatusRoEntity);
}
/// <summary>
/// Gets all rounds and their teams for a tournament prefetched.
/// </summary>
/// <param name="tournament">Tournament entity to use.</param>
/// <example><![CDATA[
/// RoundEntity round = tir.Where(t => t.Round.Name == "A").First().Round;
/// TeamEntity team = tir.Where(t => t.Team.Name == "Die Unglaublichen").First().Team;
/// RoundEntity[] rounds = tir.Select(x => x.Round).Distinct().ToArray();
/// TeamEntity[] teamsOfRound = tir.Where(x => x.Round.Name == "F").Select(y => y.Team).ToArray();
/// ]]></example>
/// <returns>Returns the TeamInRoundEntity for the tournament id.</returns>
public virtual EntityCollection <TeamInRoundEntity> GetTeamsAndRounds(TournamentEntity tournament)
{
IPrefetchPath2 prefetchPathTeamInRound = new PrefetchPath2(EntityType.TeamInRoundEntity)
{
TeamInRoundEntity.PrefetchPathRound,
TeamInRoundEntity.PrefetchPathTeam
};
var filter = new RelationPredicateBucket();
filter.Relations.Add(TeamInRoundEntity.Relations.RoundEntityUsingRoundId);
filter.PredicateExpression.Add(RoundFields.TournamentId == tournament.Id);
IPrefetchPath2 prefetchPathTeam = new PrefetchPath2(EntityType.TeamEntity)
{
TeamEntity.PrefetchPathTeamInRounds
};
var tir = new EntityCollection <TeamInRoundEntity>();
using var da = _dbContext.GetNewAdapter();
da.FetchEntityCollection(tir, filter, prefetchPathTeamInRound);
da.CloseConnection();
return(tir);
}
public static ArtiklEntity FetchArtikl(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ArtiklId)
{
ArtiklEntity _ArtiklEntity = new ArtiklEntity(ArtiklId);
adapter.FetchEntity(_ArtiklEntity, prefetchPath);
return(_ArtiklEntity);
}
internal static IPrefetchPath2 ConvertStringToPrefetchPath(EntityType entityType, string prefetchStr, string selectStr)
{
if (string.IsNullOrWhiteSpace(prefetchStr))
{
return(null);
}
// Break up the selectStr into a dictionary of keys and values
// where the key is the path (i.e.: products.supplier)
// and the value is the field name (i.e.: companyname)
var prefetchFieldKeysAndNames = (selectStr ?? "")
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Where(s => s.IndexOf('.') > 0)
.Select(s => s.Trim('.').ToLowerInvariant());
var prefetchFieldNamesDictionary = new Dictionary <string, List <string> >();
foreach (var s in prefetchFieldKeysAndNames)
{
var key = s.Substring(0, s.LastIndexOf('.'));
var value = s.Substring(s.LastIndexOf('.') + 1);
if (prefetchFieldNamesDictionary.ContainsKey(key))
{
prefetchFieldNamesDictionary[key].AddIfNotExists(value);
}
else
{
prefetchFieldNamesDictionary.Add(key, new List <string>(new[] { value }));
}
}
var prefetchStrs = prefetchStr.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var nodeLeaves =
prefetchStrs.Select(n => n.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries)).ToArray();
var rootNode = new PrefetchElementStringRepresentation {
Name = "root", MaxNumberOfItemsToReturn = 0
};
foreach (var nodeLeaf in nodeLeaves)
{
BuildTreeNode(rootNode, nodeLeaf, 0);
}
var prefetch = new PrefetchPath2(entityType);
foreach (var prefetchRepresentation in rootNode.Children)
{
ExcludeIncludeFieldsList prefetchPathElementIncludeFieldList;
IPrefetchPathElement2 prefetchPathElement =
ConvertPrefetchRepresentationToPrefetchPathElement(entityType, prefetchRepresentation,
prefetchFieldNamesDictionary,
prefetchRepresentation.Name.ToLowerInvariant(),
out prefetchPathElementIncludeFieldList);
if (prefetchPathElement != null)
{
prefetch.Add(prefetchPathElement, prefetchPathElementIncludeFieldList);
}
}
return(prefetch.Count > 0 ? prefetch : null);
}
/// <summary>
/// Fetches the orders using a prefetch path for order details.
/// </summary>
private void FetchOrders()
{
DataAccessAdapter adapter = new DataAccessAdapter();
IPrefetchPath2 orderDetailsPrefetchPath = new PrefetchPath2((int)EntityType.OrderEntity);
orderDetailsPrefetchPath.Add(OrderEntity.PrefetchPathOrderDetails);
adapter.FetchEntityCollection(_currentCustomer.Orders, _currentCustomer.GetRelationInfoOrders(), 0, _orderSorter, orderDetailsPrefetchPath);
}
private MatchEntity GetMatchWithDateRelatedEntities(IPredicate filter, long tournamentId)
{
var prefetchPathMatch = new PrefetchPath2(EntityType.MatchEntity)
{
MatchEntity.PrefetchPathHomeTeam
};
prefetchPathMatch[^ 1].SubPath.Add(TeamEntity.PrefetchPathVenue);
public static EntityCollection <PartnerEntity> FetchPartnerCollection(DataAccessAdapterBase adapter,
IRelationPredicateBucket filterBucket,
PrefetchPath2 prefetchPath)
{
EntityCollection <PartnerEntity> toReturn = new EntityCollection <PartnerEntity>(new PartnerEntityFactory());
adapter.FetchEntityCollection(toReturn, filterBucket, prefetchPath);
return(toReturn);
}
protected override void SetDataSource(SD.LLBLGen.Pro.ORMSupportClasses.DataAccessAdapterBase adapter, int pageNumber, int pageSize, string sortField, bool isSortAscending)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.SudionikEntity);
prefetchPath.Add(SudionikEntity.PrefetchPathSudionikGrupa);
IEnumerable<SudionikEntity> sudionikCollection = SudionikEntity.FetchSudionikCollectionForPaging(adapter, null, null, pageNumber, pageSize, sortField, isSortAscending);
this.DataSource = sudionikCollection;
this.NoOfRecords = SudionikEntity.GetNumberOfEntities(adapter, null);
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
IPrefetchPath2 path = new PrefetchPath2((int)EntityType.CustomerEntity);
path.Add(CustomerEntity.PrefetchPathOrders);
CustomersDS.PrefetchPathToUse = path;
}
}
protected override void SetDataSource(DataAccessAdapterBase adapter, int pageNumber, int pageSize, string sortField, bool isSortAscending)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.ArtiklEntity);
prefetchPath.Add(ArtiklEntity.PrefetchPathPdv);
IEnumerable<ArtiklEntity> artiklCollection =
ArtiklEntity.FetchArtiklCollectionForPaging(adapter, null, prefetchPath, pageNumber, pageSize, sortField, isSortAscending);
this.DataSource = artiklCollection;
this.NoOfRecords = ArtiklEntity.GetNumberOfEntities(adapter, null);
}
public static UserEntity FetchUser(DataAccessAdapterBase adapter, string userName)
{
RelationPredicateBucket bucket = new RelationPredicateBucket(UserFields.Username == userName);
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.UserEntity);
prefetchPath.Add(UserEntity.PrefetchPathRole);
IEnumerable <UserEntity> userCollection = UserEntity.FetchUserCollection(adapter, bucket, prefetchPath);
return(userCollection.SingleOrDefault());
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
IPrefetchPath2 path = new PrefetchPath2((int)EntityType.EmployeeEntity);
path.Add(EmployeeEntity.PrefetchPathEmployees);
_EmployeeDS.PrefetchPathToUse = path;
}
}
protected override void SetDataSource(DataAccessAdapterBase adapter, int pageNumber, int pageSize, string sortField, bool isSortAscending)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.RacunGlavaEntity);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathPartner);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathStatus);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathRacunStavkaCollection);
this.DataSource = RacunGlavaEntity.FetchRacunGlavaCollectionForPaging(adapter, null, prefetchPath, pageNumber, pageSize, sortField, isSortAscending);
this.NoOfRecords = RacunGlavaEntity.GetNumberOfEntities(adapter, null);
}
public void LoadViewSpecificData(DataAccessAdapterBase adapter)
{
PrefetchPath2 prefetchPathArtikl = new PrefetchPath2(EntityType.ArtiklEntity);
prefetchPathArtikl.Add(ArtiklEntity.PrefetchPathPdv);
this.ArtiklCollection = ArtiklEntity.FetchArtiklCollection(adapter, null, prefetchPathArtikl).OrderBy(a => a.Naziv);
this.PartnerCollection = PartnerEntity.FetchPartnerCollection(adapter, null, null).OrderBy(p => p.Naziv);
this.TarifaCollection = TarifaEntity.FetchTarifaCollection(adapter, null, null).OrderBy(t => t.Naziv);
this.StatusCollection = StatusRoEntity.FetchStatusRoCollection(adapter, null, null).OrderBy(s => s.Name);
}
/// <summary>
/// Retrieves a list of groups matching the criteria specified via method parameters.
/// </summary>
/// <param name="category">Category name.</param>
/// <param name="categoryId">Category Id</param>
/// <param name="pageNumber">Page number.</param>
/// <param name="pageSize">Page size.</param>
/// <param name="recordCount">Record count.</param>
/// <returns>List of groups.</returns>
public List<MonoSoftware.MonoX.Repositories.SnGroupDTO> GetPopularGroups(string category, Guid categoryId, int pageNumber, int pageSize, out int recordCount)
{
RelationPredicateBucket filter = new RelationPredicateBucket();
//introduced to filter out groups by languages and applications
filter.Relations.Add(SnGroupEntity.Relations.SnGroupCategoryEntityUsingGroupCategoryId, JoinHint.Left);
//Note: MonoX supports the multi application environment so general filter for all DB access calls should contain the application id filter
filter.PredicateExpression.Add(SnGroupCategoryFields.ApplicationId == MonoSoftware.MonoX.Repositories.MembershipRepository.GetInstance().GetApplicationId());
//Note: MonoX in supports the multi language environment so general filter for all DB access calls should contain the language id filter
filter.PredicateExpression.Add(SnGroupCategoryFields.LanguageId == LocalizationUtility.GetCurrentLanguageId());
//Filter groups by category
if (categoryId != Guid.Empty)
{
filter.PredicateExpression.Add(SnGroupFields.GroupCategoryId == categoryId);
}
if (!String.IsNullOrEmpty(category))
{
filter.PredicateExpression.Add(SnGroupCategoryFields.Slug == category);
}
IPrefetchPath2 prefetch = new PrefetchPath2((int)EntityType.SnGroupEntity);
prefetch.Add(SnGroupEntity.PrefetchPathSnGroupCategory);
//Fetch a record from the members table only for the current user so his status could be read
Guid uid = SecurityUtility.GetUserId();
if (!Guid.Empty.Equals(uid))
{
PredicateExpression memberFilter = new PredicateExpression(SnGroupMemberFields.UserId == uid);
prefetch.Add(SnGroupEntity.PrefetchPathSnGroupMembers, 1, memberFilter);
}
#region Popular groups sorter
const string memberCountField = "MemberCountField";
const string memberCountTableName = "MemberCountTable";
EntityFields2 memberFields = new EntityFields2(2);
memberFields.DefineField(SnGroupMemberFields.GroupId, 0);
memberFields.DefineField(SnGroupMemberFields.Id, 1, memberCountField, AggregateFunction.Count);
DerivedTableDefinition memberCountTable = new DerivedTableDefinition(memberFields, memberCountTableName, null, new GroupByCollection(memberFields[0]));
IDynamicRelation memberCountRelation = new DynamicRelation(memberCountTable, JoinHint.Right, MonoSoftware.MonoX.DAL.EntityType.SnGroupEntity, String.Empty, SnGroupMemberFields.GroupId.SetObjectAlias(memberCountTable.Alias) == SnGroupFields.Id);
filter.Relations.Add(memberCountRelation);
ISortExpression sorter = new SortExpression(new SortClause(new EntityField2(memberCountField, null).SetObjectAlias(memberCountTableName), null, SortOperator.Descending));
#endregion
EntityCollection<SnGroupEntity> groups = new EntityCollection<SnGroupEntity>();
//Fetch the group collection
FetchEntityCollection(groups, filter, 0, sorter, prefetch, pageNumber, pageSize);
//Fetch the group total count used by paging
recordCount = GetDbCount(groups, filter);
//Transfer group entities to the DTO
List<MonoSoftware.MonoX.Repositories.SnGroupDTO> toReturn = groups.Select(group => new MonoSoftware.MonoX.Repositories.SnGroupDTO(group)).ToList<MonoSoftware.MonoX.Repositories.SnGroupDTO>();
return toReturn;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
// add prefetch path so the AuditInfoEntityName could be appear
PrefetchPath2 path = new PrefetchPath2((int)EntityType.AuditInfoEntity);
path.Add(AuditInfoEntity.PrefetchPathAuditActionType);
_AuditInfoDS.PrefetchPathToUse = path;
}
}
public static EntityCollection<TrgovanjeGlavaHnbEntity> FetchTrgovanjeGlavaHnbCollection(DataAccessAdapterBase adapter,
DateTime startDate,
DateTime endDate)
{
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(PredicateHelper.FilterValidEntities(startDate, endDate, TrgovanjeGlavaHnbFields.Datum));
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.TrgovanjeGlavaHnbEntity);
prefetchPath.Add(TrgovanjeGlavaHnbEntity.PrefetchPathTrgovanjeStavkaHnbCollection);
return FetchTrgovanjeGlavaHnbCollection(adapter, bucket, prefetchPath);
}
private static PrefetchPath2 PrefetchPathForRacunReport()
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.RacunGlavaEntity);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathRacunStavkaCollection).
SubPath.Add(RacunStavkaEntity.PrefetchPathArtikl).
SubPath.Add(ArtiklEntity.PrefetchPathPdv);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathPartner);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathStatus);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathTarifa);
return(prefetchPath);
}
public virtual RoundEntity GetRoundWithLegs(long roundId)
{
var round = new RoundEntity(roundId);
IPrefetchPath2 prefetchPathRoundLegs = new PrefetchPath2(EntityType.RoundEntity);
prefetchPathRoundLegs.Add(RoundEntity.PrefetchPathRoundLegs);
using var da = _dbContext.GetNewAdapter();
da.FetchEntity(round, prefetchPathRoundLegs);
da.CloseConnection();
return(round);
}
public override string[] GetRolesForUser(string username)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.UserEntity);
prefetchPath.Add(UserEntity.PrefetchPathRole);
DataAccessAdapterBase adapter = Helper.GetDataAccessAdapterFactory();
UserEntity user = UserEntity.FetchUser(username, prefetchPath, adapter);
List<string> roleList = new List<string>();
roleList.Add(user.Role.Name);
return roleList.ToArray();
}
public static EntityCollection<TrgovanjeStavkaHnbEntity> FetchTrgovanjeStavkaHnbCollection(DataAccessAdapterBase adapter, int godina)
{
DateTime startDate = new DateTime(godina, 1, 1);
DateTime endDate = startDate.AddYears(1);
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.Relations.Add(TrgovanjeStavkaHnbEntity.Relations.TrgovanjeGlavaHnbEntityUsingTrgovanjeGlavaHnbId);
bucket.PredicateExpression.Add(PredicateHelper.FilterValidEntities(startDate, endDate, TrgovanjeGlavaHnbFields.Datum));
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.TrgovanjeStavkaHnbEntity);
prefetchPath.Add(TrgovanjeStavkaHnbEntity.PrefetchPathTrgovanjeGlavaHnb);
EntityCollection<TrgovanjeStavkaHnbEntity> trgovanjeStavkaHnbCollection = TrgovanjeStavkaHnbEntity.FetchTrgovanjeStavkaHnbCollection(adapter, bucket, prefetchPath);
return trgovanjeStavkaHnbCollection;
}
public TrgovanjeHnbViewModel(DataAccessAdapterBase adapter, long? trgovanjeGlavaHnbId)
{
if (trgovanjeGlavaHnbId.HasValue && trgovanjeGlavaHnbId.Value > 0)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.TrgovanjeGlavaHnbEntity);
IPrefetchPathElement2 trgovanjeStavkaHnbPrefetchElement = prefetchPath.Add(TrgovanjeGlavaHnbEntity.PrefetchPathTrgovanjeStavkaHnbCollection);
trgovanjeStavkaHnbPrefetchElement.SubPath.Add(TrgovanjeStavkaHnbEntity.PrefetchPathTrgovanjeVrsta);
this.TrgovanjeGlavaHnb = TrgovanjeGlavaHnbEntity.FetchTrgovanjeGlavaHnb(adapter, prefetchPath, trgovanjeGlavaHnbId.Value);
this.TrgovanjeStavkaHnbCollection = this.TrgovanjeGlavaHnb.TrgovanjeStavkaHnbCollection;
}
else
{
this.TrgovanjeGlavaHnb = new TrgovanjeGlavaHnbEntity();
this.TrgovanjeGlavaHnb.Datum = DateTime.Now;
this.TrgovanjeStavkaHnbCollection = new List<TrgovanjeStavkaHnbEntity>();
}
}
internal static IPrefetchPath2 ConvertStringToPrefetchPath(EntityType entityType, string prefetchStr, string selectStr)
{
if (string.IsNullOrWhiteSpace(prefetchStr))
return null;
// Break up the selectStr into a dictionary of keys and values
// where the key is the path (i.e.: products.supplier)
// and the value is the field name (i.e.: companyname)
var prefetchFieldKeysAndNames = (selectStr ?? "")
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Where(s => s.IndexOf('.') > 0)
.Select(s => s.Trim('.').ToLowerInvariant());
var prefetchFieldNamesDictionary = new Dictionary<string, List<string>>();
foreach (var s in prefetchFieldKeysAndNames)
{
var key = s.Substring(0, s.LastIndexOf('.'));
var value = s.Substring(s.LastIndexOf('.') + 1);
if (prefetchFieldNamesDictionary.ContainsKey(key))
prefetchFieldNamesDictionary[key].AddIfNotExists(value);
else
prefetchFieldNamesDictionary.Add(key, new List<string>(new[] { value }));
}
var prefetchStrs = prefetchStr.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var nodeLeaves =
prefetchStrs.Select(n => n.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries)).ToArray();
var rootNode = new PrefetchElementStringRepresentation { Name = "root", MaxNumberOfItemsToReturn = 0 };
foreach (var nodeLeaf in nodeLeaves)
BuildTreeNode(rootNode, nodeLeaf, 0);
var prefetch = new PrefetchPath2(entityType);
foreach (var prefetchRepresentation in rootNode.Children)
{
ExcludeIncludeFieldsList prefetchPathElementIncludeFieldList;
IPrefetchPathElement2 prefetchPathElement =
ConvertPrefetchRepresentationToPrefetchPathElement(entityType, prefetchRepresentation,
prefetchFieldNamesDictionary,
prefetchRepresentation.Name.ToLowerInvariant(),
out prefetchPathElementIncludeFieldList);
if (prefetchPathElement != null)
prefetch.Add(prefetchPathElement, prefetchPathElementIncludeFieldList);
}
return prefetch.Count > 0 ? prefetch : null;
}
public RacunViewModel(DataAccessAdapterBase adapter, long? racunGlavaId)
{
if (racunGlavaId.HasValue && racunGlavaId.Value > 0)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.RacunGlavaEntity);
SortExpression racunStavkaSort = new SortExpression(RacunStavkaFields.Pozicija | SortOperator.Ascending);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathRacunStavkaCollection, 0, null, null, racunStavkaSort).
SubPath.Add(RacunStavkaEntity.PrefetchPathArtikl);
this.RacunGlava = RacunGlavaEntity.FetchRacunGlava(adapter, prefetchPath, racunGlavaId.Value);
this.RacunStavkaCollection = this.RacunGlava.RacunStavkaCollection;
}
else
{
this.RacunGlava = new RacunGlavaEntity();
this.RacunGlava.Datum = DateTime.Now;
this.RacunStavkaCollection = new List<RacunStavkaEntity>();
}
}
public static List<SpecialOfferEntity> GetSpecialOffers(short numberToReturn)
{
EntityCollection offers = new EntityCollection(new SpecialOfferEntityFactory());
IPrefetchPath2 pf = new PrefetchPath2((int)EntityType.SpecialOfferEntity);
pf.Add(SpecialOfferEntity.PrefetchPathProduct).SubPath.Add(ProductEntity.PrefetchPathProductSection);
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
adapter.FetchEntityCollection(offers, null, numberToReturn, null, pf);
}
offers.SupportsSorting = true;
offers.Sort((int) SpecialOfferFieldIndex.Number, ListSortDirection.Ascending);
SpecialOfferEntity [] specialOffers = new SpecialOfferEntity[numberToReturn];
foreach (SpecialOfferEntity sof in offers)
{
specialOffers[sof.Number - 1] = sof;
}
return FillMissingOffers(specialOffers);
}
public static TrgovanjeGlavaEntity FetchTrgovanjeGlavaForGuiDisplay(DataAccessAdapterBase adapter, long trgovanjeGlavaId)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.TrgovanjeGlavaEntity);
IPrefetchPathElement2 trgovanjeStavkaPrefetchElement = prefetchPath.Add(TrgovanjeGlavaEntity.PrefetchPathTrgovanjeStavkaCollection);
trgovanjeStavkaPrefetchElement.SubPath.Add(TrgovanjeStavkaEntity.PrefetchPathValuta);
trgovanjeStavkaPrefetchElement.SubPath.Add(TrgovanjeStavkaEntity.PrefetchPathTrgovanjeVrsta);
TrgovanjeGlavaEntity trgovanjeGlava = TrgovanjeGlavaEntity.FetchTrgovanjeGlava(adapter, prefetchPath, trgovanjeGlavaId);
trgovanjeGlava.LoadTrgovanjeGlavaPrethodniDan(adapter);
return trgovanjeGlava;
}
public static HtmlPageEntity FetchHtmlPage(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long HtmlPageId)
{
HtmlPageEntity _HtmlPageEntity = new HtmlPageEntity(HtmlPageId);
adapter.FetchEntity(_HtmlPageEntity, prefetchPath);
return _HtmlPageEntity;
}
public static ArtiklEntity FetchArtikl(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ArtiklId)
{
ArtiklEntity _ArtiklEntity = new ArtiklEntity(ArtiklId);
adapter.FetchEntity(_ArtiklEntity, prefetchPath);
return _ArtiklEntity;
}
public static EntityCollection<ErrorEntity> FetchErrorCollection(DataAccessAdapterBase adapter,
IRelationPredicateBucket filterBucket,
PrefetchPath2 prefetchPath)
{
EntityCollection<ErrorEntity> toReturn = new EntityCollection<ErrorEntity>(new ErrorEntityFactory());
adapter.FetchEntityCollection(toReturn, filterBucket, prefetchPath);
return toReturn;
}
public static EntityRoEntity FetchEntityRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long EntityRoId)
{
EntityRoEntity _EntityRoEntity = new EntityRoEntity(EntityRoId);
adapter.FetchEntity(_EntityRoEntity, prefetchPath);
return _EntityRoEntity;
}
public static ValutaRoEntity FetchValutaRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ValutaRoId)
{
ValutaRoEntity _ValutaRoEntity = new ValutaRoEntity(ValutaRoId);
adapter.FetchEntity(_ValutaRoEntity, prefetchPath);
return _ValutaRoEntity;
}
public static UserEntity FetchUser(string userName, PrefetchPath2 prefetchPath, DataAccessAdapterBase adapter)
{
RelationPredicateBucket bucket = new RelationPredicateBucket(UserFields.Username == userName);
return FetchUserCollection(adapter, bucket, prefetchPath).SingleOrDefault();
}
public static RepoAukcijaEntity FetchRepoAukcija(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long RepoAukcijaId)
{
RepoAukcijaEntity _RepoAukcijaEntity = new RepoAukcijaEntity(RepoAukcijaId);
adapter.FetchEntity(_RepoAukcijaEntity, prefetchPath);
return _RepoAukcijaEntity;
}
public static EntityCollection<SistemskaInstancaPodatakaRoEntity> FetchSistemskaInstancaPodatakaRoCollection(DataAccessAdapterBase adapter,
IRelationPredicateBucket filterBucket,
PrefetchPath2 prefetchPath)
{
EntityCollection<SistemskaInstancaPodatakaRoEntity> toReturn = new EntityCollection<SistemskaInstancaPodatakaRoEntity>(new SistemskaInstancaPodatakaRoEntityFactory());
adapter.FetchEntityCollection(toReturn, filterBucket, prefetchPath);
return toReturn;
}
public static TrgovanjeStavkaHnbEntity FetchTrgovanjeStavkaHnb(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long TrgovanjeStavkaHnbId)
{
TrgovanjeStavkaHnbEntity _TrgovanjeStavkaHnbEntity = new TrgovanjeStavkaHnbEntity(TrgovanjeStavkaHnbId);
adapter.FetchEntity(_TrgovanjeStavkaHnbEntity, prefetchPath);
return _TrgovanjeStavkaHnbEntity;
}
public static AuditInfoActionTypeRoEntity FetchAuditInfoActionTypeRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long AuditInfoActionTypeRoId)
{
AuditInfoActionTypeRoEntity _AuditInfoActionTypeRoEntity = new AuditInfoActionTypeRoEntity(AuditInfoActionTypeRoId);
adapter.FetchEntity(_AuditInfoActionTypeRoEntity, prefetchPath);
return _AuditInfoActionTypeRoEntity;
}
public static PartnerEntity FetchPartner(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long PartnerId)
{
PartnerEntity _PartnerEntity = new PartnerEntity(PartnerId);
adapter.FetchEntity(_PartnerEntity, prefetchPath);
return _PartnerEntity;
}
public static ErrorEntity FetchError(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long ErrorId)
{
ErrorEntity _ErrorEntity = new ErrorEntity(ErrorId);
adapter.FetchEntity(_ErrorEntity, prefetchPath);
return _ErrorEntity;
}
public static RacunGlavaEntity FetchRacunGlava(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long RacunGlavaId)
{
RacunGlavaEntity _RacunGlavaEntity = new RacunGlavaEntity(RacunGlavaId);
adapter.FetchEntity(_RacunGlavaEntity, prefetchPath);
return _RacunGlavaEntity;
}
public static SistemskaInstancaPodatakaRoEntity FetchSistemskaInstancaPodatakaRo(DataAccessAdapterBase adapter, PrefetchPath2 prefetchPath, long SistemskaInstancaPodatakaRoId)
{
SistemskaInstancaPodatakaRoEntity _SistemskaInstancaPodatakaRoEntity = new SistemskaInstancaPodatakaRoEntity(SistemskaInstancaPodatakaRoId);
adapter.FetchEntity(_SistemskaInstancaPodatakaRoEntity, prefetchPath);
return _SistemskaInstancaPodatakaRoEntity;
}
