コード例 #1
0
 static HxSelect()
 {
     Defaults = new SelectSettings()
     {
         InputSize = InputSize.Regular,
     };
 }
コード例 #2
0
        /// <summary>
        /// Provides a user-friendly description of the specified filter values.
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A string containing the user-friendly description of the settings.
        /// </returns>
        public override string FormatSelection(Type entityType, string selection)
        {
            var settings = new SelectSettings(selection);

            string result = GetTitle(null);

            if (!settings.IsValid)
            {
                return(result);
            }

            using (var context = new RockContext())
            {
                var dataView = new DataViewService(context).Get(settings.DataViewGuid.GetValueOrDefault());

                result = string.Format("Members of Groups in Data View \"{0}\"", (dataView != null ? dataView.ToString() : string.Empty));

                var groupMemberStatus = settings.MemberStatus;

                if (groupMemberStatus.HasValue)
                {
                    result += ", with Status: " + groupMemberStatus.ToString();
                }

                if (settings.RoleType.HasValue &&
                    settings.RoleType != RoleTypeSpecifier.Any)
                {
                    result += ", with Role Type: " + settings.RoleType.ToString();
                }
            }

            return(result);
        }
コード例 #3
0
        /// <summary>
        /// Gets the expression.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="entityIdProperty">The entity identifier property.</param>
        /// <param name="selection">The selection.</param>
        /// <returns></returns>
        public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
        {
            var settings = new SelectSettings(selection);

            var entityFields = GetGroupMemberAttributes();
            var entityField  = entityFields.FirstOrDefault(f => f.Name == settings.AttributeKey);

            if (entityField == null)
            {
                return(null);
            }

            var serviceInstance = new AttributeValueService(context);

            var entityTypeId = EntityTypeCache.GetId(typeof(Rock.Model.GroupMember));

            var valuesQuery = serviceInstance.Queryable()
                              .Where(x => x.Attribute.Key == settings.AttributeKey && x.Attribute.EntityTypeId == entityTypeId)
                              .Select(x => new { x.EntityId, x.Value });

            var groupMemberService = new GroupMemberService(context);

            var resultQuery = groupMemberService.Queryable()
                              .Select(gm => valuesQuery.FirstOrDefault(v => v.EntityId == gm.Id).Value);

            var exp = SelectExpressionExtractor.Extract(resultQuery, entityIdProperty, "gm");

            return(exp);
        }
コード例 #4
0
        /// <summary>
        /// Sets the selection.
        /// </summary>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection(Control[] controls, string selection)
        {
            var ddlDataView          = controls.GetByName <DataViewPicker>(_CtlDataView);
            var ddlRoleType          = controls.GetByName <RockDropDownList>(_CtlRoleType);
            var ddlFormat            = controls.GetByName <RockDropDownList>(_CtlFormat);
            var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);

            var settings = new SelectSettings(selection);

            if (!settings.IsValid)
            {
                return;
            }

            ddlFormat.SelectedValue = settings.ListFormat.ToString();

            if (settings.DataViewGuid.HasValue)
            {
                var dsService = new DataViewService(new RockContext());

                var dataView = dsService.Get(settings.DataViewGuid.Value);

                if (dataView != null)
                {
                    ddlDataView.SelectedValue = dataView.Id.ToString();
                }
            }

            ddlRoleType.SelectedValue          = settings.RoleType.ToStringSafe();
            ddlGroupMemberStatus.SelectedValue = settings.MemberStatus.ToStringSafe();
        }
コード例 #5
0
        /// <summary>
        /// Sets the selection.
        /// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection(Type entityType, Control[] controls, string selection)
        {
            var dvpDataView          = controls.GetByName <DataViewItemPicker>(_CtlDataView);
            var ddlRoleType          = controls.GetByName <RockDropDownList>(_CtlRoleType);
            var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);

            var settings = new SelectSettings(selection);

            if (!settings.IsValid)
            {
                return;
            }

            if (settings.DataViewGuid.HasValue)
            {
                var dsService = new DataViewService(new RockContext());

                var dataView = dsService.Get(settings.DataViewGuid.Value);

                dvpDataView.SetValue(dataView);
            }

            ddlRoleType.SelectedValue          = settings.RoleType.ToStringSafe();
            ddlGroupMemberStatus.SelectedValue = settings.MemberStatus.ToStringSafe();
        }
