Esempio n. 1
0
        private EntitySchemaQuery GetCFSchemaDataEsq(EntitySchema modelRootSchema, string cfColumnPath,
                                                     string filterData)
        {
            EntitySchema cfColumnSchema = modelRootSchema.GetSchemaColumnByPath(cfColumnPath).ReferenceSchema;
            var          esq            = new EntitySchemaQuery(cfColumnSchema);

            esq.PrimaryQueryColumn.IsAlwaysSelect = true;
            var converter = new FilterEditConverter(UserConnection);
            IEntitySchemaQueryFilterItem filter = converter.ConvertToEntitySchemaQueryFilterItem(esq, Owner,
                                                                                                 filterData);

            if (!filter.GetFilterInstances().IsEmpty())
            {
                esq.Filters.Add(filter);
            }
            return(esq);
        }
Esempio n. 2
0
        /// <summary>
        /// Returns true when search data has filters and filters aren't disabled.
        /// </summary>
        /// <param name="schemaName">Root schema name.</param>
        /// <param name="searchData">Folder search data.</param>
        /// <param name="userConnection">User connection.</param>
        /// <returns>True when search data has filter.</returns>
        public virtual bool CheckSearchDataHasFilter(string schemaName, byte[] searchData,
                                                     UserConnection userConnection)
        {
            if (searchData == null || searchData.Length == 0)
            {
                return(false);
            }
            var foldersQuery = new EntitySchemaQuery(userConnection.EntitySchemaManager, schemaName);
            IEntitySchemaQueryFilterItem filters = CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection,
                                                                                                       searchData, foldersQuery.RootSchema.UId);

            CommonUtilities.DisableEmptyEntitySchemaQueryFilters(new [] { filters });
            if (!filters.GetFilterInstances().Any())
            {
                return(false);
            }
            return(true);
        }
        private Select GetSelectByFilterData(UserConnection userConnection, byte[] filterEditData,
                                             string rootSchemaName, string customPrefix)
        {
            EntitySchema entitySchema            = userConnection.EntitySchemaManager.GetInstanceByName(rootSchemaName);
            IEntitySchemaQueryFilterItem filters = CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection,
                                                                                                       filterEditData, entitySchema.UId, customPrefix);
            var esq = GetEntitySchemaQuery(customPrefix, entitySchema);

            if (filters.GetFilterInstances().IsEmpty())
            {
                return(esq.GetSelectQuery(userConnection));
            }
            esq.Filters.Add(CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection,
                                                                                filterEditData, entitySchema.UId, customPrefix));
            Select esqSelect = esq.GetSelectQuery(userConnection);

            return(esqSelect);
        }