projekt kivitendo

  my $ref = \$attachment->content;

  if ( $attachment->file_id > 0 ) {

    my $file = SL::File->get(id => $attachment->file_id );

    $ref = SL::File->get_content(dbfile => $file) if $file;

  }

  $self->send_file($ref, name => $attachment->name, type => $attachment->mime_type);

  file_id          => { type => 'integer', default => '0', not_null => 1 },

    $self->{print_file_id} = $self->store_pdf($self);

    if ( getcwd() eq $self->{"tmpdir"} ) {

      # in the case of generating pdf we are in the tmpdir, but WHY ???

      $self->{tmpfile} = $userspath."/".$self->{tmpfile};

      chdir("$self->{cwd}");

    }

    $self->send_email(\%::myconfig,$ext_for_format);

  }

  else {

    $self->{OUT}      = $out;

    $self->{OUT_MODE} = $out_mode;

    $self->output_file($template->get_mime_type,$command_formatter);

  }

  delete $self->{print_file_id};

  $self->cleanup;

  chdir("$self->{cwd}");

  $main::lxdebug->leave_sub();

}

sub get_bcc_defaults {

  my ($self, $myconfig, $mybcc) = @_;

#  if (SL::DB::Default->get->bcc_to_login) {

#    $mybcc .= ", " if $mybcc;

#    $mybcc .= $myconfig->{email};

#  }

  my $otherbcc = SL::DB::Default->get->global_bcc;

  if ($otherbcc) {

    $mybcc .= ", " if $mybcc;

    $mybcc .= $otherbcc;

  }

  return $mybcc;

}

sub send_email {

  $main::lxdebug->enter_sub();

  my ($self, $myconfig, $ext_for_format) = @_;

  my $mail = Mailer->new;

  map { $mail->{$_} = $self->{$_} }

    qw(cc subject message version format);

  $mail->{bcc}    = $self->get_bcc_defaults($myconfig, $self->{bcc});

  $mail->{to}     = $self->{EMAIL_RECIPIENT} ? $self->{EMAIL_RECIPIENT} : $self->{email};

  $mail->{from}   = qq|"$myconfig->{name}" <$myconfig->{email}>|;

  $mail->{fileid} = time() . '.' . $$ . '.';

  my $full_signature     =  $self->create_email_signature();

  $full_signature        =~ s/\r//g;

  $mail->{attachments} =  [];

  my @attfiles;

  # if we send html or plain text inline

  if (($self->{format} eq 'html') && ($self->{sendmode} eq 'inline')) {

    $mail->{contenttype}    =  "text/html";

    $mail->{message}        =~ s/\r//g;

    $mail->{message}        =~ s/\n/<br>\n/g;

    $full_signature         =~ s/\n/<br>\n/g;

    $mail->{message}       .=  $full_signature;

    $mail->{message} .= $_ while <IN>;

    close(IN);

  } else {

    $main::lxdebug->message(LXDebug->DEBUG2(),"action_oldfile=" . $self->{action_oldfile}." action_nofile=".$self->{action_nofile});

    if (!$self->{"do_not_attach"} && !$self->{action_nofile}) {

      my $attachment_name  =  $self->{attachment_filename}  || $self->{tmpfile};

      $attachment_name     =~ s/\.(.+?)$/.${ext_for_format}/ if ($ext_for_format);

      if ( $self->{action_oldfile} ) {

        $main::lxdebug->message(LXDebug->DEBUG2(),"object_id =>". $self->{id}." object_type =>". $self->{formname});

        my ( $attfile ) = SL::File->get_all(object_id   => $self->{id},

                                            object_type => $self->{formname},

                                            file_type   => 'document');

        $main::lxdebug->message(LXDebug->DEBUG2(), "old file obj=".$attfile);

        push @attfiles, $attfile if $attfile;

      } else {

        push @{ $mail->{attachments} }, { path => $self->{tmpfile},

                                          id   => $self->{print_file_id},

                                          type => "application/pdf",

                                          name => $attachment_name };

      }

    }

  }

  if (!$self->{"do_not_attach"}) {

    for my $i (1 .. $self->{attfile_count}) {

      if (  $self->{"attsel_$i"} ) {

        my $attfile = SL::File->get(id => $self->{"attfile_$i"});

        $main::lxdebug->message(LXDebug->DEBUG2(), "att file=".$self->{"attfile_$i"}." obj=".$attfile);

        push @attfiles, $attfile if $attfile;

      }

    }

    for my $i (1 .. $self->{attfile_cv_count}) {

      if (  $self->{"attsel_cv_$i"} ) {

        my $attfile = SL::File->get(id => $self->{"attfile_cv_$i"});

        $main::lxdebug->message(LXDebug->DEBUG2(), "att file=".$self->{"attfile_$i"}." obj=".$attfile);

        push @attfiles, $attfile if $attfile;

      }

    }

    for my $i (1 .. $self->{attfile_part_count}) {

      if (  $self->{"attsel_part_$i"} ) {

        my $attfile = SL::File->get(id => $self->{"attfile_part_$i"});

        $main::lxdebug->message(LXDebug->DEBUG2(), "att file=".$self->{"attfile_$i"}." obj=".$attfile);

        push @attfiles, $attfile if $attfile;

      }

    }

    foreach my $attfile ( @attfiles ) {

      push @{ $mail->{attachments} }, { path => SL::File->get_file_path(dbfile => $attfile),

                                        id   => $attfile->id,

                                        type => $attfile->file_mime_type,

                                        name => $attfile->file_name };

    }

  }

  $mail->{message}  =~ s/\r//g;

  $mail->{message} .= $full_signature;

  $self->{emailerr} = $mail->send();

  # $self->error($self->cleanup . "$err") if $self->{emailerr};

  $self->{email_journal_id} = $mail->{journalentry};

  #write back for message info and mail journal

  $self->{cc}  = $mail->{cc};

  $self->{bcc} = $mail->{bcc};

  $self->{email} = $mail->{to};

  $main::lxdebug->leave_sub();

}

