Jifty::Notification - Send emails from Jifty

use warnings;
use strict;

package Jifty::Notification;

use base qw/Jifty::Object Class::Accessor::Fast/;
use Email::Send            ();
use Email::MIME::CreateHTML;

__PACKAGE__->mk_accessors(
    qw/body html_body preface footer subject from _recipients _to_list to cc bcc/);

sub new {
    my $class = shift;
    my $self  = bless {}, $class;

    my %args = @_;

    # initialize message bits to avoid 'undef' warnings
    #for (qw(body preface footer subject)) { $self->$_(''); }
    $self->_recipients( [] );

    while ( my ( $arg, $value ) = each %args ) {
        if ( $self->can($arg) ) {
            $self->$arg($value);
        } else {
            $self->log->error(
                ( ref $self ) . " called with invalid argument $arg" );
        }
    }

    $self->setup;

    return $self;
}

sub setup { }

sub send_one_message {
    my $self       = shift;
    my @recipients = $self->recipients;
    my $to         = join( ', ',
        map { ( ref $_ && $_->can('email') ? $_->email : $_ ) } grep {$_} @recipients );
    $self->log->debug("Sending a ".ref($self)." to $to"); 
    return unless ($to);
    my $message = "";
    my $appname = Jifty->config->framework('ApplicationName');

    my %attrs = ( charset => 'UTF-8' );

    my $from = Encode::encode(
        'MIME-Header',
        $self->from || _('%1 <%2>' , $appname, Jifty->config->framework('AdminEmail'))
    );
    my $subj = Encode::encode(
        'MIME-Header',
        $self->subject || _("A notification from %1!",$appname )
    );

    my $cc  = Encode::encode('MIME-Header', $self->cc  || '');
    my $bcc = Encode::encode('MIME-Header', $self->bcc || '');

    if ( defined $self->html_body ) {

        # Email::MIME takes _bytes_, not characters, for the "body"
        # argument, so we need to encode the full_body into UTF8.
        # Modern Email::MIME->create takes a "body_str" argument which
        # does the encoding for us, but Email::MIME::CreateHTML
        # doesn't grok it.  See also L</parts> for the other location
        # which does the encode.
        $message = Email::MIME->create_html(
            header => [
                From    => $from,
                To      => $to,
                Cc      => $cc,
                Bcc     => $bcc,
                Subject => $subj,
            ],
            attributes           => \%attrs,
            text_body_attributes => \%attrs,
            body_attributes      => \%attrs,
            text_body            => Encode::encode_utf8( $self->full_body ),
            body                 => Encode::encode_utf8( $self->full_html ),
            embed                => 0,
            inline_css           => 0,
        );

        # Since the containing messsage will still be us-ascii otherwise
        $message->charset_set( $attrs{'charset'} );
    } else {
        $message = Email::MIME->create(
            header => [
                From    => $from,
                To      => $to,
                Cc      => $cc,
                Bcc     => $bcc,
                Subject => $subj,
            ],
            attributes => \%attrs,
            parts      => $self->parts,
        );
    }
    $message->encoding_set('8bit')
        if ( scalar $message->parts == 1 );
    $self->set_headers($message);

    my $method   = Jifty->config->framework('Mailer');
    my $args_ref = Jifty->config->framework('MailerArgs');
    $args_ref = [] unless defined $args_ref;

    my $sender
        = Email::Send->new( { mailer => $method, mailer_args => $args_ref } );

    my $ret = $sender->send($message);

    unless ($ret) {
        $self->log->error("Error sending mail: $ret");
    }

    $ret;
}

sub set_headers {}

sub recipients {
    my $self = shift;
    $self->_recipients( [@_] ) if @_;
    return @{ $self->_recipients };
}

sub email_from {
    my $self = shift;
    my ($obj) = @_;
    if ( $obj->can('email') ) {
        return $obj->email;
    } else {
        die "No 'email' method on " . ref($obj) . "; override 'email_from'";
    }
}

sub to_list {
    my $self = shift;
    if (@_) {
        my %ids = ();
        $ids{ $self->to->id } = undef if $self->to;
        $ids{ $_->id } = $_ for @_;
        $self->_to_list( [ grep defined, values %ids ] );
    }
    return @{ $self->_to_list || [] };
}

sub send {
    my $self = shift;
    my $currentuser_object_class = Jifty->app_class("CurrentUser");
    for my $to ( grep {defined} ($self->to, $self->to_list) ) {
        if ($to->can('id')) {
        next if     $currentuser_object_class->can("nobody")
                and $currentuser_object_class->nobody->id
                and $to->id == $currentuser_object_class->nobody->id;
                
        next if $to->id == $currentuser_object_class->superuser->id;
        } 
        $self->to($to);
        $self->recipients($to);
        $self->send_one_message(@_);
    }
}

sub full_body {
  my $self = shift;
  return join( "\n", grep { defined } $self->preface, $self->body, $self->footer );
}

sub full_html {
  my $self = shift;
  return join( "\n", grep { defined } $self->preface, $self->html_body, $self->footer );
}

sub parts {
  my $self = shift;
# NOTICE: we should keep string in perl string (with utf8 flag)
# rather then encode it into octets. Email::MIME would call Encode::encode in 
# its create function.
  return [ Email::MIME->create(
      attributes => { charset => 'UTF-8' },
      body       => Encode::encode_utf8( $self->full_body ),
    ) ];
}

sub magic_letme_token_for {
    my $self = shift;
    my $path = shift;
    my %args = @_;

    my $letme = Jifty::LetMe->new();
    $letme->email( $self->to->email );
    $letme->path($path);
    $letme->args( \%args );
    return ( $letme->as_url );
}

1;