view release on metacpan or  search on metacpan

lib/Elive/Entity/Group.pm  view on Meta::CPAN

    my $app_data = shift;

    $app_data = $class->SUPER::_freeze($app_data, @_);
    $app_data->{groupId} =~ s{^\*}{} if $app_data->{groupId};

    return $app_data;
}

sub _thaw {
    my $class = shift;
    my $db_data = shift;
    my $path = shift || '';

    return $db_data unless ref $db_data;

    return $class->SUPER::_thaw($db_data, $path, @_);
}

=head1 METHODS

=cut

=head2 insert

    #
    # insert from an array of User Ids. Elements may be integers, strings
    # and/or user objects.
    #
    my $alice = Elive::Entity::User->get_by_loginName('alice');
    my $bob = Elive::Entity::User->get_by_loginName('bob');

    my $group = Elive::Entity::Group->insert({
	name => 'Elluminati',
        # following are all ok
	members => [111111, '222222', $alice->userId, $bob ],
     },
    );

    #
    # insert from a comma separated string of user IDs
    #
    my $group = Elive::Entity::Group->insert({
	name => 'Elluminati',
	members => '111111,222222,333333',
     },
    );

Inserts a new group.

=cut

=head2 update 

    $group->update({members => [111111,'222222', $alice->userId, $bob]});
    $group->update({members => '111111,222222,333333'});

Updates an existing group.

=cut

sub update {
    my ($self, $data, %opt) = @_;
    #
    # updateGroup barfs unless the groupName is included as a parameter.
    #
    $self->set(%$data);
    my @changed = $self->is_changed;
    push (@changed, 'name')
	unless grep {$_ eq 'name'} @changed;

    return $self->SUPER::update( undef, %opt, changed => \@changed);
}

=head2 expand_members

This is a utility method that includes the sum total of all members in
the group, including those in recursively nested sub-groups. The list
is further reduced to only include unique members.

    my @all_members = $group_obj->expand_members();

It returns C<loginNames> as an array of strings.

=cut

sub expand_members {
    my $self = shift;
    my %seen = @_;

    my @members;

    foreach (@{ $self->members || []}) {
	my @elements;

	if (Scalar::Util::blessed($_)
	    && $_->can('groupId')
	    && $_->can('expand_members')) {
	    # recursive expansion
	    @elements = $_->expand_members(%seen)
		unless $seen{g => $_->groupId}++;
	}
	else {
	    @elements = (Elive::Util::string($_));
	}

	foreach my $member (@elements) {
	    $member = Elive::Util::string($member)
		if ref $member;

	    if (defined $member && $member =~ m{^\*}) {
		# should be caught in BUILDARGS anyway...
		carp "skipping unexpanded group: $member";
	    }
	    else {
		push(@members, $member)
		unless $seen{u => $member}++;
	    }
	}
    }

    @members = sort @members;