Пример #1
1
        public EntityCollection<CatalogsEntity> GetAllParent(SortExpression sort)
        {
            EntityCollection<CatalogsEntity> cats = new EntityCollection<CatalogsEntity>();

            SortExpression _sort = new SortExpression();
            if (sort != null)
            {
                _sort = sort;
            }
            else
            {
                _sort.Add(CatalogsFields.CatalogName | SortOperator.Ascending);
            }

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(CatalogsFields.ParentId == 0);
            predicate.AddWithAnd(CatalogsFields.IsVisible == true);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(cats, filter, 0, _sort);
            }

            return cats;
        }
Пример #2
0
        public AdminSitesCollection GetAdminSites(int siteUserGuid)
        {
            MCB.MasterPiece.Data.CollectionClasses.AdminSitesCollection adminSites = new AdminSitesCollection();

            IRelationCollection relations = new RelationCollection();

            relations.Add(AdminSitesEntity.Relations.AdminSiteModuleEntityUsingSiteGuid);
            relations.Add(AdminSiteModuleEntity.Relations.AdminUserAccessEntityUsingSiteModuleGuid);
            relations.Add(AdminUserAccessEntity.Relations.AdminUserEntityUsingUserGuid);

            IPredicateExpression filter = new PredicateExpression();

            filter.Add(AdminUserAccessFields.UserGuid == siteUserGuid);
            filter.AddWithAnd(AdminSitesFields.AccountingMarkAsInactive != 1);

            IPredicateExpression sensitiveDataFilter = new PredicateExpression();

            sensitiveDataFilter.Add(AdminUserFields.HasAccessToSitesWithSensitiveData == 1);
            sensitiveDataFilter.AddWithOr(AdminSitesFields.SiteContainsSensitiveData == 0);
            filter.AddWithAnd(sensitiveDataFilter);

            ISortExpression sort = new SortExpression();

            sort.Add(AdminSitesFields.CostumerFullname | SortOperator.Ascending);

            adminSites.GetMulti(filter, 0, sort, relations);

            return(adminSites);
        }
Пример #3
0
        /// <summary>
        /// Creates the attachment filter. The filter filters on attachments with the specified approvalstate in the threads viewable by the calling user.
        /// </summary>
        /// <param name="accessableForums">The accessable forums.</param>
        /// <param name="forumsWithApprovalRight">The forums with approval right.</param>
        /// <param name="forumsWithThreadsFromOthers">The forums with threads from others.</param>
        /// <param name="userID">The user ID.</param>
        /// <param name="filter">The filter.</param>
        /// <returns>ready to use predicate expression for fetch actions on attachments with the approval state specified in the threads
        /// matching the forumID's.</returns>
        private static PredicateExpression CreateAttachmentFilter(List <int> accessableForums, List <int> forumsWithApprovalRight,
                                                                  List <int> forumsWithThreadsFromOthers, int userID, bool approvalState)
        {
            PredicateExpression filter = new PredicateExpression();

            // specify the filter for the accessable forums. Do this by a fieldcomparerange predicate and filter on Thread.ForumID. As 'accessableForums' is a list
            // the following statement will create a fieldcomparerange predicate for us.
            if (accessableForums.Count == 1)
            {
                // optimization, specify the only value instead of the range, so we won't get a WHERE Field IN (@param) query which is slow on some
                // databases, but we'll get a WHERE Field == @param
                filter.Add(ThreadFields.ForumID == accessableForums[0]);
            }
            else
            {
                filter.Add(ThreadFields.ForumID == accessableForums);
            }
            // specify the filter for the forums with approval rights:
            if (forumsWithApprovalRight.Count == 1)
            {
                // optimization, specify the only value instead of the range, so we won't get a WHERE Field IN (@param) query which is slow on some
                // databases, but we'll get a WHERE Field == @param
                filter.Add(ThreadFields.ForumID == forumsWithApprovalRight[0]);
            }
            else
            {
                filter.Add(ThreadFields.ForumID == forumsWithApprovalRight);
            }
            // Also filter on the threads viewable by the passed in userid, which is the caller of the method. If a forum isn't in the list of
            // forumsWithThreadsFromOthers, only the sticky threads and the threads started by userid should be counted / taken into account.
            filter.AddWithAnd(ThreadGuiHelper.CreateThreadFilter(forumsWithApprovalRight, userID));
            // as last filter, we'll add a filter to only get the data for attachments which aren't approved yet.
            filter.AddWithAnd(AttachmentFields.Approved == false);
            return(filter);
        }
 public MembershipEntity GetMember(string uName, string password)
 {
     MembershipCollection memberships = new MembershipCollection();
     PredicateExpression filter = new PredicateExpression();
     filter.AddWithAnd(MembershipFields.UserName == uName);
     filter.AddWithAnd(MembershipFields.Password == Business.Encryption.SHA1Encryption.EncryptMessage(password));
     filter.AddWithAnd(MembershipFields.Status == true);
     memberships.GetMulti(filter);
     if (memberships.Count > 0)
         return memberships.FirstOrDefault();
     else
         return null;
 }
 /// <summary>
 /// Handles the Click event of the btnSearchPK 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 btnSearchPk_Click(object sender, EventArgs e)
 {
     if (!Page.IsValid)
     {
         return;
     }
     _filter = new PredicateExpression();
     _filter.AddWithAnd(CustomerCustomerDemoFields.CustomerId == (System.String)Convert.ChangeType(tbxCustomerId.Text, typeof(System.String)));
     _filter.AddWithAnd(CustomerCustomerDemoFields.CustomerTypeId == (System.String)Convert.ChangeType(tbxCustomerTypeId.Text, typeof(System.String)));
     if ((SearchClicked != null) && (_filter.Count > 0))
     {
         SearchClicked(this, new EventArgs());
     }
 }
 /// <summary>
 /// Handles the Click event of the btnSearchPK 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 btnSearchPk_Click(object sender, EventArgs e)
 {
     if (!Page.IsValid)
     {
         return;
     }
     _filter = new PredicateExpression();
     _filter.AddWithAnd(OrderDetailFields.OrderId == (System.Int32)Convert.ChangeType(tbxOrderId.Text, typeof(System.Int32)));
     _filter.AddWithAnd(OrderDetailFields.ProductId == (System.Int32)Convert.ChangeType(tbxProductId.Text, typeof(System.Int32)));
     if ((SearchClicked != null) && (_filter.Count > 0))
     {
         SearchClicked(this, new EventArgs());
     }
 }
 /// <summary>
 /// Handles the Click event of the btnSearchPK 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 btnSearchPk_Click(object sender, EventArgs e)
 {
     if (!Page.IsValid)
     {
         return;
     }
     _filter = new PredicateExpression();
     _filter.AddWithAnd(EmployeeTerritoryFields.EmployeeId == (System.Int32)Convert.ChangeType(tbxEmployeeId.Text, typeof(System.Int32)));
     _filter.AddWithAnd(EmployeeTerritoryFields.TerritoryId == (System.String)Convert.ChangeType(tbxTerritoryId.Text, typeof(System.String)));
     if ((SearchClicked != null) && (_filter.Count > 0))
     {
         SearchClicked(this, new EventArgs());
     }
 }