コード例 #6
0
        protected override void CreateMenu(ControlBase menu)
        {
            Button worlds = new(menu)
            {
                Text = Language.Worlds
            };

            worlds.Clicked += (_, _) => SelectWorlds?.Invoke();

            Button settings = new(menu)
            {
                Text = Language.Settings
            };

            settings.Pressed += (_, _) => SelectSettings?.Invoke();

            Button credits = new(menu)
            {
                Text = Language.Credits
            };

            credits.Pressed += (_, _) => SelectCredits?.Invoke();

            Button exit = new(menu)
            {
                Text = Language.Exit
            };

            exit.Pressed += (_, _) => SelectExit?.Invoke();
        }
コード例 #7
0
        /// <summary>
        /// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
        /// </summary>
        /// <param name="entityType">The type of entity in the result set.</param>
        /// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
        /// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A Linq Expression that can be used to filter an IQueryable.
        /// </returns>
        public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
        {
            var settings = new SelectSettings(selection);

            var context = ( RockContext )serviceInstance.Context;

            //
            // Evaluate the Data View that defines the candidate Groups.
            //
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);

            var personService = new PersonService(context);

            var personQuery = personService.Queryable();

            if (dataView != null)
            {
                personQuery = DataComponentSettingsHelper.FilterByDataView(personQuery, dataView, personService);
            }

            var personKeys = personQuery.Select(x => x.Id);

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var connectionRequestQuery = new ConnectionRequestService(context).Queryable();

            // Filter By Person.
            connectionRequestQuery = connectionRequestQuery.Where(p => personKeys.Contains(p.PersonAlias.PersonId));

            var selectExpression = FilterExpressionExtractor.Extract <Model.ConnectionRequest>(connectionRequestQuery, parameterExpression, "p");

            return(selectExpression);
        }
コード例 #8
0
        /// <summary>
        /// Gets the selection.
        /// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="controls">The collection of controls used to set the filter values.</param>
        /// <returns>
        /// A formatted string.
        /// </returns>
        public override string GetSelection(Type entityType, Control[] controls)
        {
            var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);

            var settings = new SelectSettings();

            settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(dvpDataView.SelectedValue);

            return(settings.ToSelectionString());
        }
コード例 #9
0
        /// <summary>
        /// Gets the grid field.
        /// </summary>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="selection">The selection.</param>
        /// <returns></returns>
        public override DataControlField GetGridField(Type entityType, string selection)
        {
            BoundField boundField;

            var settings = new SelectSettings(selection);

            var entityFields = GetGroupMemberAttributeEntityFields();

            var entityField = entityFields.FirstOrDefault(f => f.UniqueName == settings.AttributeKey);

            if (entityField == null)
            {
                // This shouldn't happe, but if searching by UniqueName didn't work, search by Name instead
                entityField = entityFields.FirstOrDefault(f => f.Name == settings.AttributeKey);
            }

            if (entityField == null)
            {
                // should't happen, but just in case
                return(new BoundField());
            }

            if (entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.BOOLEAN.AsGuid()))
            {
                boundField = new BoolField();
            }
            else if (entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DATE.AsGuid()))
            {
                boundField = new DateField();
            }
            else if (entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DATE_TIME.AsGuid()))
            {
                boundField = new DateTimeField();
            }
            else if (entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DEFINED_VALUE.AsGuid()))
            {
                boundField = new DefinedValueField();
            }
            else
            {
                boundField = new BoundField();
            }

            boundField.SortExpression = boundField.DataField;

            if (entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.INTEGER.AsGuid()) ||
                entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DATE.AsGuid()) ||
                entityField.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.FILTER_DATE.AsGuid()))
            {
                boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
                boundField.ItemStyle.HorizontalAlign   = HorizontalAlign.Right;
            }

            return(boundField);
        }
