예제 #1
0
 public ColumnModel(string name, Type type)
 {
     Name         = name;
     DisplayName  = name;
     Type         = type;
     ColumnFilter = new ColumnFilter(Type);
 }
예제 #2
0
        private object GetValueField(ColumnFilter filter)
        {
            switch (filter.Type.Name)
            {
            case "Int16":
                return(filter.Value);

            case "Int32":
                return(filter.Value);

            case "Int64":
                return(filter.Value);

            case "String":
                return($"'{filter.Value}'");

            case "Decimal":
                return($"{filter.Value}");

            case "Double":
                return($"{filter.Value}");

            default:
                throw new Exception($"Tipo não mapeado {filter.Type}");
            }
        }
        public override IColumnFilter CreateColumnFilter(ColumnFilterStorage storage)
        {
            ColumnFilter columnFilter = new ColumnFilter();

            columnFilter.SetStorage(storage);
            return(columnFilter);
        }
예제 #4
0
        public bool HasFiltering()
        {
            bool ret = false;

            foreach (KeyValuePair <string, TextBox> entry in filtering_textBoxes.ToArray())
            {
                String  key = entry.Key;
                TextBox tb  = entry.Value;
                if (tb.Text != "")
                {
                    ret = true;
                }
            }

            // also check the internal filters (needed ???)
            foreach (KeyValuePair <string, ColumnFilter> entry in columnFilters)
            {
                String       key    = entry.Key;
                ColumnFilter filter = entry.Value;

                if (filter.FilterValue != "")
                {
                    ret = true;
                }
            }
            return(ret);
        }
예제 #5
0
        int DrawColumn(IDrawer2D drawer, string header, int columnI, int x, ColumnFilter filter)
        {
            int  y         = table.Y + 3;
            int  maxWidth  = table.ColumnWidths[columnI];
            bool separator = columnI > 0;

            DrawTextArgs args        = new DrawTextArgs(header, titleFont, true);
            TableEntry   headerEntry = default(TableEntry);

            DrawColumnEntry(drawer, ref args, maxWidth, x, ref y, ref headerEntry);
            maxIndex = table.Count;

            y += 5;
            for (int i = table.CurrentIndex; i < table.Count; i++)
            {
                TableEntry entry = table.Get(i);
                args = new DrawTextArgs(filter(entry), font, true);

                if ((i == table.SelectedIndex || entry.Featured) && !separator)
                {
                    int startY = y - 3;
                    int height = Math.Min(startY + (entryHeight + 4), table.Y + table.Height) - startY;
                    drawer.Clear(GetGridCol(entry.Featured, i == table.SelectedIndex), table.X, startY, table.Width, height);
                }
                if (!DrawColumnEntry(drawer, ref args, maxWidth, x, ref y, ref entry))
                {
                    maxIndex = i; break;
                }
            }
            if (separator && !game.ClassicBackground)
            {
                drawer.Clear(LauncherSkin.BackgroundCol, x - 7, table.Y, 2, table.Height);
            }
            return(maxWidth + 5);
        }
예제 #6
0
        public static void ClearStaticValues()
        {
            _Accounts              = null;
            _Columns               = null;
            _TweetTasks            = null;
            _BackgroundLoadColumns = null;

#if !BACKGROUND_AGENT
            _FollowMessageShown   = null;
            _ProtectedAccounts    = null;
            _Filters              = null;
            _GlobalFilter         = null;
            _RetweetAsMentions    = null;
            _TweetsPerRequest     = null;
            _DefaultMuteTime      = null;
            _Drafts               = null;
            _ReadLaterCredentials = null;
            _Background           = null;
            _FirstInit            = null;
            _FontSize             = null;
            _ReadPositions        = null;
            _RecoverReadPositions = null;
            _EnabledGeolocation   = null;
            _TweetGeotagging      = null;
            _BufferProfiles       = null;
            _BufferAccessToken    = null;
            _TrialStart           = null;
            _CouponCodeValidated  = null;
            _ReloadOptions        = null;
            _TopicPlace           = null;
            _TopicPlaceId         = null;
#endif
        }
예제 #7
0
        /// <summary>
        /// Update the internal filter
        /// </summary>
        /// <param name="textBox"></param>
        /// <param name="header"></param>
        private void UpdateFilter(TextBox textBox, DataGridColumnHeader header)
        {
            // Try to get the property bound to the column.
            // This should be stored as datacontext.
            string columnName = header.DataContext != null?
                                header.DataContext.ToString() : "";

            ColumnFilter filter;

            if (!columnFilters.TryGetValue(columnName, out filter))
            {
                var dataGridBoundColumn = header.Column as DataGridBoundColumn;
                if (dataGridBoundColumn != null)
                {
                    var binding = dataGridBoundColumn.Binding as Binding;
                    if (binding != null)
                    {
                        filter = new ColumnFilter
                        {
                            ColumnName    = columnName,
                            ColumnBinding = binding
                        };

                        columnFilters.Add(filter.ColumnName, filter);
                    }
                }
            }

            if (filter != null)
            {
                filter.FilterValue = textBox.Text;
            }
        }
예제 #8
0
        ///
        // private void remember_textbox_list(TextBox filterTextBox, DataGridColumnHeader header)
        // {
        //     int i = 9;
        //     List<TextBox> new_list = new List<TextBox>();/
        //
        //     m_filtertb.Add(filterTextBox);  //pestrela: clear filter feature
        //
        // }
        //


        public void ClearFiltering()
        {
            var a = filtering_textBoxes;

            // clear the text boxes
            foreach (KeyValuePair <string, TextBox> entry in filtering_textBoxes)
            {
                String  key          = entry.Key;
                TextBox tb           = entry.Value;
                String  old_contents = tb.Text;

                tb.Text = "";
            }

            // also clear the internal filters
            foreach (KeyValuePair <string, ColumnFilter> entry in columnFilters)
            {
                String       key    = entry.Key;
                ColumnFilter filter = entry.Value;

                filter.FilterValue = "";
            }

            ApplyFilters();
        }
