source: LATMOS-Accounts/lib/LATMOS/Accounts/Cli.pm @ 844

package LATMOS::Accounts::Cli;

use strict;
use warnings;
use LATMOS::Accounts::Log;
use Term::ReadLine;
use Text::ParseWords;

my $term = Term::ReadLine->new('LA CLI');
my $OUT = $term->OUT || \*STDOUT;

sub globalenv {
    my ($labase) = @_;
    my $env = LATMOS::Accounts::Cli->new({ prompt => sub { "LA cli > " }, },
        $labase);
    $env->add_func('ls', {
            help => 'ls object_type - list object of type object_type', 
            completion => sub {
                if(!$_[3]) {
                    return grep { /^\Q$_[1]\E/ } $_[0]->base->list_supported_objects
                } else { () }
            },
            code => sub {
                if ($_[1]) {
                    print $OUT map { "$_\n" } $_[0]->base->list_objects($_[1]);
                } else {
                    print $OUT "Object type missing";
                }
            },
        });
    $env->add_func('select', {
            help => 'select object_type - select objects to perform action on it',
            completion => sub {
                if ($_[2]) {
                    return $_[0]->base->list_objects($_[2]);
                } else {
                    return $_[0]->base->list_supported_objects;
                }
            },
            code => sub {
                my ($env, $otype, @ids) = @_;
                my @objs;
                if (!@ids) {
                    print $OUT 'not enough arguments';
                    return;
                }
                foreach (@ids) {
                    my $obj = $env->base->get_object($otype, $_) or do {
                        print $OUT "Cannot get $otype $_";
                        return;
                    };
                    push(@objs, $obj);
                }
                print $OUT "Selecting $otype " . join(', ', @ids);
                objenv($_[0]->base, $otype, @objs)->cli();
            },
        });
    $env->add_func('user',  { alias => [qw'select user' ] });
    $env->add_func('group', { alias => [qw'select group'] });
    return $env
}

sub objenv {
    my ($labase, $otype, @objs) = @_;
    my $objenv = LATMOS::Accounts::Cli->new(
        {
            prompt => sub {
                sprintf("%s (%s) > ",
                    $_[0]->{_otype},
                    @{$_[0]->{_objects}} > 1 ? '...' : $_[0]->{_objects}[0]->id,
                );
            },
        },
        $labase
    );
    $objenv->{_otype} = $otype;
    $objenv->{_objects} = [ @objs ];
    $objenv->add_func('show', {
        help => 'show attributes - show an attributes of object',
        code => sub {
            my ($env, $attr) = @_;
            if (!$attr) {
                foreach (@{$env->{_objects}}) {
                    print $OUT $_->dump;
                }
            } else {
                foreach (@{$env->{_objects}}) {
                    print $OUT sort map { ($_ || '') . "\n" } $_->get_attributes($attr);
                }
            }
        },
        completion => sub {
            if (!$_[2]) {
                return $_[0]->base->list_canonical_fields($_[0]->{_otype}, 'r')
            }
        },
    });
    $objenv->add_func('set', {
        help => 'set attribute value - set an attributes to single value "value"',
        code => sub {
            my ($env, $attr, $value) = @_;
            foreach (@{$env->{_objects}}) {
                defined $_->set_c_fields($attr => $value) or do {
                    $_->base->rollback;
                    print $OUT "Cannot set $attr to $value for " . $_->id;
                    return;
                };
            }
            $env->base->commit;
            print $OUT "done";
        },
        completion => sub {
            my ($env, $lastw, @args) = @_;
            if (!$args[0]) {
                return $env->base->list_canonical_fields($env->{_otype}, 'w')
            } else {
                for ($args[0]) {
                    /^manager|managedBy$/ and return
                        $env->base->search_objects('user');
                    /^department$/ and return
                        $env->base->search_objects('group', 'sutype=dpmt');
                    if (@{$env->{_objects}} == 1) {
                        return $env->{_objects}[0]->get_attributes($args[0]);
                    }
                }
            }
        },
    });
    if (lc($otype) eq 'user') {
        $objenv->add_func('group', {
            help => 'group add|remove goupname',
            code => sub {
                my ($env, $action, @groups) = @_;
                foreach my $obj (@{$env->{_objects}}) {
                    my %gr;
                    foreach ($obj->get_attributes('memberOf')) {
                        $gr{$_} = 1;
                    }
                    if ($action eq 'add') {
                        $gr{$_} = 1 foreach(@groups);
                    } elsif ($action eq 'remove') {
                        delete($gr{$_}) foreach(@groups);
                    } else {
                        print $OUT 'invalid action';
                        return;
                    }
                    defined $obj->set_c_fields('memberOf' => [ keys %gr ]) or do {
                        print $OUT "cannot set memberOf attributes for " .
                        $obj->id;
                        return;
                    };
                }
                $env->base->commit;
            },
            completion => sub {
                if (!$_[2]) {
                    return (qw(add remove));
                } else {
                    return $_[0]->base->search_objects('group');
                }
            },
        });
    } elsif ($otype eq 'group') {
        $objenv->add_func('member', {
            help => 'member add|remove user',
            code => sub {
                my ($env, $action, @groups) = @_;
                foreach my $obj (@{$env->{_objects}}) {
                    my %gr;
                    foreach ($obj->get_attributes('memberUID')) {
                        $gr{$_} = 1;
                    }
                    if ($action eq 'add') {
                        $gr{$_} = 1 foreach(@groups);
                    } elsif ($action eq 'remove') {
                        delete($gr{$_}) foreach(@groups);
                    } else {
                        print $OUT 'invalid action';
                        return;
                    }
                    defined $obj->set_c_fields('memberUID' => [ keys %gr ]) or do {
                        print $OUT "cannot set memberUID attributes for " .
                        $obj->id;
                        return;
                    };
                }
                $env->base->commit;
            },
            completion => sub {
                if (!$_[2]) {
                    return (qw(add remove));
                } else {
                    return $_[0]->base->search_objects('user');
                }
            },
        });
    }

    return $objenv;
}