コード例 #10
0
        /// <summary>
        /// Gets the selection.
        /// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="controls">The collection of controls used to set the filter values.</param>
        /// <returns>
        /// A formatted string.
        /// </returns>
        public override string GetSelection(Type entityType, Control[] controls)
        {
            var dvpDataView          = controls.GetByName <DataViewItemPicker>(_CtlDataView);
            var ddlRoleType          = controls.GetByName <RockDropDownList>(_CtlRoleType);
            var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);

            var settings = new SelectSettings();

            settings.MemberStatus = ddlGroupMemberStatus.SelectedValue.ConvertToEnumOrNull <GroupMemberStatus>();
            settings.RoleType     = ddlRoleType.SelectedValue.ConvertToEnumOrNull <RoleTypeSpecifier>();
            settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(dvpDataView.SelectedValue);

            return(settings.ToSelectionString());
        }
コード例 #11
0
        /// <summary>
        /// Gets the selection.
        /// This is typically a string that contains the values selected with the Controls
        /// </summary>
        /// <param name="controls">The controls.</param>
        /// <returns></returns>
        public override string GetSelection(Control[] controls)
        {
            var ddlDataView          = controls.GetByName <DataViewPicker>(_CtlDataView);
            var ddlRoleType          = controls.GetByName <RockDropDownList>(_CtlRoleType);
            var ddlFormat            = controls.GetByName <RockDropDownList>(_CtlFormat);
            var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);

            var settings = new SelectSettings();

            settings.MemberStatus = ddlGroupMemberStatus.SelectedValue.ConvertToEnumOrNull <GroupMemberStatus>();
            settings.RoleType     = ddlRoleType.SelectedValue.ConvertToEnumOrNull <RoleTypeSpecifier>();
            settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(ddlDataView.SelectedValue);
            settings.ListFormat   = ddlFormat.SelectedValue.ConvertToEnum <ListFormatSpecifier>(ListFormatSpecifier.FirstNameLastNameRole);

            return(settings.ToSelectionString());
        }
コード例 #12
0
        /// <summary>
        /// Gets the selection.
        /// This is typically a string that contains the values selected with the Controls
        /// </summary>
        /// <param name="controls">The controls.</param>
        /// <returns></returns>
        public override string GetSelection(Control[] controls)
        {
            // Get selection control instances.
            var pnlGroupAttributeFilterControls = controls.GetByName <Panel>(_CtlGroup);
            var ddlProperty = controls.GetByName <DropDownList>(_CtlProperty);

            if (pnlGroupAttributeFilterControls == null)
            {
                return(null);
            }

            var settings = new SelectSettings();

            settings.AttributeKey = ddlProperty.SelectedValue;

            return(settings.ToSelectionString());
        }
コード例 #13
0
        /// <summary>
        /// Sets the selection.
        /// </summary>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection(Control[] controls, string selection)
        {
            // Get selection control instances.
            var pnlGroupAttributeFilterControls = controls.GetByName <Panel>(_CtlGroup);
            var ddlProperty = controls.GetByName <DropDownList>(_CtlProperty);

            if (pnlGroupAttributeFilterControls == null)
            {
                return;
            }

            var settings = new SelectSettings(selection);

            if (!settings.IsValid)
            {
                return;
            }

            ddlProperty.SelectedValue = settings.AttributeKey;
        }
コード例 #14
0
        /// <summary>
        /// Provides a user-friendly description of the specified filter values.
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A string containing the user-friendly description of the settings.
        /// </returns>
        public override string FormatSelection(Type entityType, string selection)
        {
            var settings = new SelectSettings(selection);

            string result = GetTitle(null);

            if (!settings.IsValid)
            {
                return(result);
            }

            using (var context = new RockContext())
            {
                var dataView = new DataViewService(context).Get(settings.DataViewGuid.GetValueOrDefault());

                result = string.Format("People - matched to the Requestor \"{0}\"", dataView != null ? dataView.ToString() : string.Empty);
            }

            return(result);
        }