Пример #8
0
        /// <summary>
        /// Removes all users which ID's are stored in UsersToRemove, from the role with ID RoleID.
        /// </summary>
        /// <param name="userIDsToRemove">ArrayList with UserIDs of the users to Remove</param>
        /// <param name="roleID">ID of role the users will be removed from</param>
        /// <returns>true if succeeded, false otherwise</returns>
        public static bool RemoveUsersFromRole(List <int> userIDsToRemove, int roleID)
        {
            if (userIDsToRemove.Count <= 0)
            {
                return(true);
            }

            // we'll delete all role-user combinations for the users in the given range plus for the given role.
            // if there's just one user, we'll use an optimization, as the range query will result in an IN (param, param... ) query,
            // and an field IN (param) query, is much slower compared to field = param, at least on Sqlserver.

            // produce the filter which will be used to filter out the entities to delete.
            PredicateExpression filter = new PredicateExpression();

            if (userIDsToRemove.Count == 1)
            {
                // use compare value predicate instead
                filter.Add((RoleUserFields.UserID == userIDsToRemove[0]));
            }
            else
            {
                // add a range filter
                filter.Add((RoleUserFields.UserID == userIDsToRemove));
            }
            // add the filter for the role as with AND.
            filter.AddWithAnd((RoleUserFields.RoleID == roleID));

            // delete the entities directly from the database. As this gives a single DELETE statement, we don't have to start a transaction manually.
            RoleUserCollection roleUsers = new RoleUserCollection();

            return(roleUsers.DeleteMulti(filter) > 0);
        }
Пример #9
0
        public static Double GetPurchases(Boolean sinceInception)
        {
            PurchaseHistoryCollection purchaseHistoryCollection = new PurchaseHistoryCollection();

            try
            {
                Decimal totalPurchases = 0;
                if (!sinceInception)
                {
                    PredicateExpression filter = new PredicateExpression(PurchaseHistoryFields.PurchaseTime >= DateTime.Now.Date);
                    filter.AddWithAnd(PurchaseHistoryFields.PurchaseTime < DateTime.Now.Date.AddDays(1));
                    purchaseHistoryCollection.GetMulti(filter);
                }
                purchaseHistoryCollection.GetMulti(null);
                foreach (PurchaseHistoryEntity ece in purchaseHistoryCollection)
                {
                    totalPurchases = totalPurchases + ece.AmountPaid;
                }
                return((Double)totalPurchases);
            }
            catch
            {
                return(0.00);
            }
        }
