SL/Controller/File.pm

   1 package SL::Controller::File;
   2
   3 use strict;
   4
   5 use parent qw(SL::Controller::Base);
   6
   7 use List::Util qw(first max);
   8
   9 use utf8;
  10 use Encode qw(decode);
  11 use URI::Escape;
  12 use Cwd;
  13 use DateTime;
  14 use File::stat;
  15 use File::Spec::Unix;
  16 use File::Spec::Win32;
  17 use File::MimeInfo::Magic;
  18 use SL::DB::Helper::Mappings;
  19 use SL::DB::Order;
  20 use SL::DB::DeliveryOrder;
  21 use SL::DB::Invoice;
  22
  23 use SL::DB::PurchaseInvoice;
  24 use SL::DB::Part;
  25 use SL::DB::GLTransaction;
  26 use SL::DB::Draft;
  27 use SL::DB::History;
  28 use SL::JSON;
  29 use SL::Helper::CreatePDF qw(:all);
  30 use SL::Locale::String;
  31 use SL::SessionFile;
  32 use SL::File;
  33 use SL::Controller::Helper::ThumbnailCreator qw(file_probe_image_type);
  34
  35 use constant DO_DELETE   => 0;
  36 use constant DO_UNIMPORT => 1;
  37
  38 use Rose::Object::MakeMethods::Generic
  39 (
  40     'scalar --get_set_init' => [ qw() ],
  41     'scalar' => [ qw(object object_type object_model object_id object_right file_type files is_global existing) ],
  42 );
  43
  44 __PACKAGE__->run_before('check_object_params', only => [ qw(list ajax_delete ajax_importdialog ajax_import ajax_unimport ajax_upload ajax_files_uploaded) ]);
  45
  46 my %file_types = (
  47   'sales_quotation'         => { gen => 1, gltype => '',   dir =>'SalesQuotation',       model => 'Order',          right => 'import_ar'  },
  48   'sales_order'             => { gen => 1, gltype => '',   dir =>'SalesOrder',           model => 'Order',          right => 'import_ar'  },
  49   'sales_delivery_order'    => { gen => 1, gltype => '',   dir =>'SalesDeliveryOrder',   model => 'DeliveryOrder',  right => 'import_ar'  },
  50   'invoice'                 => { gen => 1, gltype => 'ar', dir =>'SalesInvoice',         model => 'Invoice',        right => 'import_ar'  },
  51   'credit_note'             => { gen => 1, gltype => '',   dir =>'CreditNote',           model => 'Invoice',        right => 'import_ar'  },
  52   'request_quotation'       => { gen => 3, gltype => '',   dir =>'RequestForQuotation',  model => 'Order',          right => 'import_ap'  },
  53   'purchase_order'          => { gen => 3, gltype => '',   dir =>'PurchaseOrder',        model => 'Order',          right => 'import_ap'  },
  54   'purchase_delivery_order' => { gen => 3, gltype => '',   dir =>'PurchaseDeliveryOrder',model => 'DeliveryOrder',  right => 'import_ap'  },
  55   'purchase_invoice'        => { gen => 2, gltype => 'ap', dir =>'PurchaseInvoice',      model => 'PurchaseInvoice',right => 'import_ap'  },
  56   'vendor'                  => { gen => 0, gltype => '',   dir =>'Vendor',               model => 'Vendor',         right => 'xx'         },
  57   'customer'                => { gen => 1, gltype => '',   dir =>'Customer',             model => 'Customer',       right => 'xx'         },
  58   'part'                    => { gen => 0, gltype => '',   dir =>'Part',                 model => 'Part',           right => 'xx'         },
  59   'gl_transaction'          => { gen => 2, gltype => 'gl', dir =>'GeneralLedger',        model => 'GLTransaction',  right => 'import_ap'  },
  60   'draft'                   => { gen => 0, gltype => '',   dir =>'Draft',                model => 'Draft',          right => 'xx'         },
  61   'csv_customer'            => { gen => 1, gltype => '',   dir =>'Reports',              model => 'Customer',       right => 'xx'         },
  62   'csv_vendor'              => { gen => 1, gltype => '',   dir =>'Reports',              model => 'Vendor',         right => 'xx'         },
  63   'shop_image'              => { gen => 0, gltype => '',   dir =>'ShopImages',           model => 'Part',           right => 'xx'         },
  64 );
  65
  66 #--- 4 locale ---#
  67 # $main::locale->text('imported')
  68
  69 #
  70 # actions
  71 #
  72
  73 sub action_list {
  74   my ($self) = @_;
  75
  76   my $is_json = 0;
  77   $is_json = 1 if $::form->{json};
  78
  79   $self->_do_list($is_json);
  80 }
  81
  82 sub action_ajax_importdialog {
  83   my ($self) = @_;
  84   $::auth->assert($self->object_right);
  85   my $path   = $::form->{path};
  86   my @files  = $self->_get_from_import($path);
  87   my $source = {
  88     'name'         => $::form->{source},
  89     'path'         => $path ,
  90     'chk_action'   => $::form->{source}.'_import',
  91     'chk_title'    => $main::locale->text('Import scanned documents'),
  92     'chkall_title' => $main::locale->text('Import all'),
  93     'files'        => \@files
  94   };
  95   $self->render('file/import_dialog',
  96                 { layout => 0
  97                 },
  98                 source => $source
  99   );
 100 }
 101
 102 sub action_ajax_import {
 103   my ($self) = @_;
 104   $::auth->assert($self->object_right);
 105   my $ids    = $::form->{ids};
 106   my $source = $::form->{source};
 107   my $path   = $::form->{path};
 108   my @files  = $self->_get_from_import($path);
 109   foreach my $filename (@{ $::form->{$ids} || [] }) {
 110     my ($file, undef) = grep { $_->{name} eq $filename } @files;
 111     if ( $file ) {
 112       my $obj = SL::File->save(object_id   => $self->object_id,
 113                                object_type => $self->object_type,
 114                                mime_type   => 'application/pdf',
 115                                source      => $source,
 116                                file_type   => 'document',
 117                                file_name   => $file->{filename},
 118                                file_path   => $file->{path}
 119                              );
 120       unlink($file->{path}) if $obj;
 121     }
 122   }
 123   $self->_do_list(1);
 124 }
 125
 126 sub action_ajax_delete {
 127   my ($self) = @_;
 128   $self->_delete_all(DO_DELETE, $::locale->text('Following files are deleted:'));
 129 }
 130
 131 sub action_ajax_unimport {
 132   my ($self) = @_;
 133   $self->_delete_all(DO_UNIMPORT, $::locale->text('Following files are unimported:'));
 134 }
 135
 136 sub action_ajax_rename {
 137   my ($self) = @_;
 138   my $file = SL::File->get(id => $::form->{id});
 139   if ( ! $file ) {
 140     $self->js->flash('error', $::locale->text('File not exists !'))->render();
 141     return;
 142   }
 143   my $sessionfile = $::form->{sessionfile};
 144   if ( $sessionfile && -f $sessionfile ) {
 145     # new uploaded file
 146     if ( $::form->{to} eq $file->file_name ) {
 147       # no rename so use as new version
 148       $file->save_file($sessionfile);
 149       $self->js->flash('warning', $::locale->text('File \'#1\' is used as new Version !', $file->file_name));
 150
 151     } else {
 152       # new filename, so it is a new file with the same attributes as the old file
 153       eval {
 154         SL::File->save(object_id   => $file->object_id,
 155                        object_type => $file->object_type,
 156                        mime_type   => $file->mime_type,
 157                        source      => $file->source,
 158                        file_type   => $file->file_type,
 159                        file_name   => $::form->{to},
 160                        file_path   => $sessionfile
 161                      );
 162         unlink($sessionfile);
 163         1;
 164       } or do {
 165         $self->js->flash(       'error', t8('internal error (see details)'))
 166                  ->flash_detail('error', $@)->render;
 167         return;
 168       }
 169     }
 170
 171   } else {
 172     # normal rename
 173     my $result;
 174
 175     eval {
 176       $result = $file->rename($::form->{to});
 177       1;
 178     } or do {
 179       $self->js->flash(       'error', t8('internal error (see details)'))
 180                ->flash_detail('error', $@)->render;
 181       return;
 182     };
 183
 184     if ($result != SL::File::RENAME_OK) {
 185       $self->js->flash('error',
 186                          $result == SL::File::RENAME_EXISTS ? $::locale->text('File still exists !')
 187                        : $result == SL::File::RENAME_SAME   ? $::locale->text('Same Filename !')
 188                        :                                      $::locale->text('File not exists !'))
 189         ->render;
 190       return;
 191     }
 192   }
 193   $self->is_global($::form->{is_global});
 194   $self->file_type(  $file->file_type);
 195   $self->object_type($file->object_type);
 196   $self->object_id(  $file->object_id);
 197   #$self->object_model($file_types{$file->module}->{model});
 198   #$self->object_right($file_types{$file->module}->{right});
 199   if ( $::form->{next_ids} ) {
 200     my @existing = split(/,/, $::form->{next_ids});
 201     $self->existing(\@existing);
 202   }
 203   $self->_do_list(1);
 204 }
 205
 206 sub action_ajax_upload {
 207   my ($self) = @_;
 208   $self->{maxsize} = $::instance_conf->get_doc_max_filesize;
 209   $self->{accept_types} = '';
 210   $self->{accept_types} = 'image/png,image/gif,image/jpeg,image/tiff,*png,*gif,*.jpg,*.tif' if $self->{file_type} eq 'image';
 211   $self->render('file/upload_dialog',
 212                 { layout => 0
 213                 },
 214   );
 215 }
 216
 217 sub action_ajax_files_uploaded {
 218   my ($self) = @_;
 219
 220   my $source = 'uploaded';
 221   my @existing;
 222   if ( $::form->{ATTACHMENTS}->{uploadfiles} ) {
 223     my @upfiles = @{ $::form->{ATTACHMENTS}->{uploadfiles} };
 224     foreach my $idx (0 .. scalar(@upfiles) - 1) {
 225       eval {
 226         my $fname = uri_unescape($upfiles[$idx]->{filename});
 227         # normalize and find basename
 228         # first split with unix rules
 229         # after that split with windows rules
 230         my ($volume, $directories, $basefile) = File::Spec::Unix->splitpath($fname);
 231         ($volume, $directories, $basefile) = File::Spec::Win32->splitpath($basefile);
 232
 233         # to find real mime_type by magic we must save the filedata
 234
 235         my $sess_fname = "file_upload_" . $self->object_type . "_" . $self->object_id . "_" . $idx;
 236         my $sfile      = SL::SessionFile->new($sess_fname, mode => 'w');
 237
 238         $sfile->fh->print(${$upfiles[$idx]->{data}});
 239         $sfile->fh->close;
 240         my $mime_type = File::MimeInfo::Magic::magic($sfile->file_name);
 241
 242         if (! $mime_type) {
 243           # if filename has the suffix "pdf", but isn't really a pdf, set mimetype for no suffix
 244           $mime_type = File::MimeInfo::Magic::mimetype($basefile);
 245           $mime_type = 'application/octet-stream' if $mime_type eq 'application/pdf' || !$mime_type;
 246         }
 247         if ( $self->file_type eq 'image' && $self->file_probe_image_type($mime_type, $basefile)) {
 248           next;
 249         }
 250         my ($existobj) = SL::File->get_all(object_id   => $self->object_id,
 251                                            object_type => $self->object_type,
 252                                            mime_type   => $mime_type,
 253                                            source      => $source,
 254                                            file_type   => $self->file_type,
 255                                            file_name   => $basefile,
 256                                       );
 257
 258         if ($existobj) {
 259           push @existing, $existobj->id.'_'.$sfile->file_name;
 260         } else {
 261           my $fileobj = SL::File->save(object_id        => $self->object_id,
 262                                        object_type      => $self->object_type,
 263                                        mime_type        => $mime_type,
 264                                        source           => $source,
 265                                        file_type        => $self->file_type,
 266                                        file_name        => $basefile,
 267                                        title            => $::form->{title},
 268                                        description      => $::form->{description},
 269                                        ## two possibilities: what is better ? content or sessionfile ??
 270                                        file_contents    => ${$upfiles[$idx]->{data}},
 271                                        file_path        => $sfile->file_name
 272                                      );
 273           unlink($sfile->file_name);
 274         }
 275         1;
 276       } or do {
 277         $self->js->flash(       'error', t8('internal error (see details)'))
 278                  ->flash_detail('error', $@)->render;
 279         return;
 280       }
 281     }
 282   }
 283   $self->existing(\@existing);
 284   $self->_do_list(1);
 285 }
 286
 287 sub action_download {
 288   my ($self) = @_;
 289   my ($id, $version) = split /_/, $::form->{id};
 290   my $file = SL::File->get(id => $id );
 291   $file->version($version) if $version;
 292   my $ref  = $file->get_content;
 293   if ( $file && $ref ) {
 294     return $self->send_file($ref,
 295       type => $file->mime_type,
 296       name => $file->file_name,
 297     );
 298   }
 299 }
 300
 301 #
 302 # filters
 303 #
 304
 305 sub check_object_params {
 306   my ($self) = @_;
 307
 308   my $id      = ($::form->{object_id} // 0) * 1;
 309   my $draftid = ($::form->{draft_id}  // 0) * 1;
 310   my $gldoc   = 0;
 311   my $type    = undef;
 312
 313   if ( $draftid == 0 && $id == 0 && $::form->{is_global} ) {
 314     $gldoc = 1;
 315     $type  = $::form->{object_type};
 316   }
 317   elsif ( $id == 0 ) {
 318     $id   = $::form->{draft_id};
 319     $type = 'draft';
 320   } elsif ( $::form->{object_type} ) {
 321     $type = $::form->{object_type};
 322   }
 323   die "No object type"     unless $type;
 324   die "No file type"       unless $::form->{file_type};
 325   die "Unkown object type" unless $file_types{$type};
 326
 327   $self->is_global($gldoc);
 328   $self->file_type($::form->{file_type});
 329   $self->object_type($type);
 330   $self->object_id($id);
 331   $self->object_model($file_types{$type}->{model});
 332   $self->object_right($file_types{$type}->{right});
 333
 334  # $::auth->assert($self->object_right);
 335
 336  # my $model = 'SL::DB::' . $self->object_model;
 337  # $self->object($model->new(id => $self->object_id)->load || die "Record not found");
 338
 339   return 1;
 340 }
 341
 342 #
 343 # private methods
 344 #
 345
 346 sub _delete_all {
 347   my ($self, $do_unimport, $infotext) = @_;
 348   my $files = '';
 349   my $ids = $::form->{ids};
 350   foreach my $id_version (@{ $::form->{$ids} || [] }) {
 351     my ($id, $version) = split /_/, $id_version;
 352     my $dbfile = SL::File->get(id => $id);
 353     $dbfile->version($version) if $dbfile && $version;
 354     if ( $dbfile && $dbfile->delete ) {
 355       $files .= ' ' . $dbfile->file_name;
 356     }
 357   }
 358   $self->js->flash('info', $infotext . $files) if $files;
 359   $self->_do_list(1);
 360 }
 361
 362 sub _do_list {
 363   my ($self, $json) = @_;
 364   my @files;
 365   if ( $self->file_type eq 'document' ) {
 366     my @object_types;
 367     push @object_types, $self->object_type;
 368     push @object_types, qw(dunning dunning1 dunning2 dunning3) if $self->object_type eq 'invoice'; # hardcoded object types?
 369     @files = SL::File->get_all_versions(object_id   => $self->object_id,
 370                                         object_type => \@object_types,
 371                                         file_type   => $self->file_type,
 372                                        );
 373
 374   }
 375   elsif ( $self->file_type eq 'attachment' || $self->file_type eq 'image' ) {
 376     @files   = SL::File->get_all(object_id   => $self->object_id,
 377                                  object_type => $self->object_type,
 378                                  file_type   => $self->file_type,
 379                                 );
 380   }
 381   $self->files(\@files);
 382
 383   if($self->object_type eq 'shop_image'){
 384     $self->js
 385       ->run('kivi.ShopPart.show_images', $self->object_id)
 386       ->render();
 387   }else{
 388     $self->_mk_render('file/list', 1, 0, $json);
 389   }
 390 }
 391
 392 sub _get_from_import {
 393   my ($self, $path) = @_;
 394   my @foundfiles ;
 395
 396   my $language = $::lx_office_conf{system}->{language};
 397   my $timezone = $::locale->get_local_time_zone()->name;
 398   if (opendir my $dir, $path) {
 399     my @files = ( readdir $dir);
 400     foreach my $file ( @files) {
 401       next if (($file eq '.') || ($file eq '..'));
 402       $file = Encode::decode('utf-8', $file);
 403
 404       next if ( -d "$path/$file" );
 405
 406       my $tmppath = File::Spec->catfile( $path, $file );
 407       next if( ! -f $tmppath );
 408
 409       my $st = stat($tmppath);
 410       my $dt = DateTime->from_epoch( epoch => $st->mtime, time_zone => $timezone, locale => $language );
 411       my $sname = $main::locale->quote_special_chars('HTML', $file);
 412       push @foundfiles, {
 413         'name'     => $file,
 414         'filename' => $sname,
 415         'path'     => $tmppath,
 416         'mtime'    => $st->mtime,
 417         'date'     => $dt->dmy('.') . " " . $dt->hms,
 418       };
 419
 420     }
 421   }
 422   return @foundfiles;
 423 }
 424
 425 sub _mk_render {
 426   my ($self, $template, $edit, $scanner, $json) = @_;
 427   my $err;
 428   eval {
 429     ##TODO make code configurable
 430
 431     my $title;
 432     my @sources = $self->_get_sources();
 433     foreach my $source ( @sources ) {
 434       @{$source->{files}} = grep { $_->source eq $source->{name}} @{ $self->files };
 435     }
 436     if ( $self->file_type eq 'document' ) {
 437       $title = $main::locale->text('Documents');
 438     } elsif ( $self->file_type eq 'attachment' ) {
 439       $title = $main::locale->text('Attachments');
 440     } elsif ( $self->file_type eq 'image' ) {
 441       $title = $main::locale->text('Images');
 442     }
 443
 444     my $output         = SL::Presenter->get->render(
 445       $template,
 446       title            => $title,
 447       SOURCES          => \@sources,
 448       edit_attachments => $edit,
 449       object_type      => $self->object_type,
 450       object_id        => $self->object_id,
 451       file_type        => $self->file_type,
 452       is_global        => $self->is_global,
 453       json             => $json,
 454     );
 455     if ( $json ) {
 456       $self->js->html('#'.$self->file_type.'_list_'.$self->object_type, $output);
 457       if ( $self->existing && scalar(@{$self->existing}) > 0) {
 458         my $first = shift @{$self->existing};
 459         my ($first_id, $sfile) = split('_', $first, 2);
 460         my $file = SL::File->get(id => $first_id );
 461         $self->js->run('kivi.File.askForRename', $first_id, $file->file_name, $sfile, join (',', @{$self->existing}), $self->is_global);
 462       }
 463       $self->js->render();
 464     } else {
 465         $self->render(\$output, { layout => 0, process => 0 });
 466     }
 467     1;
 468   } or do {
 469     if ($json ){
 470       $self->js->flash(       'error', t8('internal error (see details)'))
 471                ->flash_detail('error', $@)->render;
 472     } else {
 473       $self->render('generic/error', { layout => 0 }, label_error => $@);
 474     }
 475   };
 476 }
 477
 478
 479 sub _get_sources {
 480   my ($self) = @_;
 481   my @sources;
 482   if ( $self->file_type eq 'document' ) {
 483     # TODO statt gen neue attribute in filetypes :
 484     if (($file_types{$self->object_type}->{gen}*1 & 1)==1) {
 485       my $gendata = {
 486         'name'         => 'created',
 487         'title'        => $main::locale->text('generated Files'),
 488         'chk_action'   => 'documents_delete',
 489         'chk_title'    => $main::locale->text('Delete Documents'),
 490         'chkall_title' => $main::locale->text('Delete all'),
 491         'file_title'   => $main::locale->text('filename'),
 492         'confirm_text' => $main::locale->text('delete'),
 493         'can_rename'   => 1,
 494         'rename_title' => $main::locale->text('Rename Documents'),
 495         'done_text'    => $main::locale->text('deleted')
 496       };
 497       push @sources , $gendata;
 498     }
 499     if (($file_types{$self->object_type}->{gen}*1 & 2)==2) {
 500       my @others =  SL::File->get_other_sources();
 501       foreach my $scanner_or_mailrx (@others) {
 502         my $other = {
 503           'name'         => $scanner_or_mailrx->{name},
 504           'title'        => $main::locale->text('from \'#1\' imported Files', $scanner_or_mailrx->{description}),
 505           'chk_action'   => $scanner_or_mailrx->{name}.'_unimport',
 506           'chk_title'    => $main::locale->text('Unimport documents'),
 507           'chkall_title' => $main::locale->text('Unimport all'),
 508           'file_title'   => $main::locale->text('filename'),
 509           'confirm_text' => $main::locale->text('unimport'),
 510           'can_rename'   => 1,
 511           'rename_title' => $main::locale->text('Rename Documents'),
 512           'can_import'   => 1,
 513           'import_title' => $main::locale->text('Add Document from \'#1\'', $scanner_or_mailrx->{name}),
 514           'path'         => $scanner_or_mailrx->{directory},
 515           'done_text'    => $main::locale->text('unimported')
 516         };
 517         push @sources , $other;
 518       }
 519     }
 520   }
 521   elsif ( $self->file_type eq 'attachment' ) {
 522     my $attdata = {
 523       'name'         => 'uploaded',
 524       'title'        => $main::locale->text(''),
 525       'chk_action'   => 'attachments_delete',
 526       'chk_title'    => $main::locale->text('Delete Attachments'),
 527       'chkall_title' => $main::locale->text('Delete all'),
 528       'file_title'   => $main::locale->text('filename'),
 529       'confirm_text' => $main::locale->text('delete'),
 530       'can_rename'   => 1,
 531       'are_existing' => $self->existing ? 1 : 0,
 532       'rename_title' => $main::locale->text('Rename Attachments'),
 533       'can_upload'   => 1,
 534       'upload_title' => $main::locale->text('Upload Attachments'),
 535       'done_text'    => $main::locale->text('deleted')
 536     };
 537     push @sources , $attdata;
 538   }
 539   elsif ( $self->file_type eq 'image' ) {
 540     my $attdata = {
 541       'name'         => 'uploaded',
 542       'title'        => $main::locale->text(''),
 543       'chk_action'   => 'images_delete',
 544       'chk_title'    => $main::locale->text('Delete Images'),
 545       'chkall_title' => $main::locale->text('Delete all'),
 546       'file_title'   => $main::locale->text('filename'),
 547       'confirm_text' => $main::locale->text('delete'),
 548       'can_rename'   => 1,
 549       'are_existing' => $self->existing ? 1 : 0,
 550       'rename_title' => $main::locale->text('Rename Images'),
 551       'can_upload'   => 1,
 552       'upload_title' => $main::locale->text('Upload Images'),
 553       'done_text'    => $main::locale->text('deleted')
 554     };
 555     push @sources , $attdata;
 556   }
 557   return @sources;
 558 }
 559
 560 1;
 561
 562 __END__
 563
 564 =pod
 565
 566 =encoding utf-8
 567
 568 =head1 NAME
 569
 570 SL::Controller::File - Controller for managing files
 571
 572 =head1 SYNOPSIS
 573
 574 The Controller is called directly from the webpages
 575
 576     <a href="controller.pl?action=File/list&file_type=document\
 577        &object_type=[% HTML.escape(type) %]&object_id=[% HTML.url(id) %]">
 578
 579
 580 or indirectly via javascript functions from js/kivi.File.js
 581
 582     kivi.popup_dialog({ url:     'controller.pl',
 583                         data:    { action     : 'File/ajax_upload',
 584                                    file_type  : 'uploaded',
 585                                    object_type: type,
 586                                    object_id  : id
 587                                  }
 588                            ...
 589
 590 =head1 DESCRIPTION
 591
 592 This is a controller for handling files in a storage independent way.
 593 The storage may be a Filesystem,a WebDAV, a Database or DMS.
 594 These backends must be configered in ClientConfig.
 595 This Controller use as intermediate layer for storage C<SL::File>.
 596
 597 The Controller is responsible to display forms for displaying the files at the ERP-objects and
 598 for uploading and downloading the files.
 599
 600 More description of the intermediate layer see L<SL::File>.
 601
 602 =head1 METHODS
 603
 604 =head2 C<action_list>
 605
 606 This loads a list of files on a webpage. This can be done with a normal submit or via an ajax/json call.
 607 Dependent of file_type different sources are available.
 608
 609 For documents there are the 'created' source and the imports from scanners or email.
 610 For attachments and images only the 'uploaded' source available.
 611
 612 Available C<FORM PARAMS>:
 613
 614 =over 4
 615
 616 =item C<form.object_id>
 617
 618 The Id of the ERP-object.
 619
 620 =item C<form.object_type>
 621
 622 The Type of the ERP-object like "sales_quotation". A clear mapping to the class/model exists in the controller.
 623
 624 =item C<form.file_type>
 625
 626 For one ERP-object may exists different type of documents the type may be "documents","attachments" or "images".
 627 This file_type is a filter for the list.
 628
 629 =item C<form.json>
 630
 631 The method can be used as normal HTTP-Request (json=0) or as AJAX-JSON call to refresh the list if the parameter is set to 1.
 632
 633 =back
 634
 635
 636 =head2 C<action_ajax_upload>
 637
 638
 639 A new file or more files can selected by a dialog and insert into the system.
 640
 641
 642 Available C<FORM PARAMS>:
 643
 644 =over 4
 645
 646 =item C<form.file_type>
 647
 648 This parameter describe here the source for a new file :
 649 "attachments" and "images"
 650
 651 This is a normal upload selection, which may be more then one file to upload.
 652
 653 =item C<form.object_id>
 654
 655 and
 656
 657 =item C<form.object_type>
 658
 659 are the same as at C<action_list>
 660
 661 =back
 662
 663 =head2  C<action_ajax_files_uploaded>
 664
 665 The Upload of selected Files. The "multipart_formdata" is parsed in SL::Request into the formsvariable "form.ATTACHMENTS".
 666 The filepaths are checked about Unix and Windows paths. Also the MIME type of the files are verified ( IS the contents of a *.pdf real PDF?).
 667 If the same filename still exists at this object after the download for each existing filename a rename dialog will be opened.
 668
 669 If the filename is not changed the new uploaded file is a new version of the file, if the name is changed it is a new file.
 670
 671 Available C<FORM PARAMS>:
 672
 673 =over 4
 674
 675 =item C<form.ATTACHMENTS.uploadfiles>
 676
 677 This is an array of elements which have {filename} for the name and {data} for the contents.
 678
 679 Also object_id, object_type and file_type
 680
 681 =back
 682
 683 =head2 C<action_download>
 684
 685 This is the real download of a file normally called via javascript "$.download("controller.pl", data);"
 686
 687 Available C<FORM PARAMS>:
 688
 689 =over 4
 690
 691 Also object_id, object_type and file_type
 692
 693 =back
 694
 695 =head2 C<action_ajax_importdialog>
 696
 697 A Dialog with all available and not imported files to import is open.
 698 More then one file can be selected.
 699
 700 Available C<FORM PARAMS>:
 701
 702 =over 4
 703
 704 =item C<form.source>
 705
 706 The name of the source like "scanner1" or "email"
 707
 708 =item C<form.path>
 709
 710 The full path to the directory on the server, where the files to import can found
 711
 712 Also object_id, object_type and file_type
 713
 714 =back
 715
 716 =head2 C<action_ajax_delete>
 717
 718 Some files can be deleted
 719
 720 Available C<FORM PARAMS>:
 721
 722 =over 4
 723
 724 =item C<form.ids>
 725
 726 The ids of the files to delete. Only this files are deleted not all versions of a file if the exists
 727
 728 =back
 729
 730 =head2 C<action_ajax_unimport>
 731
 732 Some files can be unimported, dependent of the source of the file. This means they are moved
 733 back to the directory of the source
 734
 735 Available C<FORM PARAMS>:
 736
 737 =over 4
 738
 739 =item C<form.ids>
 740
 741 The ids of the files to unimport. Only these files are unimported not all versions of a file if the exists
 742
 743 =back
 744
 745 =head2 C<action_ajax_rename>
 746
 747 One file can be renamed. There can be some checks if the same filename still exists at one object.
 748
 749 =head1 AUTHOR
 750
 751 Martin Helmling E<lt>martin.helmling@opendynamic.deE<gt>
 752
 753 =cut