コード例 #15
0
        /// <summary>
        /// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
        /// </summary>
        /// <param name="entityType">The type of entity in the result set.</param>
        /// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
        /// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A Linq Expression that can be used to filter an IQueryable.
        /// </returns>
        public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
        {
            var settings = new SelectSettings(selection);

            var context = (RockContext)serviceInstance.Context;

            //
            // Evaluate the Data View that defines the candidate Groups.
            //
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);

            var groupService = new GroupService(context);

            var groupQuery = groupService.Queryable();

            if (dataView != null)
            {
                groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
            }
            else
            {
                // Apply a default Group filter to only show Groups that would be visible in a Group List.
                groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
            }

            var groupKeys = groupQuery.Select(x => x.Id);

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService(context).Queryable();

            // Filter By Group.
            groupMemberQuery = groupMemberQuery.Where(gm => groupKeys.Contains(gm.GroupId));

            var selectExpression = FilterExpressionExtractor.Extract <Model.GroupMember>(groupMemberQuery, parameterExpression, "gm");

            return(selectExpression);
        }
コード例 #16
0
        /// <summary>
        /// Sets the selection.
        /// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection(Type entityType, Control[] controls, string selection)
        {
            var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);

            var settings = new SelectSettings(selection);

            if (!settings.IsValid)
            {
                return;
            }

            if (settings.DataViewGuid.HasValue)
            {
                var dsService = new DataViewService(new RockContext());

                var dataView = dsService.Get(settings.DataViewGuid.Value);

                if (dataView != null)
                {
                    dvpDataView.SetValue(dataView);
                }
            }
        }
コード例 #17
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
        /// </summary>
        /// <param name="entityType">The type of entity in the result set.</param>
        /// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
        /// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A Linq Expression that can be used to filter an IQueryable.
        /// </returns>
        public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
        {
            var settings = new SelectSettings( selection );

            var context = (RockContext)serviceInstance.Context;

            //
            // Evaluate the Data View that defines the candidate Groups.
            //
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent( settings.DataViewGuid, context );

            var groupService = new GroupService( context );

            var groupQuery = groupService.Queryable();

            if (dataView != null)
            {
                groupQuery = DataComponentSettingsHelper.FilterByDataView( groupQuery, dataView, groupService );
            }
            else
            {
                // Apply a default Group filter to only show Groups that would be visible in a Group List.
                groupQuery = groupQuery.Where( x => x.GroupType.ShowInGroupList );
            }

            var groupKeys = groupQuery.Select( x => x.Id );

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService( context ).Queryable();

            // Filter By Group.
            groupMemberQuery = groupMemberQuery.Where( x => groupKeys.Contains( x.GroupId ) );

            // Filter By Group Role Type.
            switch ( settings.RoleType )
            {
                case RoleTypeSpecifier.Member:
                    groupMemberQuery = groupMemberQuery.Where( x => !x.GroupRole.IsLeader );
                    break;

                case RoleTypeSpecifier.Leader:
                    groupMemberQuery = groupMemberQuery.Where( x => x.GroupRole.IsLeader );
                    break;
            }

            // Filter by Group Member Status.
            if ( settings.MemberStatus.HasValue )
            {
                groupMemberQuery = groupMemberQuery.Where( x => x.GroupMemberStatus == settings.MemberStatus.Value );
            }

            //
            // Create a Select Expression to return the Person records referenced by the Group Members.
            //
            var personGroupsQuery = new PersonService( context ).Queryable()
                                                                .Where( p => groupMemberQuery.Select( gm => gm.PersonId ).Contains( p.Id ) );

            var selectExpression = FilterExpressionExtractor.Extract<Model.Person>( personGroupsQuery, parameterExpression, "p" );

            return selectExpression;
        }
コード例 #18
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Provides a user-friendly description of the specified filter values.
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A string containing the user-friendly description of the settings.
        /// </returns>
        public override string FormatSelection( Type entityType, string selection )
        {
            var settings = new SelectSettings( selection );

            string result = GetTitle( null );

            if ( !settings.IsValid )
            {
                return result;
            }

            using ( var context = new RockContext() )
            {
                var dataView = new DataViewService( context ).Get( settings.DataViewGuid.GetValueOrDefault() );

                result = string.Format( "Members of Groups in Data View \"{0}\"", (dataView != null ? dataView.ToString() : string.Empty ));

                var groupMemberStatus = settings.MemberStatus;

                if (groupMemberStatus.HasValue)
                {
                    result += ", with Status: " + groupMemberStatus.ToString();
                }

                if (settings.RoleType.HasValue
                    && settings.RoleType != RoleTypeSpecifier.Any)
                {
                    result += ", with Role Type: " + settings.RoleType.ToString();
                }
            }

            return result;
        }
