projekt kivitendo

    $self->js->flash('error',$::locale->text('File not exists !'))->render();

    return;

  }

  my $sessionfile = $::form->{sessionfile};

  if ( $sessionfile && -f $sessionfile ) {

    # new uploaded file

    if ( $::form->{to} eq $file->file_name ) {

      # no rename so use as new version

    eval {

      $res = $file->rename($::form->{to});

      1;

    } or do {

      $self->js->flash(       'error', t8('internal error (see details)'))

  my ($self) = @_;

  my $source = 'uploaded';

  my @existing;

  if ( $::form->{ATTACHMENTS}->{uploadfiles} ) {

    my @upfiles = @{ $::form->{ATTACHMENTS}->{uploadfiles} };

    foreach my $idx (0 .. scalar(@upfiles) - 1) {

      eval {

        my $fname = uri_unescape($upfiles[$idx]->{filename});

        ## normalize and find basename

        # first split with unix rules

        # after that split with windows rules

          $mime_type = File::MimeInfo::Magic::mimetype($basefile);

          $mime_type = 'application/octet-stream' if $mime_type eq 'application/pdf' || !$mime_type;

        }

        if ( $self->file_type eq 'image' && $self->file_probe_image_type($mime_type, $basefile)) {

          next;

        }

                                        file_name     => $basefile,

                                      );

        if ($existobj) {

          push @existing, $existobj->id.'_'.$sfile->file_name;

        } else {

          my $fileobj = SL::File->save(object_id     => $self->object_id,

                                       #file_contents => ${$upfiles[$idx]->{data}},

                                       file_path     => $sfile->file_name

                                     );

          unlink($sfile->file_name);

        }

        1;

  $self->object_id($id);

  $self->object_model($file_types{$type}->{model});

  $self->object_right($file_types{$type}->{right});

 # $::auth->assert($self->object_right);

sub _do_list {

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

  my @files;

  if ( $self->file_type eq 'document' ) {

    my @object_types;

    push @object_types, $self->object_type;

                                          object_type => \@object_types,

                                          file_type   => $self->file_type  );

  }

  elsif ( $self->file_type eq 'attachment' ||  $self->file_type eq 'image' ) {

    @files   = SL::File->get_all(object_id   => $self->object_id  ,

                                 object_type => $self->object_type,

                                 file_type   => $self->file_type  );

  }

  $self->files(\@files);

  $self->_mk_render('file/list',1,0,$json);

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

  my @foundfiles ;

  my $language = $::lx_office_conf{system}->{language};

  my $timezone = $::locale->get_local_time_zone()->name;

  if (opendir my $dir, $path) {

    foreach my $file ( @files) {

      next if (($file eq '.') || ($file eq '..'));

      $file = Encode::decode('utf-8', $file);

      next if( -d "$path/$file");

      my $tmppath = File::Spec->catfile( $path, $file );

      next if( ! -f $tmppath);

      my $st = stat($tmppath);

    }

  }

  return @foundfiles;

}

    ##TODO  here a configurable code must be implemented

    my $title;

    my @sources = $self->_get_sources();

    foreach my $source ( @sources ) {

      @{$source->{files}} = grep { $_->source eq $source->{name}} @{ $self->files };

    }

    if ( $self->file_type eq 'document' ) {

      if ( $self->existing && scalar(@{$self->existing}) > 0) {

        my $first = shift @{$self->existing};

        my ($first_id,$sfile) = split('_',$first,2);

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

        $self->js->run('kivi.File.askForRename',$first_id,$file->file_name,$sfile,join (',', @{$self->existing}), $self->is_global);

      }

sub _get_sources {

  my ($self) = @_;

  my @sources;

  if ( $self->file_type eq 'document' ) {

    ##TODO statt gen neue attribute in filetypes :

    if (($file_types{$self->object_type}->{gen}*1 & 1)==1) {

    }

    if (($file_types{$self->object_type}->{gen}*1 & 2)==2) {

      my @others =  SL::File->get_other_sources();

      foreach my $scanner_or_mailrx (@others) {

        my $other = {

          'name'         => $scanner_or_mailrx->{name},

    };

    push @sources , $attdata;

  }

  return @sources;

}

sub delete {

  my ($self, %params) = @_;

  die "no dbfile in backend delete" unless $params{dbfile};

  my $backend_data = $params{dbfile}->backend_data;

  $backend_data    = 0                               if $params{last};

  $backend_data    = $params{dbfile}->backend_data-1 if $params{all_but_notlast};

  if ($backend_data > 0 ) {

    for my $version ( 1..$backend_data) {

      my $file_path = $self->_filesystem_path($params{dbfile},$version);

      unlink($file_path);

    }

    if ($params{all_but_notlast}) {

      $params{dbfile}->backend_data(0);

      my $dir_path = $self->_filesystem_path($params{dbfile});

      rmdir($dir_path);

    }

  } else {

    my $file_path = $self->_filesystem_path($params{dbfile},$params{dbfile}->backend_data);

sub get_mtime {

  my ($self, %params) = @_;

  die "no dbfile" unless $params{dbfile};

  die "unknown version" if $params{version} &&

                          ($params{version} < 0 || $params{version} > $params{dbfile}->backend_data) ;

  my $path = $self->_filesystem_path($params{dbfile},$params{version});

  die "no file found in backend get_mtime" if !-f $path;

  my @st = stat($path);

  my $dt = DateTime->from_epoch(epoch => $st[9])->clone();

  return $dt;

}

  $version    = $dbfile->backend_data if !$version || $version < 1 || $version > $dbfile->backend_data;

  my $iddir   = sprintf("%04d", $dbfile->id % 1000);

  my $path    = File::Spec->catdir($::lx_office_conf{paths}->{document_path}, $::auth->client->{id}, $iddir, $dbfile->id);

  if (!-d $path) {

    File::Path::make_path($path, { chmod => 0770 });

  }