Пример #10
0
        public virtual EntityCollection <ExcludeMatchDateEntity> GetExcludedDates(DateTime queryDate, long?tournamentId,
                                                                                  long?roundId, long?teamId)
        {
            var filter = new RelationPredicateBucket();

            var scopeFilter = new PredicateExpression();

            // Condition 1: excluded on tournament level
            if (tournamentId != null)
            {
                scopeFilter.AddWithOr(ExcludeMatchDateFields.TournamentId == tournamentId);
            }

            // Condition 2: OR excluded on round level
            if (roundId != null)
            {
                scopeFilter.AddWithOr(ExcludeMatchDateFields.RoundId == roundId);
            }

            // Condition 3: OR excluded on team level
            if (teamId != null)
            {
                scopeFilter.AddWithOr(ExcludeMatchDateFields.TeamId == teamId);
            }

            filter.PredicateExpression.Add(scopeFilter);

            // Condition 4: AND date between from/to dates (including limiting dates)
            var dateFilter = new PredicateExpression();

            dateFilter.AddWithAnd(ExcludeMatchDateFields.DateFrom <= queryDate.Date);
            dateFilter.AddWithAnd(ExcludeMatchDateFields.DateTo >= queryDate.Date);
            filter.PredicateExpression.Add(dateFilter);

            var excluded = new EntityCollection <ExcludeMatchDateEntity>(new ExcludeMatchDateEntityFactory());

            using (var da = _appDb.DbContext.GetNewAdapter())
            {
                da.FetchEntityCollection(excluded, filter);
                da.CloseConnection();
            }

            //(return adapter.GetDbCount(new ExcludeMatchDateEntityFactory().CreateFields(), filter) == 0);

            return(excluded);
        }
        public SourceCodeOrderDetail GetForSourceCodeIdAndOrderDetailId(long sourceCodeId, long orderDetailId)
        {
            IPredicateExpression predicateExpression =
                new PredicateExpression(SourceCodeOrderDetailFields.OrderDetailId == orderDetailId);

            predicateExpression.AddWithAnd(SourceCodeOrderDetailFields.SourceCodeId == sourceCodeId);
            return(GetByPredicate(predicateExpression).SingleOrDefault());
        }
    /// <summary>
    /// Creates a predicate expression filter based on the query string passed in.
    /// </summary>
    /// <param name="queryString">The query string with PK field names and values.</param>
    /// <returns>a predicate expression with a filter on the pk fields and values.</returns>
    public PredicateExpression CreateFilter(NameValueCollection queryString)
    {
        PredicateExpression toReturn = new PredicateExpression();
        string valueFromQueryString  = null;

        valueFromQueryString = queryString["EmployeeId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(EmployeeTerritoryFields.EmployeeId == (System.Int32)Convert.ChangeType(valueFromQueryString, typeof(System.Int32)));
        }
        valueFromQueryString = queryString["TerritoryId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(EmployeeTerritoryFields.TerritoryId == (System.String)Convert.ChangeType(valueFromQueryString, typeof(System.String)));
        }

        return(toReturn);
    }
    /// <summary>
    /// Creates a predicate expression filter based on the query string passed in.
    /// </summary>
    /// <param name="queryString">The query string with PK field names and values.</param>
    /// <returns>a predicate expression with a filter on the pk fields and values.</returns>
    public PredicateExpression CreateFilter(NameValueCollection queryString)
    {
        PredicateExpression toReturn = new PredicateExpression();
        string valueFromQueryString  = null;

        valueFromQueryString = queryString["CustomerId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(CustomerCustomerDemoFields.CustomerId == (System.String)Convert.ChangeType(valueFromQueryString, typeof(System.String)));
        }
        valueFromQueryString = queryString["CustomerTypeId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(CustomerCustomerDemoFields.CustomerTypeId == (System.String)Convert.ChangeType(valueFromQueryString, typeof(System.String)));
        }

        return(toReturn);
    }
        public MembershipEntity GetMember(string uName, string password)
        {
            MembershipCollection memberships = new MembershipCollection();
            PredicateExpression  filter      = new PredicateExpression();

            filter.AddWithAnd(MembershipFields.UserName == uName);
            filter.AddWithAnd(MembershipFields.Password == Business.Encryption.SHA1Encryption.EncryptMessage(password));
            filter.AddWithAnd(MembershipFields.Status == true);
            memberships.GetMulti(filter);
            if (memberships.Count > 0)
            {
                return(memberships.FirstOrDefault());
            }
            else
            {
                return(null);
            }
        }
    /// <summary>
    /// Creates a predicate expression filter based on the query string passed in.
    /// </summary>
    /// <param name="queryString">The query string with PK field names and values.</param>
    /// <returns>a predicate expression with a filter on the pk fields and values.</returns>
    public PredicateExpression CreateFilter(NameValueCollection queryString)
    {
        PredicateExpression toReturn = new PredicateExpression();
        string valueFromQueryString  = null;

        valueFromQueryString = queryString["OrderId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(OrderDetailFields.OrderId == (System.Int32)Convert.ChangeType(valueFromQueryString, typeof(System.Int32)));
        }
        valueFromQueryString = queryString["ProductId"];
        if (valueFromQueryString != null)
        {
            toReturn.AddWithAnd(OrderDetailFields.ProductId == (System.Int32)Convert.ChangeType(valueFromQueryString, typeof(System.Int32)));
        }

        return(toReturn);
    }