sub output_file {

  $main::lxdebug->enter_sub();

  my ($self,$mimeType,$command_formatter) = @_;

  my $numbytes = (-s $self->{tmpfile});

  open(IN, "<", $self->{tmpfile})

    or $self->error($self->cleanup . "$self->{tmpfile} : $!");

  binmode IN;

  $self->{copies} = 1 unless $self->{media} eq 'printer';

  chdir("$self->{cwd}");

  for my $i (1 .. $self->{copies}) {

    if ($self->{OUT}) {

      $self->{OUT} = $command_formatter->($self->{OUT_MODE}, $self->{OUT});

      open  OUT, $self->{OUT_MODE}, $self->{OUT} or $self->error($self->cleanup . "$self->{OUT} : $!");

      print OUT $_ while <IN>;

      close OUT;

      seek  IN, 0, 0;

    } else {

      my %headers = ('-type'       => $mimeType,

                     '-connection' => 'close',

                     '-charset'    => 'UTF-8');

      $self->{attachment_filename} ||= $self->generate_attachment_filename;

      if ($self->{attachment_filename}) {

        %headers = (

          %headers,

          '-attachment'     => $self->{attachment_filename},

          '-content-length' => $numbytes,

          '-charset'        => '',

        );

      }

      print $::request->cgi->header(%headers);

      $::locale->with_raw_io(\*STDOUT, sub { print while <IN> });

    }

  }

  close(IN);

  { name => "MIME::Entity",                        url => "http://search.cpan.org/~dskoll/",    debian => '' },

  { name => "MIME::Parser",                        url => "http://search.cpan.org/~dskoll/",    debian => '' },

use MIME::Entity;

use MIME::Parser;

use File::MimeInfo::Magic;

use Encode;

my $parser;

  $parser = new MIME::Parser;

  $parser->output_under("users");

      push @header_addresses, encode('MIME-Header',$addr_obj->format);

    Disposition  => 'attachment',

    Encoding     => 'base64',

  my $file_id = 0;

  my $email_journal = $::instance_conf->get_email_journal;

  $main::lxdebug->message(LXDebug->DEBUG2(), "mail5 att=".$attachment." email_journal=". $email_journal." id=".$attachment->{id});

    $attributes{Path}     = $attachment->{path} || $attachment->{filename};

    $attributes{Filename} = $attachment->{name};

    $file_id              = $attachment->{id}   || '0';

    $attributes{Type}     = $attachment->{type} || 'application/pdf';

    $attachment_content   = eval { read_file($attachment->{path}) } if $email_journal > 1;

    $attributes{Path}     =  $attachment;

    $attributes{Filename} =  $attachment;

    $attributes{Filename} =~ s:.*\Q$self->{fileid}\E:: if $self->{fileid};

    $attributes{Filename} =~ s:.*/::g;

    my $application     = ($attachment =~ /(^\w+$)|\.(html|text|txt|sql)$/) ? 'text' : 'application';

    $attributes{Type}   = File::MimeInfo::Magic::magic($attachment);

    $attributes{Type} ||= "${application}/$self->{format}" if $self->{format};

    $attributes{Type} ||= 'application/octet-stream';

    $attachment_content = eval { read_file($attachment) } if $email_journal > 1;

  return undef if $email_journal > 1 && !defined $attachment_content;

  $attachment_content ||= ' ';

  $main::lxdebug->message(LXDebug->DEBUG2(), "mail6 mtype=".$attributes{Type}." path=".

                            $attributes{Path}." filename=".$attributes{Filename});

# $attributes{Charset}  = $self->{charset} if lc $application eq 'text' && $self->{charset};

  $attributes{Charset}  = $self->{charset} if $self->{charset};

  my $ent;

  if ( $attributes{Type} eq 'message/rfc822' ) {

    my $fh = IO::File->new($attributes{Path}, "r");

    if (! defined $fh) {

      return undef;

    }

    $ent = $parser->parse($fh);

    undef $fh;

    my $head = $ent->head;

    $head->replace('Content-disposition','attachment; filename='.$attributes{Filename});

  } else {

    $ent = MIME::Entity->build(%attributes);

  }

  push @{ $self->{mail_attachments}} , SL::DB::EmailJournalAttachment->new(

    name      => $attributes{Filename},

    mime_type => $attributes{Type},

    content   => ( $email_journal > 1 ? $attachment_content : ' '),

    file_id   => $file_id,

  return $ent;

  push @{ $self->{headers} }, ('Type'    =>"multipart/mixed" );

  my  $top = MIME::Entity->build(@{$self->{headers}});

    $top->attach(Data => encode($self->{charset},$self->{message}),

                 Charset => $self->{charset},

                 Type => $self->{contenttype},

                 Encoding    => 'quoted-printable');

  map { $top->add_part($self->_create_attachment_part($_)) } @{ $self->{attachments} || [] };

  return $top;

    Subject              => encode('MIME-Header',$self->{subject}),

  $self->{mail_attachments} = [];

  $self->{content_by_name}  = $::instance_conf->get_email_journal == 1 && $::instance_conf->get_doc_files;

    #$::lxdebug->message(0, "message: " . $email->as_string);

    $self->{driver}->start_mail(from => encode('MIME-Header',$self->{from}), to => [ $self->_all_recipients ]);

  $self->{journalentry} = $self->_store_in_journal;

  $parser->filer->purge;

  my $jentry = SL::DB::EmailJournal->new(

    attachments     => \@{ $self->{mail_attachments} },

  return $jentry->id;

use SL::File;

use SL::Helper::Flash;

  my (@files, @vc_files, @part_files, $has_document);

  if ($::instance_conf->get_doc_storage) {

    @files = SL::File->get_all_versions(object_id => $form->{id}, object_type => $form->{type}, file_type => 'document');

    $has_document = 1 if scalar(@files) > 0;

    @files = SL::File->get_all(object_id => $form->{id}, object_type => $form->{type}, file_type => 'attachment');

    @vc_files = SL::File->get_all(object_id => $form->{"$form->{vc}_id"}, object_type => $form->{vc})

      if $form->{vc} && $form->{"$form->{vc}_id"};

    my %part_id_map = map { $_->{id} => $_ } grep { $_->{id} } map {

      {

        'id'       => $form->{"id_$_"},

        'partname' => $form->{"partnumber_$_"}

      }

    } (1 .. $form->{rowcount});

    foreach my $partid (keys %part_id_map) {

      my @pfiles = SL::File->get_all(object_id => $partid, object_type => 'part');

      push @part_files, map { $_->{partname} = $part_id_map{$partid}->{partname}; $_ } @pfiles;

    }

  }

                                     has_document  => $has_document,

                                     FILES         => \@files,

                                     VC_FILES      => \@vc_files,

                                     PART_FILES    => \@part_files,

  if ( $form->{action_oldfile} || $form->{action_nofile} ) {

    if (!$form->{email} || $form->{email} =~ /^\s*$/) {

      flash('error', $::locale->text('E-mail address missing!'));

    }

    else {

      $form->send_email(\%myconfig,'pdf');

    }

  }

  else {

    print_form("return");

    $form->{addition} = "SCREENED";

    $form->save_history;

    $form->{addition} = "MAILED";

  }

  flash_later('info' , $::locale->text('E-Mail is sent to #1', $form->{email})) if !$form->{emailerr};

  flash_later('error', $::locale->text($form->{emailerr})) if $form->{emailerr};

  delete $form->{emailerr};

  ##TODO andere SAVE HISTORY

  'Customer Attachments'        => 'Anhänge des Kunden',

  'E-Mail is sent to #1'        => 'E-Mail wurde an #1 gesendet',

  'ImagePreview'                => 'Bildvorschau',

  'Images'                      => 'Bilder',

  'Make new document'           => 'Erzeuge ein neue Datei',

  'No document'                 => 'Kein Datei mitschicken (ggf. Anhänge)',

  'Part Attachments'            => 'Anhänge der Artikel',

  'a_credit_note'               => '',

  'a_purchase_delivery_order'   => '',

  'a_purchase_invoice'          => '',

  'a_purchase_order'            => '',

  'a_request_quotation'         => '',

  'a_sales_delivery_order'      => '',

  'a_sales_order'               => '',

  'a_sales_quotation'           => '',

  'an_invoice'                  => '',

  'mail_greeting #1'            => '',

  'other Document Attachments'  => 'Weitere Dateianhänge',

  'uploaded'                    => 'Hochgeladen',

  'use actual document'         => 'Verwende aktuelle Datei',

-- @tag: email_journal_attachments_add_fileid

-- @description: attachments mit file_id

-- @depends: email_journal filemanagement_feature files

ALTER TABLE email_journal_attachments ADD COLUMN file_id integer default 0 NOT NULL;

    <td style="width: 500px">

[%- IF INSTANCE_CONF.get_doc_storage %]

    <td align="left" rowspan="2">

      <table>

[%- USE ATT_it = Iterator(FILES) %]

[% FOREACH file = ATT_it %]

[% END %]

[%- IF ATT_it.size > 0 %]  

        <tr class="listheading">

          <th colspan="3" align="left" nowrap>[% LxERP.t8('other Document Attachments') %]</th>

          <input type="hidden" name="attfile_count" id="m_attfile_count" value="[% ATT_it.size %]">

        </tr>

         <tr class="">

           <th align="left" nowrap></th>

           <th align="left" nowrap>[% LxERP.t8('Filename') %]</th>

           <th align="left" nowrap></th>

        </tr>

        <tr><td colspan="3"><hr size="1" style="height:1px;background-color:#000;" noshade></td></tr>

       [% FOREACH file = ATT_it %]

         <tr class="listrow">

          <td></td><td>[% file.file_name %]

            <input type="hidden" name="attfile_[% ATT_it.count %]" value="[% file.id %]">

            <td><input name="attsel_[% ATT_it.count %]" type="checkbox" class="checkbox" ></td>

         </tr>

        [% END %]

[%- END %]

[%- USE ATT_it = Iterator(VC_FILES) %]

[% FOREACH file = ATT_it %]

[% END %]

[%- IF ATT_it.size > 0 %]  

        <tr><td colspan="3"><hr size="1" noshade></td></tr>

         <tr class="listheading">

           <th colspan="3" align="left" nowrap>

             <input type="hidden" name="attfile_cv_count" id="m_attfile_cv_count" value="[% ATT_it.size %]">

             [% LxERP.t8('Customer Attachments') %]

           </th>

         </tr>

        <tr class="">

           <th align="left" nowrap></th>

           <th align="left" nowrap>[% LxERP.t8('Filename') %]</th>

           <th align="left" nowrap></th>

        </tr>

        <tr><td colspan="3"><hr size="1" style="height:1px;background-color:#000;" noshade></td></tr>

        [% FOREACH file = ATT_it %]

         <tr class="listrow">

          <td></td><td>[% file.file_name %]

            <input type="hidden" name="attfile_cv_[% ATT_it.count %]" value="[% file.id %]">

            <td><input name="attsel_cv_[% ATT_it.count %]" type="checkbox" class="checkbox" ></td>

         </tr>

        [% END %]

[%- END %]

[%- USE ATT_it = Iterator(PART_FILES) %]

[%- SET lastpartid = '' %]  

[%- FOREACH file = ATT_it %]

[%- END %]

[%- IF ATT_it.size > 0 %]  

        <tr><td colspan="3"><hr size="1" noshade></td></tr>

         <tr class="listheading">

          <th colspan="3" align="left" nowrap>

            <input type="hidden" name="attfile_part_count" id="m_attfile_part_count" value="[% ATT_it.size %]">

            [% LxERP.t8('Part Attachments') %]

          </th>

        </tr>

        <tr class="">

           <th align="left" nowrap>[% LxERP.t8('Part Number') %]</th>

           <th align="left" nowrap>[% LxERP.t8('Filename') %]</th>

           <th align="left" nowrap></th>

        </tr>

        [% FOREACH file = ATT_it %]

          [%- IF lastpartid != file.trans_id %]

             [%- SET lastpartid = file.trans_id %][%- SET partname = file.partname %]

        <tr><td colspan="3"><hr size="1" style="height:1px;background-color:#000;" noshade></td></tr>

          [%- ELSE %][%- SET partname = '' %][% END %]          

        <tr class="listrow">

          <td>[% partname %]</td>

          <td>[% file.file_name %]

            <input type="hidden" name="attfile_part_[% ATT_it.count %]" value="[% file.id %]">

            <td><input name="attsel_part_[% ATT_it.count %]" type="checkbox" class="checkbox" ></td>

         </tr>

        [% END %]

[%- END %]

      </table>

    </td>

[%- ELSE %]

    <td rowspan="2">

    </td>

[%- END %]

    <td colspan="2">

    <td colspan="2"><hr size="3" noshade></td>

[% L.submit_tag('action_newfile', LxERP.t8('Make new document'), onclick="return check_prerequisites();") %]

[%- IF has_document %]  

[% L.submit_tag('action_oldfile', LxERP.t8('use actual document'), onclick="return check_prerequisites();") %]

[%- END %]

[% L.submit_tag('action_nofile',  LxERP.t8('No document'), onclick="return check_prerequisites();") %]