view release on metacpan or  search on metacpan

lib/Ado/Model/Users.pm  view on Meta::CPAN

#find and instantiate a user object by login_name
sub by_login_name {
    state $sql = $_[0]->SQL('SELECT') . ' WHERE login_name=?';
    return $_[0]->query($sql, $_[1]);
}

sub name {
    ref($_[0]) || Carp::croak("The method $_[0]::name must be called only on instances!");
    return $_[0]->{name} ||= do {
        Mojo::Util::trim(
            ($_[0]->{data}{first_name} || '') . ' ' . ($_[0]->{data}{last_name} || ''))
          || $_[0]->{data}{login_name};
    };
}

sub add {
    my $class = shift;
    my $args  = $class->_get_obj_args(@_);
    state $dbix = $class->dbix;

    state $GR = 'Ado::Model::Groups';    #shorten class name
    my ($group, $user);
    my $try = eval {
        $dbix->begin_work;

        #First we need a primary group for the user.
        $group = $GR->create(
            name        => $args->{login_name},
            disabled    => 0,
            description => 'Primary group for user ' . $args->{login_name},
            created_by => $args->{created_by} || 1,
        );

        #Let us create the user now...
        $user = $class->create(
            first_name     => $args->{first_name},
            last_name      => $args->{last_name},
            login_name     => $args->{login_name},
            login_password => $args->{login_password},
            email          => $args->{email},
            disabled       => $args->{disabled},
            tstamp         => time,
            reg_date       => time,
            created_by     => $args->{created_by},
            changed_by     => $args->{changed_by},
            stop_date      => $args->{stop_date},
            start_date     => $args->{start_date},
            description    => $args->{description},
            group_id       => $group->id,
        );

        #And link them additionally
        Ado::Model::UserGroup->create(
            user_id  => $user->id,
            group_id => $group->id
        );
        $dbix->commit;
    };
    unless ($try) {
        $dbix->rollback or croak($dbix->error);
        carp("ERROR adding user(rolling back):[$@]");
    }
    return $user;
}

#Add an existing user to a potentially not existing group(create the group)
sub add_to_group {
    my $self = shift;
    my $args = $self->_get_obj_args(@_);
    state $dbix = $self->dbix;
    state $GR   = 'Ado::Model::Groups';    #shorten class name
    my $ingroup;
    my $try = eval {
        $dbix->begin_work;

        #Create the group if it does not exist yet
        if (!(($ingroup = $GR->by_name($args->{ingroup}))->id)) {
            $ingroup = $GR->create(
                name        => $args->{ingroup},
                disabled    => 0,
                description => 'Additional group initially created for user ' . $self->login_name,
                created_by => $args->{created_by} || 1,
            );
        }

        #Link them
        Ado::Model::UserGroup->create(
            user_id  => $self->id,
            group_id => $ingroup->id
        );
        $dbix->commit;
    };
    unless ($try) {
        $dbix->rollback or croak($dbix->error);
        carp("ERROR adding user to group (rolling back):[$@]");
    }
    return $ingroup;
}

__PACKAGE__->SQL(SELECT_group_names => <<"SQL");
    SELECT name FROM groups
        WHERE id IN (SELECT group_id FROM user_group WHERE user_id=?)
SQL

sub ingroup {
    my ($self, $group) = @_;
    state $sql = __PACKAGE__->SQL('SELECT_group_names');
    my @groups = $self->dbix->query($sql, $self->id)->flat;
    if ($group) {
        return List::Util::first { $_ eq $group } @groups;
    }
    return @groups;
}

$CLASS->SQL('user_id_by_group_name' => <<"UG");
    SELECT user_id FROM user_group WHERE group_id =
        (SELECT id FROM groups  WHERE name = ?)
UG

$CLASS->SQL('by_group_name' => <<"SQL");
    SELECT id, login_name, first_name, last_name, email
    FROM ${\ $CLASS->TABLE }
    WHERE id IN(${\ $CLASS->SQL('user_id_by_group_name') })
        AND (disabled=0 AND (stop_date>? OR stop_date=0) AND start_date<?)
    ORDER BY first_name, last_name ASC

SQL

#Selects users belonging to a group only.
#returns a list of hashes
sub by_group_name {
    my ($class, $group, $limit, $offset) = @_;

    state $SQL = $class->SQL('by_group_name') . $CLASS->SQL_LIMIT('?', '?');
    $limit  //= 500;
    $offset //= 0;
    my $time = time;
    my @a = $class->query($SQL, $group, $time, $time, $limit, $offset);
    return map { +{%{$_->data}, name => $_->name} } @a;
}

1;

=pod

=encoding utf8

=head1 NAME

A class for TABLE users in schema main

=head1 SYNOPSIS