예제 #9
0
        public void SetFilter(LogViewer.LogColumnType column, string pattern)
        {
            if (string.IsNullOrEmpty(pattern))
            {
                m_Filters[column] = s_MatchAllFilter;
                return;
            }

            var isNegated    = pattern.StartsWith(NegationPrefix) && pattern.Length > NegationPrefix.Length;
            var regexPattern = pattern;

            if (isNegated)
            {
                regexPattern = pattern.Substring(NegationPrefix.Length);
            }

            var access = MakeLineAccess(column);
            var regex  = new Regex(regexPattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
            var filter = new ColumnFilter(pattern, l =>
            {
                var isMatch = regex.IsMatch(access(l) ?? string.Empty);
                return(isNegated ? !isMatch : isMatch);
            });

            m_Filters[column] = filter;
        }
예제 #10
0
        public void SplitLineIntoColumn()
        {
            //columnfilter
            string line = "12/09/2020 , comment written";

            string[] columns      = ColumnFilter.ApplyColumnFilter(line, 0, 1);
            string[] actualColumn = line.Split(',');
            Assert.True(columns[0] == actualColumn[0] && columns[1] == actualColumn[1]);
        }
예제 #11
0
        /// <summary>
        /// Filters the grid based on tool.
        /// </summary>
        /// <param name="tool">The tool.</param>
        private void FilterGridBasedOnTool(RadialMenuTool tool)
        {
            string       key = tool.Key;
            CategoryType category;

            try
            {
                // get the CategoryType from the Tag
                if (tool.Tag is CategoryType)
                {
                    category = (CategoryType)tool.Tag;

                    // if the currentGridData is still the defualt data, bind the Inventory data to the grid
                    if (this.currentGridData == MainForm.DefaultGridData)
                    {
                        this.gridInventory.DataSource = AutoPartsCatalog.Instance.InventoryTable;
                        this.currentGridData          = UI.Inventory;
                    }

                    // apply a filter to the Category column based on the CategoryType
                    UltraGridBand band   = this.gridInventory.DisplayLayout.Bands["Inventory"];
                    ColumnFilter  filter = band.ColumnFilters["Category"];
                    if (filter.FilterConditions.Count > 0)
                    {
                        filter.FilterConditions[0].CompareValue = (int)category;
                    }
                    else
                    {
                        filter.FilterConditions.Add(FilterComparisionOperator.Equals, (int)category);
                    }

                    // add secondary filter to the Components column
                    filter = band.ColumnFilters["Component"];
                    if (string.IsNullOrEmpty(key) == false)
                    {
                        if (filter.FilterConditions.Count > 0)
                        {
                            filter.FilterConditions[0].CompareValue = key;
                        }
                        else
                        {
                            filter.FilterConditions.Add(FilterComparisionOperator.Equals, key);
                        }
                    }
                    else
                    {
                        filter.ClearFilterConditions();
                    }

                    this.ChangeHeader(category, key);
                }
            }
            finally
            {
                this.gridInventory.DisplayLayout.PerformAutoResizeColumns(false, PerformAutoSizeType.VisibleRows);
            }
        }
예제 #12
0
        public static FileImporter DetectFileType(string path)
        {
            if (path.ToLower().EndsWith(".sail"))
            {
                throw new Exception(@".sail files cannot be imported, use ""open"" instead.");
            }
            else if (path.ToLower().EndsWith(".gpx") /*&& ValidateXmlWithSchema(path, GpxImporter.GpxXsdUrl,GpxImporter.GpxXsdPath)*/)
            {
                GpxImporter gi = new GpxImporter();
                return(gi);
            }
            else if (path.ToLower().EndsWith(".kml") /*&& ValidateXmlWithSchema(path, KmlImporter.KmlXsdUrl, KmlImporter.KmlXsdPath)*/)
            {
                KmlImporter ki = new KmlImporter();
                return(ki);
            }
            else if (path.ToLower().EndsWith(".vcc"))
            {
                VccImporter vi = new VccImporter();
                return(vi);
            }
            else
            {
                StreamReader reader    = new StreamReader(path);
                string       firstLine = reader.ReadLine();
                reader.Close();

                if (firstLine.Contains(","))
                {
                    //possibly a csv format
                    char[]   splitter = new char[] { ',' };
                    string[] parts    = firstLine.Split(splitter);

                    if (parts[0].StartsWith("$") || parts[0].StartsWith("!"))
                    {
                        NmeaImporter ni = new NmeaImporter();
                        return(ni);
                    }
                    else
                    {
                        //csv format
                        List <string>    mappings = CsvImporter.AutoDetectColumnMappings(parts);
                        ColumnAssignment ca       = new ColumnAssignment(mappings, path);
                        ca.ShowDialog();
                        mappings = ca.ColumnMappings;
                        ColumnFilter cf = new ColumnFilter(ca.Filters, path, ca.SkipFirstRow);
                        CsvImporter  ci = new CsvImporter(mappings, cf.FilterValues, ca.SkipFirstRow);
                        return(ci);
                    }
                }
                else
                {
                    throw new Exception("Format Could not be determined");
                }
            }
        }
예제 #13
0
        public static void InitializeColumnInfo(IExplorerViewModel explorerModel)
        {
            explorerModel.FileList.Columns.ColumnList = new ColumnInfo[]
            {
                ColumnInfo.FromTemplate("Name", "GridLabelTemplate", "EntryModel.Label", new ValueComparer <IEntryModel>(p => p.Label), 200),
                ColumnInfo.FromBindings("Type", "EntryModel.Description", "", new ValueComparer <IEntryModel>(p => p.Description), 200),

                ColumnInfo.FromBindings("Time", "EntryModel.LastUpdateTimeUtc", "",
                                        new ValueComparer <IEntryModel>(p =>
                                                                        (p is DiskEntryModelBase) ? (p as DiskEntryModelBase).LastUpdateTimeUtc
                            : DateTime.MinValue), 200),

                ColumnInfo.FromTemplate("Size", "GridSizeTemplate", "",
                                        new ValueComparer <IEntryModel>(p =>
                                                                        (p is DiskEntryModelBase) ? (p as DiskEntryModelBase).Size
                        : 0), 200),

                ColumnInfo.FromBindings("FSI.Attributes", "EntryModel.Attributes", "",
                                        new ValueComparer <IEntryModel>(p =>
                                                                        (p is FileSystemInfoModel) ? (p as FileSystemInfoModel).Attributes
                            : System.IO.FileAttributes.Normal), 200)
            };

            explorerModel.FileList.Columns.ColumnFilters = new ColumnFilter[]
            {
                ColumnFilter.CreateNew <IEntryModel>("0 - 9", "EntryModel.Label", e => Regex.Match(e.Label, "^[0-9]").Success),
                ColumnFilter.CreateNew <IEntryModel>("A - H", "EntryModel.Label", e => Regex.Match(e.Label, "^[A-Ha-h]").Success),
                ColumnFilter.CreateNew <IEntryModel>("I - P", "EntryModel.Label", e => Regex.Match(e.Label, "^[I-Pi-i]").Success),
                ColumnFilter.CreateNew <IEntryModel>("Q - Z", "EntryModel.Label", e => Regex.Match(e.Label, "^[Q-Zq-z]").Success),
                ColumnFilter.CreateNew <IEntryModel>("The rest", "EntryModel.Label", e => Regex.Match(e.Label, "^[^A-Za-z0-9]").Success),
                ColumnFilter.CreateNew <IEntryModel>("Today", "EntryModel.LastUpdateTimeUtc", e =>
                {
                    DateTime dt = DateTime.UtcNow;
                    return(e.LastUpdateTimeUtc.Year == dt.Year &&
                           e.LastUpdateTimeUtc.Month == dt.Month &&
                           e.LastUpdateTimeUtc.Day == dt.Day);
                }),
                ColumnFilter.CreateNew <IEntryModel>("Earlier this month", "EntryModel.LastUpdateTimeUtc", e =>
                {
                    DateTime dt = DateTime.UtcNow;
                    return(e.LastUpdateTimeUtc.Year == dt.Year && e.LastUpdateTimeUtc.Month == dt.Month);
                }),
                ColumnFilter.CreateNew <IEntryModel>("Earlier this year", "EntryModel.LastUpdateTimeUtc", e =>
                {
                    DateTime dt = DateTime.UtcNow;
                    return(e.LastUpdateTimeUtc.Year == dt.Year);
                }),
                ColumnFilter.CreateNew <IEntryModel>("A long time ago", "EntryModel.LastUpdateTimeUtc", e =>
                {
                    DateTime dt = DateTime.UtcNow;
                    return(e.LastUpdateTimeUtc.Year != dt.Year);
                }),
                ColumnFilter.CreateNew <IEntryModel>("Directories", "EntryModel.Description", e => e.IsDirectory),
                ColumnFilter.CreateNew <IEntryModel>("Files", "EntryModel.Description", e => !e.IsDirectory)
            };
        }
예제 #14
0
        public async Task <IEnumerable <FilteredUser> > SearchAsync(int residenitalId, string name)
        {
            var columnsToFilter = ColumnFilter.GetNames <UserEf>(x => x.Name, x => x.LastName, x => x.Email);

            var entities = await _repository.AsNoTracking()
                           .Where(x => x.ResidentialId == residenitalId)
                           .Contains(name, columnsToFilter).ToListAsync();

            return(_mapper.Map <IEnumerable <FilteredUser> >(entities));
        }
예제 #15
0
        private void setFilter(string value)
        {
            _selectedFilter = value;

            FileList.ProcessedEntries.SetFilters(
                ColumnFilter.CreateNew <IEntryModel>(value, "FullPath",
                                                     e => e.IsDirectory ||
                                                     PathFE.MatchFileMasks(
                                                         e.Profile.Path.GetFileName(e.FullPath), value)));
            NotifyOfPropertyChange(() => SelectedFilter);
        }
예제 #16
0
 void updateFilters()
 {
     //if (All.Filter == null)
     All.Filter = (e) => e != null &&
                  CustomFilter(e) &&
                  ColumnFilter.Match(_colFilters, _filterObjectGetter((VM)e));
     //else
     //    All.Filter = (e) =>
     //        All.Filter(e) && CustomFilter(e) &&
     //        ColumnFilter.Match(_colFilters, (e as IEntryViewModel).EntryModel);
 }
예제 #17
0
        public ColumnFilter BuildStatement <TEntity>(string key, string value, StatementOperation operation = StatementOperation.Equals) where TEntity : BaseEntity
        {
            var baseTableName = this.queryBuilder.GetTableName <TEntity>();
            var result        = new ColumnFilter();

            result.KeyName = $"{baseTableName}.{key}";
            result.Filter  = this.statementBuilder[operation].Invoke(result.KeyName, $"@{result.Params.Count}");
            result.Params.Add(new SqlParameter($"@{result.Params.Count}", value));

            return(result);
        }
예제 #18
0
        private bool IntFilter(int value, string filterExpression, ColumnFilter column)
        {
            if (string.IsNullOrEmpty(filterExpression))
            {
                column.InvalidFilter = false;
                return(true);
            }

            filterExpression = StringHelper.RemoveAllWhitespace(filterExpression);
            int lenght = filterExpression.Length;
            int filterInt;

            if (int.TryParse(filterExpression, out filterInt))
            {
                column.InvalidFilter = false;
                return(filterInt == value);
            }
            else if (lenght > 2 && filterExpression.Contains('_'))
            {
                var parts = filterExpression.Split('_');
                if (parts.Length == 2)
                {
                    if (int.TryParse(parts[0], out int i1) && int.TryParse(parts[1], out int i2) && i1 < i2)
                    {
                        column.InvalidFilter = false;
                        return(value >= i1 && value <= i2);
                    }
                }
            }
            else if (filterExpression.StartsWith("<") && lenght > 1 && int.TryParse(filterExpression.Remove(0, 1), out filterInt))
            {
                column.InvalidFilter = false;
                return(value < filterInt);
            }
            else if (filterExpression.StartsWith("<=") && lenght > 2 && int.TryParse(filterExpression.Remove(0, 2), out filterInt))
            {
                column.InvalidFilter = false;
                return(value <= filterInt);
            }
            else if (filterExpression.StartsWith(">") && lenght > 1 && int.TryParse(filterExpression.Remove(0, 1), out filterInt))
            {
                column.InvalidFilter = false;
                return(value > filterInt);
            }
            else if (filterExpression.StartsWith(">=") && lenght > 2 && int.TryParse(filterExpression.Remove(0, 2), out filterInt))
            {
                column.InvalidFilter = false;
                return(value >= filterInt);
            }

            column.InvalidFilter = true;
            return(false);
        }
        private Statement GetDateTimeFilterClause(ColumnFilter filter)
        {
            var clauseParameters = new List <DBParameterKeyValue>();
            var clauseText       = string.Empty;

            for (var i = 0; i < filter.Values.Count(); i++)
            {
                var      currentValue = filter.Values.ElementAt(i);
                DateTime parsedValue;
                if (DateTime.TryParseExact(currentValue, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedValue) ||
                    DateTime.TryParseExact(currentValue, @"yyyy-MM-dd\THH:mm:ss\Z", CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedValue) ||
                    DateTime.TryParseExact(currentValue, "yyyy/MM/dd HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedValue))
                {
                    // Current format sample: '2019-05-14 14:44:39'
                    currentValue  = $"{parsedValue.Year.ToString("D4")}-{parsedValue.Month.ToString("D2")}-{parsedValue.Day.ToString("D2")}";
                    currentValue += $" {parsedValue.Hour.ToString("D2")}:{parsedValue.Minute.ToString("D2")}:{parsedValue.Second.ToString("D2")}";
                }
                if (i != 0)
                {
                    clauseText += filter.FilterMethod == FilterMethod.Including ? " OR " : " AND ";
                }

                if (filter.FilterRigor == FilterRigor.Contains)
                {
                    clauseText += $" CONVERT(varchar(19), {filter.Column.Name.SanitizeSQL()}, 20)";

                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += " NOT";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("DateTimeFilterValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $" LIKE '%' + {filterValueParameter.Key} + '%'";
                }
                else if (filter.FilterRigor == FilterRigor.Equals)
                {
                    clauseText += $" CONVERT(DATETIME, CONVERT(VARCHAR(19), {filter.Column.Name.SanitizeSQL()}, 20)) ";

                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += "!";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("DateTimeFilterValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $"= {filterValueParameter.Key}";
                }
            }

            return(new Statement(clauseText, clauseParameters));
        }
예제 #20
0
        public SLORMContext Filter(ColumnFilterRequest filterRequest)
        {
            if (filterRequest == null)
            {
                throw new ArgumentNullException(nameof(filterRequest));
            }

            var column = ColumnsInTable.GetFromName(filterRequest.ColumnName);

            if (column == null)
            {
                return(this);
            }

            // Filtering incorrect value formats
            if (filterRequest.FilterRigor == FilterRigor.Equals)
            {
                switch (column.DataType)
                {
                case ColumnDataType.Number:
                    double parsedValue;
                    foreach (var currentValue in filterRequest.Values)
                    {
                        if (!double.TryParse(currentValue, out parsedValue))
                        {
                            return(this);
                        }
                    }
                    break;

                case ColumnDataType.Date:
                    DateTime parsedDateValue;
                    foreach (var currentValue in filterRequest.Values)
                    {
                        if (!DateTime.TryParse(currentValue, out parsedDateValue))
                        {
                            return(this);
                        }
                    }
                    break;
                }
            }

            var columnToFilter = new ColumnFilter(column, filterRequest);

            ColumnsToFilter.Add(columnToFilter);

            return(this);
        }
예제 #21
0
        private static OperatorEnum GetOperator(this ColumnFilter filter)
        {
            OperatorEnum?result = null;

            switch (filter.Operation.ToLower())
            {
            case "equlas":
            case "equals":
                result = OperatorEnum.Equals;
                break;

            case "notEquals":
                result = OperatorEnum.NotEquals;
                break;

            case "lessthan":
                result = OperatorEnum.LessThan;
                break;

            case "greaterthan":
                result = OperatorEnum.GreaterThan;
                break;

            case "contains":
                result = OperatorEnum.Contains;
                break;

            case "notcontains":
                result = OperatorEnum.NotContains;
                break;

            case "startswith":
                result = OperatorEnum.StartsWith;
                break;

            case "endswith":
                result = OperatorEnum.EndsWith;
                break;

            default:
                result = null;
                break;
            }
            if (!result.HasValue)
            {
                throw new InvalidOperationException();
            }
            return(result.Value);
        }
예제 #22
0
        public string ParseFilter(ColumnFilter filter)
        {
            switch (filter.Type)
            {
            default:
            case FilterType.Equals:
                return($"{filter.Column} = '{filter.Value.ToString()}'");

            case FilterType.Like:
                return($"{filter.Column} LIKE '%{filter.Value.ToString()}%'");

            case FilterType.NotLike:
                return($"{filter.Column} NOT LIKE '%{filter.Value.ToString()}%'");
            }
        }
        public void ThrowExceptionIfColumnNumberIsOutOfRange(int expectedColumnNumber)
        {
            const string csvPath   = @"D:\a\review-case-s21b11\review-case-s21b11\sample-review\review-report.csv";
            var          checkPath = PathExistence.CheckFileExistOrNot(csvPath);

            if (checkPath)
            {
                var lines = System.IO.File.ReadAllLines(csvPath);
                Assert.Throws <System.IndexOutOfRangeException>(() => ColumnFilter.PrintCsvColumn(lines, expectedColumnNumber));
            }
            else
            {
                Assert.True(false);
            }
        }
        public async Task <PaginatedList <ExpenseCategory> > GetAllAsync(int residentialId, Parameter parameter)
        {
            var columnsToFilter = ColumnFilter.GetNames <ExpenseCategoryEf>(x => x.Name, x => x.Description);

            var query = _repository.AsNoTracking()
                        .Where(x => x.ResidentialId == residentialId)
                        .Contains(parameter.Filter, columnsToFilter).ApplySort(parameter.SortBy, parameter.IsSortDesc);

            var totalOfItems = await query.CountAsync();

            var entities = await query.Take(parameter.Page, parameter.ItemsPerPage).ToListAsync();

            var models = _mapper.Map <IEnumerable <ExpenseCategory> >(entities);

            return(new PaginatedList <ExpenseCategory>(models, totalOfItems));
        }
예제 #25
0
 private FrmMain ConfigureColumnFilter()
 {
     ColumnFilter = new ColumnFilter()
                    .ConfigureVisibility("DOCUMENTO", () => chkDocumento.Checked)
                    .ConfigureVisibility("DTNASC", () => chkDtNasc.Checked)
                    .ConfigureVisibility("NOME", () => chkNome.Checked)
                    .ConfigureVisibility("ENDERECO", () => chkEndereco.Checked)
                    .ConfigureVisibility("NUM", () => chkNumero.Checked)
                    .ConfigureVisibility("COMP", () => chkComplemento.Checked)
                    .ConfigureVisibility("BAIRRO", () => chkBairro.Checked)
                    .ConfigureVisibility("CIDADE", () => chkCidade.Checked)
                    .ConfigureVisibility("CEP", () => chkCep.Checked)
                    .ConfigureVisibility("PAI", () => chkPai.Checked)
                    .ConfigureVisibility("MAE", () => chkMae.Checked);
     return(this);
 }
예제 #26
0
        public async Task <PaginatedList <User> > GetAllAsync(int residenitalId, Parameter parameter)
        {
            var columnsToFilter = ColumnFilter.GetNames <UserEf>(x => x.Name, x => x.LastName, x => x.Email);

            var query = _repository.AsNoTracking()
                        .Where(x => x.ResidentialId == residenitalId)
                        .Include(x => x.Residential).Include(x => x.UserRoles).ThenInclude(x => x.Role)
                        .Contains(parameter.Filter, columnsToFilter).ApplySort(parameter.SortBy, parameter.IsSortDesc);

            var totalOfItems = await query.CountAsync();

            var entities = await query.Take(parameter.Page, parameter.ItemsPerPage).ToListAsync();

            var models = _mapper.Map <IEnumerable <User> >(entities);

            return(new PaginatedList <User>(models, totalOfItems));
        }
예제 #27
0
        public void FullConstructor_WhenValidArguments_ShouldReturnInstanceWithCorrectData()
        {
            // Arrange
            var column        = new TableColumn("columnName", Enums.ColumnDataType.Date);
            var valueToFilter = new List <string>()
            {
                "aa"
            };
            var filterRigor  = FilterRigor.Contains;
            var filterMethod = FilterMethod.Excluding;
            // Act
            var columnFilter = new ColumnFilter(column, valueToFilter, filterRigor, filterMethod);;

            // Assert
            Assert.Equal(column, columnFilter.Column);
            Assert.Equal(filterRigor, columnFilter.FilterRigor);
            Assert.Equal(filterMethod, columnFilter.FilterMethod);
        }
        private Statement GetNumberFilterClause(ColumnFilter filter)
        {
            var clauseParameters    = new List <DBParameterKeyValue>();
            var clauseText          = string.Empty;
            var sanitizedColumnName = filter.Column.Name.SanitizeSQL();

            for (var i = 0; i < filter.Values.Count(); i++)
            {
                var currentValue = filter.Values.ElementAt(i);
                if (i != 0)
                {
                    clauseText += filter.FilterMethod == FilterMethod.Including ? " OR " : " AND ";
                }

                if (filter.FilterRigor == FilterRigor.Contains)
                {
                    clauseText += $" CONVERT(varchar(64), {sanitizedColumnName})";

                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += " NOT";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("FilterNumberValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $" LIKE '%' + {filterValueParameter.Key} + '%'";
                }
                else if (filter.FilterRigor == FilterRigor.Equals)
                {
                    clauseText += $" {sanitizedColumnName} ";

                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += "!";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("FilterNumberValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $"= {filterValueParameter.Key}";
                }
            }

            return(new Statement(clauseText, clauseParameters));
        }
예제 #29
0
        /// <summary>
        /// Updates the header.
        /// </summary>
        private void UpdateHeader()
        {
            switch (this.ultraTabControl1.SelectedTab.Key)
            {
            case "SearchGrid":

                if (this.currentGridData == UI.Delivery)
                {
                    this.lblCurrent.Text  = Properties.Resources.PendingDeliveries;
                    this.lblPrevious.Text = string.Empty;
                    return;
                }

                CategoryType  category;
                UltraGridBand band   = this.gridInventory.DisplayLayout.Bands["Inventory"];
                ColumnFilter  filter = band.ColumnFilters["Category"];
                if (filter.FilterConditions.Count > 0)
                {
                    category = (CategoryType)filter.FilterConditions[0].CompareValue;
                    string subCategory = string.Empty;
                    filter = band.ColumnFilters["Component"];
                    if (filter.FilterConditions.Count > 0)
                    {
                        subCategory = (string)filter.FilterConditions[0].CompareValue;
                    }

                    this.ChangeHeader(category, subCategory);
                }
                else
                {
                    // shouldn't get here
                    Debug.Fail("");
                    this.lblCurrent.Text  = string.Empty;
                    this.lblPrevious.Text = string.Empty;
                }

                break;

            case "DeliverySchedule":
                this.lblCurrent.Text  = Properties.Resources.Deliveries;
                this.lblPrevious.Text = string.Empty;
                break;
            }
        }
        private Statement getStringFilterClause(ColumnFilter filter)
        {
            var clauseParameters = new List <DBParameterKeyValue>();
            var clauseText       = $"( {filter.Column.Name.SanitizeSQL()} ";

            for (var i = 0; i < filter.Values.Count(); i++)
            {
                var currentValue = filter.Values.ElementAt(i);
                if (i != 0)
                {
                    clauseText += filter.FilterMethod == FilterMethod.Including
                        ? " OR"
                        : " AND";
                    clauseText += $" {filter.Column.Name.SanitizeSQL()} ";
                }

                if (filter.FilterRigor == FilterRigor.Contains)
                {
                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += "NOT ";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("StringFilterValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $"LIKE '%' + {filterValueParameter.Key} + '%'";
                }
                else if (filter.FilterRigor == FilterRigor.Equals)
                {
                    if (filter.FilterMethod == FilterMethod.Excluding)
                    {
                        clauseText += "!";
                    }

                    var filterValueParameter = new DBParameterKeyValue(GetParameterName("StringFilterValue"), currentValue);
                    clauseParameters.Add(filterValueParameter);
                    clauseText += $"= {filterValueParameter.Key}";
                }
            }
            clauseText += " )";

            return(new Statement(clauseText, clauseParameters));
        }
예제 #31
0
        public List<string> GetColumns(ColumnFilter filter) {
            StreamReader reader = new StreamReader(pcaxisFile);

            /*
            * String to hold PC-AXIS records.
            */
            String record = "";
            /*
             * String to hold PC-AXIS keyword of each record.
             */
            String keyword = "";
            /*
             * Strings to hold info for CSV header line.
             */
            String heading = "";
            String stub = "";
            String contents = null;
            /*
             * Keeps all the Keywords found in the file
             */

            string contVariable = "";

            //holds all the keywords to be used as columns
            Dictionary<string, ColumnInformation> keywordsUsed = new Dictionary<string, ColumnInformation>();


            //Regex extractRecord = new Regex("^(?<keyword>[^\\(=]+)(\\((?<var>\"[^\"]+\")\\))?=(TLIST\\((?<tlist>.+)\\),?)?(?<value>[^;]*);$", RegexOptions.IgnoreCase | RegexOptions.Singleline);
            bool stopreading = false;
            while (!reader.EndOfStream && !stopreading) {
                /*
			    * The following is required because we are not sure if a delimiter
			    * has been used at the end of each line for the DATA record.
    			 * Later on, we use \n as a delimiter.
			    */
                string val = null;
                record += '\n';
                string firstSection = GetFirstLineSection(reader);
                if (firstSection.ToLower() == "data=") {
                    stopreading = true;
                    break;
                }
                if (!reader.EndOfStream)
                    record += firstSection + reader.ReadLine().Trim();
                else
                    record += firstSection;

                if (record.EndsWith(";", StringComparison.InvariantCulture)) {
                    /*
                     * Record complete. Trim unecessary whitespace.
                     */
                    record = record.Trim();
                    Match m = extractRecord.Match(record);
                    keyword = m.Groups["keyword"].Value;
                    val = m.Groups["value"].Value.Trim();
                    if (keyword.Equals("CONTENTS", StringComparison.InvariantCultureIgnoreCase)) {
                        contents = val;
                    } else if (keyword.Equals("STUB", StringComparison.InvariantCultureIgnoreCase)) {
                        stub = val;
                    } else if (keyword.Equals("HEADING", StringComparison.InvariantCultureIgnoreCase)) {
                        heading = val;
                    //} else if (
                    //           keyword.Equals("MATRIX", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SUBJECT-CODE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SUBJECT-AREA", StringComparison.InvariantCultureIgnoreCase)
                    //        || keyword.Equals("UNITS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DECIMALS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("TITLE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DESCRIPTION", StringComparison.InvariantCultureIgnoreCase)
                    //        || keyword.Equals("UPDATE-FREQUENCY", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("TABLE_ID", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SOURCE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DATABASE", StringComparison.InvariantCultureIgnoreCase)
                    //        || keyword.Equals("REFPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("BASEPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CONTENTS", StringComparison.InvariantCultureIgnoreCase)
                    //        || keyword.Equals("LAST-UPDATED", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("STOCKFA", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CFPRICES", StringComparison.InvariantCultureIgnoreCase)
                    //        || keyword.Equals("DAYADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SEASADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("UNITS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CONTACT", StringComparison.InvariantCultureIgnoreCase)    
                    //    ) {
                    //    if (!keywordsUsed.Contains(keyword))
                    //        keywordsUsed.Add(keyword);
                    } else if (keyword.Equals("CONTVARIABLE", StringComparison.InvariantCultureIgnoreCase)) {
                        contVariable = val.Replace("\"", "").Replace("#", " ").Replace("\n", " ");

                    } else if (record.StartsWith(keyword + "=") && (
                               keyword.Equals("MATRIX", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SUBJECT-CODE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SUBJECT-AREA", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("UNITS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DECIMALS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("TITLE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DESCRIPTION", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("UPDATE-FREQUENCY", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("TABLE_ID", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SOURCE", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("DATABASE", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("REFPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("BASEPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CONTENTS", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("LAST-UPDATED", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("STOCKFA", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CFPRICES", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("DAYADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SEASADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("UNITS", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CONTACT", StringComparison.InvariantCultureIgnoreCase)
                        )
                        ) {
                        if (!keywordsUsed.ContainsKey(keyword)) {
                            ColumnInformation ci = new ColumnInformation();
                            ci.ColumnName = FormatColumnHeader(keyword);
                            val = val.Replace("\"", "").Replace("#", " ").Replace("\n", " ");
                            ci.Value = val;
                            keywordsUsed[keyword] = ci;
                        }

                    } else if (!string.IsNullOrEmpty(contVariable) && record.StartsWith(keyword + "(") && (
                               keyword.Equals("REFPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("BASEPERIOD", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CONTACT", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("LAST-UPDATED", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("STOCKFA", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("CFPRICES", StringComparison.InvariantCultureIgnoreCase)
                            || keyword.Equals("DAYADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("SEASADJ", StringComparison.InvariantCultureIgnoreCase) || keyword.Equals("UNITS", StringComparison.InvariantCultureIgnoreCase)
                        )
                        ) {
                        if (!keywordsUsed.ContainsKey(keyword)) {
                            ColumnInformation ci = new ColumnInformation();
                            ci.ColumnName = FormatColumnHeader(keyword);
                            ci.IsContVar = true;
                            val = val.Replace("\"", "").Replace("#", " ").Replace("\n", " ");
                            //ci.Values.Add(variable, val);
                            keywordsUsed[keyword] = ci;
                        } else {
                            ColumnInformation ci = keywordsUsed[keyword];
                            ci.ColumnName = FormatColumnHeader(keyword);
                            ci.IsContVar = true;
                            val = val.Replace("\"", "").Replace("#", " ").Replace("\n", " ");
                            //ci.Values.Add(variable, val);
                        }

                    } else if (keyword.Equals("TIMEVAL", StringComparison.InvariantCultureIgnoreCase)) {
                        string tList = m.Groups["tlist"].Value;
                        char freq = tList[0];

                        ColumnInformation ci = new ColumnInformation();
                        ci.ColumnName = "FREQ";
                        ci.Value = freq.ToString();
                        keywordsUsed["FREQ"] = ci;

                        ci = new ColumnInformation();
                        ci.ColumnName = "TIME_FORMAT";
                        ci.Value = TransformFREQToSDMXFormat(freq.ToString());
                        keywordsUsed["TIME_FORMAT"] = ci;

                    }
 

                    record = "";
                }
            }

            char separator = ',';
            /*
		     * Prepare CSV header String and write it.
		     */
            if (!String.IsNullOrEmpty(stub)) {
                stub += separator;
            }
            if (!String.IsNullOrEmpty(heading)) {
                heading += separator;
            }
            if (contents == null) {
                Console.WriteLine("NO CONTENTS RECORD DEFINED! MANDATORY!");
            }

            String csvHeaderString = stub + heading + contents + ",\"OBS_STATUS\"";
            List<string> headers = GetColumnHeaders(csvHeaderString);
            List<string> retval = new List<string>();
            if (filter == ColumnFilter.All || filter == ColumnFilter.Main)
                foreach (string header in headers) {
                    retval.Add(header.Replace("\"", ""));
                }
            if(filter!= ColumnFilter.Main && filter!= ColumnFilter.ContVariable)
                foreach (ColumnInformation col in keywordsUsed.Values) {
                    if(filter== ColumnFilter.KeywordsSingleValue && !col.IsContVar
                        || filter== ColumnFilter.ContVariableKeywords && col.IsContVar
                        || filter == ColumnFilter.All)
                        retval.Add(col.ColumnName);
                }

            if (filter == ColumnFilter.ContVariable)
                retval.Add(FormatColumnHeader(contVariable));

            return retval;
        }
 /// <summary>
 /// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
 /// </summary>
 /// <param name="dataContext">
 /// The data context.
 /// </param>
 /// <param name="filter">
 /// The filter.
 /// </param>
 /// <returns>
 /// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
 /// </returns>
 public bool TryCreateFilter(IDataContext dataContext, out ColumnFilter filter)
 {
     filter = null;
     return false;
 }
예제 #33
0
        /// <summary>
        /// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
        /// </summary>
        /// <param name="dataContext">
        /// The data context.
        /// </param>
        /// <param name="filter">
        /// The filter.
        /// </param>
        /// <returns>
        /// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
        /// </returns>
        public bool TryCreateFilter(IDataContext dataContext, out ColumnFilter filter)
        {
            filter = null;
            var value = GetValue(dataContext);

            if (value == null)
                return false;

            if (string.Empty.Equals(value))
                return false;

            if (DateTime.MinValue.Equals(value))
                return false;

            filter = new ColumnFilter(Property.Name, value);

            return true;
        }
        /// <summary>
        /// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
        /// </summary>
        /// <param name="dataContext">
        /// The data context.
        /// </param>
        /// <param name="filter">
        /// The filter.
        /// </param>
        /// <returns>
        /// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
        /// </returns>
        public bool TryCreateFilter(IDataContext dataContext, out ColumnFilter filter)
        {
            filter = null;

            var itemId = GetCrossReferenceItemId(dataContext);
            if (itemId == null)
                return false;

            filter = new ColumnFilter(Property.Name, itemId);

            return true;
        }
    /// <summary>
    /// Loads the filter control
    /// </summary>
    /// <param name="path">Control path</param>
    /// <param name="fieldSourceName">Field source name</param>
    /// <param name="value">Field value</param>
    /// <param name="filterDefinition">Filter definition</param>
    /// <param name="filterColumn">Filter column</param>    
    private CMSAbstractBaseFilterControl LoadFilterControl(string path, string fieldSourceName, string value, UniGridFilterField filterDefinition, ColumnFilter filterColumn = null)
    {
        string fullPath = (path.StartsWithCSafe("~/") ? path : FilterDirectoryPath + path.TrimStart('/'));

        // Load the filter control
        CMSAbstractBaseFilterControl filterControl = LoadUserControl(fullPath) as CMSAbstractBaseFilterControl;
        if (filterControl != null)
        {
            // Setup the filter control
            filterControl.ID = fieldSourceName;
            filterControl.FilteredControl = this;

            if (!RequestHelper.IsPostBack())
            {
                filterControl.Value = value;
            }

            filterDefinition.ValueControl = filterControl;
            filterDefinition.ControlPath = path;

            ISimpleDataContainer filterSimpleDataContainer = filterControl as ISimpleDataContainer;
            // If filter control is ISimpleDataContainer we can set specified parameters if they are provided
            if (filterColumn != null &&
                filterSimpleDataContainer != null &&
                filterColumn.CustomFilterParameters != null &&
                filterColumn.CustomFilterParameters.Parameters != null)
            {
                filterColumn.CustomFilterParameters.Parameters.ForEach(parameter => filterSimpleDataContainer.SetValue(parameter.Name, parameter.Value));
            }
        }

        return filterControl;
    }
    /// <summary>
    /// Add filter field to the filter table.
    /// </summary>
    /// <param name="filter">Filter definition</param>
    /// <param name="columnSourceName">Column source field name</param>
    /// <param name="fieldDisplayName">Field display name</param>
    /// <param name="filterWrapperControl">Wrapper control for filter</param>
    /// <param name="filterValue">Filter value</param>
    private void AddFilterField(ColumnFilter filter, string columnSourceName, string fieldDisplayName, Control filterWrapperControl, string filterValue)
    {
        string fieldSourceName = filter.Source ?? columnSourceName;
        if (String.IsNullOrEmpty(fieldSourceName) || (filter == null) || (filterWrapperControl == null))
        {
            return;
        }

        string fieldPath = filter.Path;
        string filterFormat = filter.Format;
        int filterSize = filter.Size;
        Unit filterWidth = filter.Width;

        Panel fieldWrapperPanel = new Panel()
        {
            CssClass = "form-group"
        };

        Panel fieldLabelPanel = new Panel()
        {
            CssClass = "filter-form-label-cell"
        };

        Panel fieldOptionPanel = new Panel()
        {
            CssClass = "filter-form-condition-cell"
        };

        Panel fieldInputPanel = new Panel()
        {
            CssClass = "filter-form-value-cell"
        };

        // Ensure fieldSourceName is JavaScript valid
        fieldSourceName = fieldSourceName.Replace(ALL, "__ALL__");

        int index = GetNumberOfFilterFieldsWithSameSourceColumn(fieldSourceName);
        string filterControlID = fieldSourceName + (index > 0 ? index.ToString() : String.Empty);

        Label textName = new Label
        {
            Text = String.IsNullOrEmpty(fieldDisplayName) ? String.Empty : fieldDisplayName + ":",
            ID = String.Format("{0}Name", filterControlID),
            EnableViewState = false,
            CssClass = "control-label"
        };

        fieldLabelPanel.Controls.Add(textName);
        fieldWrapperPanel.Controls.Add(fieldLabelPanel);

        // Filter value
        string value = null;
        if (filterValue != null)
        {
            value = ValidationHelper.GetString(filterValue, null);
        }

        // Filter definition
        UniGridFilterField filterDefinition = new UniGridFilterField();
        filterDefinition.Type = filter.Type;
        filterDefinition.Label = textName;
        filterDefinition.Format = filterFormat;
        filterDefinition.FilterRow = fieldWrapperPanel;

        // Set the filter default value
        string defaultValue = filter.DefaultValue;

        // Remember default values of filter field controls for potential UniGrid reset
        string optionFilterFieldValue = null;
        string valueFilterFieldValue = null;

        switch (filterDefinition.Type)
        {
            // Text filter
            case UniGridFilterTypeEnum.Text:
                {
                    CMSDropDownList textOptionFilterField = new CMSDropDownList();
                    ControlsHelper.FillListWithTextSqlOperators(textOptionFilterField);
                    textOptionFilterField.ID = filterControlID;

                    // Set the value
                    SetDropdownValue(value, null, textOptionFilterField);
                    optionFilterFieldValue = textOptionFilterField.SelectedValue;

                    LocalizedLabel lblSelect = new LocalizedLabel
                    {
                        EnableViewState = false,
                        CssClass = "sr-only",
                        AssociatedControlID = textOptionFilterField.ID,
                        ResourceString = "filter.mode"
                    };

                    fieldOptionPanel.Controls.Add(lblSelect);
                    fieldOptionPanel.Controls.Add(textOptionFilterField);
                    fieldWrapperPanel.Controls.Add(fieldOptionPanel);

                    CMSTextBox textValueFilterField = new CMSTextBox
                    {
                        ID = String.Format("{0}TextValue", filterControlID)
                    };

                    // Set value
                    SetTextboxValue(value, defaultValue, textValueFilterField);
                    valueFilterFieldValue = textValueFilterField.Text;

                    if (filterSize > 0)
                    {
                        textValueFilterField.MaxLength = filterSize;
                    }
                    if (!filterWidth.IsEmpty)
                    {
                        textValueFilterField.Width = filterWidth;
                    }
                    fieldInputPanel.Controls.Add(textValueFilterField);
                    fieldWrapperPanel.Controls.Add(fieldInputPanel);
                    textName.AssociatedControlID = textValueFilterField.ID;

                    filterDefinition.OptionsControl = textOptionFilterField;
                    filterDefinition.ValueControl = textValueFilterField;
                }
                break;

            // Boolean filter
            case UniGridFilterTypeEnum.Bool:
                {
                    CMSDropDownList booleanOptionFilterField = new CMSDropDownList();

                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.selectall"), String.Empty));
                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.yes"), "1"));
                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.no"), "0"));
                    booleanOptionFilterField.ID = filterControlID;
                    textName.AssociatedControlID = booleanOptionFilterField.ID;

                    // Set the value
                    SetDropdownValue(value, defaultValue, booleanOptionFilterField);
                    valueFilterFieldValue = booleanOptionFilterField.SelectedValue;

                    // Set input panel wide for boolean Drop-down list
                    fieldInputPanel.CssClass = "filter-form-value-cell-wide";

                    fieldInputPanel.Controls.Add(booleanOptionFilterField);
                    fieldWrapperPanel.Controls.Add(fieldInputPanel);

                    filterDefinition.ValueControl = booleanOptionFilterField;
                }
                break;

            // Integer filter
            case UniGridFilterTypeEnum.Integer:
            case UniGridFilterTypeEnum.Double:
                {
                    CMSDropDownList numberOptionFilterField = new CMSDropDownList();
                    numberOptionFilterField.Items.Add(new ListItem(GetString("filter.equals"), "="));
                    numberOptionFilterField.Items.Add(new ListItem(GetString("filter.notequals"), "<>"));
                    numberOptionFilterField.Items.Add(new ListItem(GetString("filter.lessthan"), "<"));
                    numberOptionFilterField.Items.Add(new ListItem(GetString("filter.greaterthan"), ">"));
                    numberOptionFilterField.ID = filterControlID;

                    // Set the value
                    SetDropdownValue(value, null, numberOptionFilterField);
                    optionFilterFieldValue = numberOptionFilterField.SelectedValue;

                    LocalizedLabel lblSelect = new LocalizedLabel
                    {
                        EnableViewState = false,
                        CssClass = "sr-only",
                        AssociatedControlID = numberOptionFilterField.ID,
                        ResourceString = "filter.mode"
                    };

                    // Add filter field
                    fieldOptionPanel.Controls.Add(lblSelect);
                    fieldOptionPanel.Controls.Add(numberOptionFilterField);
                    fieldWrapperPanel.Controls.Add(fieldOptionPanel);

                    CMSTextBox numberValueFilterField = new CMSTextBox
                    {
                        ID = String.Format("{0}NumberValue", filterControlID)
                    };

                    // Set value
                    SetTextboxValue(value, defaultValue, numberValueFilterField);
                    valueFilterFieldValue = numberValueFilterField.Text;

                    if (filterSize > 0)
                    {
                        numberValueFilterField.MaxLength = filterSize;
                    }
                    if (!filterWidth.IsEmpty)
                    {
                        numberValueFilterField.Width = filterWidth;
                    }
                    numberValueFilterField.EnableViewState = false;

                    fieldInputPanel.Controls.Add(numberValueFilterField);
                    fieldWrapperPanel.Controls.Add(fieldInputPanel);

                    filterDefinition.OptionsControl = numberOptionFilterField;
                    filterDefinition.ValueControl = numberValueFilterField;
                }
                break;

            case UniGridFilterTypeEnum.Site:
                {
                    // Site selector
                    fieldPath = "~/CMSFormControls/Filters/SiteFilter.ascx";
                }
                break;

            case UniGridFilterTypeEnum.Custom:
                // Load custom path
                {
                    if (String.IsNullOrEmpty(fieldPath))
                    {
                        throw new Exception("[UniGrid.AddFilterField]: Filter field path is not set");
                    }
                }
                break;

            default:
                // Not supported filter type
                throw new Exception("[UniGrid.AddFilterField]: Filter type '" + filterDefinition.Type + "' is not supported. Supported filter types: integer, double, bool, text, site, custom.");
        }

        // Else if filter path is defined use custom filter
        if (fieldPath != null)
        {
            // Add to the controls collection
            CMSAbstractBaseFilterControl filterControl = LoadFilterControl(fieldPath, filterControlID, value, filterDefinition, filter);
            if (filterControl != null)
            {
                // Set default value
                if (!String.IsNullOrEmpty(defaultValue))
                {
                    filterControl.SelectedValue = defaultValue;
                }

                fieldInputPanel.Controls.Add(filterControl);
            }

            fieldInputPanel.CssClass = "filter-form-value-cell-wide";
            fieldWrapperPanel.Controls.Add(fieldInputPanel);
        }

        RaiseOnFilterFieldCreated(fieldSourceName, filterDefinition);
        FilterFields[String.Format("{0}{1}", fieldSourceName, (index > 0 ? "#" + index : String.Empty))] = filterDefinition;

        filterWrapperControl.Controls.Add(fieldWrapperPanel);

        // Store initial filter state for potential UniGrid reset
        if (filterDefinition.OptionsControl != null)
        {
            InitialFilterStateControls.Add(new KeyValuePair<Control, object>(filterDefinition.OptionsControl, optionFilterFieldValue));
        }
        if (filterDefinition.ValueControl != null)
        {
            if (!(filterDefinition.ValueControl is CMSAbstractBaseFilterControl))
            {
                InitialFilterStateControls.Add(new KeyValuePair<Control, object>(filterDefinition.ValueControl, valueFilterFieldValue));
            }
        }
    }
예제 #37
0
 protected bool Equals(ColumnFilter other)
 {
     return string.Equals(ColumnCaption, other.ColumnCaption) 
         && Equals(FilterOperation, other.FilterOperation) 
         && string.Equals(Operand, other.Operand);
 }
    /// <summary>
    /// Add filter field to the filter table.
    /// </summary>
    /// <param name="filter">Filter definition</param>
    /// <param name="columnSourceName">Column source field name</param>
    /// <param name="fieldDisplayName">Field display name</param>
    /// <param name="filterTable">Filter table</param>
    /// <param name="filterOption">Filter option</param>
    /// <param name="filterValue">Filter value</param>
    private void AddFilterField(ColumnFilter filter, string columnSourceName, string fieldDisplayName, Table filterTable, object filterOption, object filterValue)
    {
        string fieldType = filter.Type;
        string fieldPath = filter.Path;
        string filterFormat = filter.Format;
        string fieldSourceName = filter.Source ?? columnSourceName;
        int filterSize = filter.Size;
        Unit filterWidth = filter.Width;

        TableRow tRow = new TableRow();

        TableCell tCellName = new TableCell();
        TableCell tCellOption = new TableCell();
        TableCell tCellValue = new TableCell();

        // Ensure fieldSourceName is JavaScript valid
        fieldSourceName = fieldSourceName.Replace(ALL, "__ALL__");

        // Label
        Label textName = new Label
        {
            Text = String.IsNullOrEmpty(fieldDisplayName) ? "" : fieldDisplayName + ":",
            ID = fieldSourceName + "Name",
            EnableViewState = false
        };

        tCellName.Controls.Add(textName);
        tRow.Cells.Add(tCellName);

        // Filter option
        string option = null;
        if (filterOption != null)
        {
            option = ValidationHelper.GetString(filterOption, null);
        }

        // Filter value
        string value = null;
        if (filterValue != null)
        {
            value = ValidationHelper.GetString(filterValue, null);
        }

        // Filter definition
        UniGridFilterField filterDefinition = new UniGridFilterField();
        filterDefinition.Type = (fieldType != null) ? fieldType.ToLowerCSafe() : "custom";
        filterDefinition.Label = textName;
        filterDefinition.Format = filterFormat;
        filterDefinition.FilterRow = tRow;

        string customPath = null;

        // Set the filter default value
        string defaultValue = filter.DefaultValue;

        // Remember default values of filter field controls for potential UniGrid reset
        string optionFilterFieldValue = null;
        string valueFilterFieldValue = null;

        switch (filterDefinition.Type)
        {
            // Text filter
            case "text":
                {
                    DropDownList textOptionFilterField = new DropDownList();

                    textOptionFilterField.Items.Add(new ListItem("LIKE", "LIKE"));
                    textOptionFilterField.Items.Add(new ListItem("NOT LIKE", "NOT LIKE"));
                    textOptionFilterField.Items.Add(new ListItem("=", "="));
                    textOptionFilterField.Items.Add(new ListItem("<>", "<>"));
                    textOptionFilterField.CssClass = "ContentDropdown";
                    textOptionFilterField.ID = fieldSourceName;

                    // Set the value
                    SetDropdownValue(value, null, textOptionFilterField);
                    optionFilterFieldValue = textOptionFilterField.SelectedValue;

                    LocalizedLabel lblSelect = new LocalizedLabel
                    {
                        EnableViewState = false,
                        Display = false,
                        AssociatedControlID = textOptionFilterField.ID,
                        ResourceString = "general.select"
                    };

                    tCellOption.Controls.Add(lblSelect);
                    tCellOption.Controls.Add(textOptionFilterField);
                    tRow.Cells.Add(tCellOption);

                    // Add text field
                    TextBox textValueFilterField = new TextBox
                    {
                        ID = fieldSourceName + "TextValue",
                        CssClass = "FilterTextBox",
                    };

                    // Set value
                    SetTextboxValue(value, defaultValue, textValueFilterField);
                    valueFilterFieldValue = textValueFilterField.Text;

                    if (filterSize > 0)
                    {
                        textValueFilterField.MaxLength = filterSize;
                    }
                    if (!filterWidth.IsEmpty)
                    {
                        textValueFilterField.Width = filterWidth;
                    }
                    tCellValue.Controls.Add(textValueFilterField);
                    tRow.Cells.Add(tCellValue);
                    textName.AssociatedControlID = textValueFilterField.ID;

                    filterDefinition.OptionsControl = textOptionFilterField;
                    filterDefinition.ValueControl = textValueFilterField;
                }
                break;

            // Boolean filter
            case "bool":
                {
                    DropDownList booleanOptionFilterField = new DropDownList();

                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.selectall"), ""));
                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.yes"), "1"));
                    booleanOptionFilterField.Items.Add(new ListItem(GetString("general.no"), "0"));
                    booleanOptionFilterField.CssClass = "ContentDropdown";
                    booleanOptionFilterField.ID = fieldSourceName;
                    textName.AssociatedControlID = booleanOptionFilterField.ID;

                    // Set the value
                    SetDropdownValue(value, defaultValue, booleanOptionFilterField);
                    valueFilterFieldValue = booleanOptionFilterField.SelectedValue;

                    tCellValue.Controls.Add(booleanOptionFilterField);
                    tRow.Cells.Add(tCellValue);

                    filterDefinition.ValueControl = booleanOptionFilterField;
                }
                break;

            // Integer filter
            case "integer":
            case "double":
                {
                    DropDownList numberOptionFilterField = new DropDownList();
                    numberOptionFilterField.Items.Add(new ListItem("=", "="));
                    numberOptionFilterField.Items.Add(new ListItem("<>", "<>"));
                    numberOptionFilterField.Items.Add(new ListItem("<", "<"));
                    numberOptionFilterField.Items.Add(new ListItem(">", ">"));
                    numberOptionFilterField.CssClass = "ContentDropdown";
                    numberOptionFilterField.ID = fieldSourceName;

                    // Set the value
                    SetDropdownValue(value, null, numberOptionFilterField);
                    optionFilterFieldValue = numberOptionFilterField.SelectedValue;

                    LocalizedLabel lblSelect = new LocalizedLabel
                    {
                        EnableViewState = false,
                        Display = false,
                        AssociatedControlID = numberOptionFilterField.ID,
                        ResourceString = "general.select"
                    };

                    // Add filter field
                    tCellOption.Controls.Add(lblSelect);
                    tCellOption.Controls.Add(numberOptionFilterField);
                    tRow.Cells.Add(tCellOption);

                    TextBox numberValueFilterField = new TextBox
                    {
                        ID = fieldSourceName + "NumberValue",
                    };

                    // Set value
                    SetTextboxValue(value, defaultValue, numberValueFilterField);
                    valueFilterFieldValue = numberValueFilterField.Text;

                    if (filterSize > 0)
                    {
                        numberValueFilterField.MaxLength = filterSize;
                    }
                    if (!filterWidth.IsEmpty)
                    {
                        numberValueFilterField.Width = filterWidth;
                    }
                    numberValueFilterField.EnableViewState = false;

                    tCellValue.Controls.Add(numberValueFilterField);
                    tRow.Cells.Add(tCellValue);

                    filterDefinition.OptionsControl = numberOptionFilterField;
                    filterDefinition.ValueControl = numberValueFilterField;
                }
                break;

            case "site":
                {
                    // Site selector
                    customPath = "~/CMSFormControls/Filters/SiteFilter.ascx";
                }
                break;

            case "custom":
                // Load custom path
                {
                    if (String.IsNullOrEmpty(fieldPath))
                    {
                        throw new Exception("[UniGrid.AddFilterField]: Filter field path is not set");
                    }

                    customPath = fieldPath;
                }
                break;

            default:
                // Not supported filter type
                throw new Exception("[UniGrid.AddFilterField]: Filter type '" + filterDefinition.Type + "' is not supported. Supported filter types: integer, double, bool, text, site, custom.");
        }

        // Else if filter path is defined use custom filter
        if (customPath != null)
        {
            customPath = (customPath.StartsWithCSafe("~/") ? customPath : FilterDirectoryPath + customPath.TrimStart('/'));

            // Add to the controls collection
            CMSAbstractBaseFilterControl filterControl = LoadFilterControl(fieldPath, fieldSourceName, value, filterDefinition, customPath);
            if (filterControl != null)
            {
                // Set default value
                if (!String.IsNullOrEmpty(defaultValue))
                {
                    filterControl.SelectedValue = defaultValue;
                }

                tCellValue.Controls.Add(filterControl);
            }

            tCellValue.Attributes["colspan"] = "2";
            tRow.Cells.Add(tCellValue);
        }

        RaiseOnFilterFieldCreated(fieldSourceName, filterDefinition);
        FilterFields[fieldSourceName] = filterDefinition;

        filterTable.Rows.Add(tRow);

        // Store initial filter state for potential UniGrid reset
        if (filterDefinition.OptionsControl != null)
        {
            InitialFilterStateControls.Add(new KeyValuePair<Control, object>(filterDefinition.OptionsControl, optionFilterFieldValue));
        }
        if (filterDefinition.ValueControl != null)
        {
            if (!(filterDefinition.ValueControl is CMSAbstractBaseFilterControl))
            {
                InitialFilterStateControls.Add(new KeyValuePair<Control, object>(filterDefinition.ValueControl, valueFilterFieldValue));
            }
        }
    }
        public void UpdateTest()
        {
            // Arrange.
            const int CrId1 = 111;
            const int CrId2 = 222;
            const string ReferencedProcessName = "CRProcess";

            var value1 = new object();
            var dataContext = Mock.Create<IDataContext>(Behavior.Loose);

            var typeConverter = new Mock<ITypeConverter>();
            typeConverter.Setup(x => x.Convert<int?>(value1)).Returns(CrId1);

            var filter = new ColumnFilter("TestField", null);

            var keyField = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => keyField.IsKey).Returns(true);
            Mock.Arrange(() => keyField.TryCreateFilter(dataContext, out filter)).Returns(true);

            var dtm = new Mock<IDynamicTypeManager>();

            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            Mock.Arrange(() => runtimeDatabase.FindItems(ReferencedProcessName, Arg.IsAny<IEnumerable<ColumnFilter>>()))
                .Returns<string, IEnumerable<ColumnFilter>>(
                    (processName, filters) =>
                    {
                        var filtersArray = filters.ToArray();
                        if (filtersArray.Length == 1 && filtersArray.Contains(filter))
                            return new Collection<int> { CrId2 };

                        return new Collection<int>();
                    });

            // Update with direct value.
            var mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                dc => dc == dataContext ? value1 : null,
                false,
                typeConverter.Object,
                dtm.Object,
                runtimeDatabase,
                null);
            var editItem = new TestEditable();

            // Act.
            mapping.Update(dataContext, editItem);

            // Assert.
            Assert.AreEqual(CrId1, editItem.CR);

            // Update with key subfields.
            mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                null,
                false,
                typeConverter.Object,
                dtm.Object,
                runtimeDatabase,
                new[] { keyField });

            editItem = new TestEditable();

            // Act.
            mapping.Update(dataContext, editItem);

            // Assert.
            Assert.AreEqual(CrId2, editItem.CR);
        }
        public void TryCreateFilterTest()
        {
            // Arrange.
            const string ReferencedProcessName = "CRProcess";
            const int Id1 = 111;
            const int Id2 = 222;
            var value1 = new object();
            var dataContext = Mock.Create<IDataContext>(Behavior.Loose);

            var filter1 = new ColumnFilter("TestField", null);
            var keyField1 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => keyField1.IsKey).Returns(true);
            Mock.Arrange(() => keyField1.TryCreateFilter(dataContext, out filter1)).Returns(true);


            var filter2 = new ColumnFilter("TestField", null);
            var keyField2 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => keyField2.IsKey).Returns(true);
            Mock.Arrange(() => keyField2.TryCreateFilter(dataContext, out filter2)).Returns(true);

            var dtm = new Mock<IDynamicTypeManager>();

            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            Mock.Arrange(() => runtimeDatabase.FindItems(ReferencedProcessName, Arg.IsAny<IEnumerable<ColumnFilter>>()))
                .Returns<string, IEnumerable<ColumnFilter>>(
                    (processName, filters) =>
                    {
                        var filtersArray = Enumerable.ToArray(filters);
                        if (filtersArray.Length == 1 && Enumerable.Contains(filtersArray, filter1))
                            return new Collection<int> { Id2 };

                        return new Collection<int>();
                    });

            var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
            Mock.Arrange(() => typeConverter.Convert<int?>(value1)).Returns(Id1);

            // CR field is mapped. Value is not null.
            var mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                dc => dc == dataContext ? value1 : null,
                false,
                typeConverter,
                dtm.Object,
                runtimeDatabase,
                null);

            ColumnFilter filter;

            // Act / Assert.
            Assert.IsTrue(mapping.TryCreateFilter(dataContext, out filter));
            Assert.AreEqual("CR", filter.ColumnName);
            Assert.AreEqual(Id1, filter.Value);

            // CR field is mapped. Value is null.
            mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                dc => null,
                false,
                typeConverter,
                dtm.Object,
                runtimeDatabase,
                null);

            // Act / Assert.
            Assert.IsFalse(mapping.TryCreateFilter(dataContext, out filter));

            // CR field has key fields. Value is found.
            mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                null,
                false,
                typeConverter,
                dtm.Object,
                runtimeDatabase,
                new[] { keyField1 });

            // Act / Assert.
            Assert.IsTrue(mapping.TryCreateFilter(dataContext, out filter));
            Assert.AreEqual("CR", filter.ColumnName);
            Assert.AreEqual(Id2, filter.Value);

            // CR field has key fields. Value is not found.
            mapping = new SingleCrossReferenceFieldMapping(
                ReflectionHelper.GetProperty<TestEditable>(x => x.CR),
                null,
                false,
                typeConverter,
                dtm.Object,
                runtimeDatabase,
                new[] { keyField2 });

            // Act / Assert.
            Assert.IsFalse(mapping.TryCreateFilter(dataContext, out filter));
        }
예제 #41
0
        /// <summary>
        /// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
        /// </summary>
        /// <param name="dataContext">
        /// The data context.
        /// </param>
        /// <param name="filter">
        /// The filter.
        /// </param>
        /// <returns>
        /// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
        /// </returns>
        public bool TryCreateFilter(IDataContext dataContext, out ColumnFilter filter)
        {
            filter = null;

            var value = GetValue(dataContext);
            if (!IsValidKey(value))
                return false;

            filter = new ColumnFilter(Property.Name, value);

            return true;
        }
        public void WhenExistingItemsAreFoundInsertOrUpdateExecutesUpdate()
        {
            // Arrange.
            const string ProcessName = "TestProcess";

            var dataContext = Mock.Create<IDataContext>(Behavior.Loose);

            var mapping1 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping1.IsKey).Returns(true);
            var mapping2 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping2.IsKey).Returns(false);
            var mapping3 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping3.IsKey).Returns(true);

            var filter1 = new ColumnFilter("Field1", null);
            Mock.Arrange(() => mapping1.TryCreateFilter(dataContext, out filter1)).Returns(true);

            var filter2 = new ColumnFilter("Field2", null);
            Mock.Arrange(() => mapping3.TryCreateFilter(dataContext, out filter2)).Returns(true);

            var itemEdit1 = CreateEditableRoot(111);
            var itemEdit2 = CreateEditableRoot(222);
            SetupGetEditableRoot(ProcessName, itemEdit1, itemEdit2);

            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            Mock.Arrange(() => runtimeDatabase.FindItems(ProcessName, Arg.IsAny<IEnumerable<ColumnFilter>>()))
                .Returns<string, IEnumerable<ColumnFilter>>(
                    (processName, filters) =>
                    {
                        var filtersArray = filters.ToArray();

                        if (filtersArray.Length == 2 && filtersArray.Contains(filter1) && filtersArray.Contains(filter2))
                            return new Collection<int> { 111, 222 };

                        return new Collection<int>();
                    });

            var applicationContext = Mock.Create<IApplicationContext>(Behavior.Loose);

            var dataContextFactory = Mock.Create<IEditableRootDataContextFactory>(Behavior.Loose);
            var logger = Mock.Create<ILogger>(Behavior.Loose);

            var itemUpdater = new IntegrationServiceMethod(
                ProcessName,
                new[] { mapping1, mapping2, mapping3 },
                null,
                _dtm,
                applicationContext,
                runtimeDatabase,
                dataContextFactory,
                logger);

            // Act.
            var result = itemUpdater.InsertOrUpdate(dataContext);

            // Assert.
            Mock.Assert(() => mapping1.Update(dataContext, itemEdit1), Occurs.Once());
            Mock.Assert(() => mapping1.Update(dataContext, itemEdit2), Occurs.Once());

            Mock.Assert(() => mapping2.Update(dataContext, itemEdit1), Occurs.Once());
            Mock.Assert(() => mapping2.Update(dataContext, itemEdit2), Occurs.Once());

            Mock.Assert(() => mapping3.Update(dataContext, itemEdit1), Occurs.Once());
            Mock.Assert(() => mapping3.Update(dataContext, itemEdit2), Occurs.Once());

            Mock.Assert(() => itemEdit1.Save(), Occurs.Once());
            Mock.Assert(() => itemEdit2.Save(), Occurs.Once());

            Assert.IsNull(result);
            Assert.IsTrue(applicationContext.User.Identity is IntegrationServiceIdentity);
        }
        public void InsertTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";

            var dataContext = Mock.Create<IDataContext>(Behavior.Loose);

            var mapping1 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping1.IsKey).Returns(true);
            var mapping2 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping2.IsKey).Returns(false);
            var mapping3 = Mock.Create<IProcessFieldMapping>(Behavior.Loose);
            Mock.Arrange(() => mapping3.IsKey).Returns(true);

            var filter1 = new ColumnFilter("Field1", null);
            Mock.Arrange(() => mapping1.TryCreateFilter(dataContext, out filter1)).Returns(true);

            var filter2 = new ColumnFilter("Field2", null);
            Mock.Arrange(() => mapping3.TryCreateFilter(dataContext, out filter2)).Returns(true);

            var newEdit = CreateEditableRoot(0);

            Mock.Arrange(() => _dtm.NewEditableRoot<IEditableRoot>(ProcessName)).Returns(newEdit);

            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            Mock.Arrange(() => runtimeDatabase.FindItems(ProcessName, Arg.IsAny<IEnumerable<ColumnFilter>>()))
                .Returns<string, IEnumerable<ColumnFilter>>(
                    (processName, filters) =>
                    {
                        var filtersArray = filters.ToArray();

                        if (filtersArray.Length == 2 && filtersArray.Contains(filter1) && filtersArray.Contains(filter2))
                            return new Collection<int>();

                        return null;
                    });

            var applicationContext = Mock.Create<IApplicationContext>(Behavior.Loose);

            var editableRootDataContextFactory = Mock.Create<IEditableRootDataContextFactory>(Behavior.Loose);
            var logger = Mock.Create<ILogger>(Behavior.Loose);

            var serviceMethod = new IntegrationServiceMethod(
                ProcessName,
                new[] { mapping1, mapping2, mapping3 },
                null,
                _dtm,
                applicationContext,
                runtimeDatabase,
                editableRootDataContextFactory,
                logger);

            // Act.
            var result = serviceMethod.Insert(dataContext);

            // Assert.
            Mock.Assert(() => mapping1.Update(dataContext, newEdit), Occurs.Once());
            Mock.Assert(() => mapping2.Update(dataContext, newEdit), Occurs.Once());
            Mock.Assert(() => mapping3.Update(dataContext, newEdit), Occurs.Once());
            Mock.Assert(() => newEdit.Save(), Occurs.Once());
            Assert.IsNull(result);
            Assert.IsTrue(applicationContext.User.Identity is IntegrationServiceIdentity);
        }