source: trunk/LATMOS-Accounts-Web/lib/LATMOS/Accounts/Web/Controller/Users.pm @ 1620

package LATMOS::Accounts::Web::Controller::Users;

use strict;
use warnings;
use base 'Catalyst::Controller';

use Date::Parse;
use DateTime;
use DateTime::TimeZone;
use POSIX;

=head1 NAME

LATMOS::Accounts::Web::Controller::Users - Catalyst Controller

=head1 DESCRIPTION

Catalyst Controller.

=head1 METHODS

=cut


=head2 index 

=cut

sub index : Private {
    my ( $self, $c ) = @_;

    $c->stash->{ofilter} = $c->model('AttrFilter', 'user');
    $c->stash->{page}{title} = "Liste des utilisateurs";
}


sub change_password : Private {
    my ($self, $c, $username, $password) = @_;

    my $base = $c->model('Accounts')->db;
    $c->stash->{user} = $base->get_object('user', $username) or do {
        $c->forward('/no_object');
        return "Cannot get user object";
    };

    my $sync = $c->model('Accounts')->sync_access;

    # This is widelly burk:
    # synchaccess do not manage connect() at time, opening a
    # backdoor then :\
    foreach ($sync->bases) { $_->{_user} = $c->user->username }

    my $suser = $sync->get_object_ifexists('user', $username);
    my $msg = $c->stash->{user}->check_password($password);
    if ($msg ne 'ok') {
        return $msg . ', mot de passe inchangé';
    } elsif ($suser && $suser->_set_password($password)) {
        $sync->commit;
        return;
    } else {
        return 'Erreur lors du changement de mot de passe';
    }
}

