Пример #1
0
        /// <summary>
        /// Gets a single report parameter value from the filter
        /// </summary>
        /// <param name="parameterName">The parameter name</param>
        /// <returns>The parameter value</returns>
        public ReportFilterParameterValue GetParameterValue
        (
            string parameterName
        )
        {
            Validate.IsNotEmpty(parameterName);

            var value = _parameterValues.FirstOrDefault
                        (
                p => p.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase)
                        );

            if (value == null)
            {
                var definition = GetDefinition
                                 (
                    parameterName
                                 );

                var allParameterValues = GetParameterValuesAsDictionary();

                var lookupParameterValues = CompileLookupParameterValues
                                            (
                    parameterName,
                    allParameterValues
                                            );

                value = new ReportFilterParameterValue
                        (
                    definition,
                    definition.Parameter.DefaultValue,
                    lookupParameterValues
                        );
            }

            return(value);
        }
Пример #2
0
        /// <summary>
        /// Sets a single report filter parameter value
        /// </summary>
        /// <param name="parameterName">The parameter name</param>
        /// <param name="valueToSet">The value to set</param>
        /// <param name="isConstrained">True, if the parameter is constrained</param>
        /// <param name="constraintValue">The constrained value</param>
        /// <param name="lookupParameterValues">The lookup parameter values</param>
        private void SetParameterValue
        (
            string parameterName,
            object valueToSet,
            bool isConstrained     = false,
            object constraintValue = null,
            params ParameterValue[] lookupParameterValues
        )
        {
            Validate.IsNotEmpty(parameterName);

            var parameterValue = _parameterValues.FirstOrDefault
                                 (
                p => p.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase)
                                 );

            if (parameterValue != null)
            {
                if (valueToSet == null)
                {
                    valueToSet = parameterValue.Parameter.DefaultValue;
                }

                parameterValue.SetValue
                (
                    valueToSet,
                    lookupParameterValues
                );
            }
            else
            {
                var definition = GetDefinition
                                 (
                    parameterName
                                 );

                parameterValue = new ReportFilterParameterValue
                                 (
                    definition,
                    valueToSet,
                    lookupParameterValues
                                 );

                _parameterValues.Add
                (
                    parameterValue
                );
            }

            if (isConstrained)
            {
                var definition = parameterValue.Definition;

                if (definition.Parameter.HasLookup)
                {
                    parameterValue.AutoFilterLookupItemsForConstraint
                    (
                        constraintValue
                    );

                    var valueAllowed = parameterValue.HasLookupItem
                                       (
                        valueToSet
                                       );

                    if (false == valueAllowed)
                    {
                        parameterValue.ResetValue();
                    }

                    // NOTE:
                    // Auto hide the parameter if one or less lookup items are available
                    if (parameterValue.LookupItems.Length <= 1)
                    {
                        definition.Hide();
                    }
                }
                else
                {
                    parameterValue.SetValue
                    (
                        constraintValue,
                        lookupParameterValues
                    );

                    definition.Hide();
                }
            }
        }