コード例 #19
0
        /// <summary>
        /// Gets the expression.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="entityIdProperty">The entity identifier property.</param>
        /// <param name="selection">The selection.</param>
        /// <returns></returns>
        public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
        {
            var settings = new SelectSettings(selection);

            // Get the Person Data View that defines the set of candidates from which matching Group Members can be selected.
            IQueryable <int> personKeys = null;

            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);

            var personService = new PersonService(context);

            var personQuery = personService.Queryable();

            if (dataView != null)
            {
                personQuery = DataComponentSettingsHelper.FilterByDataView(personQuery, dataView, personService);

                personKeys = personQuery.Select(x => x.Id);
            }

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService(context).Queryable();

            // Filter By People.
            if (personKeys != null)
            {
                groupMemberQuery = groupMemberQuery.Where(x => personKeys.Contains(x.PersonId));
            }

            // Filter By Group Role Type.
            switch (settings.RoleType)
            {
            case RoleTypeSpecifier.Member:
                groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
                break;

            case RoleTypeSpecifier.Leader:
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
                break;
            }

            // Filter by Group Member Status.
            if (settings.MemberStatus.HasValue)
            {
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
            }

            //
            // Create a Select Expression to return the requested values.
            //

            // Set the Output Format of the field.
            Expression <Func <Rock.Model.GroupMember, string> > outputExpression;

            switch (settings.ListFormat)
            {
            case ListFormatSpecifier.FirstNameLastName:
                outputExpression = ((m => m.Person.FirstName + " " + m.Person.LastName));
                break;

            default:     // ListFormatSpecifier.GroupAndRole:
                outputExpression = ((m => m.Person.FirstName + " " + m.Person.LastName + " [" + m.GroupRole.Name + "]"));
                break;
            }

            // Define a Query to return the collection of filtered People for each Group.
            var groupPeopleQuery = new GroupService(context).Queryable()
                                   .Select(g => groupMemberQuery.Where(s => s.GroupId == g.Id)
                                           .OrderBy(x => x.Person.LastName)
                                           .ThenBy(x => x.Person.FirstName)
                                           .ThenBy(x => x.GroupRole.Name)
                                           .Select(outputExpression).AsEnumerable());

            var selectExpression = SelectExpressionExtractor.Extract <Model.Person>(groupPeopleQuery, entityIdProperty, "g");

            return(selectExpression);
        }
コード例 #20
0
        /// <summary>
        /// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
        /// </summary>
        /// <param name="entityType">The type of entity in the result set.</param>
        /// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
        /// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A Linq Expression that can be used to filter an IQueryable.
        /// </returns>
        public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
        {
            var settings = new SelectSettings(selection);

            var context = ( RockContext )serviceInstance.Context;

            //
            // Evaluate the Data View that defines the candidate Groups.
            //
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);

            var groupService = new GroupService(context);

            var groupQuery = groupService.Queryable();

            if (dataView != null)
            {
                groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
            }
            else
            {
                // Apply a default Group filter to only show Groups that would be visible in a Group List.
                groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
            }

            var groupKeys = groupQuery.Select(x => x.Id);

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService(context).Queryable();

            // Filter By Group.
            groupMemberQuery = groupMemberQuery.Where(x => groupKeys.Contains(x.GroupId));

            // Filter By Group Role Type.
            switch (settings.RoleType)
            {
            case RoleTypeSpecifier.Member:
                groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
                break;

            case RoleTypeSpecifier.Leader:
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
                break;
            }

            // Filter by Group Member Status.
            if (settings.MemberStatus.HasValue)
            {
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
            }

            //
            // Create a Select Expression to return the Person records referenced by the Group Members.
            //
            var personGroupsQuery = new PersonService(context).Queryable()
                                    .Where(p => groupMemberQuery.Select(gm => gm.PersonId).Contains(p.Id));

            var selectExpression = FilterExpressionExtractor.Extract <Model.Person>(personGroupsQuery, parameterExpression, "p");

            return(selectExpression);
        }
