CatalystX::Usul::Model::Roles - Manage the roles and their members

   package YourApp::Model::Roles;

   use CatalystX::Usul::Model::Roles;

   sub new {
      my ($self, $app, $config) = @_;

      my $role_obj = CatalystX::Usul::Model::Roles->new( $app, $config );
   }

   $role_obj->add_roles_to_user( $args );

   $role_obj->add_users_to_role( $args );

   $role_obj->create;

   $role_obj->delete;

   @members = $role_obj->get_member_list( $role );

   @roles = $role_obj->get_roles( $user, $rid );

   $bool = $role_obj->is_role( $role );

   $role_obj->remove_roles_from_user( $args );

   $role_obj->remove_users_from_role( $args );

   $role_obj->role_form;

   $role_obj->update;

# @(#)$Id: Roles.pm 576 2009-06-09 23:23:46Z pjf $

package CatalystX::Usul::Model::Roles;

use strict;
use warnings;
use version; our $VERSION = qv( sprintf '0.3.%d', q$Rev: 576 $ =~ /\d+/gmx );
use parent qw(CatalystX::Usul::Model);

use Class::C3;

__PACKAGE__->mk_accessors( qw(auth_realms domain_attributes domain_class
                              role_domain users) );

sub new {
   my ($self, $app, @rest) = @_;

   my $new       = $self->next::method( $app, @rest );
   my $dom_class = $new->domain_class;

   $self->ensure_class_loaded( $dom_class );

   my $dom_attrs = $new->domain_attributes || {};

   $new->role_domain( $dom_class->new( $app, $dom_attrs ) );

   return $new;
}

sub build_per_context_instance {
   my ($self, $c, @rest) = @_;

   my $new = $self->next::method( $c, @rest );

   my $dom_attrs = $new->domain_attributes;

   my $rdm = $new->role_domain( $new->domain_class->new( $c, $dom_attrs ) );

   if ($rdm->can( q(dbic_role_class) )) {
      my $class;

      if ($class = $rdm->dbic_role_class) {
         $rdm->dbic_role_model( $c->model( $class ) );
      }

      if ($class = $rdm->dbic_user_roles_class) {
         $rdm->dbic_user_roles_model( $c->model( $class ) );
      }
   }

   return $new;
}

sub add_roles_to_user {
   my ($self, $args) = @_; my ($msg, $role, $user);

   $self->throw( 'No user specified' ) unless ($user = $args->{user});

   for $role (@{ $self->query_array( $args->{field} ) }) {
      $self->role_domain->add_user_to_role( $role, $user );
      $msg .= $msg ? q(, ).$role : $role;
   }

   $self->add_result_msg( q(roles_added), $user, $msg );
   return;
}

sub add_users_to_role {
   my ($self, $args) = @_; my ($msg, $role, $user);

   unless ($role = $args->{role} and $self->is_role( $role )) {
      $self->throw( error => 'Role [_1] unknown', args => [ $role ] );
   }

   for $user (@{ $self->query_array( $args->{field} ) }) {
      $self->role_domain->add_user_to_role( $role, $user );
      $msg .= $msg ? q(, ).$user : $user;
   }

   $self->add_result_msg( q(users_added), $role, $msg );
   return;
}

sub create {
   my $self = shift; my $s = $self->context->stash; my $name;

   unless ($name = $self->query_value( q(name) )) {
      $self->throw( 'No role specified' );
   }

   if ($self->is_role( $name )) {
      $self->throw( error => 'Role [_1] already exists', args => [ $name ] );
   }

   $name = $self->check_field( $s->{form}->{name}.q(.name), $name );
   $self->role_domain->create( $name );
   $self->add_result_msg( q(role_created), $name );
   return $name;
}

sub delete {
   my $self = shift; my $role;

   unless ($role = $self->query_value( q(role) )) {
      $self->throw( 'No role specified' );
   }

   unless ($self->is_role( $role )) {
      $self->throw( error => 'Role [_1] unknown', args => [ $role ] );
   }

   $self->role_domain->delete( $role );
   $self->add_result_msg( q(role_deleted), $role );
   return;
}

sub get_member_list {
   my ($self, @rest) = @_;

   return $self->role_domain->get_member_list( @rest );
}

sub get_roles {
   my ($self, @rest) = @_; return $self->role_domain->get_roles( @rest );
}

sub is_role {
   my ($self, @rest) = @_; return $self->role_domain->is_role( @rest );
}

sub remove_roles_from_user {
   my ($self, $args) = @_; my ($msg, $role, $user);

   $self->throw( 'No user specified' ) unless ($user = $args->{user});

   for $role (@{ $self->query_array( $args->{field} ) }) {
      $self->role_domain->remove_user_from_role( $role, $user );
      $msg .= $msg ? q(, ).$role : $role;
   }

   $self->add_result_msg( q(roles_removed), $user, $msg );
   return;
}

sub remove_users_from_role {
   my ($self, $args) = @_; my ($msg, $role, $user);

   unless ($role = $args->{role} and $self->is_role( $role )) {
      $self->throw( error => 'Role [_1] unknown', args => [ $role ] );
   }

   for $user (@{ $self->query_array( $args->{field} ) }) {
      $self->role_domain->remove_user_from_role( $role, $user );
      $msg .= $msg ? q(, ).$user : $user;
   }

   $self->add_result_msg( q(users_removed), $role, $msg );
   return;
}

sub role_manager_form {
   my ($self, $realm, $role) = @_; my ($e, @members, @roles, @users);

   eval {
      @members = $self->get_member_list( $role );
      @roles   = $self->get_roles( q(all) );
      @users   = grep { !$self->is_member( $_, @members ) }
                 @{ $self->users->retrieve( q([^\?]+), q() )->user_list };
   };

   return $self->add_error( $e ) if ($e = $self->catch);

   my $s      = $self->context->stash; $s->{pwidth} -= 10;
   my $first  = $role eq $s->{newtag} ? q(.name) : q(.role);
   my $values = [ q(), sort keys %{ $self->auth_realms } ];
   my $form   = $s->{form}->{name};

   unshift @roles, q(), $s->{newtag};

   $self->clear_form(   { firstfld => $form.$first } );
   $self->add_field(    { default  => $realm,
                          id       => $form.q(.realm),
                          values   => $values } );
   $self->add_field(    { default  => $role,
                          id       => $form.q(.role),
                          values   => \@roles } );
   $self->group_fields( { id       => $form.q(.select), nitems => 2 } );

   return unless ($role);

   if ($role eq $s->{newtag}) {
      $self->add_field(    { ajaxid  => $form.q(.name) } );
      $self->group_fields( { id      => $form.q(.create), nitems => 1 } );
      $self->add_buttons(  qw(Insert) );
   }
   else {
      $self->add_field(    { all     => \@users,
                             current => \@members,
                             id      => $form.q(.users) } );
      $self->group_fields( { id      => $form.q(.add_remove), nitems => 1 } );
      $self->add_buttons(  qw(Update Delete) );
   }

   return;
}

sub update {
   my ($self, $role) = @_; my $args;

   if ($self->query_value( q(users_n_added) )) {
      $args = { field => q(users_added), role => $role };
      $self->add_users_to_role( $args );
   }

   if ($self->query_value( q(users_n_deleted) )) {
      $args = { field => q(users_deleted), role => $role };
      $self->remove_users_from_role( $args );
   }

   return;
}

1;

__END__

# Local Variables:
# mode: perl
# tab-width: 3
# End: