projekt kivitendo

package SL::BackgroundJob::SendFollowUpReminder;

use strict;

use parent qw(SL::BackgroundJob::Base);

use SL::DB::AuthUser;

use SL::DB::FollowUp;

use SL::Locale::String qw(t8);

use SL::Mailer;

use SL::Presenter;

use SL::Util qw(trim);

use DateTime;

use File::Slurp qw(slurp);

use List::Util qw(any);

use Try::Tiny;

use URI;

sub create_job {

  $_[0]->create_standard_job('7 6 1-5 * *'); # every workday at 06:07

}

use Rose::Object::MakeMethods::Generic (

 'scalar' => [ qw(params) ],

);

#

# If job does not throw an error,

# success in background_job_histories is 'success'.

# It is 'failure' otherwise.

#

# Return value goes to result in background_job_histories.

#

sub run {

  my ($self, $db_obj) = @_;

  $self->{$_} = [] for qw(job_errors);

  $self->initialize_params($db_obj->data_as_hash) if $db_obj;

  my   @follow_up_date_where = ();

  push @follow_up_date_where, (follow_up_date => { ge    => [ $self->params->{from_date} ]}) if $self->params->{from_date};

  push @follow_up_date_where, (follow_up_date => { le    => [ $self->params->{to_date}   ]}) if $self->params->{to_date};

  my $follow_ups = SL::DB::Manager::FollowUp->get_all(where        => ['done.id' => undef,

                                                                       @follow_up_date_where, ],

                                                      with_objects => ['done'],

                                                      sort_by      => ['follow_up_date']);

  # Collect follow ups for users with e-mail-address.

  my $mail_to_by_employee_id;

  foreach my $follow_up (@$follow_ups) {

    # add link

    $follow_up->{link} = URI->new_abs('fu.pl?action=edit&id=' . $follow_up->id, $::form->_get_request_uri);

    foreach my $employee (@{ $follow_up->created_for_employees }) {

      next if $employee->deleted;

      if (!exists $mail_to_by_employee_id->{$employee->id}) {

        my $user = SL::DB::Manager::AuthUser->find_by(login => $employee->login);

        if ($user) {

          my $mail_to = trim($user->get_config_value('email'));

          next if !$mail_to;

          $mail_to_by_employee_id->{$employee->id}->{mail_to} = $mail_to;

        }

      }

      if (exists $mail_to_by_employee_id->{$employee->id}) {

        push @{ $mail_to_by_employee_id->{$employee->id}->{follow_ups} }, $follow_up;

      }

    }

  }

  foreach (keys %$mail_to_by_employee_id) {

    my ($message, $content_type) = $self->generate_message($mail_to_by_employee_id->{$_}->{follow_ups});

    my $mail              = Mailer->new;

    $mail->{from}         = $self->params->{email_from};

    $mail->{to}           = $mail_to_by_employee_id->{$_}->{mail_to};

    $mail->{bcc}          = SL::DB::Default->get->global_bcc;

    $mail->{subject}      = $self->params->{email_subject};

    $mail->{message}      = $message;

    $mail->{content_type} = $content_type;

    my $error = $mail->send;

    if ($error) {

      push @{ $self->{job_errors} }, $error;

    }

  }

  my $msg = t8('Follow ups reminder sent.');

  # die if errors exists

  if (@{ $self->{job_errors} }) {

    $msg .= t8('The following errors occurred:');

    $msg .= join "\n", @{ $self->{job_errors} };

    die $msg . "\n";

  }

  return $msg;

}

# helper

sub initialize_params {

  my ($self, $data) = @_;

  # valid parameters with default values

  my %valid_params = (

    from_date      => undef,

    to_date        => DateTime->today_local->to_kivitendo,

    email_from     => $::lx_office_conf{follow_up_reminder}->{email_from},

    email_subject  => $::lx_office_conf{follow_up_reminder}->{email_subject},

    email_template => $::lx_office_conf{follow_up_reminder}->{email_template},

  );

  # check user input param names

  foreach my $param (keys %$data) {

    die "Not a valid parameter: $param" unless exists $valid_params{$param};

  }

  # set defaults

  $self->params(

    { map { ($_ => $data->{$_} // $valid_params{$_}) } keys %valid_params }

  );

  # convert date from string to object

  my ($from_date, $to_date);

  try {

    if ($self->params->{from_date}) {

      $from_date = DateTime->from_kivitendo($self->params->{from_date});

      # Not undef and no other type.

      die unless ref $from_date eq 'DateTime';

    }

    if ($self->params->{to_date}) {

      $to_date = DateTime->from_kivitendo($self->params->{to_date});

      # Not undef and no other type.

      die unless ref $to_date eq 'DateTime';

    }

  } catch {

    die t8("Cannot convert date.") ."\n" .

        t8("Input from string: #1", $self->params->{from_date}) . "\n" .

        t8("Input to string: #1",   $self->params->{to_date})   . "\n" .

        t8("Details: #1", $_);

  };

  $self->params->{from_date} = $from_date;

  $self->params->{to_date}   = $to_date;

  $self->params->{email_from} = trim($self->params->{email_from});

  die t8('No email sender address given.') if !$self->params->{email_from};

  return $self->params;

}

sub generate_message {

  my ($self, $follow_ups) = @_;

  # Force scripts/locales.pl to parse this template:

  # parse_html_template('fu/follow_up_reminder_mail')

  my $email_template = $self->params->{email_template};

  my $template       = 'fu/follow_up_reminder_mail';

  my $content_type   = 'text/html';

  my $render_type    = 'html';

  if ($email_template) {

    my $content;

    try {

      $content = slurp $email_template;

    } catch {

      $::lxdebug->message(LXDebug->WARN(), 'Cannot read template file. Error: ' . $_);

    };

    return $self->generate_message_simple_text($follow_ups) if !$content;

    $template     = \$content;

    $content_type = $email_template =~ m/.html$/ ? 'text/html' : 'text/plain';

    $render_type  = $email_template =~ m/.html$/ ? 'html'      : 'text';

  }

  my $output = SL::Presenter->get->render($template,

                                          {type => $render_type},

                                          follow_ups => $follow_ups);

  return ($output, $content_type);

}

sub generate_message_simple_text {

  my ($self, $follow_ups) = @_;

  my $output = t8('Unfinished follow-ups') . ":\n";

  foreach my $follow_up (@$follow_ups) {

    $output .= t8('Follow-Up Date') . ': ' . $follow_up->follow_up_date_as_date;

    $output .= ': ' . $follow_up->note->subject;

    $output .= ': (' . t8('by') . ' ' . $follow_up->created_by_employee->safe_name . ')';

    $output .= ' (' . $follow_up->{link} . ')';

    $output .= "\n";

  }

  $output .= "\n\n";

  return ($output, 'text/plain');

}

1;

__END__

=pod

=encoding utf8

=head1 NAME

SL::BackgroundJob::SendFollowUpReminder - Send emails to employees to

remind them of due follow ups

=head1 SYNOPSIS

Get all due follow ups. This are the ones that are not done yet and have a

follow up date until today (configurable, see below).

For each employee addreesed by this follow ups, an email is send (if the

employees email address is configured).

=head1 CONFIGURATION

In the kivitendo configuration file (C<config/kivitendo.conf>) in the section

"follow_up_reminder" some settings can be made:

=over 4

=item C<email_from>

The senders email address. This information can be overwriten by

data provided to the background job.

=item C<email_subject>

The subject of the emails. This information can be overwriten by

data provided to the background job.

=item C<email_template>

A template file used to generate the emails content. It will be given an

array of the follow ups in the template variable C<follow_ups>.

You can provide a text or a html template.

If not given, it defaults to C<fu/follow_up_reminder_mail.html> in the

webpages directory.

If given, but not found, a simple text version will be generated as

content.

This information can be overwriten by data provided to the background job.

=back

Also some data can be provided to configure this backgroung job.

If there is data provided and it cannot be validated the background job

fails.

Example:

  from_date: 01.01.2022

  to_date: 01.07.2022

  email_subject: To-Do

=over 4

=item C<from_date>

The date from which on follow ups not done yet should be collected. It defaults

undef which means from the beginning on.

Example (format depends on your settings):

from_date: 01.01.2022

=item C<to_date>

The date till which follow ups not done yet should be collected. It defaults

to today.

Example (format depends on your settings):

to_date: 01.07.2022

=item C<email_from>

The senders email address. It defaults to the one given in the kivitendo

configuration file (see above). This information must be provided some

how.

Example:

email_from: bernd@kivitendo.de

=item C<email_subject>

The subject of the emails.

It defaults to the one given in the kvitendo configuration file (see above).

email_subject: To-Do

=item C<email_template>

A template file used to generate the emails content. It will be given an

array of the follow ups in the template variable C<follow_ups>. You can

provide a text or a html template.

It defaults to the one given in the kvitendo configuration file (see above).

email_template: templates/my_templates/my_reminder_template.txt

=back

=head1 AUTHOR

Bernd Bleßmann E<lt>bernd@kivitendo-premium.deE<gt>

=cut

[follow_up_reminder]

# Email notifications for due follow ups.

# The "From:" header for said email.

email_from     = kivitendo Daemon <root@localhost>

# The subject for said email.

email_subject  = kivitendo: fällige Wiedervorlagen

# The template file used for the email's body.

# If empty fu/follow_up_reminder_mail.html will be used.

email_template =

 - Erinnerungen an fällige Wiedervorlagen können an Benutzer gemailt werden.

   Dazu gibt es einen Hintergrund-Job (SendFollowUpReminder), der angelegt und

   aktiviert werden kann.

  'Follow ups reminder sent.'   => 'Erinnerung an Wiedervorlagen versendet.',

  'No email sender address given.' => 'Es ist keine E-Mail-Absender-Adresse angegeben.',

  'Follow ups reminder sent.'   => '',

  'No email sender address given.' => '',

[%- USE T8 %]

[%- USE HTML %]

<!DOCTYPE HTML>

<html>

 <head>

  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

 </head>

 <body>

  <h2>[% 'Unfinished follow-ups' | $T8 %]</h2>

  <table>

   <tr>

    <th>[% 'Follow-Up Date' | $T8 %]</th>

    <th>[% 'Subject' | $T8 %]</th>

    <th>[% 'Created by' | $T8 %]</th>

   </tr>

   [%- FOREACH fu = follow_ups %]

   <tr>

    <td>[% HTML.escape(fu.follow_up_date_as_date) %]</td>

    <td><a href="[% fu.link %]">[% HTML.escape(fu.note.subject) %]</a></td>

    <td>[% HTML.escape(fu.created_by_employee.safe_name) %]</td>

   </tr>

   [%- END %]

  </table>

 </body>

</html>