コード例 #21
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Provides a user-friendly description of the specified filter values.
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A string containing the user-friendly description of the settings.
        /// </returns>
        public override string FormatSelection( Type entityType, string selection )
        {
            var settings = new SelectSettings( selection );

            string result = GetTitle( null );

            if ( !settings.IsValid )
            {
                return result;
            }

            using ( var context = new RockContext() )
            {
                var dataView = new DataViewService( context ).Get( settings.DataViewGuid.GetValueOrDefault() );

                result = string.Format( "Members of Groups in Data View \"{0}\"", (dataView != null ? dataView.ToString() : string.Empty ));
            }

            return result;
        }
コード例 #22
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
        /// </summary>
        /// <param name="entityType">The type of entity in the result set.</param>
        /// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
        /// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
        /// <param name="selection">A formatted string representing the filter settings.</param>
        /// <returns>
        /// A Linq Expression that can be used to filter an IQueryable.
        /// </returns>
        public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
        {
            var settings = new SelectSettings( selection );

            var context = (RockContext)serviceInstance.Context;

            //
            // Evaluate the Data View that defines the candidate Groups.
            //
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent( settings.DataViewGuid, context );

            var groupService = new GroupService( context );

            var groupQuery = groupService.Queryable();

            if (dataView != null)
            {
                groupQuery = DataComponentSettingsHelper.FilterByDataView( groupQuery, dataView, groupService );
            }
            else
            {
                // Apply a default Group filter to only show Groups that would be visible in a Group List.
                groupQuery = groupQuery.Where( x => x.GroupType.ShowInGroupList );
            }

            var groupKeys = groupQuery.Select( x => x.Id );

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService( context ).Queryable();

            // Filter By Group.
            groupMemberQuery = groupMemberQuery.Where( gm => groupKeys.Contains( gm.GroupId ) );

            var selectExpression = FilterExpressionExtractor.Extract<Model.GroupMember>( groupMemberQuery, parameterExpression, "gm" );

            return selectExpression;
        }
コード例 #23
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Gets the selection.
        /// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="controls">The collection of controls used to set the filter values.</param>
        /// <returns>
        /// A formatted string.
        /// </returns>
        public override string GetSelection( Type entityType, Control[] controls )
        {
            var ddlDataView = controls.GetByName<DataViewPicker>( _CtlDataView );

            var settings = new SelectSettings();

            settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid( ddlDataView.SelectedValue );

            return settings.ToSelectionString();
        }
コード例 #24
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Gets the selection.
        /// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
        /// <param name="controls">The collection of controls used to set the filter values.</param>
        /// <returns>
        /// A formatted string.
        /// </returns>
        public override string GetSelection( Type entityType, Control[] controls )
        {
            var ddlDataView = controls.GetByName<DataViewPicker>( _CtlDataView );
            var ddlRoleType = controls.GetByName<RockDropDownList>( _CtlRoleType );
            var ddlGroupMemberStatus = controls.GetByName<RockDropDownList>( _CtlGroupStatus );

            var settings = new SelectSettings();

            settings.MemberStatus = ddlGroupMemberStatus.SelectedValue.ConvertToEnumOrNull<GroupMemberStatus>();
            settings.RoleType = ddlRoleType.SelectedValue.ConvertToEnumOrNull<RoleTypeSpecifier>();
            settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid( ddlDataView.SelectedValue );

            return settings.ToSelectionString();
        }
