Ejemplo n.º 1
0
        private void SetupTreeViewField(FieldPathPropertyDefinition propertyDefinition, EditorCreatedEventArgs e)
        {
            var linkField = propertyDefinition.LinkFieldSystemName;
            if (linkField != Constants.IdColumnName)
            {
                linkField += Constants.IdColumnName;
            }

            var filter = new FilterDescriptor(linkField, FilterOperator.IsNotEqualTo, null, typeof(int));

            LoadReferenceItems(propertyDefinition.DeclaringProcessSystemName, propertyDefinition.SystemName, filter.ToJSON(), e, propertyDefinition.ReferencedFieldSystemName);
        }
Ejemplo n.º 2
0
        private void SetupCrossReferenceField(FieldPathPropertyDefinition propertyDefinition, EditorCreatedEventArgs e)
        {
            var crProcessName = propertyDefinition.ReferencedProcessSystemName;
            var displayField = propertyDefinition.ReferencedFieldSystemName;

            FilterDescriptor filterDescriptor = null;
            if (Constants.StateProcessName.Equals(crProcessName) && !string.IsNullOrEmpty(propertyDefinition.DeclaringProcessSystemName))
            {
                filterDescriptor = new FilterDescriptor(
                    Constants.ProcessFieldName,
                    FilterOperator.IsEqualTo,
                    propertyDefinition.DeclaringProcessSystemName,
                    typeof(string));
            }

            var filter = filterDescriptor == null ? string.Empty : filterDescriptor.ToJSON();

            LoadReferenceItems(propertyDefinition.DeclaringProcessSystemName, propertyDefinition.SystemName, filter, e, displayField);
        }
        private async void LoadCrossReferenceItems(FieldPathPropertyDefinition propertyDefinition, EditorCreatedEventArgs e)
        {
            if (string.IsNullOrEmpty(propertyDefinition.ReferencedProcessSystemName))
            {
                return;
            }

            var busyIndicator = e.Editor.FindChildByType<RadBusyIndicator>();
            if (busyIndicator != null)
            {
                busyIndicator.IsBusy = true;
            }

            try
            {
                string filterExpression = null;
                if (propertyDefinition.SystemName == Constants.CurrentStateColumnName)
                {
                    // If it's a CurrentState filter, show only declaring process states.
                    var filterDescriptor = new FilterDescriptor(
                        Constants.ProcessFieldName,
                        FilterOperator.IsEqualTo,
                        propertyDefinition.DeclaringProcessSystemName,
                        typeof(string));

                    filterExpression = filterDescriptor.ToJSON();
                }

                var displayFieldName = propertyDefinition.ReferencedFieldSystemName == "AqlDetail" ? Constants.AqlDisplayField : propertyDefinition.ReferencedFieldSystemName;

                var infoList =
                    await
                    DynamicTypeManager.GetInfoListAsync<IInfoClass>(
                        propertyDefinition.ReferencedProcessSystemName,
                        int.MaxValue,
                        0,
                        filterExpression,
                        null,
                        new SortList { new SortDescriptor(displayFieldName, SortDirection.Ascending) });

                var comboBox = e.Editor.FindChildByType<RadComboBox>();
                if (comboBox == null)
                {
                    return;
                }

                dataFilter.Tag = true;

                try
                {
                    comboBox.ItemsSource = infoList;
                    comboBox.SelectedValuePath = "Id";

                    Observable.FromEventPattern<SelectionChangedEventHandler, SelectionChangedEventArgs>(
                        handler => comboBox.SelectionChanged += handler,
                        handler => comboBox.SelectionChanged -= handler).SubscribeWeakly(this, OnComboBoxSelectionChanged);

                    if (infoList != null)
                    {
                        comboBox.DisplayMemberPath = string.Join(".", infoList.ElementType.GetFullPropertyPath(displayFieldName));
                    }

                    var filterViewModel = (SimpleFilterViewModel)e.Editor.DataContext;
                    if (filterViewModel != null && filterViewModel.Descriptor != null)
                    {
                        var placeholder = filterViewModel.Descriptor.Value as IInfoClass;
                        if (placeholder != null)
                        {
                            comboBox.SelectedValue = placeholder.Id;
                        }
                    }
                }
                finally
                {
                    dataFilter.Tag = null;
                }
            }
            catch (DataPortalException ex)
            {
                PopupFactory.NotifyFailure(ex);
            }
            finally
            {
                if (busyIndicator != null)
                {
                    busyIndicator.IsBusy = false;
                }
            }
        }
        private async void LoadReverseCrossReferenceItems(FieldPathPropertyDefinition propertyDefinition, EditorCreatedEventArgs e)
        {
            if (string.IsNullOrEmpty(propertyDefinition.ReferencedProcessSystemName))
            {
                return;
            }

            try
            {
                var displayField = propertyDefinition.ReferencedFieldSystemName;
                var filter = new FilterDescriptor(propertyDefinition.LinkFieldSystemName, FilterOperator.IsGreaterThan, 0, typeof(int));

                var infoList =
                    await
                    DynamicTypeManager.GetInfoListAsync<IInfoClass>(
                        propertyDefinition.ReferencedProcessSystemName,
                        int.MaxValue,
                        0,
                        filter.ToJSON(),
                        null,
                        new SortList { new SortDescriptor(displayField, SortDirection.Ascending) });

                var comboBox = e.Editor.FindChildByType<RadComboBox>();
                if (comboBox == null)
                {
                    return;
                }

                dataFilter.Tag = true;
                try
                {
                    comboBox.ItemsSource = infoList;
                    comboBox.SelectedValuePath = "Id";
                    Observable.FromEventPattern<SelectionChangedEventHandler, SelectionChangedEventArgs>(
                        handler => comboBox.SelectionChanged += handler,
                        handler => comboBox.SelectionChanged -= handler).SubscribeWeakly(this, OnComboBoxSelectionChanged);

                    if (infoList != null)
                    {
                        //comboBox.ItemTemplate = CreateTemplateForReferenceField((IInfoClass) infoList[0], displayField);
                        comboBox.DisplayMemberPath = string.Join(".", infoList.ElementType.GetFullPropertyPath(displayField));
                    }

                    var filterViewModel = (SimpleFilterViewModel)e.Editor.DataContext;
                    if (filterViewModel != null && filterViewModel.Descriptor != null)
                    {
                        var placeholder = filterViewModel.Descriptor.Value as IInfoClass;
                        if (placeholder != null)
                        {
                            comboBox.SelectedValue = placeholder.Id;
                        }
                    }
                }
                finally
                {
                    dataFilter.Tag = null;
                }
            }
            catch (DataPortalException ex)
            {
                PopupFactory.NotifyFailure(ex);
            }
        }