Пример #16
0
        public AdminUserEntity GetAdminUser(int userGuid)
        {
            var filter = new PredicateExpression();

            filter.AddWithAnd(AdminUserFields.UserGuid == userGuid);
            var userCollection = new AdminUserCollection();

            userCollection.GetMulti(filter);
            return(userCollection.FirstOrDefault());
        }
        /// <summary>
        /// Returns valid entities which are valid for given moment in time.
        /// Valid entities have:
        /// 1. Begining is not NULL AND is LESS than given moment in time.
        /// 2. End is NULL OR is GREATER OR EQUAL than given moment in time.
        /// </summary>
        public static PredicateExpression FilterValidEntities(DateTime momentInTime,
            EntityField2 validFromDateTimeField,
            EntityField2 validToDateTimeField)
        {
            PredicateExpression predicateExpression = new PredicateExpression();
            predicateExpression.Add(validFromDateTimeField != DBNull.Value & validFromDateTimeField <= momentInTime);
            predicateExpression.AddWithAnd(validToDateTimeField == DBNull.Value | validToDateTimeField >= momentInTime);

            return predicateExpression;
        }
Пример #18
0
        private static IPredicate BuildPredicateTree(Func <string, IEntityField2> fieldGetter, Func <string, List <IEntityRelation>, IEntityField2> relatedFieldGetter, FilterNode filterNode, List <IEntityRelation> inferredRelationsList)
        {
            if (filterNode.NodeCount > 0)
            {
                if (filterNode.NodeType == FilterNodeType.Root && filterNode.Nodes.Count > 0)
                {
                    if (filterNode.NodeCount == 1)
                    {
                        return(BuildPredicateTree(fieldGetter, relatedFieldGetter, filterNode.Nodes[0], inferredRelationsList));
                    }

                    var predicate = new PredicateExpression();
                    foreach (var childNode in filterNode.Nodes)
                    {
                        var newPredicate = BuildPredicateTree(fieldGetter, relatedFieldGetter, childNode, inferredRelationsList);
                        if (newPredicate != null)
                        {
                            predicate.AddWithAnd(newPredicate);
                        }
                    }
                    return(predicate);
                }
                else if (filterNode.NodeType == FilterNodeType.AndExpression ||
                         filterNode.NodeType == FilterNodeType.OrExpression)
                {
                    var predicate = new PredicateExpression();
                    foreach (var childNode in filterNode.Nodes)
                    {
                        var newPredicate = BuildPredicateTree(fieldGetter, relatedFieldGetter, childNode, inferredRelationsList);
                        if (newPredicate != null)
                        {
                            if (filterNode.NodeType == FilterNodeType.OrExpression)
                            {
                                predicate.AddWithOr(newPredicate);
                            }
                            else
                            {
                                predicate.AddWithAnd(newPredicate);
                            }
                        }
                    }
                    return(predicate);
                }
            }
            else if (filterNode.ElementCount > 0)
            {
                // convert elements to IPredicate
                var nodePredicate = BuildPredicateFromClauseNode(fieldGetter, relatedFieldGetter, filterNode, inferredRelationsList);
                if (nodePredicate != null)
                {
                    return(nodePredicate);
                }
            }
            return(null);
        }
Пример #19
0
        public AdminUserCollection GetAdminUserCollection(SiteAdminTypeEnum adminSiteType, string userName, string email, string token)
        {
            var userCollection = new AdminUserCollection();

            if (string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(email) && string.IsNullOrEmpty(token))
            {
                return(userCollection);
            }

            var filter    = new PredicateExpression();
            var relations = new RelationCollection();

            if (adminSiteType == SiteAdminTypeEnum.Accumolo)
            {
                relations.Add(AdminUserEntityBase.Relations.AdminUserAccessEntityUsingUserGuid);
                relations.Add(AdminUserAccessEntityBase.Relations.AdminSiteModuleEntityUsingSiteModuleGuid);
                relations.Add(AdminSiteModuleEntityBase.Relations.AdminSitesEntityUsingSiteGuid);
                filter.AddWithAnd(AdminSitesFields.AccountingMarkAsInactive != 1);
            }
            else if (adminSiteType == SiteAdminTypeEnum.Management)
            {
                filter.Add(AdminUserFields.UserManagementAccess == true);
            }

            if (!string.IsNullOrEmpty(userName))
            {
                filter.AddWithAnd(AdminUserFields.UserName == userName);
            }
            if (!string.IsNullOrEmpty(email))
            {
                filter.AddWithAnd(AdminUserFields.UserEmail == email);
            }
            if (!string.IsNullOrEmpty(token))
            {
                filter.AddWithAnd(AdminUserFields.UserPasswordResetToken == token);
                filter.AddWithAnd(AdminUserFields.TokenExpiration >= DateTime.Now);
            }

            userCollection.GetMulti(filter, relations);
            return(userCollection);
        }