コード例 #25
0
        public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
        {
            var settings = new SelectSettings(selection);

            //
            // Define Candidate Groups.
            //

            // Get the Group Data View that defines the set of candidates from which matching Groups can be selected.
            var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);

            // Evaluate the Data View that defines the candidate Groups.
            var groupService = new GroupService(context);

            var groupQuery = groupService.Queryable();

            if (dataView != null)
            {
                groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
            }
            else
            {
                // Apply a default Group filter to only show Groups that would be visible in a Group List.
                groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
            }

            var groupKeys = groupQuery.Select(x => x.Id);

            //
            // Construct the Query to return the list of Group Members matching the filter conditions.
            //
            var groupMemberQuery = new GroupMemberService(context).Queryable();

            // Filter By Group.
            groupMemberQuery = groupMemberQuery.Where(x => groupKeys.Contains(x.GroupId));

            // Filter By Group Role Type.
            switch (settings.RoleType)
            {
            case RoleTypeSpecifier.Member:
                groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
                break;

            case RoleTypeSpecifier.Leader:
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
                break;
            }

            // Filter by Group Member Status.
            if (settings.MemberStatus.HasValue)
            {
                groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
            }

            //
            // Create a Select Expression to return the requested values.
            //

            // Set the Output Format of the field.
            Expression selectExpression;

            if (settings.ListFormat == ListFormatSpecifier.YesNo)
            {
                // Define a Query to return True/False text indicating if the Person participates in any of the filtered Groups.
                // Note that the text must be returned as an Enumerable to satisfy the expected output of this field.
                var personGroupsQuery = new PersonService(context).Queryable()
                                        .Select(p => new List <string> {
                    groupMemberQuery.Any(s => s.PersonId == p.Id) ? "Yes" : "No"
                });

                selectExpression = SelectExpressionExtractor.Extract(personGroupsQuery, entityIdProperty, "p");
            }
            else
            {
                // Define a Query to return the collection of filtered Groups for each Person.
                Expression <Func <Rock.Model.GroupMember, string> > outputExpression;

                if (settings.ListFormat == ListFormatSpecifier.GroupOnly)
                {
                    outputExpression = ((m => m.Group.Name));
                }
                else
                {
                    outputExpression = ((m => m.Group.Name + " [" + m.GroupRole.Name + "]"));
                }

                // Define a Query to return the collection of filtered Groups for each Person.
                var personGroupsQuery = new PersonService(context).Queryable()
                                        .Select(p => groupMemberQuery.Where(s => s.PersonId == p.Id)
                                                .OrderBy(x => x.Group.Name)
                                                .ThenBy(x => x.GroupRole.Name)
                                                .Select(outputExpression).AsEnumerable());

                selectExpression = SelectExpressionExtractor.Extract(personGroupsQuery, entityIdProperty, "p");
            }

            return(selectExpression);
        }
コード例 #26
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Sets the selection.
        /// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection( Type entityType, Control[] controls, string selection )
        {
            var ddlDataView = controls.GetByName<DataViewPicker>( _CtlDataView );
            var ddlRoleType = controls.GetByName<RockDropDownList>( _CtlRoleType );
            var ddlGroupMemberStatus = controls.GetByName<RockDropDownList>( _CtlGroupStatus );

            var settings = new SelectSettings( selection );

            if ( !settings.IsValid )
            {
                return;
            }

            if ( settings.DataViewGuid.HasValue )
            {
                var dsService = new DataViewService( new RockContext() );

                var dataView = dsService.Get( settings.DataViewGuid.Value );

                if ( dataView != null )
                {
                    ddlDataView.SelectedValue = dataView.Id.ToString();
                }
            }

            ddlRoleType.SelectedValue = settings.RoleType.ToStringSafe();
            ddlGroupMemberStatus.SelectedValue = settings.MemberStatus.ToStringSafe();
        }
コード例 #27
0
ファイル: GroupDataViewFilter.cs プロジェクト: NewSpring/Rock
        /// <summary>
        /// Sets the selection.
        /// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
        /// </summary>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="controls">The controls.</param>
        /// <param name="selection">The selection.</param>
        public override void SetSelection( Type entityType, Control[] controls, string selection )
        {
            var ddlDataView = controls.GetByName<DataViewPicker>( _CtlDataView );

            var settings = new SelectSettings( selection );

            if ( !settings.IsValid )
            {
                return;
            }

            if ( settings.DataViewGuid.HasValue )
            {
                var dsService = new DataViewService( new RockContext() );

                var dataView = dsService.Get( settings.DataViewGuid.Value );

                if ( dataView != null )
                {
                    ddlDataView.SelectedValue = dataView.Id.ToString();
                }
            }
        }