projekt kivitendo

package SL::Controller::CsvImport;

use strict;

use SL::System::TaskServer;

use parent qw(SL::Controller::Base);

use Rose::Object::MakeMethods::Generic

(

progress_tracker => { },

add_progress_tracker => { interface => 'add', hash_key => 'progress_tracker' },

],

# actions

#

sub action_new {

my ($self) = @_;

$self->load_default_profile unless $self->profile;

$self->render_inputs;

}

sub action_test {

my ($self) = @_;

sub action_import {

my $self = shift;

sub action_save {

my ($self) = @_;

flash_later('info', $::locale->text("The profile has been saved under the name '#1'.", $self->profile->name));

$self->redirect_to(action => 'new', 'profile.type' => $self->type, 'profile.id' => $self->profile->id);

}

sub action_destroy {

my $self = shift;

flash_later('info', $::locale->text('The profile \'#1\' has been deleted.', $profile->name));

$self->redirect_to(action => 'new', 'profile.type' => $self->type);

}

my $self = shift;

# load resultobject

$self->{background_job} = SL::DB::Manager::BackgroundJob->find_by(id => $::form->{job});

my $data = $self->{background_job}->data_as_hash;

flash('error', $::locale->text('There was an error parsing the csv file: #1 in line #2.', $first_error->[2], $first_error->[4]));

} else {

flash('error', $::locale->text('There was an error parsing the csv file: #1', $first_error));

}

$self->task_server->start;

$self->{status_text} = t8('Task Server is not running, starting it now. If this does not change, please check your task server config');

} elsif (my $phase = $data->{progress}{phase}) {

$self->{status_text} = "$data->{progress}{plan}{$phase} / $data->{progress}{num_phases} " . t8($phase);

} else {

$self->{status_text} = t8('Import not started yet, please wait...');

}

}

my $self = shift;

$self->profile_from_form;

$self->setup_help;

my $file_name = 'csv_import_sample_' . $self->type . '.csv';

my $file = SL::SessionFile->new($file_name, mode => '>', encoding => $self->profile->get('charset'));

my $csv = Text::CSV_XS->new({ binary => 1, map { ( $_ => $self->profile->get($_) ) } qw(sep_char escape_char quote_char),});

$csv->print($file->fh, [ map { $_->{name} } @{ $self->displayable_columns->{$p->{row_ident}} } ]);

}

$csv->print($file->fh, [ map { $_->{description} } @{ $self->displayable_columns->{$p->{row_ident}} } ]);

}

} else {

$csv->print($file->fh, [ map { $_->{name} } @{ $self->displayable_columns } ]);

$file->fh->print("\r\n");

$csv->print($file->fh, [ map { $_->{description} } @{ $self->displayable_columns } ]);

$file->fh->print("\r\n");

}

$file->fh->close;

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

$self->{report} = SL::DB::Manager::CsvImportReport->find_by(id => $report_id);

if (!$self->{report}) {

$::form->error(t8('No report with id #1', $report_id));

}

my $show_first_20 = ($self->{report}->profile->get('full_preview', 0) == 2);

my $num_rows = 0;

if ($show_first_20) {

$num_rows = min($self->{report}->numrows, 20);

} elsif ($show_info_err) {

# count each status row only once

$num_rows = SL::DB::Manager::CsvImportReportStatus->get_all_count(query => [csv_import_report_id => $report_id],

select => ['row'],

distinct => 1,);

} else {

# show all

$num_rows = $self->{report}->numrows;

}

# manual paginating, yuck

my $pages = {};

$pages->{per_page} = $::form->{per_page} || 20;

$pages->{max} = SL::DB::Helper::Paginated::ceil($num_rows, $pages->{per_page}) || 1;

$pages->{page} = $page < 1 ? 1

: $page > $pages->{max} ? $pages->{max}

: $ page;

$pages->{common} = [ grep { $_->{visible} } @{ SL::DB::Helper::Paginated::make_common_pages($pages->{page}, $pages->{max}) } ];

my $last_row_header = $self->{report_numheaders} - 1;

my $first_row_data = $pages->{per_page} * ($pages->{page}-1) + $self->{report_numheaders};

my $last_row_data = min($pages->{per_page} * $pages->{page}, $num_rows) + $self->{report_numheaders} - 1;

$self->{display_rows} = [];

if ($show_info_err) {

my $limit = $last_row_data - $first_row_data + 1;

my $offset = $first_row_data - $self->{report_numheaders};

my @err_rows = map { $_->row } @{SL::DB::Manager::CsvImportReportStatus->get_all(query => [csv_import_report_id => $report_id],

distinct => 1,

select => ['row'],

limit => $limit,

offset => $offset,

sort_by => 'row')};

$self->{display_rows} = [ $first_row_header .. $last_row_header,

@err_rows ];

} else {

$self->{display_rows} = [ $first_row_header .. $last_row_header,

$first_row_data .. $last_row_data ];

}