Пример #20
0
        public static EntityCollection <GroupRecordPermissionEntity> GetGroupPermissions(int groupUID, int entityTypeGUID, int uID)
        {
            //User Entity Type 2
            EntityCollection <GroupRecordPermissionEntity> l_coll = new EntityCollection <GroupRecordPermissionEntity>();

            //Create filter for GUID's
            IPredicateExpression l_filter = new PredicateExpression();

            l_filter.Add(GroupRecordPermissionFields.RecordUID == uID);
            l_filter.AddWithAnd(GroupRecordPermissionFields.EntityTypeGUID == entityTypeGUID);
            l_filter.AddWithAnd(GroupRecordPermissionFields.GroupUID == groupUID);
            //Add to a bucket
            RelationPredicateBucket l_bucket = new RelationPredicateBucket(l_filter);
            //Retreive data
            DataAccessAdapter l_daa = new DataAccessAdapter();

            l_daa.FetchEntityCollection(l_coll, l_bucket);


            return(l_coll);
        }
Пример #21
0
        public static int GetDaysSupportRequests()
        {
            SupportIssueCollection supportIssueCollection = new SupportIssueCollection();

            try
            {
                PredicateExpression filter = new PredicateExpression(SupportIssueFields.CreateTime >= DateTime.Now.Date);
                filter.AddWithAnd(SupportIssueFields.CreateTime < DateTime.Now.Date.AddDays(1));
                return(supportIssueCollection.GetDbCount(filter));
            }
            catch
            {
                return(0);
            }
        }
Пример #22
0
        public static int GetActiveDevices()
        {
            DeviceCollection ecDeviceCollection = new DeviceCollection();

            try
            {
                PredicateExpression filter = new PredicateExpression(DeviceFields.LastReportTime >= DateTime.Now.Date);
                filter.AddWithAnd(DeviceFields.LastReportTime < DateTime.Now.Date.AddDays(1));
                return(ecDeviceCollection.GetDbCount(filter));
            }
            catch
            {
                return(0);
            }
        }
Пример #23
0
        public static Int64 GetDaysExceptions()
        {
            ExceptionLogCollection exceptionLogCollection = new ExceptionLogCollection();

            try
            {
                PredicateExpression filter = new PredicateExpression(ExceptionLogFields.ReceivedTime >= DateTime.Now.Date);
                filter.AddWithAnd(ExceptionLogFields.ReceivedTime < DateTime.Now.Date.AddDays(1));
                return(exceptionLogCollection.GetDbCount(filter));
            }
            catch
            {
                return(0L);
            }
        }
        public Auction.Domain.Bidder GetByNumberAndEvent(int number, long eventId, ref IAuctionTransaction trans)
        {
            using(var records = new BidderCollection())
            {
                var filter = new PredicateExpression(BidderFields.EventId == eventId);
                filter.AddWithAnd(BidderFields.Number == number);

                if(trans != null)
                {
                    trans.Add(records);
                }
                records.GetMulti(filter, 1);
                var b = records.ToList().FirstOrDefault();
                return new Bidder() { Id = b.Id, Number = number, Name = b.Name, EventId = eventId, Phone = b.Phone };
            }
        }
Пример #25
0
        /// <summary>
        /// Gets the matches (<see cref="PlannedMatchRow"/>s) for a venue, which are occupied within the given <see cref="DateTimePeriod"/> of a tournament.
        /// </summary>
        /// <param name="venueId"></param>
        /// <param name="searchPeriod"></param>
        /// <param name="tournamentId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns>Returns the matches (<see cref="PlannedMatchRow"/>s) for a venue, which are occupied within the given <see cref="DateTimePeriod"/> of a tournament.</returns>
        public virtual async Task <List <PlannedMatchRow> > GetOccupyingMatchesAsync(long venueId, DateTimePeriod searchPeriod, long tournamentId, CancellationToken cancellationToken)
        {
            using var da = _dbContext.GetNewAdapter();
            var metaData = new LinqMetaData(da);

            var matchIds = await(from m in metaData.Match
                                 where m.Round.TournamentId == tournamentId && m.VenueId == venueId && !m.IsComplete && m.PlannedStart.HasValue && m.PlannedEnd.HasValue &&
                                 (m.PlannedStart <= searchPeriod.End && searchPeriod.Start <= m.PlannedEnd) // overlapping periods
                                 select m.Id).ExecuteAsync <List <long> >(cancellationToken);

            var filter = new PredicateExpression(PlannedMatchFields.TournamentId == tournamentId);

            filter.AddWithAnd(PlannedMatchFields.Id.In(matchIds));
            return(matchIds.Count > 0
                ? await new MatchRepository(_dbContext).GetPlannedMatchesAsync(filter, cancellationToken)
                : new List <PlannedMatchRow>());
        }
Пример #26
0
        public DocumentEntity GetByID(Guid ID)
        {
            EntityCollection<DocumentEntity> items = new EntityCollection<DocumentEntity>();

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(DocumentFields.Id == ID);
            predicate.AddWithAnd(DocumentFields.IsDeleted == false);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(items, filter);
            }

            if (items != null && items.Count > 0)
                return items[0];
            return null;
        }