sub new {
    my ($class, $env, $labase) = @_;
    bless($env, $class);
    $env->{_labase} = $labase;
    $env->add_func('quit', { help => 'quit - exit the tool',
            code => sub { print "\n"; exit(0) }, });
    $env;
}

sub base { $_[0]->{_labase} }

sub cli {
    my ($self) = @_;
    while (1) {
        $term->Attribs->{completion_function} = sub {
            $self->complete($_[0], shellwords(substr($_[1], 0, $_[2])));
        };
        defined (my $line = $term->readline($self->prompt)) or return;
        $self->run(shellwords($line));
        $self->base->rollback;
    }
}

sub prompt {
    my ($self) = @_;
    if (!$self->{prompt}) {
        return "LA cli > ";
    } else {
        $self->{prompt}->($self);
    }
}

sub add_func {
    my ($self, $name, $param) = @_;
    $self->{funcs}{$name} = $param;
}

sub parse_arg {
    my ($self, $name, @args) = @_;
    if ($self->{funcs}{$name}{opt}) {
        @ARGV = @args;
    } else {
        return @args;
    }
    return @ARGV;
}

sub complete {
    my ($self, $lastw, $name, @args) = @_;
    if (!$name) {
        return grep { /^\Q$lastw\E/ } sort
            ('help', keys %{ $self->{funcs} || {}});
    } elsif ($name eq 'help') {
        return grep { /^\Q$lastw\E/ } sort keys %{ $self->{funcs} || {}};
    } elsif ($self->{funcs}{$name}{alias}) {
        $self->complete($lastw, @{$self->{funcs}{$name}{alias}}, @args);
    } elsif ($self->{funcs}{$name}{completion}) {
        my @pargs = $self->parse_arg($name, @args);
        return map { my $t = $_; $t =~ s/\s/\\ /g; $t } grep { $_ && /^\Q$lastw\E/ } $self->{funcs}{$name}{completion}->($self, $lastw, @pargs);
    } else {
        return ();
    }
}

sub run {
    my ($self, $name, @args) = @_;
    return if (!$name);
    if ($name eq 'help') {
        $self->help(@args);
    } elsif ($self->{funcs}{$name}{alias}) {
        $self->run(@{$self->{funcs}{$name}{alias}}, @args);
    } elsif ($self->{funcs}{$name}{code}) {
        my @pargs = $self->parse_arg($name, @args);
        $self->{funcs}{$name}{code}->($self, @args);
    }
}

sub help {
    my ($self, $name) = @_;
    if (!$name) {
        print $OUT join(', ', sort keys %{ $self->{funcs} || {}});
    } elsif ($self->{funcs}{$name}{alias}) {
        print $OUT "$name is an alias for `$self->{funcs}{$name}{alias} $name'";
    } elsif ($self->{funcs}{$name}{help}) {
        print $OUT $self->{funcs}{$name}{help};
    } else {
        print $OUT "No help availlable";
    }
}


1;