public List <MedicalVendorInvoiceStatistic> GetInvoiceStatisticsForMedicalVendor(long medicalVendorId,
DateTime startDate, DateTime endDate, int pageNumber, int pageSize)
{
IRelationPredicateBucket bucket = GetRelationPredicateBucketForVendor(medicalVendorId, startDate, endDate);
return(FetchPagedInvoiceStatistics(bucket, pageSize, pageNumber));
}
public List <MedicalVendorEarningCustomerAggregate> GetEarningCustomerAggregates(long organizationRoleUserId,
DateTime startDate, DateTime endDate, int pageNumber, int pageSize)
{
IRelationPredicateBucket bucket = GetEarningCustomerAggregateFilter(organizationRoleUserId, startDate, endDate);
return(FetchEarningCustomerAggregates(bucket, pageSize, pageNumber));
}
/// <summary>
/// Returns number of entities after filterBucket is applied.
/// If you need number of all entities send null as filterBucket.
/// </summary>
public static int GetNumberOfEntities(DataAccessAdapterBase adapter,
IRelationPredicateBucket filterBucket)
{
EntityCollection entityCollection = new EntityCollection(new PartnerEntityFactory());
return(adapter.GetDbCount(entityCollection, filterBucket));
}
private int FetchNumberOfInvoiceStatistics(IRelationPredicateBucket bucket)
{
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
return(myAdapter.GetDbCount(new EntityCollection <PhysicianInvoiceEntity>(), bucket));
}
}
private int FetchNumberOfEarningCustomerAggregates(IRelationPredicateBucket bucket)
{
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
return(myAdapter.GetDbCount(new MedicalVendorEarningCustomerTypedView().GetFieldsInfo(), bucket));
}
}
public static int Update(IEntity2 entity, IRelationPredicateBucket filter)
{
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
return(adapter.UpdateEntitiesDirectly(entity, filter));
}
}
private IEnumerable <CustomerCriticalData> Get(IRelationPredicateBucket expression)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var collection = new EntityCollection <CustomerEventCriticalTestDataEntity>();
adapter.FetchEntityCollection(collection, expression);
var criticalDataCollection = Mapper.Map <IEnumerable <CustomerEventCriticalTestDataEntity>, IEnumerable <CustomerCriticalData> >(collection.AsEnumerable());
var ids = criticalDataCollection.Select(ccd => ccd.Id).ToArray();
var linqMetaData = new LinqMetaData(adapter);
var eventCustomers = (from ecr in linqMetaData.EventCustomerResult
join cest in linqMetaData.CustomerEventScreeningTests on ecr.EventCustomerResultId equals cest.EventCustomerResultId
where ids.Contains(cest.CustomerEventScreeningTestId)
select new { ecr.EventId, ecr.CustomerId, cest.TestId, cest.CustomerEventScreeningTestId }).ToArray();
foreach (var customerCriticalData in criticalDataCollection)
{
var eventCustomer =
eventCustomers.Where(ec => ec.CustomerEventScreeningTestId == customerCriticalData.Id).Single();
customerCriticalData.EventId = eventCustomer.EventId;
customerCriticalData.CustomerId = eventCustomer.CustomerId;
customerCriticalData.TestId = eventCustomer.TestId;
}
return(criticalDataCollection);
}
}
public static object GetSum(IEntityField2 field, IRelationPredicateBucket filter)
{
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
return(adapter.GetScalar(field, null, AggregateFunction.Sum, filter.PredicateExpression, null, filter.Relations));
}
}
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));
}
public static int GetDbCount(IRelationPredicateBucket filter)
{
EntityCollection ec = new EntityCollection(new TEntityFactory());
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
return(adapter.GetDbCount(ec, filter));
}
}
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);
}
internal EntityCollection <TEntity> Fetch(IDataAccessAdapter adapter, SortExpression sortExpression,
ExcludeIncludeFieldsList excludedIncludedFields,
IPrefetchPath2 prefetchPath, IRelationPredicateBucket predicateBucket,
int pageNumber,
int pageSize, int limit, out int totalItemCount)
{
return(Fetch(adapter, sortExpression, excludedIncludedFields, prefetchPath, predicateBucket, pageNumber,
pageSize, limit, 0, out totalItemCount));
}
public static int Update(EntityBase2 entity, IRelationPredicateBucket filter)
{
int result = 0;
using (DataAccessAdapterBase dataAccessAdapterBase = new DataAccessAdapter(ManageBase.ConnectionString))
{
result = dataAccessAdapterBase.UpdateEntitiesDirectly(entity, filter);
}
return(result);
}
private IEnumerable <CustomerEventPriorityInQueueData> Get(IRelationPredicateBucket expression)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var collection = new EntityCollection <CustomerEventPriorityInQueueDataEntity>();
adapter.FetchEntityCollection(collection, expression);
var priorityDataCollection = Mapper.Map <IEnumerable <CustomerEventPriorityInQueueDataEntity>, IEnumerable <CustomerEventPriorityInQueueData> >(collection.AsEnumerable());
return(priorityDataCollection);
}
}
public static EntityCollection SelectAll(int iTop, ISortExpression sorter, IRelationPredicateBucket filter, IncludeFieldsList includeFields)
{
EntityCollection ec = new EntityCollection(new TEntityFactory());
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
adapter.FetchEntityCollection(ec, filter, iTop, sorter, null, includeFields);
}
return(ec);
}
public static int GetDbCount(IRelationPredicateBucket filter, EntityField2 fieldStatus)
{
EntityCollection ec = new EntityCollection(new TEntityFactory());
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
filter.PredicateExpression.Add(fieldStatus == true);
return(adapter.GetDbCount(ec, filter));
}
}
public static bool Delete(Type type, IRelationPredicateBucket filter)
{
bool result = false;
using (DataAccessAdapterBase dataAccessAdapterBase = new DataAccessAdapter(ManageBase.ConnectionString))
{
result = (dataAccessAdapterBase.DeleteEntitiesDirectly(type, filter) > 0);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="typeOfEntity"></param>
/// <param name="filterBucket"></param>
/// <returns></returns>
public int DeleteEntitiesDirectly(Type typeOfEntity, IRelationPredicateBucket filterBucket)
{
try
{
return(this.adapter.DeleteEntitiesDirectly(typeOfEntity, filterBucket));
}
catch (Exception e)
{
throw new ApplicationException(MessageSuppressionImpossible, e);
}
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket)
{
if (collection != null)
{
collection.Add(new GlobalConfigurationEntity
{
Name = ConfigurationSettingName.EpochDate.ToString(), Value = _expectedDateString
});
}
return(true);
}
private IEnumerable <EventSchedulingSlot> Get(IRelationPredicateBucket expression)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var eventSlotEntities = new EntityCollection <EventSchedulingSlotEntity>();
adapter.FetchEntityCollection(eventSlotEntities, expression);
var eventSlots = Mapper.Map <IEnumerable <EventSchedulingSlotEntity>, IEnumerable <EventSchedulingSlot> >(eventSlotEntities);
return(eventSlots.OrderBy(es => es.StartTime).ToArray());
}
}
public static DataTable SelectAllRDT(int iTop, ISortExpression sorter, IRelationPredicateBucket filter)
{
DataTable toReturn = new DataTable();
EntityCollection ec = new EntityCollection(new TEntityFactory());
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
adapter.FetchTypedList(ec.EntityFactoryToUse.CreateFields(), toReturn, filter, iTop, sorter, false);
}
return(toReturn);
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket)
{
if (_entitiesToReturn != null)
{
foreach (IEntity2 entity in _entitiesToReturn)
{
collection.Add(entity);
}
}
return(true);
}
private IEnumerable <DirectMail> Get(IRelationPredicateBucket expressionBucket)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var entities = new EntityCollection <DirectMailEntity>();
adapter.FetchEntityCollection(entities, expressionBucket);
return(Mapper.Map <IEnumerable <DirectMailEntity>, IEnumerable <DirectMail> >(entities).ToArray());
}
}
private bool FetchTypedView(ITypedView2 viewToFill, IRelationPredicateBucket bucket, bool allowDuplicates)
{
if (_typedViewToReturn != null)
{
for (var i = 0; i < _typedViewToReturn.Count; i++)
{
((DataTable)viewToFill).Rows.Add();
}
}
return(true);
}
public static int DeleteByCondition(IRelationPredicateBucket filter)
{
int toReturn = 0;
TEntity _entity = (TEntity)Activator.CreateInstance(typeof(TEntity));
IEntityCore _entityCore = (IEntityCore)_entity;
using (DataAccessAdapter adapter = DataAccessAdapterManagerBase.CreateAdapter())
{
toReturn = adapter.DeleteEntitiesDirectly(_entityCore.LLBLGenProEntityName, filter);
}
return(toReturn);
}
private bool FetchEntityCollectionWithSortExpression(IEntityCollection2 collection,
IRelationPredicateBucket bucket, int maxNumberOfItemsToReturn, ISortExpression sortExpression)
{
if (_entitiesToReturnForSortExpression != null)
{
foreach (IEntity2 entity in _entitiesToReturnForSortExpression)
{
collection.Add(entity);
}
}
return(true);
}
private IEnumerable <Lab> Get(IRelationPredicateBucket expressionBucket)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var entities = new EntityCollection <LabEntity>();
adapter.FetchEntityCollection(entities, expressionBucket);
var callQueues = Mapper.Map <IEnumerable <LabEntity>, IEnumerable <Lab> >(entities);
return(callQueues.OrderBy(t => t.Name).ToArray());
}
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket,
int maxNumberOfItemsToReturn, ISortExpression sortExpression, IPrefetchPath2 prefetchPath,
ExcludeIncludeFieldsList excludeIncludeFieldsList, int pageNumber, int pageSize)
{
if (_entitiesToReturn != null)
{
foreach (IEntity2 entity in _entitiesToReturn)
{
collection.Add(entity);
}
}
return(true);
}
private IEnumerable <DirectMailType> Get(IRelationPredicateBucket expressionBucket)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var entities = new EntityCollection <DirectMailTypeEntity>();
adapter.FetchEntityCollection(entities, expressionBucket);
var directMailTypes = Mapper.Map <IEnumerable <DirectMailTypeEntity>, IEnumerable <DirectMailType> >(entities);
return(directMailTypes.OrderBy(x => x.DateModified).ToArray());
}
}
private IEnumerable <CampaignAssignment> Get(IRelationPredicateBucket expressionBucket)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var entities = new EntityCollection <CampaignAssignmentEntity>();
adapter.FetchEntityCollection(entities, expressionBucket);
var campaignAssignment = Mapper.Map <IEnumerable <CampaignAssignmentEntity>, IEnumerable <CampaignAssignment> >(entities);
return(campaignAssignment.ToArray());
}
}
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;
}
/// <summary>
/// Returns number of entities after filterBucket is applied.
/// If you need number of all entities send null as filterBucket.
/// </summary>
public static int GetNumberOfEntities(DataAccessAdapterBase adapter,
IRelationPredicateBucket filterBucket)
{
EntityCollection entityCollection = new EntityCollection(new ErrorEntityFactory());
return adapter.GetDbCount(entityCollection, filterBucket);
}
internal static IRelationPredicateBucket ConvertStringToRelationPredicateBucket(TypedListType typedListType, IRelationPredicateBucket predicateBucket, string filterStr)
{
if (string.IsNullOrEmpty(filterStr))
return predicateBucket;
var inferredRelationsList = new List<IEntityRelation>();
var predicate = ConvertStringToPredicate(s => GetField(typedListType, s), null, filterStr, inferredRelationsList);
if (inferredRelationsList.Count > 0)
predicateBucket.Relations.AddRange(inferredRelationsList);
if (predicate != null)
predicateBucket.PredicateExpression.Add(predicate);
return predicateBucket;
}
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;
}
private static EntityCollection LoadProductsForSection(IRelationPredicateBucket filter)
{
EntityCollection products = new EntityCollection(new ProductEntityFactory());
ISortExpression sorter = new SortExpression();
sorter.Add(SortClauseFactory.Create(ProductFieldIndex.SortIndex, SortOperator.Ascending));
IPrefetchPath2 pfVariations = new PrefetchPath2((int)EntityType.ProductEntity);
pfVariations.Add(ProductEntity.PrefetchPathProductVariation);
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
adapter.FetchEntityCollection(products, filter, 0, sorter, pfVariations);
}
return products;
}