Пример #27
0
        public CodeMarkEntity GetByCode(string code)
        {
            EntityCollection<CodeMarkEntity> items = new EntityCollection<CodeMarkEntity>();

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(CodeMarkFields.Code == code);
            predicate.AddWithAnd(CodeMarkFields.IsDeleted == false);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(items, filter);
            }

            if (items != null && items.Count > 0)
                return items[0];
            return null;
        }
Пример #28
0
        public bool IsExistsGroupName(string GroupName, string PositionId)
        {
            EntityCollection<AdvertsPositionEntity> items = new EntityCollection<AdvertsPositionEntity>();

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(AdvertsPositionFields.GroupName == GroupName);
            predicate.AddWithAnd(AdvertsPositionFields.PositionId == PositionId);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(items, filter);
            }

            if (items != null && items.Count > 0)
                return true;
            return false;
        }
Пример #29
0
        public IEnumerable <ShippingDetailOrderDetail> GetForOrderDetailId(long orderDetailId)
        {
            IPredicateExpression predicateExpression = new PredicateExpression(ShippingDetailOrderDetailFields.IsActive == true);

            predicateExpression.AddWithAnd(ShippingDetailOrderDetailFields.OrderDetailId == orderDetailId);
            var prefetchPath = new PrefetchPath2(EntityType.ShippingDetailOrderDetailEntity)
            {
                ShippingDetailOrderDetailEntity.PrefetchPathShippingDetail
            };

            var entityCollection            = new EntityCollection <ShippingDetailOrderDetailEntity>();
            IRelationPredicateBucket bucket = new RelationPredicateBucket(predicateExpression);

            using (var adapter = PersistenceLayer.GetDataAccessAdapter())
            {
                adapter.FetchEntityCollection(entityCollection, bucket, prefetchPath);
            }

            return(Mapper.MapMultiple(entityCollection).ToList());
        }
        /// <summary>
        /// Returns predicate which returns single (on none) entity for given moment in time.
        /// Vraća predikat koji filtrira jedan entitet koji je validan za dani momentInTime.
        /// </summary>
        /// <param name="setFilter">Additional filter which applies before datetime predicate.</param>
        public static PredicateExpression FilterValidEntities(DateTime momentInTime,
            EntityField2 validDateTimeField,
            IPredicateExpression setFilter)
        {
            PredicateExpression newSetFilter;

            if (null != setFilter)
            {
                newSetFilter = new PredicateExpression(setFilter);
                newSetFilter.AddWithAnd(validDateTimeField <= momentInTime);
            }
            else
            {
                newSetFilter = new PredicateExpression(validDateTimeField <= momentInTime);
            }

            PredicateExpression toReturn = new PredicateExpression();
            toReturn.Add(validDateTimeField <= momentInTime);
            toReturn.Add(new FieldCompareSetPredicate(validDateTimeField, null, validDateTimeField, null, SetOperator.GreaterEqualAll, newSetFilter));

            return toReturn;
        }
Пример #31
0
        public static Int64 GetScanCount(Boolean sinceInception)
        {
            //Random r = new Random();
            //Thread.Sleep(20);
            //Int64 Newvalue = r.Next();
            //return Newvalue;
            ScanHistoryCollection scanHistoryCollection = new ScanHistoryCollection();

            try
            {
                if (sinceInception)
                {
                    return((long)scanHistoryCollection.GetDbCount());
                }
                PredicateExpression filter = new PredicateExpression(ScanHistoryFields.ScanStartTime >= DateTime.Now.Date);
                filter.AddWithAnd(ScanHistoryFields.ScanStartTime < DateTime.Now.Date.AddDays(1));
                return(scanHistoryCollection.GetDbCount(filter));
            }
            catch
            {
                return(0L);
            }
        }
Пример #32
0
        /// <summary>
        /// Creates the thread filter. Filters on the threads viewable by the passed in userid, which is the caller of the method.
        /// If a forum isn't in the list of forumsWithThreadsFromOthers, only the sticky threads and the threads started by userid should
        /// be counted / taken into account.
        /// </summary>
        /// <param name="forumsWithThreadsFromOthers">The forums with threads from others.</param>
        /// <param name="userID">The user ID.</param>
        /// <returns>ready to use thread filter.</returns>
        internal static IPredicateExpression CreateThreadFilter(List <int> forumsWithThreadsFromOthers, int userID)
        {
            var threadFilter = new PredicateExpression();

            if ((forumsWithThreadsFromOthers != null) && (forumsWithThreadsFromOthers.Count > 0))
            {
                PredicateExpression onlyOwnThreadsFilter = new PredicateExpression();

                // accept only those threads who aren't in the forumsWithThreadsFromOthers list and which are either started by userID or sticky.
                // the filter on the threads not in the forums listed in the forumsWithThreadsFromOthers
                if (forumsWithThreadsFromOthers.Count == 1)
                {
                    // optimization, specify the only value instead of the range, so we won't get a WHERE Field IN (@param) query which is slow on some
                    // databases, but we'll get a WHERE Field == @param
                    // accept all threads which are in a forum located in the forumsWithThreadsFromOthers list
                    threadFilter.Add((ThreadFields.ForumID == forumsWithThreadsFromOthers[0]));
                    onlyOwnThreadsFilter.Add(ThreadFields.ForumID != forumsWithThreadsFromOthers[0]);
                }
                else
                {
                    // accept all threads which are in a forum located in the forumsWithThreadsFromOthers list
                    threadFilter.Add((ThreadFields.ForumID == forumsWithThreadsFromOthers));
                    onlyOwnThreadsFilter.Add(ThreadFields.ForumID != forumsWithThreadsFromOthers);
                }
                // the filter on either sticky or threads started by the calling user
                onlyOwnThreadsFilter.AddWithAnd((ThreadFields.IsSticky == true).Or(ThreadFields.StartedByUserID == userID));
                threadFilter.AddWithOr(onlyOwnThreadsFilter);
            }
            else
            {
                // there are no forums enlisted in which the user has the right to view threads from others. So just filter on
                // sticky threads or threads started by the calling user.
                threadFilter.Add((ThreadFields.IsSticky == true).Or(ThreadFields.StartedByUserID == userID));
            }
            return(threadFilter);
        }