sub default : LocalPath {
    my ( $self, $c, undef, $username, $subform, $arg ) = @_;

    if ($c->config->{features}->{user_employment}) {
        # Replace standard RH form by employment
        $subform ||= 'employment';
    }

    my $base = $c->model('Accounts')->db;

    $c->stash->{page}{title} = "Utilisateur :: $username";
    $c->stash->{username} = $username;
    $c->stash->{user} = $base->get_object('user', $username) or do {
        $c->forward('/no_object');
        return;
    };
    $c->stash->{subform} = $subform || '';
    $c->stash->{page}{title} = "Utilisateur :: $username";

    if ($c->req->param('make_active')) {
        $c->stash->{user}->set_c_fields('unexported' => undef);
        $base->commit;
    }
    if ($c->req->param('make_inactive')) {
        $c->stash->{user}->set_c_fields('unexported' => 1);
        $base->commit;
    }
    if ($c->req->param('delete')) {
        $base->delete_object('user', $username);
        $base->commit;
        $c->res->redirect('/users');
    }


    for ($subform || '') {
        # Exceptions...
        /^employment$/ and do {
            $arg ||= $c->stash->{user}->get_attributes('currentEmployment') ||
                     $c->stash->{user}->get_attributes('nextEmployment');

            $c->stash->{employment} = $base->get_object('employment', $arg) unless($arg =~ /^\@/);
            $c->stash->{forme} = $c->model('AttrForms', 'employment',
                $c->stash->{employment} ? $c->stash->{employment} : 'employment', $base);
            $c->stash->{forme}->set_attrs if($c->stash->{employment});
            $c->stash->{template} = 'users/employment.tt';
            if ($arg) {
                if ($arg =~ m/^\@/) {
                    $c->stash->{newemployment} = 1;
                    if ($arg =~ m/\@duplicate/i) {
                        my $oldempl = $c->model('Accounts')->db->get_object('employment', 
                            $c->req->param('source')
                            ? $c->req->param('source')
                            : ($c->stash->{user}->listEmployment)[0])
                            or return;
                        foreach (qw(company managerContact contratType department)) {
                            $c->req->params->{$_} = $oldempl->get_attributes($_);
                        }
                        if (my $lastday = $oldempl->get_attributes('lastday')) {
                            my $time = DateTime->from_epoch(epoch => str2time($lastday));
                            $time->set_time_zone( DateTime::TimeZone->new( name => 'local' ) );
                            $time->add( days => 1 );
                            $c->req->params->{firstday} = $time->ymd;
                        }
                    } elsif ($arg =~ m/\@create/i) {

                        for (1) {
                            my $frtoen = $c->req->param('firstday');
                            # Date::Parse understand only mm/dd/yyyy...
                            $frtoen =~ s:^(\d+)/(\d+)/(\d+):$2/$1/$3:;
                            my $time = str2time($frtoen) or last;
                            my $lastd = DateTime->from_epoch( epoch => $time )
                                ->set_time_zone( DateTime::TimeZone->new( name => 'local' ) );

                            my ($empl) = $c->stash->{user}->listEmployment;
                            if ($empl) {
                                my $obj = $c->model('Accounts')->db->get_object('employment', $empl);
                                if (!$obj->get_attributes('lastday')) {
                                    $obj->set_c_fields(lastday => $lastd->subtract(days => 1)->ymd('-'));
                                } 
                            }

                            my $id = $username . '-' . $lastd->ymd('-');
                            $c->req->params->{user} = $username;
                            if ($id = $c->stash->{forme}->set_attrs([ 'user',
                                        map { $_->name } $c->stash->{forme}->write_attributes], $id)) {
                                $c->res->redirect($c->uri_for('/users', $username, 'employment', $id));
                                return 1;
                            }
                        }
                    }
                }
            }
            if (my $delemp = $c->req->param('delemployment')) {
                $base->delete_object('employment', $delemp);
                $base->commit;
            }
            
        };
        /^passwd$/ and do {
            $c->stash->{template} = 'users/passwd.tt';
            if ($c->req->param('passwd')) {
                if ($base->check_acl($c->stash->{user}, 'userPassword', 'w')) {
                    if ($c->req->param('passwd') eq ($c->req->param('cpasswd') || '')) {
                        $c->stash->{pmerror} = $c->forward('change_password',
                            [ $username, $c->req->param('passwd') ] ) || 'Mot de passe changé';
                    } else {
                        $c->stash->{pmerror} = 'Mot de passe différents';
                    }
                }
            }
            last;
        };
        /^groups$/ and do {
            $c->stash->{template} = 'users/groups.tt';
            # list of group for which users can be added
            my %ingroups = map { $_ => 1 } @{ $c->stash->{user}->get_c_field('memberOf') || []};
            if ($c->req->param('addgroup')) {
                $c->stash->{user}->set_c_fields('memberOf', [ keys %ingroups, $c->req->param('addgroup') ]);
                $c->stash->{user}->base->commit;
                # reread:
                %ingroups = map { $_ => 1 } @{ $c->stash->{user}->get_c_field('memberOf') || []};
            } elsif ($c->req->param('delgroup')) {
                $c->stash->{user}->set_c_fields('memberOf',
                    [ grep { $_ ne $c->req->param('delgroup') } keys %ingroups ]
                );
                $c->stash->{user}->base->commit;
                %ingroups = map { $_ => 1 } @{ $c->stash->{user}->get_c_field('memberOf') || []};
            }

            $c->stash->{othergroups} = [ grep { ! $ingroups{$_} } $base->list_objects('group') ];
            last;
        };
        /^address$/ and do {
            if ($arg) {
                $c->stash->{address} = $base->get_object('address', $arg);
            } else {

                if ($c->req->param('del_addr')) {
                    $base->delete_object('address', $c->req->param('del_addr'));
                    $base->commit;
                } elsif ($c->req->param('add_addr')) {
                    my $addname = $username . join('', map
                        {('a'..'z')[rand(26)]}(0..4));
                    if ($base->create_c_object('address',
                        $addname,
                        user => $username,
                    )) {
                        $base->commit;
                        $c->res->redirect($c->uri_for($username, 'address',
                                $addname));
                        return;
                    }
                } elsif ($c->req->param('main')) {
                    if (my $ad = $base->get_object('address',
                            $c->req->param('main'))) {
                        $ad->base->commit;
                    }
                }

                my ($main) = $c->stash->{user}->get_attributes('otheraddress');
                $c->stash->{address} = $base->get_object('address', $main);
            }
            if ($c->stash->{address}) {
                $c->stash->{form} = $c->model('AttrForms', 'address',
                    $c->stash->{address});
                $c->stash->{form}->set_attrs;
            }
            $c->stash->{template} = 'users/address.tt';

            last;
        };
        /^mail$/ and do {

            $c->stash->{db} = $base;
            $c->stash->{template} = 'users/mail.tt';

            if ($c->req->param('usermail')) {

                my %expaliases = map { $_ => 1 } $c->req->param('expaliases');
                foreach my $alias ($c->stash->{user}->get_attributes('aliases'), $c->stash->{user}->id) {
                    my $oalias = $base->get_object('aliases', $alias) or next;
                    if (($expaliases{ $alias } || 0) xor ($oalias->get_c_field('exported') || 0)) {
                        $oalias->set_c_fields('unexported' => ($expaliases{ $alias } ? undef : 1)) or do {
                            $base->rollback;
                            last;
                        };
                    }
                }
                $c->stash->{user}->set_c_fields(
                    mail => $c->req->param('mail') || undef,
                    aliases => [ grep { $_ } $c->req->param('aliases') ],
                    revaliases => $c->req->param('revaliases') || undef,
                    forward => $c->req->param('forward') || undef,
                ) or do {
                    $base->rollback;
                    last;
                };

                $base->commit;
            }

            last;
        };
        /^my$/ and do {
            $c->stash->{db} = $base;
            $c->stash->{template} = 'users/my.tt';
        };
        /^dump$/ and do {
            $c->stash->{db} = $base;
            $c->stash->{template} = 'users/dump.tt'
            #$c->res->body($c->stash->{user}->dump({only_rw => 1}));
        };

        $c->stash->{form} = $c->model('AttrForms', 'user' . $c->stash->{subform}, $c->stash->{user});
        $c->stash->{form}->set_attrs;
    }
}

=head1 AUTHOR

Thauvin Olivier

=head1 LICENSE

This library is free software, you can redistribute it and/or modify
it under the same terms as Perl itself.

=cut

1;