Ejemplo n.º 5
0
        private void DataFilterEditorCreated(object sender, EditorCreatedEventArgs e)
        {
            var viewModel = DataContext as ISearchListViewModel;

            if (viewModel == null)
                return;

            var fieldName = e.ItemPropertyDefinition.PropertyName;
            if (fieldName.EndsWith("Id", StringComparison.Ordinal))
            {
                fieldName = fieldName.Substring(0, fieldName.Length - 2);
            }

            var column = ((IDynamicList)DataContext).Columns[fieldName];
            
            if (column == null)
            {
                return;
            }

            if (fieldName == Constants.CurrentStateColumnName && SetupStateCombobox(e, viewModel)) 
                return;

            if (!string.IsNullOrEmpty(column.ReferenceTableName))
            {
                var crProcessName = column.ReferenceTableName;

                var type = column.Property.DeclaringType;
                var processInfoAttr = (ProcessInfoAttribute)type.GetCustomAttributes(typeof(ProcessInfoAttribute), false).First();

                var displayField = ((CrossRefFieldAttribute)(column.Property.GetCustomAttributes(typeof (CrossRefFieldAttribute), true).First())).RefFieldName;

                FilterDescriptor filterDescriptor = null;
                if (Constants.StateProcessName.Equals(crProcessName) && !string.IsNullOrEmpty(viewModel.ProcessSystemName))
                {
                    filterDescriptor = new FilterDescriptor(Constants.ProcessFieldName, FilterOperator.IsEqualTo, viewModel.ProcessSystemName, typeof(string));
                }

                var filter = filterDescriptor == null ? string.Empty : filterDescriptor.ToJSON();

                LoadReferenceItems(processInfoAttr.Name, fieldName, filter, e, displayField);
            }


            if (FilteringUtils.IsReverseReference(column.Property))
            {
                var rcrAttr = (ReverseCrossRefFieldAttribute)column.Property.GetCustomAttributes(typeof(ReverseCrossRefFieldAttribute), false).FirstOrDefault();
                if (rcrAttr == null)
                    return;

                var filter = new FilterDescriptor(rcrAttr.CrossReferenceFieldName + Constants.IdColumnName, FilterOperator.IsNotEqualTo, null) { MemberType = typeof(int) };

                LoadReferenceItems(viewModel.ProcessSystemName, column.Property.Name, filter.ToJSON(), e, rcrAttr.RefFieldName);
            }

            if (FilteringUtils.IsApproval(column.Property))
            {
                var comboBox = e.Editor.FindChildByType<RadComboBox>();

                if (comboBox != null)
                {
                    dataFilter.Tag = true;

                    var approvalStates = typeof(ApprovalStates).GetFields().Where(f => f.IsLiteral).Select(state => (ApprovalStates)state.GetValue(null)).ToList();

                    comboBox.ItemsSource = approvalStates;

                    Observable.FromEventPattern<SelectionChangedEventHandler, SelectionChangedEventArgs>(
                        handler => comboBox.SelectionChanged += handler, handler => comboBox.SelectionChanged -= handler)
                              .SubscribeWeakly(this, (target, handler) => target.ComboBoxOnSelectionChanged(handler.Sender, handler.EventArgs));

                    var weakListener = new WeakEventListener<FilteringView, RadComboBox, DependencyPropertyChangedEventArgs>(this, comboBox);
                    comboBox.DataContextChanged += weakListener.OnEvent;
                    weakListener.OnEventAction += ComboBoxOnDataContextChanged;
                    weakListener.OnDetachAction += (listener, source) => { source.DataContextChanged -= listener.OnEvent; };

                    dataFilter.Tag = null;
                }
            }

            if (FilteringUtils.IsNumeric(column.Property))
            {
                var numericUpDown = e.Editor.FindChildByType<RadNumericUpDown>();

                if (numericUpDown != null)
                {
                    var weakListener =
                        new WeakEventListener<FilteringView, RadNumericUpDown, DependencyPropertyChangedEventArgs>(
                            this, numericUpDown);
                    numericUpDown.DataContextChanged += weakListener.OnEvent;
                    weakListener.OnEventAction += NumericUpDownOnDataContextChanged;
                    weakListener.OnDetachAction +=
                        (listener, source) => { source.DataContextChanged -= listener.OnEvent; };

                    var filterViewModel = (SimpleFilterViewModel)e.Editor.DataContext;

                    if (filterViewModel != null && filterViewModel.Value == OperatorValueFilterDescriptorBase.UnsetValue)
                    {
                        filterViewModel.Value = null;
                    }
                }
            }

            if (FilteringUtils.IsNullableBool(column.Property))
            {
                var checkBox = e.Editor.FindChildByType<CheckBox>();

                if (checkBox != null)
                {
                    var weakListener = new WeakEventListener<FilteringView, CheckBox, DependencyPropertyChangedEventArgs>(this, checkBox);
                    checkBox.DataContextChanged += weakListener.OnEvent;
                    weakListener.OnEventAction += CheckBoxOnDataContextChanged;
                    weakListener.OnDetachAction += (listener, source) => { source.DataContextChanged -= listener.OnEvent; };

                    var filterViewModel = (SimpleFilterViewModel)e.Editor.DataContext;

                    if (filterViewModel != null && filterViewModel.Value == OperatorValueFilterDescriptorBase.UnsetValue)
                    {
                        filterViewModel.Value = null;
                    }
                }
            }
        }