Пример #33
0
        /// <summary>
        /// Removes all users which ID's are stored in UsersToRemove, from the role with ID RoleID.
        /// </summary>
        /// <param name="userIDsToRemove">ArrayList with UserIDs of the users to Remove</param>
        /// <param name="roleID">ID of role the users will be removed from</param>
        /// <returns>true if succeeded, false otherwise</returns>
        public static bool RemoveUsersFromRole(List<int> userIDsToRemove, int roleID)
        {
            if(userIDsToRemove.Count<=0)
            {
                return true;
            }

            // we'll delete all role-user combinations for the users in the given range plus for the given role.
            // if there's just one user, we'll use an optimization, as the range query will result in an IN (param, param... ) query,
            // and an field IN (param) query, is much slower compared to field = param, at least on Sqlserver.

            // produce the filter which will be used to filter out the entities to delete.
            PredicateExpression filter = new PredicateExpression();
            if(userIDsToRemove.Count == 1)
            {
                // use compare value predicate instead
                filter.Add((RoleUserFields.UserID == userIDsToRemove[0]));
            }
            else
            {
                // add a range filter
                filter.Add((RoleUserFields.UserID == userIDsToRemove));
            }
            // add the filter for the role as with AND.
            filter.AddWithAnd((RoleUserFields.RoleID == roleID));

            // delete the entities directly from the database. As this gives a single DELETE statement, we don't have to start a transaction manually.
            RoleUserCollection roleUsers = new RoleUserCollection();
            return (roleUsers.DeleteMulti(filter) > 0);
        }
        /// <summary>
        /// Za svaki član this.rules kolekcije kreira jedan Predicate.
        /// Ako je rules.Count == 0 vraća NULL
        /// </summary>
        /// <returns>PredicateExpression</returns>
        /// <param name="entityFieldsType">Ako se filtrira artikl onda typeof(ArtiklFields)</param>
		/// <param name="getEntityFieldTypeFunction">Funkcija prima string (EntityFields type name) a vraća tip. Ako se desi da se filtrira po entitetu vezanom na glavni entitet (RacunGlava.Partner) tada se koristi ova funkcija za dohvat EntityFieldsType preko refleksije.</param>
		public PredicateExpression KreirajPredicate(Type entityFieldsType, 
                                            Func<string, Type> getEntityFieldTypeFunction)
        {
            PredicateExpression toReturn = null;

            if (rules.Count() > 0)
            {
                toReturn = new PredicateExpression();

                foreach (JqGridFilterItem item in rules)
                {
                    Predicate predicateToAdd = JqGridFilter.KreirajPredikatIzJqGridFilterItem(entityFieldsType, item, getEntityFieldTypeFunction);
                    
                    if (predicateToAdd != null)
                    {
                        if (groupOp.ToUpper() == "AND")
                        {
                            toReturn.AddWithAnd(predicateToAdd);
                        }
                        else if (groupOp.ToUpper() == "OR")
                        {
                            toReturn.AddWithOr(predicateToAdd);
                        }
                    }
                }
            }

            return toReturn;
        }
Пример #35
0
        public EntityCollection<EventsEntity> GetEvents(string EventType)
        {
            EntityCollection<EventsEntity> items = new EntityCollection<EventsEntity>();

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(EventsFields.EventType == EventType);
            predicate.AddWithAnd(EventsFields.Approved == false);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            SortExpression sort = new SortExpression();
            sort.Add(EventsFields.CreatedDate | SortOperator.Descending);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(items, filter);
            }

            return items;
        }
