remove unnecessary spaces
[kivitendo-erp.git] / SL / File.pm
1 package SL::File;
2
3 use strict;
4
5 use parent qw(Rose::Object);
6
7 use Clone qw(clone);
8 use SL::File::Backend;
9 use SL::File::Object;
10 use SL::DB::History;
11 use SL::DB::ShopImage;
12 use SL::DB::File;
13 use SL::Helper::UserPreferences;
14 use SL::Controller::Helper::ThumbnailCreator qw(file_probe_type);
15 use SL::JSON;
16
17 use constant RENAME_OK          => 0;
18 use constant RENAME_EXISTS      => 1;
19 use constant RENAME_NOFILE      => 2;
20 use constant RENAME_SAME        => 3;
21 use constant RENAME_NEW_VERSION => 4;
22
23 sub get {
24   my ($self, %params) = @_;
25   die 'no id' unless $params{id};
26   my $dbfile = SL::DB::Manager::File->get_first(query => [id => $params{id}]);
27   die 'not found' unless $dbfile;
28   $main::lxdebug->message(LXDebug->DEBUG2(), "object_id=".$dbfile->object_id." object_type=".$dbfile->object_type." dbfile=".$dbfile);
29   SL::File::Object->new(db_file => $dbfile, id => $dbfile->id, loaded => 1);
30 }
31
32 sub get_version_count {
33   my ($self, %params) = @_;
34   die "no id or dbfile" unless $params{id} || $params{dbfile};
35   $params{dbfile} = SL::DB::Manager::File->get_first(query => [id => $params{id}]) if !$params{dbfile};
36   die 'not found' unless $params{dbfile};
37   my $backend = $self->_get_backend($params{dbfile}->backend);
38   return $backend->get_version_count(%params);
39 }
40
41 sub get_all {
42   my ($self, %params) = @_;
43
44   my @files;
45   return @files unless $params{object_type};
46   return @files unless defined($params{object_id});
47
48   my @query = (
49     object_id   => $params{object_id},
50     object_type => $params{object_type}
51   );
52   push @query, (file_name => $params{file_name}) if $params{file_name};
53   push @query, (file_type => $params{file_type}) if $params{file_type};
54   push @query, (mime_type => $params{mime_type}) if $params{mime_type};
55   push @query, (source    => $params{source})    if $params{source};
56
57   my $sortby = $params{sort_by} || 'itime DESC,file_name ASC';
58
59   @files = @{ SL::DB::Manager::File->get_all(query => [@query], sort_by => $sortby) };
60   map { SL::File::Object->new(db_file => $_, id => $_->id, loaded => 1) } @files;
61 }
62
63 sub get_all_versions {
64   my ($self, %params) = @_;
65   my @versionobjs;
66   my @fileobjs = $self->get_all(%params);
67   if ( $params{dbfile} ) {
68     push @fileobjs, SL::File::Object->new(dbfile => $params{db_file}, id => $params{dbfile}->id, loaded => 1);
69   } else {
70     @fileobjs = $self->get_all(%params);
71   }
72   foreach my $fileobj (@fileobjs) {
73     $main::lxdebug->message(LXDebug->DEBUG2(), "obj=" . $fileobj . " id=" . $fileobj->id." versions=".$fileobj->version_count);
74     my $maxversion = $fileobj->version_count;
75     $fileobj->version($maxversion);
76     push @versionobjs, $fileobj;
77     if ($maxversion > 1) {
78       for my $version (2..$maxversion) {
79         $main::lxdebug->message(LXDebug->DEBUG2(), "clone for version=".($maxversion-$version+1));
80         eval {
81           my $clone = clone($fileobj);
82           $clone->version($maxversion-$version+1);
83           $clone->newest(0);
84           $main::lxdebug->message(LXDebug->DEBUG2(), "clone version=".$clone->version." mtime=". $clone->mtime);
85           push @versionobjs, $clone;
86           1;
87         }
88       }
89     }
90   }
91   return @versionobjs;
92 }
93
94 sub get_all_count {
95   my ($self, %params) = @_;
96   return 0 unless $params{object_type};
97
98   my @query = (
99     object_id   => $params{object_id},
100     object_type => $params{object_type}
101   );
102   push @query, (file_name => $params{file_name}) if $params{file_name};
103   push @query, (file_type => $params{file_type}) if $params{file_type};
104   push @query, (mime_type => $params{mime_type}) if $params{mime_type};
105   push @query, (source    => $params{source})    if $params{source};
106
107   my $cnt = SL::DB::Manager::File->get_all_count(query => [@query]);
108   return $cnt;
109 }
110
111 sub delete_all {
112   my ($self, %params) = @_;
113   return 0 unless defined($params{object_id}) || $params{object_type};
114   my $files = SL::DB::Manager::File->get_all(
115     query => [
116       object_id   => $params{object_id},
117       object_type => $params{object_type}
118     ]
119   );
120   foreach my $file (@{$files}) {
121     $params{dbfile} = $file;
122     $self->delete(%params);
123   }
124 }
125
126 sub delete {
127   my ($self, %params) = @_;
128   die "no id or dbfile in delete" unless $params{id} || $params{dbfile};
129   my $rc = 0;
130   eval {
131     $rc = SL::DB->client->with_transaction(\&_delete, $self, %params);
132     1;
133   } or do { die $@ };
134   return $rc;
135 }
136
137 sub _delete {
138   my ($self, %params) = @_;
139   $params{dbfile} = SL::DB::Manager::File->get_first(query => [id => $params{id}]) if !$params{dbfile};
140
141   my $backend = $self->_get_backend($params{dbfile}->backend);
142   if ( $params{dbfile}->file_type eq 'document' && $params{dbfile}->source ne 'created')
143   {
144     ## must unimport
145     my $hist = SL::DB::Manager::History->get_first(
146       where => [
147         addition  => 'IMPORT',
148         trans_id  => $params{dbfile}->object_id,
149         what_done => $params{dbfile}->id
150       ]
151     );
152
153     if ($hist) {
154       if (!$main::auth->assert('import_ar | import_ap', 1)) {
155         die 'no permission to unimport';
156       }
157       my $file = $backend->get_filepath(dbfile => $params{dbfile});
158       $main::lxdebug->message(LXDebug->DEBUG2(), "del file=" . $file . " to=" . $hist->snumbers);
159       File::Copy::copy($file, $hist->snumbers) if $file;
160       $hist->addition('UNIMPORT');
161       $hist->save;
162     }
163   }
164   if ($backend->delete(%params)) {
165     my $do_delete = 0;
166     if ( $params{last} || $params{version} || $params{all_but_notlast} ) {
167       if ( $backend->get_version_count(%params) > 0 ) {
168         $params{dbfile}->mtime(DateTime->now_local);
169         $params{dbfile}->save;
170       } else {
171         $do_delete = 1;
172       }
173     } else {
174       $do_delete = 1;
175     }
176     $params{dbfile}->delete if $do_delete;
177     return 1;
178   }
179   return 0;
180 }
181
182 sub save {
183   my ($self, %params) = @_;
184
185   my $obj;
186   eval {
187     $obj = SL::DB->client->with_transaction(\&_save, $self, %params);
188     1;
189   } or do { die $@ };
190   return $obj;
191 }
192
193 sub _save {
194   my ($self, %params) = @_;
195   my $file = $params{dbfile};
196   my $exists = 0;
197
198   if ($params{id}) {
199     $file = SL::DB::File->new(id => $params{id})->load;
200     die 'dbfile not exists'     unless $file;
201   } elsif (!$file) {
202   $main::lxdebug->message(LXDebug->DEBUG2(), "obj_id=" .$params{object_id});
203     die 'no object type set'    unless $params{object_type};
204     die 'no object id set'      unless defined($params{object_id});
205
206     $exists = $self->get_all_count(%params);
207     die 'filename still exist' if $exists && $params{fail_if_exists};
208     if ($exists) {
209       my ($obj1) = $self->get_all(%params);
210       $file = $obj1->db_file;
211     } else {
212       $file = SL::DB::File->new();
213       $file->assign_attributes(
214         object_id      => $params{object_id},
215         object_type    => $params{object_type},
216         source         => $params{source},
217         file_type      => $params{file_type},
218         file_name      => $params{file_name},
219         mime_type      => $params{mime_type},
220         title          => $params{title},
221         description    => $params{description},
222       );
223       $file->itime($params{mtime})    if $params{mtime};
224       $params{itime} = $params{mtime} if $params{mtime};
225     }
226   } else {
227     $exists = 1;
228   }
229   if ($exists) {
230     #change attr on existing file
231     $file->file_name  ($params{file_name})   if $params{file_name};
232     $file->mime_type  ($params{mime_type})   if $params{mime_type};
233     $file->title      ($params{title})       if $params{title};
234     $file->description($params{description}) if $params{description};
235   }
236   if ( !$file->backend ) {
237     $file->backend($self->_get_backend_by_file_type($file));
238     # load itime for new file
239     $file->save->load;
240   }
241
242   $file->mtime(DateTime->now_local) unless $params{mtime};
243   $file->mtime($params{mtime}     ) if     $params{mtime};
244
245   my $backend = $self->_get_backend($file->backend);
246   $params{dbfile} = $file;
247   $backend->save(%params);
248
249   $file->save;
250   #ShopImage
251   if($file->object_type eq "shop_image"){
252     my $image_content = $params{file_contents};
253     my $thumbnail = file_probe_type($image_content);
254     my $shopimage = SL::DB::ShopImage->new();
255     $shopimage->assign_attributes(
256                                   file_id                => $file->id,
257                                   thumbnail_content      => $thumbnail->{thumbnail_img_content},
258                                   org_file_height        => $thumbnail->{file_image_height},
259                                   org_file_width         => $thumbnail->{file_image_width},
260                                   thumbnail_content_type => $thumbnail->{thumbnail_img_content_type},
261                                   object_id              => $file->object_id,
262                                  );
263     $shopimage->save;
264   }
265   if ($params{file_type} eq 'document' && $params{source} ne 'created') {
266     SL::DB::History->new(
267       addition    => 'IMPORT',
268       trans_id    => $params{object_id},
269       snumbers    => $params{file_path},
270       employee_id => SL::DB::Manager::Employee->current->id,
271       what_done   => $params{dbfile}->id
272     )->save();
273   }
274   return $params{obj} if $params{dbfile} && $params{obj};
275   return SL::File::Object->new(db_file => $file, id => $file->id, loaded => 1);
276 }
277
278 sub rename {
279   my ($self, %params) = @_;
280   return RENAME_NOFILE unless $params{id} || $params{dbfile};
281   my $file = $params{dbfile};
282   $file = SL::DB::Manager::File->get_first(query => [id => $params{id}]) if !$file;
283   return RENAME_NOFILE unless $file;
284
285   $main::lxdebug->message(LXDebug->DEBUG2(), "rename id=" . $file->id . " to=" . $params{to});
286   if ($params{to}) {
287     return RENAME_SAME   if $params{to} eq $file->file_name;
288     return RENAME_EXISTS if $self->get_all_count( object_id     => $file->object_id,
289                                                   object_type   => $file->object_type,
290                                                   mime_type     => $file->mime_type,
291                                                   source        => $file->source,
292                                                   file_type     => $file->file_type,
293                                                   file_name     => $params{to}
294                                                 ) > 0;
295
296     my $backend = $self->_get_backend($file->backend);
297     $backend->rename(dbfile => $file) if $backend;
298     $file->file_name($params{to});
299     $file->save;
300   }
301   return RENAME_OK;
302 }
303
304 sub get_backend_class {
305   my ($self, $backendname) = @_;
306   die "no backend name set" unless $backendname;
307   $self->_get_backend($backendname);
308 }
309
310 sub get_other_sources {
311   my ($self) = @_;
312   my $pref = SL::Helper::UserPreferences->new(namespace => 'file_sources');
313   $pref->login("#default#");
314   my @sources;
315   foreach my $tuple (@{ $pref->get_all() }) {
316     my %lkeys  = %{ SL::JSON::from_json($tuple->{value}) };
317     my $source = {
318       'name'        => $tuple->{key},
319       'description' => $lkeys{desc},
320       'directory'   => $lkeys{dir}
321     };
322     push @sources, $source;
323   }
324   return @sources;
325 }
326
327 sub sync_from_backend {
328   my ($self, %params) = @_;
329   return unless $params{file_type};
330   my $file = SL::DB::File->new;
331   $file->file_type($params{file_type});
332   my $backend = $self->_get_backend($self->_get_backend_by_file_type($file));
333   return unless $backend;
334   $backend->sync_from_backend(%params);
335 }
336
337 #
338 # internal
339 #
340 sub _get_backend {
341   my ($self, $backend_name) = @_;
342   my $class = 'SL::File::Backend::' . $backend_name;
343   my $obj   = undef;
344   die $::locale->text('no backend enabled') if $backend_name eq 'None';
345   eval {
346     eval "require $class";
347     $obj = $class->new;
348     die $::locale->text('backend "#1" not enabled',$backend_name) unless $obj->enabled;
349     1;
350   } or do {
351     if ( $obj ) {
352       die $@;
353     } else {
354       die $::locale->text('backend "#1" not found',$backend_name);
355     }
356   };
357   return $obj;
358 }
359
360 sub _get_backend_by_file_type {
361   my ($self, $dbfile) = @_;
362
363   $main::lxdebug->message(LXDebug->DEBUG2(), "_get_backend_by_file_type=" .$dbfile." type=".$dbfile->file_type);
364   return "Filesystem" unless $dbfile;
365   return $::instance_conf->get_doc_storage_for_documents   if $dbfile->file_type eq 'document';
366   return $::instance_conf->get_doc_storage_for_attachments if $dbfile->file_type eq 'attachment';
367   return $::instance_conf->get_doc_storage_for_images      if $dbfile->file_type eq 'image';
368   return "Filesystem";
369 }
370
371 1;
372
373 __END__
374
375 =pod
376
377 =encoding utf8
378
379 =head1 NAME
380
381 SL::File - The intermediate Layer for handling files
382
383 =head1 SYNOPSIS
384
385   # In a controller or helper ( see SL::Controller::File or SL::Helper::File )
386   # you can create, remove, delete etc. a file in a backend independent way
387
388   my $file  = SL::File->save(
389                      object_id     => $self->object_id,
390                      object_type   => $self->object_type,
391                      mime_type     => 'application/pdf',
392                      file_type     => 'documents',
393                      file_contents => 'this is no pdf');
394
395   my $file1  = SL::File->get(id => $id);
396   SL::File->delete(id => $id);
397   SL::File->delete(dbfile => $file1);
398   SL::File->delete_all(object_id   => $object_id,
399                        object_type => $object_type,
400                        file_type   => $filetype      # may be optional
401                       );
402   SL::File->rename(id => $id,to => $newname);
403   my $files1 = SL::File->get_all(object_id   => $object_id,
404                                  object_type => $object_type,
405                                  file_type   => 'images',  # may be optional
406                                  source      => 'uploaded' # may be optional
407                                 );
408
409   # Alternativelly some operation can be done with the filemangement object wrapper
410   # and additional oparations see L<SL::File::Object>
411
412 =head1 OVERVIEW
413
414 The Filemanagemt can handle files in a storage independent way. Internal the File
415 use the configured storage backend for the type of file.
416 These backends must be configured in L<SL::Controller::ClientConfig> or an extra database table.
417
418 There are three types of files:
419
420 =over 2
421
422 =item - documents,
423
424 which can be generated files (for sales), scanned files or uploaded files (for purchase) for an ERP-object.
425 They can exist in different versions. The versioning is handled implicit. All versions of a file may be
426 deleted by the user if she/he is allowed to do this.
427
428 =item - attachments,
429
430 which have additional information for an ERP-objects. They are uploadable. If a filename still exists
431 on a ERP-Object the new uploaded file is a new version of this or it must be renamed by user.
432
433 There are generic attachments for a specific document group (like sales_invoices). This attachments can be
434 combinide/merged with the document-file in the time of printing.
435 Today only PDF-Attachmnets can be merged with the generated document-PDF.
436
437 =item - images,
438
439 they are like attachments, but they may be have thumbnails for displaying.
440 So the must have an image format like png,jpg. The versioning is like attachments
441
442 =back
443
444 For each type of files the backend can configured in L<SL::Controller::ClientConfig>.
445
446 The files have also the parameter C<Source>:
447
448 =over 2
449
450 =item - created, generated by LaTeX
451
452 =item - uploaded
453
454 =item - scanner, import from scanner
455
456 ( or scanner1, scanner2 if there are different scanner, be configurable via UserPreferences )
457
458 =item - email, received by email and imported by hand or automatic.
459
460 =back
461
462 The files from source 'scanner' or 'email' are not allowed to delete else they must be send back to the sources.
463 This means they are moved back into the correspondent source directories.
464
465 The scanner and email import must be configured  via Table UserPreferences:
466
467 =begin text
468
469  id |  login  |  namespace   | version |   key    |                        value
470 ----+---------+--------------+---------+----------+------------------------------------------------------
471   1 | default | file_sources | 0.00000 | scanner1 | {"dir":"/var/tmp/scanner1","desc":"Scanner Einkauf" }
472   2 | default | file_sources | 0.00000 | emails   | {"dir":"/var/tmp/emails"  ,"desc":"Empfangene Mails"}
473
474 =end text
475
476 .
477
478 The Fileinformation is stored in the table L<SL::DB::File> for saving the information.
479 The modul and object_id describe the link to the object.
480
481 The interface SL::File:Object encapsulate SL::DB:File, see L<SL::DB::Object>
482
483 The storage backends are extra classes which depends from L<SL::File::Backend>.
484 So additional backend classes can be added.
485
486 The implementation of versioning is done in the different backends.
487
488 =head1 METHODS
489
490 =over 4
491
492 =item C<save>
493
494 Creates a new SL::DB:File object or save an existing object for a specific backend depends of the C<file_type>
495 and config, like
496
497 =begin text
498
499           SL::File->save(
500                          object_id    => $self->object_id,
501                          object_type  => $self->object_type,
502                          content_type => 'application/pdf'
503                         );
504
505 =end text
506
507 .
508
509 The file data is stored in the backend. If the file_type is "document" and the source is not "created" the file is imported,
510 so in the history the import is documented also as a hint to can unimport the file later.
511
512 Available C<PARAMS>:
513
514 =over 4
515
516 =item C<id>
517
518 The id of SL::DB::File for an existing file
519
520 =item C<object_id>
521
522 The Id of the ERP-object for a new file.
523
524 =item C<object_type>
525
526 The Type of the ERP-object like "sales_quotation" for a new file. A clear mapping to the class/model exists in the controller.
527
528 =item C<file_type>
529
530 The type may be "documents", "attachments" or "images" for a new file.
531
532 =item C<source>
533
534 The type may be "created", "uploaded" or email sources or scanner sources for a new file.
535
536 =item C<file_name>
537
538 The file_name of the file for a new file. This name is used in the WebGUI and as name for download.
539
540 =item C<mime_type>
541
542 The mime_type of a new file. This is used for downloading or for email attachments.
543
544 =item C<description> or C<title>
545
546 The description or title of a new file. This must be discussed if this attribute is needed.
547
548 =back
549
550 =item C<delete PARAMS>
551
552 The file data is deleted in the backend. If the file comes from source 'scanner' or 'email'
553 they moved back to the source folders. This is documented in the history.
554
555 Available C<PARAMS>:
556
557 =over 4
558
559 =item C<id>
560
561 The id of SL::DB::File
562
563 =item C<dbfile>
564
565 As alternative if the SL::DB::File as object is available.
566
567 =back
568
569 =item C<delete_all PARAMS>
570
571 All file data of an ERP-object is deleted in the backend.
572
573 =over 4
574
575 =item C<object_id>
576
577 The Id of the ERP-object.
578
579 =item C<object_type>
580
581 The Type of the ERP-object like "sales_quotation". A clear mapping to the class/model exists in the controller.
582
583 =back
584
585 =item C<rename PARAMS>
586
587 The Filename of the file is changed
588
589 Available C<PARAMS>:
590
591 =over 4
592
593 =item C<id>
594
595 The id of SL::DB::File
596
597 =item C<to>
598
599 The new filename
600
601 =back
602
603 =item C<get PARAMS>
604
605 The actual file object is retrieved. The id of the object is needed.
606
607 Available C<PARAMS>:
608
609 =over 4
610
611 =item C<id>
612
613 The id of SL::DB::File
614
615 =back
616
617 =item C<get_all PARAMS>
618
619 All last versions of file data objects which are related to an ERP-Document,Part,Customer,Vendor,... are retrieved.
620
621 Available C<PARAMS>:
622
623 =over 4
624
625 =item C<object_id>
626
627 The Id of the ERP-object.
628
629 =item C<object_type>
630
631 The Type of the ERP-object like "sales_quotation". A clear mapping to the class/model exists in the controller.
632
633 =item C<file_type>
634
635 The type may be "documents", "attachments" or "images". This parameter is optional.
636
637 =item C<file_name>
638
639 The name of the file . This parameter is optional.
640
641 =item C<mime_type>
642
643 The MIME type of the file . This parameter is optional.
644
645 =item C<source>
646
647 The type may be "created", "uploaded" or email sources or scanner soureces. This parameter is optional.
648
649 =item C<sort_by>
650
651 An optional parameter in which sorting the files are retrieved. Default is decrementing itime and ascending filename
652
653 =back
654
655 =item C<get_all_versions PARAMS>
656
657 All versions of file data objects which are related to an ERP-Document,Part,Customer,Vendor,... are retrieved.
658 If only the versions of one file are wanted, additional parameter like file_name must be set.
659 If the param C<dbfile> set, only the versions of this file are returned.
660
661 Available C<PARAMS> ar the same as L<get_all>
662
663
664
665 =item C<get_all_count PARAMS>
666
667 The count of available files is returned.
668 Available C<PARAMS> ar the same as L<get_all>
669
670
671 =item C<get_content PARAMS>
672
673 The data of a file can retrieved. A reference to the data is returned.
674
675 Available C<PARAMS>:
676
677 =over 4
678
679 =item C<id>
680
681 The id of SL::DB::File
682
683 =item C<dbfile>
684
685 If no Id exists the object SL::DB::File as param.
686
687 =back
688
689 =item C<get_file_path PARAMS>
690
691 Sometimes it is more useful to have a path to the file not the contents. If the backend has not stored the content as file
692 it is in the responsibility of the backend to create a tempory session file.
693
694 Available C<PARAMS>:
695
696 =over 4
697
698 =item C<id>
699
700 The id of SL::DB::File
701
702 =item C<dbfile>
703
704 If no Id exists the object SL::DB::File as param.
705
706 =back
707
708 =item C<get_other_sources>
709
710 A helpful method to get the sources for scanner and email from UserPreferences. This method is need from SL::Controller::File
711
712 =item C<sync_from_backend>
713
714 For Backends which may be changed outside of kivitendo a synchronization of the database is done.
715 This sync must be triggered by a periodical task.
716
717 Needed C<PARAMS>:
718
719 =over 4
720
721 =item C<file_type>
722
723 The synchronization is done file_type by file_type.
724
725 =back
726
727 =back
728
729 =head1 AUTHOR
730
731 Martin Helmling E<lt>martin.helmling@opendynamic.deE<gt>
732
733 =cut