my @query = (

);

my $status = SL::DB::Manager::CsvImportReportStatus->get_all(query => \@query, sort_by => 'row');

$self->{report_rows} = $self->{report}->folded_rows(rows => $rows);

$self->{report_status} = $self->{report}->folded_status(status => $status);

$self->{base_url} = $self->url_for(action => 'report', id => $report_id, no_layout => $params{no_layout} || $::form->{no_layout} );

my ($self) = @_;

$self->profile_from_form;

$self->setup_help;

$self->js

->append('#csv_import_mappings', $self->render('csv_import/_mapping_item', { layout => 0, output => 0 }))

->hide('#mapping_empty')

->render;

}

sub action_add_mapping_from_upload {

my ($self) = @_;

$self->profile_from_form(SL::DB::CsvImportProfile->new(id => $::form->{tmp_profile_id})->load);

} else {

$self->profile_from_form;

}

if ($self->profile->get('file_name')) {

$file_name = $self->profile->get('file_name');

} else {

$self->js

->flash('error', t8('No file has been uploaded yet.'))

->render;

return;

}

my $file = SL::SessionFile->new($file_name, mode => '<', encoding => $self->profile->get('charset'));

$self->js

->flash('error', t8('No file has been uploaded yet.'))

->render;

return;

}

file => $file->file_name,

map { $_ => $self->profile->get($_) } qw(sep_char escape_char quote_char),

);

$csv->_open_file;

my $header = $csv->check_header;

for my $field (@$header) {

next if $self->mappings_for_profile->{$field};

$self->js->append(

'#csv_import_mappings',

$self->render('csv_import/_mapping_item', { layout => 0, output => 0 }, item => { from => $field }),

);

}

$self->js

->hide('#mapping_empty')

->render;

}

# filters

#

sub check_auth {

$_[0]->worker->check_auth;

sub check_type {

my ($self) = @_;

}

sub ensure_form_structure {

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

$::form->{profile} = {} unless ref $::form->{profile} eq 'HASH';

$::form->{settings} = {} unless ref $::form->{settings} eq 'HASH';

}

#

# helpers

#

sub render_inputs {

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

$self->all_charsets([ [ 'UTF-8', 'UTF-8' ],

[ 'ISO-8859-1', 'ISO-8859-1 (Latin 1)' ],

[ 'ISO-8859-15', 'ISO-8859-15 (Latin 9)' ],

[ 'CP850', 'CP850 (DOS/ANSI)' ],

[ 'CP1252', 'CP1252 (Windows)' ],

]);

my %char_map = $self->char_map;

foreach my $type (qw(sep quote escape)) {

my $sub = "all_${type}_chars";

$self->$sub([ sort { $a->[0] cmp $b->[0] } values %{ $char_map{$type} } ]);

my $char = $self->profile->get($type . '_char');

$sub = "${type}_char";

$self->$sub(($char_map{$type}->{$char} || [])->[0] || $char);

}

$self->file(SL::SessionFile->new($self->profile->get('file_name')));

}

: $self->type eq 'contacts' ? $::locale->text('CSV import: contacts')

};

$self->all_buchungsgruppen(SL::DB::Manager::Buchungsgruppe->get_all_sorted);

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

$::form->{profile}->{id} = $::form->{tmp_profile_id} if $::form->{tmp_profile_id};

$self->profile_from_form(SL::DB::CsvImportProfile->new(id => $::form->{tmp_profile_id})->load);

} else {

};

$self->profile->set('file_name', $file_name);

} elsif ($self->profile->get('file_name')) {

$file_name = $self->profile->get('file_name');

} else {

flash('error', $::locale->text('No file has been uploaded yet.'));

return $self->action_new;

flash('error', $::locale->text('No file has been uploaded yet.'));

return $self->action_new;

}

$self->profile($self->profile->clone_and_reset_deep)->save;

test => $params{test},

employee_id => SL::DB::Manager::Employee->current->id,

$self->task_server->wake_up;

} else {

$self->task_server->start;

}

$self->{deferred} = 1;

$self->render(\ SL::JSON::to_json($self->{background_job}->as_tree), { type => 'json' })

} else {

$self->render_inputs;

}

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

encoding => $self->profile->get('charset'),

session_id => $params{session_id}

);

my $worker = $self->worker();

sub load_default_profile {

my ($self) = @_;

$profile ||= SL::DB::CsvImportProfile->new(type => $self->{type}, login => $::myconfig{login});