Пример #36
0
		/// <summary>
		/// Creates the thread filter. Filters on the threads viewable by the passed in userid, which is the caller of the method. 
		/// If a forum isn't in the list of forumsWithThreadsFromOthers, only the sticky threads and the threads started by userid should 
		/// be counted / taken into account. 
		/// </summary>
		/// <param name="forumsWithThreadsFromOthers">The forums with threads from others.</param>
		/// <param name="userID">The user ID.</param>
		/// <returns>ready to use thread filter.</returns>
		internal static IPredicateExpression CreateThreadFilter(List<int> forumsWithThreadsFromOthers, int userID)
		{
			var threadFilter = new PredicateExpression();
			if((forumsWithThreadsFromOthers != null) && (forumsWithThreadsFromOthers.Count > 0))
			{
				PredicateExpression onlyOwnThreadsFilter = new PredicateExpression();

				// accept only those threads who aren't in the forumsWithThreadsFromOthers list and which are either started by userID or sticky.
				// the filter on the threads not in the forums listed in the forumsWithThreadsFromOthers
				if(forumsWithThreadsFromOthers.Count == 1)
				{
					// optimization, specify the only value instead of the range, so we won't get a WHERE Field IN (@param) query which is slow on some
					// databases, but we'll get a WHERE Field == @param
					// accept all threads which are in a forum located in the forumsWithThreadsFromOthers list 
					threadFilter.Add((ThreadFields.ForumID == forumsWithThreadsFromOthers[0]));
					onlyOwnThreadsFilter.Add(ThreadFields.ForumID != forumsWithThreadsFromOthers[0]);
				}
				else
				{
					// accept all threads which are in a forum located in the forumsWithThreadsFromOthers list 
					threadFilter.Add((ThreadFields.ForumID == forumsWithThreadsFromOthers));
					onlyOwnThreadsFilter.Add(ThreadFields.ForumID != forumsWithThreadsFromOthers);
				}
				// the filter on either sticky or threads started by the calling user
				onlyOwnThreadsFilter.AddWithAnd((ThreadFields.IsSticky == true).Or(ThreadFields.StartedByUserID == userID));
				threadFilter.AddWithOr(onlyOwnThreadsFilter);
			}
			else
			{
				// there are no forums enlisted in which the user has the right to view threads from others. So just filter on
				// sticky threads or threads started by the calling user.
				threadFilter.Add((ThreadFields.IsSticky == true).Or(ThreadFields.StartedByUserID == userID));
			}
			return threadFilter;
		}
Пример #37
0
        public void RemoveFromEvent(long donorId,
                                    long eventId,
                                    ref IAuctionTransaction trans)
        {
            using (var records = new AuctionEventDonorCollection())
            {
                var filter = new PredicateExpression { AuctionEventDonorFields.DonorId == donorId };
                filter.AddWithAnd(AuctionEventDonorFields.EventId == eventId);

                records.DeleteMulti(filter);
            }
        }
Пример #38
0
        public EntityCollection<CatalogsEntity> GetByParentIdNotId(int Id, int ParentId)
        {
            EntityCollection<CatalogsEntity> cats = new EntityCollection<CatalogsEntity>();

            SortExpression _sort = new SortExpression();
            _sort.Add(CatalogsFields.CatalogName | SortOperator.Ascending);

            IPredicateExpression predicate = new PredicateExpression();
            predicate.Add(CatalogsFields.ParentId == ParentId);
            predicate.AddWithAnd(CatalogsFields.Id != Id);

            RelationPredicateBucket filter = new RelationPredicateBucket();
            filter.PredicateExpression.Add(predicate);

            using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
            {
                adapter.FetchEntityCollection(cats, filter, 0, _sort);
            }

            return cats;
        }
        private static IPredicate BuildPredicateTree(Func<string, IEntityField2> fieldGetter, Func<string, List<IEntityRelation>, IEntityField2> relatedFieldGetter, FilterNode filterNode, List<IEntityRelation> inferredRelationsList)
        {
            if (filterNode.NodeCount > 0)
            {
                if (filterNode.NodeType == FilterNodeType.Root && filterNode.Nodes.Count > 0)
                {
                    if (filterNode.NodeCount == 1)
                        return BuildPredicateTree(fieldGetter, relatedFieldGetter, filterNode.Nodes[0], inferredRelationsList);

                    var predicate = new PredicateExpression();
                    foreach (var childNode in filterNode.Nodes)
                    {
                        var newPredicate = BuildPredicateTree(fieldGetter, relatedFieldGetter, childNode, inferredRelationsList);
                        if (newPredicate != null)
                            predicate.AddWithAnd(newPredicate);
                    }
                    return predicate;
                }
                else if (filterNode.NodeType == FilterNodeType.AndExpression ||
                    filterNode.NodeType == FilterNodeType.OrExpression)
                {
                    var predicate = new PredicateExpression();
                    foreach (var childNode in filterNode.Nodes)
                    {
                        var newPredicate = BuildPredicateTree(fieldGetter, relatedFieldGetter, childNode, inferredRelationsList);
                        if (newPredicate != null)
                        {
                            if (filterNode.NodeType == FilterNodeType.OrExpression)
                                predicate.AddWithOr(newPredicate);
                            else
                                predicate.AddWithAnd(newPredicate);
                        }
                    }
                    return predicate;
                }
            }
            else if (filterNode.ElementCount > 0)
            {
                // convert elements to IPredicate
                var nodePredicate = BuildPredicateFromClauseNode(fieldGetter, relatedFieldGetter, filterNode, inferredRelationsList);
                if (nodePredicate != null)
                    return nodePredicate;
            }
            return null;
        }