ImportExport
1.1.3
OTRS AG
http://otrs.org/
GNU GENERAL PUBLIC LICENSE Version 2, June 1991
Build for OTRS::ITSM 1.1.3.
Build for OTRS::ITSM 1.1.2.
Build for OTRS::ITSM 1.1.1.
Build for OTRS::ITSM 1.1.0 rc1.
Build for OTRS::ITSM 1.1.0 beta4.
Build for OTRS::ITSM 1.1.0 beta3.
Build for OTRS::ITSM 1.1.0 beta2.
Build for OTRS::ITSM 1.1.0 beta1.
Testbuild for OTRS::ITSM 1.1.0 beta1.
The ImportExport package.
Das ImportExport Paket.
2.2.8
2.2.x CVS
<br>
WELCOME<br>
<br>
You are about to install the OTRS module ImportExport.<br>
<br>
<br>
((enjoy))<br>
<br>
<br>
WILLKOMMEN<br>
<br>
Sie sind im Begriff das OTRS-Modul ImportExport zu installieren.<br>
<br>
<br>
((enjoy))<br>
<br>
<br>
WELCOME<br>
<br>
You are about to upgrade the OTRS module ImportExport.<br>
<br>
<br>
((enjoy))<br>
<br>
<br>
WILLKOMMEN<br>
<br>
Sie sind im Begriff das OTRS-Modul ImportExport zu aktualisieren.<br>
<br>
<br>
((enjoy))<br>
<br>
2008-08-25 12:24:20
opms.otrs.com
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
package Text::CSV;


use strict;
use Carp ();

BEGIN {
    $Text::CSV::VERSION = '1.06';
    $Text::CSV::DEBUG   = 0;
}

# if use CSV_XS, requires version
my $Module_XS  = 'Text::CSV_XS';
my $Module_PP  = 'Text::CSV_PP';
my $XS_Version = '0.51';

my $Is_Dynamic = 0;

# used in _load_xs and _load_pp
my $Install_Dont_Die = 1; # When _load_xs fails to load XS, don't die.
my $Install_Only     = 2; # Don't call _set_methods()


my @PublicMethods = qw/
    version types quote_char escape_char sep_char eol always_quote binary allow_whitespace
    keep_meta_info allow_loose_quotes allow_loose_escapes verbatim meta_info is_quoted is_binary eof
    getline print parse combine fields string error_diag error_input status blank_is_undef
    getline_hr column_names bind_columns
    PV IV NV
/;
#
my @UndocumentedXSMethods = qw/Combine Parse SetDiag/;

my @UndocumentedPPMethods = qw//; # Currently empty


# Check the environment variable to decide worker module. 

unless ($Text::CSV::Worker) {
    $Text::CSV::DEBUG and  Carp::carp("Check used worker module...");

    if ( exists $ENV{PERL_TEXT_CSV} ) {
        if ($ENV{PERL_TEXT_CSV} eq '0' or $ENV{PERL_TEXT_CSV} eq 'Text::CSV_PP') {
            _load_pp();
        }
        elsif ($ENV{PERL_TEXT_CSV} eq '1' or $ENV{PERL_TEXT_CSV} =~ /Text::CSV_XS\s*,\s*Text::CSV_PP/) {
            _load_xs($Install_Dont_Die) or _load_pp();
        }
        elsif ($ENV{PERL_TEXT_CSV} eq '2' or $ENV{PERL_TEXT_CSV} eq 'Text::CSV_XS') {
            _load_xs();
        }
        else {
            Carp::croak "The value of environmental variable 'PERL_TEXT_CSV' is invalid.";
        }
    }
    else {
        _load_xs($Install_Dont_Die) or _load_pp();
    }

}



sub import {
    my ($class, $option) = @_;
}



sub new { # normal mode
    my $proto = shift;
    my $class = ref($proto) || $proto;

    unless ( $proto ) { # for Text::CSV_XS/PP::new(0);
        return eval qq| $Text::CSV::Worker\::new( \$proto ) |;
    }

    #if (ref $_[0] and $_[0]->{module}) {
    #    Carp::croak("Can't set 'module' in non dynamic mode.");
    #}

    if ( my $obj = $Text::CSV::Worker->new(@_) ) {
        $obj->{_MODULE} = $Text::CSV::Worker;
        bless $obj, $class;
        return $obj;
    }
    else {
        return;
    }


}


sub require_xs_version { $XS_Version; }


sub module {
    my $proto = shift;
    return   !ref($proto)            ? $Text::CSV::Worker
           :  ref($proto->{_MODULE}) ? ref($proto->{_MODULE}) : $proto->{_MODULE};
}

*backend = *module;


sub is_xs {
    return $_[0]->module eq $Module_XS;
}


sub is_pp {
    return $_[0]->module eq $Module_PP;
}


sub is_dynamic { $Is_Dynamic; }


sub AUTOLOAD {
    my $self = $_[0];
    my $attr = $Text::CSV::AUTOLOAD;
    $attr =~ s/.*:://;

    return if $attr =~ /^[A-Z]+$/;
    Carp::croak( "Can't locate method $attr" ) unless $attr =~ /^_/;

    my $pkg = $Text::CSV::Worker;

    my $method = "$pkg\::$attr";

    $Text::CSV::DEBUG and Carp::carp("'$attr' is private method, so try to autoload...");

    local $^W;
    no strict qw(refs);

    *{"Text::CSV::$attr"} = *{"$pkg\::$attr"};

    goto &$attr;
}



sub _load_xs {
    my $opt = shift;

    $Text::CSV::DEBUG and Carp::carp "Load $Module_XS.";

    eval qq| use $Module_XS $XS_Version |;

    if ($@) {
        if (defined $opt and $opt & $Install_Dont_Die) {
            $Text::CSV::DEBUG and Carp::carp "Can't load $Module_XS...($@)";
            return 0;
        }
        Carp::croak $@;
    }

    push @Text::CSV::ISA, 'Text::CSV_XS';

    unless (defined $opt and $opt & $Install_Only) {
        _set_methods( $Text::CSV::Worker = $Module_XS );
    }

    return 1;
};


sub _load_pp {
    my $opt = shift;

    $Text::CSV::DEBUG and Carp::carp "Load $Module_PP.";

    eval qq| require $Module_PP |;
    if ($@) {
        Carp::croak $@;
    }

    push @Text::CSV::ISA, 'Text::CSV_PP';

    unless (defined $opt and $opt & $Install_Only) {
        _set_methods( $Text::CSV::Worker = $Module_PP );
    }
};




sub _set_methods {
    my $class = shift;

    #return;

    local $^W;
    no strict qw(refs);

    for my $method (@PublicMethods) {
        *{"Text::CSV::$method"} = \&{"$class\::$method"};
    }

    if ($Text::CSV::Worker eq $Module_XS) {
        for my $method (@UndocumentedXSMethods) {
            *{"Text::CSV::$method"} = \&{"$Module_XS\::$method"};
        }
    }

    if ($Text::CSV::Worker eq $Module_PP) {
        for my $method (@UndocumentedPPMethods) {
            *{"Text::CSV::$method"} = \&{"$Module_PP\::$method"};
        }
    }

}



1;
__END__

=pod

=head1 NAME

Text::CSV - comma-separated values manipulator (using XS or PurePerl)


=head1 SYNOPSIS

 use Text::CSV;
 
 $csv = Text::CSV->new();              # create a new object
 
 # If you want to handle non-ascii char.
 $csv = Text::CSV->new({binary => 1});
 
 $status = $csv->combine(@columns);    # combine columns into a string
 $line   = $csv->string();             # get the combined string
 
 $status  = $csv->parse($line);        # parse a CSV string into fields
 @columns = $csv->fields();            # get the parsed fields
 
 $status       = $csv->status ();      # get the most recent status
 $bad_argument = $csv->error_input (); # get the most recent bad argument
 $diag         = $csv->error_diag ();  # if an error occured, explains WHY
 
 $status = $csv->print ($io, $colref); # Write an array of fields
                                       # immediately to a file $io
 $colref = $csv->getline ($io);        # Read a line from file $io,
                                       # parse it and return an array
                                       # ref of fields
 $csv->column_names (@names);          # Set column names for getline_hr ()
 $ref = $csv->getline_hr ($io);        # getline (), but returns a hashref
 $eof = $csv->eof ();                  # Indicate if last parse or
                                       # getline () hit End Of File
 
 $csv->types(\@t_array);               # Set column types


=head1 DESCRIPTION

Text::CSV provides facilities for the composition and decomposition of
comma-separated values using L<Text::CSV_XS> or its pure Perl version.

An instance of the Text::CSV class can combine fields into a CSV string
and parse a CSV string into fields.

The module accepts either strings or files as input and can utilize any
user-specified characters as delimiters, separators, and escapes so it is
perhaps better called ASV (anything separated values) rather than just CSV.

=head1 VERSION

    1.06

This module is compatible with Text::CSV_XS B<0.51> or later.

=head2 BINARY MODE

The default behavior is to only accept ascii characters.
In many cases, you should create a Text::CSV object with
binary mode.

 my $csv = Text::CSV->new({binary => 1});

See to L<Text::CSV_XS/Embedded newlines>.

=head2 Unicode (UTF8)

On parsing (both for C<getline ()> and C<parse ()>), if the source is
marked being UTF8, then parsing that source will mark all fields that
are marked binary will also be marked UTF8.

On combining (C<print ()> and C<combine ()>), if any of the combining
fields was marked UTF8, the resulting string will be marked UTF8.

=head1 SPECIFICATION

See to L<Text::CSV_XS/SPECIFICATION>.

=head1 FUNCTIONS

These methods are common between XS and puer Perl version.
Most of the document was shamelessly copied and replaced from Text::CSV_XS.

=head2 version ()

(Class method) Returns the current backend module version.
If you want the module version, you can use the C<VERSION> method,

 print Text::CSV->VERSION;      # This module version
 print Text::CSV->version;      # The version of the worker module
                                # same as Text::CSV->backend->version

=head2 new (\%attr)

(Class method) Returns a new instance of Text::CSV_XS. The objects
attributes are described by the (optional) hash ref C<\%attr>.
Currently the following attributes are available:

=over 4

=item eol

An end-of-line string to add to rows, usually C<undef> (nothing,
default), C<"\012"> (Line Feed) or C<"\015\012"> (Carriage Return,
Line Feed). Cannot be longer than 7 (ASCII) characters.

If both C<$/> and C<eol> equal C<"\015">, parsing lines that end on
only a Carriage Return without Line Feed, will be C<parse>d correct.
Line endings, whether in C<$/> or C<eol>, other than C<undef>,
C<"\n">, C<"\r\n">, or C<"\r"> are not (yet) supported for parsing.

=item sep_char

The char used for separating fields, by default a comma. (C<,>).
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The separation character can not be equal to the quote character.
The separation character can not be equal to the escape character.

=item allow_whitespace

When this option is set to true, whitespace (TAB's and SPACE's)
surrounding the separation character is removed when parsing. So
lines like:

  1 , "foo" , bar , 3 , zapp

are now correctly parsed, even though it violates the CSV specs.
Note that B<all> whitespace is stripped from start and end of each
field. That would make is more a I<feature> than a way to be able
to parse bad CSV lines, as

 1,   2.0,  3,   ape  , monkey

will now be parsed as

 ("1", "2.0", "3", "ape", "monkey")

even if the original line was perfectly sane CSV.

=item blank_is_undef

Under normal circumstances, CSV data makes no distinction between
quoted- and unquoted empty fields. They both end up in an empty
string field once read, so

 1,"",," ",2

is read as

 ("1", "", "", " ", "2")

When I<writing> CSV files with C<always_quote> set, the unquoted empty
field is the result of an undefined value. To make it possible to also
make this distinction when reading CSV data, the C<blank_is_undef> option
will cause unquoted empty fields to be set to undef, causing the above to
be parsed as

 ("1", "", undef, " ", "2")

=item quote_char

The char used for quoting fields containing blanks, by default the
double quote character (C<">). A value of undef suppresses
quote chars. (For simple cases only).
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The quote character can not be equal to the separation character.

=item allow_loose_quotes

By default, parsing fields that have C<quote_char> characters inside
an unquoted field, like

 1,foo "bar" baz,42

would result in a parse error. Though it is still bad practice to
allow this format, we cannot help there are some vendors that make
their applications spit out lines styled like this.

In case there is B<really> bad CSV data, like

 1,"foo "bar" baz",42

or

 1,""foo bar baz"",42

there is a way to get that parsed, and leave the quotes inside the quoted
field as-is. This can be achieved by setting C<allow_loose_quotes> B<AND>
making sure that the C<escape_char> is I<not> equal to C<quote_char>.

=item escape_char

The character used for escaping certain characters inside quoted fields.
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The C<escape_char> defaults to being the literal double-quote mark (C<">)
in other words, the same as the default C<quote_char>. This means that
doubling the quote mark in a field escapes it:

  "foo","bar","Escape ""quote mark"" with two ""quote marks""","baz"

If you change the default quote_char without changing the default
escape_char, the escape_char will still be the quote mark.  If instead 
you want to escape the quote_char by doubling it, you will need to change
the escape_char to be the same as what you changed the quote_char to.

The escape character can not be equal to the separation character.

=item allow_loose_escapes

By default, parsing fields that have C<escape_char> characters that
escape characters that do not need to be escaped, like:

 my $csv = Text::CSV->new ({ escape_char => "\\" });
 $csv->parse (qq{1,"my bar\'s",baz,42});

would result in a parse error. Though it is still bad practice to
allow this format, this option enables you to treat all escape character
sequences equal.

=item binary

If this attribute is TRUE, you may use binary characters in quoted fields,
including line feeds, carriage returns and NULL bytes. (The latter must
be escaped as C<"0>.) By default this feature is off.

=item types

A set of column types; this attribute is immediately passed to the
I<types> method below. You must not set this attribute otherwise,
except for using the I<types> method. For details see the description
of the I<types> method below.

=item always_quote

By default the generated fields are quoted only, if they need to, for
example, if they contain the separator. If you set this attribute to
a TRUE value, then all fields will be quoted. This is typically easier
to handle in external applications.

=item keep_meta_info

By default, the parsing of input lines is as simple and fast as
possible. However, some parsing information - like quotation of
the original field - is lost in that process. Set this flag to
true to be able to retrieve that information after parsing with
the methods C<meta_info ()>, C<is_quoted ()>, and C<is_binary ()>
described below.  Default is false.

=item verbatim

This is a quite controversial attribute to set, but it makes hard
things possible.

The basic thought behind this is to tell the parser that the normally
special characters newline (NL) and Carriage Return (CR) will not be
special when this flag is set, and be dealt with as being ordinary
binary characters. This will ease working with data with embedded
newlines.

When C<verbatim> is used with C<getline ()>, getline
auto-chomp's every line.

Imagine a file format like

  M^^Hans^Janssen^Klas 2\n2A^Ja^11-06-2007#\r\n

where, the line ending is a very specific "#\r\n", and the sep_char
is a ^ (caret). None of the fields is quoted, but embedded binary
data is likely to be present. With the specific line ending, that
shouldn't be too hard to detect.

By default, Text::CSV' parse function however is instructed to only
know about "\n" and "\r" to be legal line endings, and so has to deal
with the embedded newline as a real end-of-line, so it can scan the next
line if binary is true, and the newline is inside a quoted field.
With this attribute however, we can tell parse () to parse the line
as if \n is just nothing more than a binary character.

For parse () this means that the parser has no idea about line ending
anymore, and getline () chomps line endings on reading.

=back

To sum it up,

 $csv = Text::CSV->new ();

is equivalent to

 $csv = Text::CSV->new ({
     quote_char          => '"',
     escape_char         => '"',
     sep_char            => ',',
     eol                 => '',
     always_quote        => 0,
     binary              => 0,
     keep_meta_info      => 0,
     allow_loose_quotes  => 0,
     allow_loose_escapes => 0,
     allow_whitespace    => 0,
     blank_is_undef      => 0,
     verbatim            => 0,
     });

For all of the above mentioned flags, there is an accessor method
available where you can inquire for the current value, or change
the value

 my $quote = $csv->quote_char;
 $csv->binary (1);

It is unwise to change these settings halfway through writing CSV
data to a stream. If however, you want to create a new stream using
the available CSV object, there is no harm in changing them.

If the C<new ()> constructor call fails, it returns C<undef>, and makes
the fail reason available through the C<error_diag ()> method.

 $csv = Text::CSV->new ({ ecs_char => 1 }) or
     die Text::CSV->error_diag ();

C<error_diag ()> will return a string like

 "Unknown attribute 'ecs_char'"

=head2 combine

 $status = $csv->combine (@columns);

This object function constructs a CSV string from the arguments, returning
success or failure.  Failure can result from lack of arguments or an argument
containing an invalid character.  Upon success, C<string ()> can be called to
retrieve the resultant CSV string.  Upon failure, the value returned by
C<string ()> is undefined and C<error_input ()> can be called to retrieve an
invalid argument.

=head2 print

 $status = $csv->print ($io, $colref);

Similar to combine, but it expects an array ref as input (not an array!)
and the resulting string is not really created, but immediately written
to the I<$io> object, typically an IO handle or any other object that
offers a I<print> method. Note, this implies that the following is wrong:

 open FILE, ">", "whatever";
 $status = $csv->print (\*FILE, $colref);

The glob C<\*FILE> is not an object, thus it doesn't have a print
method. The solution is to use an IO::File object or to hide the
glob behind an IO::Wrap object. See L<IO::File(3)> and L<IO::Wrap(3)>
for details.

For performance reasons the print method doesn't create a result string.
In particular the I<$csv-E<gt>string ()>, I<$csv-E<gt>status ()>,
I<$csv->fields ()> and I<$csv-E<gt>error_input ()> methods are meaningless
after executing this method.

=head2 string

 $line = $csv->string ();

This object function returns the input to C<parse ()> or the resultant CSV
string of C<combine ()>, whichever was called more recently.

=head2 parse

 $status = $csv->parse ($line);

This object function decomposes a CSV string into fields, returning
success or failure.  Failure can result from a lack of argument or the
given CSV string is improperly formatted.  Upon success, C<fields ()> can
be called to retrieve the decomposed fields .  Upon failure, the value
returned by C<fields ()> is undefined and C<error_input ()> can be called
to retrieve the invalid argument.

You may use the I<types ()> method for setting column types. See the
description below.

=head2 getline

 $colref = $csv->getline ($io);

This is the counterpart to print, like parse is the counterpart to
combine: It reads a row from the IO object $io using $io->getline ()
and parses this row into an array ref. This array ref is returned
by the function or undef for failure.

When fields are bound with C<bind_columns ()>, the return value is a
reference to an empty list.

The I<$csv-E<gt>string ()>, I<$csv-E<gt>fields ()> and I<$csv-E<gt>status ()>
methods are meaningless, again.

=head2 getline_hr

The C<getline_hr ()> and C<column_names ()> methods work together to allow
you to have rows returned as hashrefs. You must call C<column_names ()>
first to declare your column names. 

 $csv->column_names (qw( code name price description ));
 $hr = $csv->getline_hr ($io);
 print "Price for $hr->{name} is $hr->{price} EUR\n";

C<getline_hr ()> will croak if called before C<column_names ()>.

=head2 column_names

Set the keys that will be used in the C<getline_hr ()> calls. If no keys
(column names) are passed, it'll return the current setting.

C<column_names ()> accepts a list of scalars (the column names) or a
single array_ref, so you can pass C<getline ()>

  $csv->column_names ($csv->getline ($io));

C<column_names ()> croaks on invalid arguments.

=head2 bind_columns

Takes a list of references to scalars to store the fields fetched
C<getline ()> in. When you don't pass enough references to store the
fetched fields in, C<getline ()> will fail. If you pass more than there are
fields to return, the remaining references are left untouched.

  $csv->bind_columns (\$code, \$name, \$price, \$description);
  while ($csv->getline ()) {
      print "The price of a $name is \x{20ac} $price\n";
      }

=head2 eof

 $eof = $csv->eof ();

If C<parse ()> or C<getline ()> was used with an IO stream, this
method will return true (1) if the last call hit end of file, otherwise
it will return false (''). This is useful to see the difference between
a failure and end of file.

=head2 types

 $csv->types (\@tref);

This method is used to force that columns are of a given type. For
example, if you have an integer column, two double columns and a
string column, then you might do a

 $csv->types ([Text::CSV::IV (),
               Text::CSV::NV (),
               Text::CSV::NV (),
               Text::CSV::PV ()]);

Column types are used only for decoding columns, in other words
by the I<parse ()> and I<getline ()> methods.

You can unset column types by doing a

 $csv->types (undef);

or fetch the current type settings with

 $types = $csv->types ();

=over 4

=item IV

Set field type to integer.

=item NV

Set field type to numeric/float.

=item PV

Set field type to string.

=back

=head2 fields

 @columns = $csv->fields ();

This object function returns the input to C<combine ()> or the resultant
decomposed fields of C<parse ()>, whichever was called more recently.

=head2 meta_info

 @flags = $csv->meta_info ();

This object function returns the flags of the input to C<combine ()> or
the flags of the resultant decomposed fields of C<parse ()>, whichever
was called more recently.

For each field, a meta_info field will hold flags that tell something about
the field returned by the C<fields ()> method or passed to the C<combine ()>
method. The flags are bitwise-or'd like:

=over 4

=item 0x0001

The field was quoted.

=item 0x0002

The field was binary.

=back

See the C<is_*** ()> methods below.

=head2 is_quoted

  my $quoted = $csv->is_quoted ($column_idx);

Where C<$column_idx> is the (zero-based) index of the column in the
last result of C<parse ()>.

This returns a true value if the data in the indicated column was
enclosed in C<quote_char> quotes. This might be important for data
where C<,20070108,> is to be treated as a numeric value, and where
C<,"20070108",> is explicitly marked as character string data.

=head2 is_binary

  my $binary = $csv->is_binary ($column_idx);

Where C<$column_idx> is the (zero-based) index of the column in the
last result of C<parse ()>.

This returns a true value if the data in the indicated column
contained any byte in the range [\x00-\x08,\x10-\x1F,\x7F-\xFF]

=head2 status

 $status = $csv->status ();

This object function returns success (or failure) of C<combine ()> or
C<parse ()>, whichever was called more recently.

=head2 error_input

 $bad_argument = $csv->error_input ();

This object function returns the erroneous argument (if it exists) of
C<combine ()> or C<parse ()>, whichever was called more recently.

=head2 error_diag

 $csv->error_diag ();
 $error_code   = 0  + $csv->error_diag ();
 $error_str    = "" . $csv->error_diag ();
 ($cde, $str, $pos) = $csv->error_diag ();

If (and only if) an error occured, this function returns the diagnostics
of that error.

If called in void context, it will print the internal error code and the
associated error message to STDERR.

If called in list context, it will return the error code and the error
message in that order. If the last error was from parsing, the third
value returned is the best guess at the location within the line that was
being parsed. It's value is 1-based.

Note: C<$pos> returned by the backend Text::CSV_PP does not show
the error point in many cases (see to the below line).
It is for conscience's sake in using Text::CSV_PP.

If called in scalar context, it will return the diagnostics in a single
scalar, a-la $!. It will contain the error code in numeric context, and
the diagnostics message in string context.

Depending on the used worker module, returned diagnostics is diffferent.

Text::CSV_XS parses csv strings by dividing one character while Text::CSV_PP
by using the regular expressions. That difference makes the different cause
of the failure.

=head2 SetDiag

 $csv->SetDiag (0);

Use to reset the diagnostics if you are dealing with errors.

=head2 Some methods are Text::CSV only.

=over

=item backend

Returns the backend module name called by Text::CSV.
C<module> is an alias.


=item is_xs

Returns true value if Text::CSV or the object uses XS module as worker.

=item is_pp

Returns true value if Text::CSV or the object uses pure-Perl module as worker.


=back


=head1 DIAGNOSTICS

If an error occured, $csv->error_diag () can be used to get more information
on the cause of the failure. Note that for speed reasons, the internal value
is never cleared on success, so using the value returned by error_diag () in
normal cases - when no error occured - may cause unexpected results.

This function changes depending on the used module (XS or PurePerl).

See to L<Text::CSV_XS/DIAGNOSTICS> and L<Text::CSV_PP/DIAGNOSTICS>.



=head2 HISTORY AND WORKER MODULES

This module, L<Text::CSV> was firstly written by Alan Citterman which could deal with
B<only ascii characters>. Then, Jochen Wiedmann wrote L<Text::CSV_XS> which has
the B<binary mode>. This XS version is maintained by H.Merijn Brand and L<Text::CSV_PP>
written by Makamaka was pure-Perl version of Text::CSV_XS.

Now, Text::CSV was rewritten by Makamaka and become a wrapper to Text::CSV_XS or Text::CSV_PP.
Text::CSV_PP will be bundled in this distribution.

When you use Text::CSV, it calls a backend worker module - L<Text::CSV_XS> or L<Text::CSV_PP>.
By default, Text::CSV tries to use Text::CSV_XS which must be complied and installed properly.
If this call is fail, Text::CSV uses L<Text::CSV_PP>.

The required Text::CSV_XS version is I<0.41> in Text::CSV version 1.03.

If you set an enviornment variable C<PERL_TEXT_CSV>, The calling action will be changed.

=over

=item PERL_TEXT_CSV = 0

=item PERL_TEXT_CSV = 'Text::CSV_PP'

Always use Text::CSV_PP

=item PERL_TEXT_CSV = 1

=item PERL_TEXT_CSV = 'Text::CSV_XS,Text::CSV_PP'

(The default) Use compiled Text::CSV_XS if it is properly compiled & installed,
otherwise use Text::CSV_PP

=item PERL_TEXT_CSV = 2

=item PERL_TEXT_CSV = 'Text::CSV_XS'

Always use compiled Text::CSV_XS, die if it isn't properly compiled & installed.

=back

These ideas come from L<DBI::PurePerl> mechanism.

example:

  BEGIN { $ENV{PERL_TEXT_CSV} = 0 }
  use Text::CSV; # always uses Text::CSV_PP


In future, it may be able to specify another module.

=head1 TODO

=over

=item Wrapper mechanism

Currently the wrapper mechanism is to change symbolic table for speed.

 for my $method (@PublicMethods) {
     *{"Text::CSV::$method"} = \&{"$class\::$method"};
 }

But how about it - calling worker module object?

 sub parse {
     my $self = shift;
     $self->{_WORKER_OBJECT}->parse(@_); # XS or PP CSV object
 }



=item Simple option

 $csv = Text::CSV->simple;

is equivalent to

 $csv = Text::CSV->new ({
     quote_char          => '"',
     escape_char         => '"',
     sep_char            => ',',
     eol                 => '',
     binary              => 1,
     allow_loose_quotes  => 1,
     allow_loose_escapes => 1,
     allow_whitespace    => 1,
     blank_is_undef      => 1,
 });

Is it needless?


=back

See to L<Text::CSV_XS/TODO> and L<Text::CSV_PP/TODO>.


=head1 SEE ALSO

L<Text::CSV_PP(3)> and L<Text::CSV_XS(3)>.


=head1 AUTHORS and MAINTAINERS

Alan Citterman F<E<lt>alan[at]mfgrtl.comE<gt>> wrote the original Perl
module. Please don't send mail concerning Text::CSV to Alan, as
he's not a present maintainer.

Jochen Wiedmann F<E<lt>joe[at]ispsoft.deE<gt>> rewrote the encoding and
decoding in C by implementing a simple finite-state machine and added
the variable quote, escape and separator characters, the binary mode
and the print and getline methods. See ChangeLog releases 0.10 through
0.23.

H.Merijn Brand F<E<lt>h.m.brand[at]xs4all.nlE<gt>> cleaned up the code,
added the field flags methods, wrote the major part of the test suite,
completed the documentation, fixed some RT bugs. See ChangeLog releases
0.25 and on.

Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> wrote Text::CSV_PP
which is the pure-Perl version of Text::CSV_XS.

New Text::CSV (since 0.99) is maintained by Makamaka.


=head1 COPYRIGHT AND LICENSE

Text::CSV

Copyright (C) 1997 Alan Citterman. All rights reserved.
Copyright (C) 2007-2008 Makamaka Hannyaharamitu.


Text::CSV_PP:

Copyright (C) 2005-2008 Makamaka Hannyaharamitu.


Text:CSV_XS:

Copyright (C) 2007-2008 H.Merijn Brand for PROCURA B.V.
Copyright (C) 1998-2001 Jochen Wiedmann. All rights reserved.
Portions Copyright (C) 1997 Alan Citterman. All rights reserved.


This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself. 

=cut

package Text::CSV_PP;

################################################################################
#
# Text::CSV_PP - Text::CSV_XS compatible pure-Perl module
#
################################################################################
require 5.005;

use strict;
use vars qw($VERSION);
use Carp ();

$VERSION = '1.14';

sub PV  { 0 }
sub IV  { 1 }
sub NV  { 2 }

sub IS_QUOTED () { 0x0001; }
sub IS_BINARY () { 0x0002; }


my $ERRORS = {
        # PP and XS
        1000 => "INI - constructor failed",
        1001 => "sep_char is equal to quote_char or escape_char",

        2010 => "ECR - QUO char inside quotes followed by CR not part of EOL",
        2011 => "ECR - Characters after end of quoted field",

        2021 => "EIQ - NL char inside quotes, binary off",
        2022 => "EIQ - CR char inside quotes, binary off",
        2025 => "EIQ - Loose unescaped escape",
        2026 => "EIQ - Binary character inside quoted field, binary off",
        2027 => "EIQ - Quoted field not terminated",

        2030 => "EIF - NL char inside unquoted verbatim, binary off",
        2031 => "EIF - CR char is first char of field, not part of EOL",
        2032 => "EIF - CR char inside unquoted, not part of EOL",
        2034 => "EIF - Loose unescaped quote",
        2037 => "EIF - Binary character in unquoted field, binary off",

        2110 => "ECB - Binary character in Combine, binary off",

        # PP Only Error
        4002 => "EIQ - Unescaped ESC in quoted field",
        4003 => "EIF - ESC CR",
        4004 => "EUF - ",

        # Hash-Ref errors
        3001 => "EHR - Unsupported syntax for column_names ()",
        3002 => "EHR - getline_hr () called before column_names ()",
        3003 => "EHR - bind_columns () and column_names () fields count mismatch",
        3004 => "EHR - bind_columns () only accepts refs to scalars",
        3006 => "EHR - bind_columns () did not pass enough refs for parsed fields",
        3007 => "EHR - bind_columns needs refs to writeable scalars",
        3008 => "EHR - unexpected error in bound fields",

        0    => "",
};


my $last_new_error = '';

my %def_attr = (
    quote_char          => '"',
    escape_char         => '"',
    sep_char            => ',',
    eol                 => '',
    always_quote        => 0,
    binary              => 0,
    keep_meta_info      => 0,
    allow_loose_quotes  => 0,
    allow_loose_escapes => 0,
    allow_whitespace    => 0,
    chomp_verbatim      => 0,
    types               => undef,
    verbatim            => 0,
    blank_is_undef      => 0,

    _EOF                => 0,
    _STATUS             => undef,
    _FIELDS             => undef,
    _FFLAGS             => undef,
    _STRING             => undef,
    _ERROR_INPUT        => undef,
    _ERROR_DIAG         => undef,

    _COLUMN_NAMES       => undef,
    _BOUND_COLUMNS      => undef,
);


BEGIN {
    if ( $] < 5.006 ) {
        $INC{'bytes.pm'} = 1 unless $INC{'bytes.pm'}; # dummy
        no strict 'refs';
        *{"utf8::is_utf8"} = sub { 0; };
    }
    elsif ( $] < 5.008 ) {
        no strict 'refs';
        *{"utf8::is_utf8"} = sub { 0; };
    }
    elsif ( !defined &utf8::is_utf8 ) {
       require Encode;
       *utf8::is_utf8 = *Encode::is_utf8;
    }

    eval q| require Scalar::Util |;
    if ( $@ ) {
        eval q| require B |;
        if ( $@ ) {
            Carp::croak $@;
        }
        else {
            *Scalar::Util::readonly = sub (\$) {
                my $b = B::svref_2object( $_[0] );
                $b->FLAGS & 0x00800000; # SVf_READONLY?
            }
        }
    }
}

################################################################################
# version
################################################################################
sub version {
    return $VERSION;
}
################################################################################
# new
################################################################################
sub new {
    my $proto = shift;
    my $attr  = shift || {};

    $last_new_error = 'usage: my $csv = Text::CSV_PP->new ([{ option => value, ... }]);';

    my $class = ref($proto) || $proto or return;
    my $self  = { %def_attr };

    for my $prop (keys %$attr) { # if invalid attr, return undef
        unless ($prop =~ /^[a-z]/ && exists $def_attr{$prop}) {
            $last_new_error = "Unknown attribute '$prop'";
            return;
        }
        $self->{$prop} = $attr->{$prop};
    }

    $last_new_error = '';

    bless $self, $class;

    if(exists($self->{types})) {
        $self->types($self->{types});
    }

    return $self;
}
################################################################################
# status
################################################################################
sub status {
    $_[0]->{_STATUS};
}
################################################################################
# error_input
################################################################################
sub error_input {
    $_[0]->{_ERROR_INPUT};
}
################################################################################
# error_diag
################################################################################
sub error_diag {
    my $self = shift;
    my @diag = (0, $last_new_error, 0);

    unless ($self and ref $self) {	# Class method or direct call
        $last_new_error and $diag[0] = 1000;
    }
    elsif ( $self->isa (__PACKAGE__) and defined $self->{_ERROR_DIAG} ) {
        @diag = ( 0 + $self->{_ERROR_DIAG}, $ERRORS->{ $self->{_ERROR_DIAG} } );
        exists $self->{_ERROR_POS} and $diag[2] = 1 + $self->{_ERROR_POS};
    }

    my $context = wantarray;

    my $diagobj = bless \@diag, 'Text::CSV::ErrorDiag';

    unless (defined $context) {	# Void context
        print STDERR "# CSV_PP ERROR: ", $diag[0], " - $diag[1]\n" if ( $diag[0] );
        return;
    }

    return $context ? @diag : $diagobj;
}
################################################################################
# string
################################################################################
*string = \&_string;
sub _string {
    defined $_[0]->{_STRING} ? ${ $_[0]->{_STRING} } : undef;
}
################################################################################
# fields
################################################################################
*fields = \&_fields;
sub _fields {
    ref($_[0]->{_FIELDS}) ?  @{$_[0]->{_FIELDS}} : undef;
}
################################################################################
# combine
################################################################################
*combine = \&_combine;
sub _combine {
    my ($self, @part) = @_;

    # at least one argument was given for "combining"...
    return $self->{_STATUS} = 0 unless(@part);

    $self->{_FIELDS}      = \@part;
    $self->{_ERROR_INPUT} = undef;
    $self->{_STRING}      = '';
    $self->{_STATUS}      = 0;

    my ($always_quote, $binary, $quot, $sep, $esc)
            = @{$self}{qw/always_quote binary quote_char sep_char escape_char/};

    if(!defined $quot){ $quot = ''; }

    return $self->_set_error_diag(1001) if ($sep eq $esc or $sep eq $quot);

    my $re_esc = $self->{_re_comb_escape}->{$quot}->{$esc} ||= qr/(\Q$quot\E|\Q$esc\E)/;
    my $re_sp  = $self->{_re_comb_sp}->{$sep}              ||= qr/[\s\Q$sep\E]/;

    my $must_be_quoted;
    for my $column (@part) {

        unless (defined $column) {
            $column = '';
            next;
        }
        elsif ( !$binary ) {
            $binary = 1 if utf8::is_utf8 $column;
        }

        if (!$binary and $column =~ /[^\x09\x20-\x7E]/) {
            # an argument contained an invalid character...
            $self->{_ERROR_INPUT} = $column;
            $self->_set_error_diag(2110);
            return $self->{_STATUS};
        }

        $must_be_quoted = 0;

        if($quot ne '' and $column =~ s/$re_esc/$esc$1/g){
            $must_be_quoted++;
        }
        if($column =~ /$re_sp/){
            $must_be_quoted++;
        }

        if($binary){
            use bytes;
            $must_be_quoted++ if ( $column =~ s/\0/${esc}0/g || $column =~ /[\x00-\x1f\x7f-\xa0]/ );
        }

        if($always_quote or $must_be_quoted){
            $column = $quot . $column . $quot;
        }
    }

    $self->{_STRING} = \do { join($sep, @part) . $self->{eol} };
    $self->{_STATUS} = 1;

    return $self->{_STATUS};
}
################################################################################
# parse
################################################################################
my %allow_eol = ("\r" => 1, "\r\n" => 1, "\n" => 1, "" => 1);

*parse = \&_parse;

sub _parse {
    my ($self, $line) = @_;

    @{$self}{qw/_STRING _FIELDS _STATUS _ERROR_INPUT/} = ($line, undef, 0, $line);

    return 0 if(!defined $line);

    my ($binary, $quot, $sep, $esc, $types, $keep_meta_info, $allow_whitespace, $eol, $blank_is_undef)
         = @{$self}{qw/binary quote_char sep_char escape_char types keep_meta_info allow_whitespace eol blank_is_undef/};
    $sep  = "\0" unless (defined $sep);
    $esc  = "\0" unless (defined $esc);
    $quot = ''   unless (defined $quot);

    return $self->_set_error_diag(1001) if (($sep eq $esc or $sep eq $quot) and $sep ne "\0");

    my $meta_flag      = $keep_meta_info ? [] : undef;
    my $re_split       = $self->{_re_split}->{$quot}->{$esc}->{$sep} ||= _make_regexp_split_column($esc, $quot, $sep);
    my $re_quoted       = $self->{_re_quoted}->{$quot}               ||= qr/^\Q$quot\E(.*)\Q$quot\E$/s;
    my $re_in_quot_esp1 = $self->{_re_in_quot_esp1}->{$esc}          ||= qr/\Q$esc\E(.)/;
    my $re_in_quot_esp2 = $self->{_re_in_quot_esp2}->{$quot}->{$esc} ||= qr/[\Q$quot$esc\E0]/;
    my $re_quot_char    = $self->{_re_quot_char}->{$quot}            ||= qr/\Q$quot\E/;
    my $re_esc          = $self->{_re_esc}->{$quot}->{$esc}          ||= qr/\Q$esc\E(\Q$quot\E|\Q$esc\E|0)/;
    my $re_invalid_quot = $self->{_re_invalid_quot}->{$quot}->{$esc} ||= qr/^$re_quot_char|[^\Q$re_esc\E]$re_quot_char/;
    my $re_rs           = $self->{_re_rs}->{$/} ||= qr{\Q$/\E?$}; # $/ .. input record separator

    if ($allow_whitespace) {
        $re_split = $self->{_re_split_allow_sp}->{$quot}->{$esc}->{$sep}
                     ||= _make_regexp_split_column_allow_sp($esc, $quot, $sep);
    }

    my $palatable = 1;
    my @part      = ();

    my $i = 0;
    my $flag;

    if (defined $eol and $eol eq "\r") {
        $line =~ s/[\r ]*\r[ ]*$//;
    }

    if ($self->{verbatim}) {
        $line .= $sep;
    }
    else {
        if (defined $eol and !$allow_eol{$eol}) {
            $line .= $sep;
        }
        else {
            $line =~ s/(?:\x0D\x0A|\x0A)?$|(?:\x0D\x0A|\x0A)[ ]*$/$sep/;
        }
    }

    my $pos = 0;

    my $utf8 = 1 if utf8::is_utf8( $line ); # if UTF8 marked, flag on.

    for my $col ($line =~ /$re_split/g) {

        if ($keep_meta_info) {
            $flag = 0x0000;
            $flag |= IS_BINARY if ($col =~ /[^\x09\x20-\x7E]/);
        }

        $pos += length $col;

        if ( ( !$binary and !$utf8 ) and $col =~ /[^\x09\x20-\x7E]/) { # Binary character, binary off
            if ( $col =~ $re_quoted ) {
                $self->_set_error_diag(
                      $col =~ /\n([^\n]*)/ ? (2021, $pos - 1 - length $1)
                    : $col =~ /\r([^\r]*)/ ? (2022, $pos - 1 - length $1)
                    : (2026, $pos -2) # Binary character inside quoted field, binary off
                );
            }
            else {
                $self->_set_error_diag(
                      $col =~ /\Q$quot\E(.*)\Q$quot\E\r$/   ? (2010, $pos - 2)
                    : $col =~ /^\r/                         ? (2031, $pos - length $col)
                    : $col =~ /\r([^\r]*)/                  ? (2032, $pos - 1 - length $1)
                    : (2037, $pos - length $col) # Binary character in unquoted field, binary off
                );
            }
            $palatable = 0;
            last;
        }

        if ( ($utf8 and !$binary) and  $col =~ /\n|\0/ ) { # \n still needs binary (Text::CSV_XS 0.51 compat)
            $self->_set_error_diag(2021, $pos);
            $palatable = 0;
            last;
        }

        if ($col =~ $re_quoted) {
            $flag |= IS_QUOTED if ($keep_meta_info);
            $col = $1;

            if ($col =~ $re_in_quot_esp1) {
                my $str = $1;
                if ($str !~ $re_in_quot_esp2) {
                    unless ($self->{allow_loose_escapes}) {
                        $self->_set_error_diag( 2025, $pos - 2 ); # Needless ESC in quoted field
                        $palatable = 0;
                        last;
                    }
                    else {
                        $col =~ s/\Q$esc\E(.)/$1/g;
                    }
                }
            }
            else {
                if ($col =~ /(?<!\Q$esc\E)\Q$esc\E/) {
                    $self->_set_error_diag( 4002, $pos - 1 ); # No escaped ESC in quoted field
                    $palatable = 0;
                    last;
                }
            }

            $col =~ s{$re_esc}{$1 eq '0' ? "\0" : $1}eg;

            if ($types and $types->[$i]) { # IV or NV
                _check_type(\$col, $types->[$i]);
            }
        }

        # quoted but invalid

        elsif ($col =~ $re_invalid_quot) {

            unless ($self->{allow_loose_quotes} and $col =~ /$re_quot_char/) {
                $self->_set_error_diag(
                      $col =~ /^\Q$quot\E(.*)\Q$quot\E.$/s  ? (2011, $pos - 2)
                    : $col =~ /^$re_quot_char/              ? (2027, $pos - 1)
                    : (2034, $pos - length $col) # Loose unescaped quote
                );
                $palatable = 0;
                last;
            }

        }

        elsif ($types and $types->[$i]) { # IV or NV
            _check_type(\$col, $types->[$i]);
        }

        # unquoted

        else {

            if (!$self->{verbatim} and $col =~ /\r\n|\n/) {
                unless (defined $eol and !$allow_eol{$eol}) {
                    $col =~ s/(?:\r\n|\n).*//sm;
                }
            }

            if ($col =~ /\Q$esc\E\r$/) { # for t/15_flags : test 165 'ESC CR' at line 203
                $self->_set_error_diag( 4003, $pos );
                $palatable = 0;
                last;
            }

            if ($col =~ /.\Q$esc\E$/) { # for t/65_allow : test 53-54 parse('foo\') at line 62, 65
                $self->_set_error_diag( 4004, $pos );
                $palatable = 0;
                last;
            }

            if ( $col eq '' and $blank_is_undef ) {
                $col = undef;
            }

        }

        push @part,$col;
        push @{$meta_flag}, $flag if ($keep_meta_info);

        $i++;
    }

    if ($palatable and ! @part) {
        $palatable = 0;
    }

    if ($palatable) {
        $self->{_ERROR_INPUT} = undef;
        $self->{_FIELDS}      = \@part;
    }

    $self->{_FFLAGS} = $keep_meta_info ? $meta_flag : [];

    return $self->{_STATUS} = $palatable;
}


sub _make_regexp_split_column {
    my ($esc, $quot, $sep) = @_;
    qr/(
        \Q$quot\E
            [^\Q$quot$esc\E]*(?:\Q$esc\E[\Q$quot$esc\E0][^\Q$quot$esc\E]*)*
        \Q$quot\E
        | # or
        [^\Q$sep\E]*
       )
       \Q$sep\E
    /xs;
}


sub _make_regexp_split_column_allow_sp {
    my ($esc, $quot, $sep) = @_;
    qr/[\x20\x09]*
       (
        \Q$quot\E
            [^\Q$quot$esc\E]*(?:\Q$esc\E[\Q$quot$esc\E0][^\Q$quot$esc\E]*)*
        \Q$quot\E
        | # or
        [^\Q$sep\E]*?
       )
       [\x20\x09]*\Q$sep\E[\x20\x09]*
    /xs;
}
################################################################################
# print
################################################################################
sub print {
    my ($self, $io, $cols) = @_;

    require IO::Handle;

    if(ref($cols) ne 'ARRAY'){
        Carp::croak("Expected fields to be an array ref");
    }

    $self->_combine(@$cols) or return '';

    $io->print( $self->_string );
}
################################################################################
# getline
################################################################################
sub getline {
    my ($self, $io) = @_;

    require IO::Handle;

    $self->{_EOF} = eof($io) ? 1 : '';

    my $line = $io->getline();
    my $quot = $self->{quote_char};
    my $re   = qr/(?:\Q$quot\E)/;

    $line .= $io->getline() while ( defined $line and scalar(my @list = $line =~ /$re/g) % 2 and !eof($io) );

    my $eol = $self->{eol};

    if (defined $eol and defined $line) {
        $line =~ s/\Q$eol\E$//;
    }

    $self->_parse($line) or return;

    if ( $self->{_BOUND_COLUMNS} ) {
        my @vals  = $self->_fields();
        my ( $max, $count ) = ( scalar @vals, 0 );

        if ( @{ $self->{_BOUND_COLUMNS} } < $max ) {
                $self->_set_error_diag(3006);
                return;
        }

        for ( my $i = 0; $i < $max; $i++ ) {
            my $bind = $self->{_BOUND_COLUMNS}->[ $i ];
            if ( Scalar::Util::readonly( $$bind ) ) {
                $self->_set_error_diag(3008);
                return;
            }
            $$bind = $vals[ $i ];
        }

        return [];
    }
    else {
        [ $self->_fields() ];
    }

}
################################################################################
# getline_hr
################################################################################
sub getline_hr {
    my ( $self, $io) = @_;
    my %hr;

    unless ( $self->{_COLUMN_NAMES} ) {
        $self->SetDiag( 3002 );
    }

    my $fr = $self->getline( $io ) or return undef;

    @hr{ @{ $self->{_COLUMN_NAMES} } } = @$fr;

    \%hr;
}
################################################################################
# column_names
################################################################################
sub column_names {
    my ( $self, @clumns ) = @_;

    @clumns or return defined $self->{_COLUMN_NAMES} ? @{$self->{_COLUMN_NAMES}} : undef;
    @clumns == 1 && ! defined $clumns[0] and return $self->{_COLUMN_NAMES} = undef;

    if ( @clumns == 1 && ref $clumns[0] eq "ARRAY" ) {
        @clumns = @{ $clumns[0] };
    }
    elsif ( join "", map { defined $_ ? ref $_ : "UNDEF" } @clumns ) {
        $self->SetDiag( 3001 );
    }

    if ( $self->{_is_bound} && @clumns != $self->{_is_bound} ) {
        $self->SetDiag( 3003 );
    }

    $self->{_COLUMN_NAMES} = [ @clumns ];

    @clumns;
}
################################################################################
# bind_columns
################################################################################
sub bind_columns {
    my ( $self, @refs ) = @_;

    @refs or return defined $self->{_BOUND_COLUMNS} ? @{$self->{_BOUND_COLUMNS}} : undef;
    @refs == 1 && ! defined $refs[0] and return $self->{_BOUND_COLUMNS} = undef;

    if ( $self->{_COLUMN_NAMES} && @refs != @{$self->{_COLUMN_NAMES}} ) {
        $self->SetDiag( 3003 );
    }

    if ( grep { ref $_ ne "SCALAR" } @refs ) { # why don't use grep?
        $self->SetDiag( 3004 );
    }

    $self->{_is_bound} = scalar @refs; #pack("C", scalar @refs);
    $self->{_BOUND_COLUMNS} = [ @refs ];
    @refs;
}
################################################################################
# eof
################################################################################
sub eof {
    $_[0]->{_EOF};
}
################################################################################
# type
################################################################################
sub types {
    my $self = shift;

    if (@_) {
        if (my $types = shift) {
            $self->{'_types'} = join("", map{ chr($_) } @$types);
            $self->{'types'} = $types;
        }
        else {
            delete $self->{'types'};
            delete $self->{'_types'};
            undef;
        }
    }
    else {
        $self->{'types'};
    }
}
################################################################################
sub meta_info {
    $_[0]->{_FFLAGS} ? @{ $_[0]->{_FFLAGS} } : undef;
}

sub is_quoted {
    return unless (defined $_[0]->{_FFLAGS});
    return if( $_[1] =~ /\D/ or $_[1] < 0 or  $_[1] > $#{ $_[0]->{_FFLAGS} } );

    $_[0]->{_FFLAGS}->[$_[1]] & IS_QUOTED ? 1 : 0;
}

sub is_binary {
    return unless (defined $_[0]->{_FFLAGS});
    return if( $_[1] =~ /\D/ or $_[1] < 0 or  $_[1] > $#{ $_[0]->{_FFLAGS} } );
    $_[0]->{_FFLAGS}->[$_[1]] & IS_BINARY ? 1 : 0;
}
################################################################################
# _check_type
#  take an arg as scalar referrence.
#  if not numeric, make the value 0. otherwise INTEGERized.
################################################################################
sub _check_type {
    my ($col_ref, $type) = @_;
    unless ($$col_ref =~ /^[+-]?(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/) {
        Carp::carp sprintf("Argument \"%s\" isn't numeric in subroutine entry",$$col_ref);
        $$col_ref = 0;
    }
    elsif ($type == NV) {
        $$col_ref = sprintf("%G",$$col_ref);
    }
    else {
        $$col_ref = sprintf("%d",$$col_ref);
    }
}
################################################################################
# _set_error_diag
################################################################################
sub _set_error_diag {
    my ( $self, $error, $pos ) = @_;

    $self->{_ERROR_DIAG} = $error;

    if (defined $pos) {
        $_[0]->{_ERROR_POS} = $pos;
    }

    return;
}
################################################################################

BEGIN {
    for my $method (qw/quote_char escape_char sep_char eol always_quote binary allow_whitespace
                        keep_meta_info allow_loose_quotes allow_loose_escapes verbatim blank_is_undef/) {
        eval qq|
            sub $method {
                \$_[0]->{$method} = \$_[1] if (\@_ > 1);
                \$_[0]->{$method};
            }
        |;
    }
}


sub SetDiag {
    if ( defined $_[1] and $_[1] == 0 ) {
        $_[0]->{_ERROR_DIAG} = undef;
    }

    $_[0]->_set_error_diag( $_[1] );
    Carp::croak( $_[0]->error_diag . '' );
}

################################################################################
package Text::CSV::ErrorDiag;

use strict;
use overload (
    '""' => \&stringify,
    '+'  => \&numeric,
    '-'  => \&numeric,
    '*'  => \&numeric,
    '/'  => \&numeric,
);


sub numeric {
    my ($left, $right) = @_;
    return ref $left ? $left->[0] : $right->[0];
}


sub stringify {
    $_[0]->[1];
}
################################################################################
1;
__END__

=head1 NAME

Text::CSV_PP - Text::CSV_XS compatible pure-Perl module


=head1 SYNOPSIS

 use Text::CSV_PP;
 
 $csv = Text::CSV_PP->new();     # create a new object
 # If you want to handle non-ascii char.
 $csv = Text::CSV_PP->new({binary => 1});
 
 $status = $csv->combine(@columns);    # combine columns into a string
 $line   = $csv->string();             # get the combined string
 
 $status  = $csv->parse($line);        # parse a CSV string into fields
 @columns = $csv->fields();            # get the parsed fields
 
 $status       = $csv->status ();      # get the most recent status
 $bad_argument = $csv->error_input (); # get the most recent bad argument
 $diag         = $csv->error_diag ();  # if an error occured, explains WHY
 
 $status = $csv->print ($io, $colref); # Write an array of fields
                                       # immediately to a file $io
 $colref = $csv->getline ($io);        # Read a line from file $io,
                                       # parse it and return an array
                                       # ref of fields
 $csv->column_names (@names);          # Set column names for getline_hr ()
 $ref = $csv->getline_hr ($io);        # getline (), but returns a hashref
 $eof = $csv->eof ();                  # Indicate if last parse or
                                       # getline () hit End Of File
 
 $csv->types(\@t_array);               # Set column types


=head1 DESCRIPTION

Text::CSV_PP has almost same functions of L<Text::CSV_XS> which 
provides facilities for the composition and decomposition of
comma-separated values. As its name suggests, L<Text::CSV_XS>
is a XS module and Text::CSV_PP is a Puer Perl one.

=head2 Unicode (UTF8)

On parsing (both for C<getline ()> and C<parse ()>), if the source is
marked being UTF8, then parsing that source will mark all fields that
are marked binary will also be marked UTF8.

On combining (C<print ()> and C<combine ()>), if any of the combining
fields was marked UTF8, the resulting string will be marked UTF8.

=head1 FUNCTIONS

These methods are almost same as Text::CSV_XS.
Most of the documentation was shamelessly copied and replaced from Text::CSV_XS.

See to L<Text::CSV_XS>.

=head2 version ()

(Class method) Returns the current module version.

=head2 new (\%attr)

(Class method) Returns a new instance of Text::CSV_XS. The objects
attributes are described by the (optional) hash ref C<\%attr>.
Currently the following attributes are available:

=over 4

=item eol

An end-of-line string to add to rows, usually C<undef> (nothing,
default), C<"\012"> (Line Feed) or C<"\015\012"> (Carriage Return,
Line Feed). Cannot be longer than 7 (ASCII) characters.

If both C<$/> and C<eol> equal C<"\015">, parsing lines that end on
only a Carriage Return without Line Feed, will be C<parse>d correct.
Line endings, whether in C<$/> or C<eol>, other than C<undef>,
C<"\n">, C<"\r\n">, or C<"\r"> are not (yet) supported for parsing.

=item sep_char

The char used for separating fields, by default a comma. (C<,>).
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The separation character can not be equal to the quote character.
The separation character can not be equal to the escape character.

=item allow_whitespace

When this option is set to true, whitespace (TAB's and SPACE's)
surrounding the separation character is removed when parsing. So
lines like:

  1 , "foo" , bar , 3 , zapp

are now correctly parsed, even though it violates the CSV specs.
Note that B<all> whitespace is stripped from start and end of each
field. That would make is more a I<feature> than a way to be able
to parse bad CSV lines, as

 1,   2.0,  3,   ape  , monkey

will now be parsed as

 ("1", "2.0", "3", "ape", "monkey")

even if the original line was perfectly sane CSV.

=item blank_is_undef

Under normal circumstances, CSV data makes no distinction between
quoted- and unquoted empty fields. They both end up in an empty
string field once read, so

 1,"",," ",2

is read as

 ("1", "", "", " ", "2")

When I<writing> CSV files with C<always_quote> set, the unquoted empty
field is the result of an undefined value. To make it possible to also
make this distinction when reading CSV data, the C<blank_is_undef> option
will cause unquoted empty fields to be set to undef, causing the above to
be parsed as

 ("1", "", undef, " ", "2")

=item quote_char

The char used for quoting fields containing blanks, by default the
double quote character (C<">). A value of undef suppresses
quote chars. (For simple cases only).
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The quote character can not be equal to the separation character.

=item allow_loose_quotes

By default, parsing fields that have C<quote_char> characters inside
an unquoted field, like

 1,foo "bar" baz,42

would result in a parse error. Though it is still bad practice to
allow this format, we cannot help there are some vendors that make
their applications spit out lines styled like this.

In case there is B<really> bad CSV data, like

 1,"foo "bar" baz",42

or

 1,""foo bar baz"",42

there is a way to get that parsed, and leave the quotes inside the quoted
field as-is. This can be achieved by setting C<allow_loose_quotes> B<AND>
making sure that the C<escape_char> is I<not> equal to C<quote_char>.

=item escape_char

The character used for escaping certain characters inside quoted fields.
Limited to a single-byte character, usually in the range from 0x20
(space) to 0x7e (tilde).

The C<escape_char> defaults to being the literal double-quote mark (C<">)
in other words, the same as the default C<quote_char>. This means that
doubling the quote mark in a field escapes it:

  "foo","bar","Escape ""quote mark"" with two ""quote marks""","baz"

If you change the default quote_char without changing the default
escape_char, the escape_char will still be the quote mark.  If instead 
you want to escape the quote_char by doubling it, you will need to change
the escape_char to be the same as what you changed the quote_char to.

The escape character can not be equal to the separation character.

=item allow_loose_escapes

By default, parsing fields that have C<escape_char> characters that
escape characters that do not need to be escaped, like:

 my $csv = Text::CSV_PP->new ({ escape_char => "\\" });
 $csv->parse (qq{1,"my bar\'s",baz,42});

would result in a parse error. Though it is still bad practice to
allow this format, this option enables you to treat all escape character
sequences equal.

=item binary

If this attribute is TRUE, you may use binary characters in quoted fields,
including line feeds, carriage returns and NULL bytes. (The latter must
be escaped as C<"0>.) By default this feature is off.

=item types

A set of column types; this attribute is immediately passed to the
I<types> method below. You must not set this attribute otherwise,
except for using the I<types> method. For details see the description
of the I<types> method below.

=item always_quote

By default the generated fields are quoted only, if they need to, for
example, if they contain the separator. If you set this attribute to
a TRUE value, then all fields will be quoted. This is typically easier
to handle in external applications.

=item keep_meta_info

By default, the parsing of input lines is as simple and fast as
possible. However, some parsing information - like quotation of
the original field - is lost in that process. Set this flag to
true to be able to retrieve that information after parsing with
the methods C<meta_info ()>, C<is_quoted ()>, and C<is_binary ()>
described below.  Default is false.

=item verbatim

This is a quite controversial attribute to set, but it makes hard
things possible.

The basic thought behind this is to tell the parser that the normally
special characters newline (NL) and Carriage Return (CR) will not be
special when this flag is set, and be dealt with as being ordinary
binary characters. This will ease working with data with embedded
newlines.

When C<verbatim> is used with C<getline ()>, getline
auto-chomp's every line.

Imagine a file format like

  M^^Hans^Janssen^Klas 2\n2A^Ja^11-06-2007#\r\n

where, the line ending is a very specific "#\r\n", and the sep_char
is a ^ (caret). None of the fields is quoted, but embedded binary
data is likely to be present. With the specific line ending, that
shouldn't be too hard to detect.

By default, Text::CSV_PP' parse function however is instructed to only
know about "\n" and "\r" to be legal line endings, and so has to deal
with the embedded newline as a real end-of-line, so it can scan the next
line if binary is true, and the newline is inside a quoted field.
With this attribute however, we can tell parse () to parse the line
as if \n is just nothing more than a binary character.

For parse () this means that the parser has no idea about line ending
anymore, and getline () chomps line endings on reading.

=back

To sum it up,

 $csv = Text::CSV_PP->new ();

is equivalent to

 $csv = Text::CSV_PP->new ({
     quote_char          => '"',
     escape_char         => '"',
     sep_char            => ',',
     eol                 => '',
     always_quote        => 0,
     binary              => 0,
     keep_meta_info      => 0,
     allow_loose_quotes  => 0,
     allow_loose_escapes => 0,
     allow_whitespace    => 0,
     blank_is_undef      => 0,
     verbatim            => 0,
     });

For all of the above mentioned flags, there is an accessor method
available where you can inquire for the current value, or change
the value

 my $quote = $csv->quote_char;
 $csv->binary (1);

It is unwise to change these settings halfway through writing CSV
data to a stream. If however, you want to create a new stream using
the available CSV object, there is no harm in changing them.

If the C<new ()> constructor call fails, it returns C<undef>, and makes
the fail reason available through the C<error_diag ()> method.

 $csv = Text::CSV_PP->new ({ ecs_char => 1 }) or
     die Text::CSV_PP->error_diag ();

C<error_diag ()> will return a string like

 "Unknown attribute 'ecs_char'"

=head2 combine

 $status = $csv->combine (@columns);

This object function constructs a CSV string from the arguments, returning
success or failure.  Failure can result from lack of arguments or an argument
containing an invalid character.  Upon success, C<string ()> can be called to
retrieve the resultant CSV string.  Upon failure, the value returned by
C<string ()> is undefined and C<error_input ()> can be called to retrieve an
invalid argument.

=head2 print

 $status = $csv->print ($io, $colref);

Similar to combine, but it expects an array ref as input (not an array!)
and the resulting string is not really created, but immediately written
to the I<$io> object, typically an IO handle or any other object that
offers a I<print> method. Note, this implies that the following is wrong:

 open FILE, ">", "whatever";
 $status = $csv->print (\*FILE, $colref);

The glob C<\*FILE> is not an object, thus it doesn't have a print
method. The solution is to use an IO::File object or to hide the
glob behind an IO::Wrap object. See L<IO::File(3)> and L<IO::Wrap(3)>
for details.

For performance reasons the print method doesn't create a result string.
In particular the I<$csv-E<gt>string ()>, I<$csv-E<gt>status ()>,
I<$csv->fields ()> and I<$csv-E<gt>error_input ()> methods are meaningless
after executing this method.

=head2 string

 $line = $csv->string ();

This object function returns the input to C<parse ()> or the resultant CSV
string of C<combine ()>, whichever was called more recently.

=head2 parse

 $status = $csv->parse ($line);

This object function decomposes a CSV string into fields, returning
success or failure.  Failure can result from a lack of argument or the
given CSV string is improperly formatted.  Upon success, C<fields ()> can
be called to retrieve the decomposed fields .  Upon failure, the value
returned by C<fields ()> is undefined and C<error_input ()> can be called
to retrieve the invalid argument.

You may use the I<types ()> method for setting column types. See the
description below.

=head2 getline

 $colref = $csv->getline ($io);

This is the counterpart to print, like parse is the counterpart to
combine: It reads a row from the IO object $io using $io->getline ()
and parses this row into an array ref. This array ref is returned
by the function or undef for failure.

When fields are bound with C<bind_columns ()>, the return value is a
reference to an empty list.

The I<$csv-E<gt>string ()>, I<$csv-E<gt>fields ()> and I<$csv-E<gt>status ()>
methods are meaningless, again.

=head2 getline_hr

The C<getline_hr ()> and C<column_names ()> methods work together to allow
you to have rows returned as hashrefs. You must call C<column_names ()>
first to declare your column names. 

 $csv->column_names (qw( code name price description ));
 $hr = $csv->getline_hr ($io);
 print "Price for $hr->{name} is $hr->{price} EUR\n";

C<getline_hr ()> will croak if called before C<column_names ()>.

=head2 column_names

Set the keys that will be used in the C<getline_hr ()> calls. If no keys
(column names) are passed, it'll return the current setting.

C<column_names ()> accepts a list of scalars (the column names) or a
single array_ref, so you can pass C<getline ()>

  $csv->column_names ($csv->getline ($io));

C<column_names ()> croaks on invalid arguments.

=head2 bind_columns

Takes a list of references to scalars (max 255) to store the fields fetched
C<getline ()> in. When you don't pass enough references to store the
fetched fields in, C<getline ()> will fail. If you pass more than there are
fields to return, the remaining references are left untouched.

  $csv->bind_columns (\$code, \$name, \$price, \$description);
  while ($csv->getline ()) {
      print "The price of a $name is \x{20ac} $price\n";
      }

=head2 eof

 $eof = $csv->eof ();

If C<parse ()> or C<getline ()> was used with an IO stream, this
method will return true (1) if the last call hit end of file, otherwise
it will return false (''). This is useful to see the difference between
a failure and end of file.

=head2 types

 $csv->types (\@tref);

This method is used to force that columns are of a given type. For
example, if you have an integer column, two double columns and a
string column, then you might do a

 $csv->types ([Text::CSV_PP::IV (),
               Text::CSV_PP::NV (),
               Text::CSV_PP::NV (),
               Text::CSV_PP::PV ()]);

Column types are used only for decoding columns, in other words
by the I<parse ()> and I<getline ()> methods.

You can unset column types by doing a

 $csv->types (undef);

or fetch the current type settings with

 $types = $csv->types ();

=over 4

=item IV

Set field type to integer.

=item NV

Set field type to numeric/float.

=item PV

Set field type to string.

=back

=head2 fields

 @columns = $csv->fields ();

This object function returns the input to C<combine ()> or the resultant
decomposed fields of C<parse ()>, whichever was called more recently.

=head2 meta_info

 @flags = $csv->meta_info ();

This object function returns the flags of the input to C<combine ()> or
the flags of the resultant decomposed fields of C<parse ()>, whichever
was called more recently.

For each field, a meta_info field will hold flags that tell something about
the field returned by the C<fields ()> method or passed to the C<combine ()>
method. The flags are bitwise-or'd like:

=over 4

=item 0x0001

The field was quoted.

=item 0x0002

The field was binary.

=back

See the C<is_*** ()> methods below.

=head2 is_quoted

  my $quoted = $csv->is_quoted ($column_idx);

Where C<$column_idx> is the (zero-based) index of the column in the
last result of C<parse ()>.

This returns a true value if the data in the indicated column was
enclosed in C<quote_char> quotes. This might be important for data
where C<,20070108,> is to be treated as a numeric value, and where
C<,"20070108",> is explicitly marked as character string data.

=head2 is_binary

  my $binary = $csv->is_binary ($column_idx);

Where C<$column_idx> is the (zero-based) index of the column in the
last result of C<parse ()>.

This returns a true value if the data in the indicated column
contained any byte in the range [\x00-\x08,\x10-\x1F,\x7F-\xFF]

=head2 status

 $status = $csv->status ();

This object function returns success (or failure) of C<combine ()> or
C<parse ()>, whichever was called more recently.

=head2 error_input

 $bad_argument = $csv->error_input ();

This object function returns the erroneous argument (if it exists) of
C<combine ()> or C<parse ()>, whichever was called more recently.

=head2 error_diag

 $csv->error_diag ();
 $error_code   = 0  + $csv->error_diag ();
 $error_str    = "" . $csv->error_diag ();
 ($cde, $str, $pos) = $csv->error_diag ();

If (and only if) an error occured, this function returns the diagnostics
of that error.

If called in void context, it will print the internal error code and the
associated error message to STDERR.

If called in list context, it will return the error code and the error
message in that order. If the last error was from parsing, the third
value returned is the best guess at the location within the line that was
being parsed. It's value is 1-based.

Note: C<$pos> does not show the error point in many cases.
It is for conscience's sake.

If called in scalar context, it will return the diagnostics in a single
scalar, a-la $!. It will contain the error code in numeric context, and
the diagnostics message in string context.

To achieve this behavior with CSV_PP, the returned diagnostics is blessed object.

=head2 SetDiag

 $csv->SetDiag (0);

Use to reset the diagnostics if you are dealing with errors.

=head1 DIAGNOSTICS

If an error occured, $csv->error_diag () can be used to get more information
on the cause of the failure. Note that for speed reasons, the internal value
is never cleared on success, so using the value returned by error_diag () in
normal cases - when no error occured - may cause unexpected results.

Note: CSV_PP's diagnostics is different from CSV_XS's:

Text::CSV_XS parses csv strings by dividing one character
while Text::CSV_PP by using the regular expressions.
That difference makes the different cause of the failure.

Currently these errors are available:

=over 2

=item 1001 "sep_char is equal to quote_char or escape_char"

The separation character cannot be equal to either the quotation character
or the escape character, as that will invalidate all parsing rules.

=item 2010 "ECR - QUO char inside quotes followed by CR not part of EOL"

=item 2011 "ECR - Characters after end of quoted field"

=item 2021 "EIQ - NL char inside quotes, binary off"

=item 2022 "EIQ - CR char inside quotes, binary off"

=item 2025 "EIQ - Loose unescaped escape"

=item 2026 "EIQ - Binary character inside quoted field, binary off"

=item 2027 "EIQ - Quoted field not terminated"

=item 2030 "EIF - NL char inside unquoted verbatim, binary off",

=item 2031 "EIF - CR char is first char of field, not part of EOL",

=item 2032 "EIF - CR char inside unquoted, not part of EOL",

=item 2034 "EIF - Loose unescaped quote",

=item 2037 "EIF - Binary character in unquoted field, binary off",

=item 2110 "ECB - Binary character in Combine, binary off"

=item 4002 "EIQ - Unescaped ESC in quoted field"

=item 4003 "EIF - ESC CR"

=item 4004 "EUF - "

=item 3001 "EHR - Unsupported syntax for column_names ()"

=item 3002 "EHR - getline_hr () called before column_names ()"

=item 3003 "EHR - bind_columns () and column_names () fields count mismatch"

=item 3004 "EHR - bind_columns () only accepts refs to scalars"

=item 3006 "EHR - bind_columns () did not pass enough refs for parsed fields"

=item 3007 "EHR - bind_columns needs refs to writeable scalars"

=item 3008 "EHR - unexpected error in bound fields"

=back

=head1 AUTHOR

Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>

Text::CSV_XS was written by E<lt>joe[at]ispsoft.deE<gt>
and maintained by E<lt>h.m.brand[at]xs4all.nlE<gt>.

Text::CSV was written by E<lt>alan[at]mfgrtl.comE<gt>.


=head1 COPYRIGHT AND LICENSE

Copyright 2005-2008 by Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself. 

=head1 SEE ALSO

L<Text::CSV_XS>, L<Text::CSV>

I got many regexp bases from L<http://www.din.or.jp/~ohzaki/perl.htm>

=cut

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
IyAtLQojIEtlcm5lbC9MYW5ndWFnZS9iZ19JbXBvcnRFeHBvcnQucG0gLSB0aGUgYnVsZ2FyaWFuIHRyYW5zbGF0aW9uIG9mIEltcG9ydEV4cG9ydAojIENvcHlyaWdodCAoQykgMjAwMS0yMDA4IE9UUlMgQUcsIGh0dHA6Ly9vdHJzLm9yZy8KIyBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOCBNaWxlbiBLb3V0ZXYKIyAtLQojICRJZDogYmdfSW1wb3J0RXhwb3J0LnBtLHYgMS40LjIuMSAyMDA4LzA4LzE0IDExOjU3OjU4IG1oIEV4cCAkCiMgLS0KIyBUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQojIHRoZSBlbmNsb3NlZCBmaWxlIENPUFlJTkcgZm9yIGxpY2Vuc2UgaW5mb3JtYXRpb24gKEdQTCkuIElmIHlvdQojIGRpZCBub3QgcmVjZWl2ZSB0aGlzIGZpbGUsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3BsLTIuMC50eHQuCiMgLS0KCnBhY2thZ2UgS2VybmVsOjpMYW5ndWFnZTo6YmdfSW1wb3J0RXhwb3J0OwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIHZhcnMgcXcoJFZFUlNJT04pOwokVkVSU0lPTiA9IHF3KCRSZXZpc2lvbjogMS40LjIuMSAkKSBbMV07CgpzdWIgRGF0YSB7CiAgICBteSAkU2VsZiA9IHNoaWZ0OwoKICAgIG15ICRMYW5nID0gJFNlbGYtPntUcmFuc2xhdGlvbn07CgogICAgcmV0dXJuIGlmIHJlZiAkTGFuZyBuZSAnSEFTSCc7CgogICAgJExhbmctPnsnSW1wb3J0L0V4cG9ydCd9ID0gJ0ltcG9ydC9FeHBvcnQnOwoKICAgIHJldHVybiAxOwp9CgoxOwo=
IyAtLQojIEtlcm5lbC9MYW5ndWFnZS9jel9JbXBvcnRFeHBvcnQucG0gLSB0aGUgY3plY2ggdHJhbnNsYXRpb24gb2YgSW1wb3J0RXhwb3J0CiMgQ29weXJpZ2h0IChDKSAyMDAxLTIwMDggT1RSUyBBRywgaHR0cDovL290cnMub3JnLwojIENvcHlyaWdodCAoQykgMjAwNy0yMDA4IE1pbGVuIEtvdXRldgojIC0tCiMgJElkOiBjel9JbXBvcnRFeHBvcnQucG0sdiAxLjQuMi4xIDIwMDgvMDgvMTQgMTE6NTc6NTggbWggRXhwICQKIyAtLQojIFRoaXMgc29mdHdhcmUgY29tZXMgd2l0aCBBQlNPTFVURUxZIE5PIFdBUlJBTlRZLiBGb3IgZGV0YWlscywgc2VlCiMgdGhlIGVuY2xvc2VkIGZpbGUgQ09QWUlORyBmb3IgbGljZW5zZSBpbmZvcm1hdGlvbiAoR1BMKS4gSWYgeW91CiMgZGlkIG5vdCByZWNlaXZlIHRoaXMgZmlsZSwgc2VlIGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy9ncGwtMi4wLnR4dC4KIyAtLQoKcGFja2FnZSBLZXJuZWw6Okxhbmd1YWdlOjpjel9JbXBvcnRFeHBvcnQ7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgdmFycyBxdygkVkVSU0lPTik7CiRWRVJTSU9OID0gcXcoJFJldmlzaW9uOiAxLjQuMi4xICQpIFsxXTsKCnN1YiBEYXRhIHsKICAgIG15ICRTZWxmID0gc2hpZnQ7CgogICAgbXkgJExhbmcgPSAkU2VsZi0+e1RyYW5zbGF0aW9ufTsKCiAgICByZXR1cm4gaWYgcmVmICRMYW5nIG5lICdIQVNIJzsKCiAgICAkTGFuZy0+eydJbXBvcnQvRXhwb3J0J30gPSAnSW1wb3J0L0V4cG9ydCc7CgogICAgcmV0dXJuIDE7Cn0KCjE7Cg==
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
# --
# Kernel/Modules/AdminImportExport.pm - admin frontend of import export module
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: AdminImportExport.pm,v 1.19 2008/04/17 11:28:24 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::Modules::AdminImportExport;

use strict;
use warnings;

use Kernel::System::ImportExport;
use Kernel::System::Valid;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.19 $) [1];

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {%Param};
    bless( $Self, $Type );

    # check needed objects
    for my $Object (qw(ConfigObject ParamObject LogObject LayoutObject EncodeObject)) {
        if ( !$Self->{$Object} ) {
            $Self->{LayoutObject}->FatalError( Message => "Got no $Object!" );
        }
    }
    $Self->{ImportExportObject} = Kernel::System::ImportExport->new( %{$Self} );
    $Self->{ValidObject}        = Kernel::System::Valid->new( %{$Self} );

    return $Self;
}

sub Run {
    my ( $Self, %Param ) = @_;

    # ------------------------------------------------------------ #
    # template edit (common)
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'TemplateEdit1' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );
        if ( $TemplateData->{TemplateID} eq 'NEW' ) {

            # get needed data
            $TemplateData->{Object} = $Self->{ParamObject}->GetParam( Param => 'Object' );
            $TemplateData->{Format} = $Self->{ParamObject}->GetParam( Param => 'Format' );

            # redirect to overview
            return $Self->{LayoutObject}->Redirect( OP => "Action=$Self->{Action}" )
                if !$TemplateData->{Object} || !$TemplateData->{Format};
        }
        else {

            # get template data
            $TemplateData = $Self->{ImportExportObject}->TemplateGet(
                TemplateID => $TemplateData->{TemplateID},
                UserID     => $Self->{UserID},
            );

            return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
                if !$TemplateData->{TemplateID};
        }

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # generate ValidOptionStrg
        my %ValidList        = $Self->{ValidObject}->ValidList();
        my %ValidListReverse = reverse %ValidList;
        my $ValidOptionStrg  = $Self->{LayoutObject}->BuildSelection(
            Name       => 'ValidID',
            Data       => \%ValidList,
            SelectedID => $TemplateData->{ValidID} || $ValidListReverse{valid},
        );

        # output list
        $Self->{LayoutObject}->Block(
            Name => 'TemplateEdit1',
            Data => {
                %{$TemplateData},
                ObjectName      => $ObjectList->{ $TemplateData->{Object} },
                FormatName      => $FormatList->{ $TemplateData->{Format} },
                ValidOptionStrg => $ValidOptionStrg,
            },
        );

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # template save
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateSave1' ) {
        my $TemplateData = {};

        # get params
        for my $Param (qw(TemplateID Object Format Name ValidID Comment)) {
            $TemplateData->{$Param} = $Self->{ParamObject}->GetParam( Param => $Param ) || '';
        }

        my %Submit = (
            SubmitNext => 'TemplateEdit2',
            Reload     => 'TemplateEdit1',
        );

        # get submit action
        my $Subaction = $Submit{Reload};

        PARAM:
        for my $SubmitKey ( keys %Submit ) {
            next PARAM if !$Self->{ParamObject}->GetParam( Param => $SubmitKey );

            $Subaction = $Submit{$SubmitKey};
            last PARAM;
        }

        # save to database
        my $Success;
        if ( $TemplateData->{TemplateID} eq 'NEW' ) {
            $TemplateData->{TemplateID} = $Self->{ImportExportObject}->TemplateAdd(
                %{$TemplateData},
                UserID => $Self->{UserID},
            );

            $Success = $TemplateData->{TemplateID};
        }
        else {
            $Success = $Self->{ImportExportObject}->TemplateUpdate(
                %{$TemplateData},
                UserID => $Self->{UserID},
            );
        }

        return $Self->{LayoutObject}->FatalError( Message => "Can't insert/update template!" )
            if !$Success;

        # redirect to overview object list
        return $Self->{LayoutObject}->Redirect(
            OP =>
                "Action=$Self->{Action}&Subaction=TemplateEdit2&TemplateID=$TemplateData->{TemplateID}",
        );
    }

    # ------------------------------------------------------------ #
    # template edit (object)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateEdit2' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # output list
        $Self->{LayoutObject}->Block(
            Name => 'TemplateEdit2',
            Data => {
                %{$TemplateData},
                ObjectName => $ObjectList->{ $TemplateData->{Object} },
            },
        );

        # get object attributes
        my $ObjectAttributeList = $Self->{ImportExportObject}->ObjectAttributesGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # get object data
        my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # output object attributes
        for my $Item ( @{$ObjectAttributeList} ) {

            # create form input
            my $InputString = $Self->{LayoutObject}->ImportExportFormInputCreate(
                Item  => $Item,
                Value => $ObjectData->{ $Item->{Key} },
            );

            # output attribute row
            $Self->{LayoutObject}->Block(
                Name => 'TemplateEdit2Row',
                Data => {
                    Name => $Item->{Name} || '',
                    InputStrg => $InputString,
                },
            );

            # output required notice
            if ( $Item->{Input}->{Required} ) {
                $Self->{LayoutObject}->Block(
                    Name => 'TemplateEdit2RowRequired',
                );
            }
        }

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # template save (object)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateSave2' ) {

        # get template id
        my $TemplateID = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        my %Submit = (
            SubmitNext => 'TemplateEdit3',
            SubmitBack => 'TemplateEdit1',
            Reload     => 'TemplateEdit2',
        );

        # get submit action
        my $Subaction = $Submit{Reload};

        PARAM:
        for my $SubmitKey ( keys %Submit ) {
            next PARAM if !$Self->{ParamObject}->GetParam( Param => $SubmitKey );

            $Subaction = $Submit{$SubmitKey};
            last PARAM;
        }

        # get object attributes
        my $ObjectAttributeList = $Self->{ImportExportObject}->ObjectAttributesGet(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # get attribute values from form
        my %AttributeValues;
        for my $Item ( @{$ObjectAttributeList} ) {

            # get form data
            $AttributeValues{ $Item->{Key} } = $Self->{LayoutObject}->ImportExportFormDataGet(
                Item => $Item,
            );

            # reload form if value is required
            if ( $Item->{Form}->{Invalid} ) {
                $Subaction = $Submit{Reload};
            }
        }

        # save the object data
        $Self->{ImportExportObject}->ObjectDataSave(
            TemplateID => $TemplateID,
            ObjectData => \%AttributeValues,
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->Redirect(
            OP => "Action=$Self->{Action}&Subaction=$Subaction&TemplateID=$TemplateID",
        );
    }

    # ------------------------------------------------------------ #
    # template edit (format)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateEdit3' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # output list
        $Self->{LayoutObject}->Block(
            Name => 'TemplateEdit3',
            Data => {
                %{$TemplateData},
                FormatName => $FormatList->{ $TemplateData->{Format} },
            },
        );

        # get format attributes
        my $FormatAttributeList = $Self->{ImportExportObject}->FormatAttributesGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # get format data
        my $FormatData = $Self->{ImportExportObject}->FormatDataGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # output format attributes
        for my $Item ( @{$FormatAttributeList} ) {

            # create form input
            my $InputString = $Self->{LayoutObject}->ImportExportFormInputCreate(
                Item  => $Item,
                Value => $FormatData->{ $Item->{Key} },
            );

            # output attribute row
            $Self->{LayoutObject}->Block(
                Name => 'TemplateEdit3Row',
                Data => {
                    Name => $Item->{Name} || '',
                    InputStrg => $InputString,
                },
            );

            # output required notice
            if ( $Item->{Input}->{Required} ) {
                $Self->{LayoutObject}->Block(
                    Name => 'TemplateEdit3RowRequired',
                );
            }
        }

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # template save (format)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateSave3' ) {

        # get template id
        my $TemplateID = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        my %Submit = (
            SubmitNext => 'TemplateEdit4',
            SubmitBack => 'TemplateEdit2',
            Reload     => 'TemplateEdit3',
        );

        # get submit action
        my $Subaction = $Submit{Reload};

        PARAM:
        for my $SubmitKey ( keys %Submit ) {
            next PARAM if !$Self->{ParamObject}->GetParam( Param => $SubmitKey );

            $Subaction = $Submit{$SubmitKey};
            last PARAM;
        }

        # get format attributes
        my $FormatAttributeList = $Self->{ImportExportObject}->FormatAttributesGet(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # get attribute values from form
        my %AttributeValues;
        for my $Item ( @{$FormatAttributeList} ) {

            # get form data
            $AttributeValues{ $Item->{Key} } = $Self->{LayoutObject}->ImportExportFormDataGet(
                Item => $Item,
            );

            # reload form if value is required
            if ( $Item->{Form}->{Invalid} ) {
                $Subaction = $Submit{Reload};
            }
        }

        # save the format data
        $Self->{ImportExportObject}->FormatDataSave(
            TemplateID => $TemplateID,
            FormatData => \%AttributeValues,
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->Redirect(
            OP => "Action=$Self->{Action}&Subaction=$Subaction&TemplateID=$TemplateID",
        );
    }

    # ------------------------------------------------------------ #
    # template edit (mapping)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateEdit4' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # output headline
        $Self->{LayoutObject}->Block(
            Name => 'TemplateEdit4',
            Data => {
                %{$TemplateData},
                ObjectName => $ObjectList->{ $TemplateData->{Object} },
                FormatName => $FormatList->{ $TemplateData->{Format} },
            },
        );

        # get mapping data list
        my $MappingList = $Self->{ImportExportObject}->MappingList(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # get object attributes
        my $MappingObjectAttributes = $Self->{ImportExportObject}->MappingObjectAttributesGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # get format attributes
        my $MappingFormatAttributes = $Self->{ImportExportObject}->MappingFormatAttributesGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        my $Counter = 0;
        for my $MappingID ( @{$MappingList} ) {

            # output attribute row
            $Self->{LayoutObject}->Block(
                Name => 'TemplateEdit4Row',
                Data => {
                    MappingID => $MappingID,
                },
            );

            # get mapping object data
            my $MappingObjectData = $Self->{ImportExportObject}->MappingObjectDataGet(
                MappingID => $MappingID,
                UserID    => $Self->{UserID},
            );

            # get mapping format data
            my $MappingFormatData = $Self->{ImportExportObject}->MappingFormatDataGet(
                MappingID => $MappingID,
                UserID    => $Self->{UserID},
            );

            for my $Item ( @{$MappingObjectAttributes} ) {

                # create form input
                my $InputString = $Self->{LayoutObject}->ImportExportFormInputCreate(
                    Item   => $Item,
                    Prefix => 'Object::' . $Counter . '::',
                    Value  => $MappingObjectData->{ $Item->{Key} },
                );

                # output attribute row
                $Self->{LayoutObject}->Block(
                    Name => 'TemplateEdit4RowObject',
                    Data => {
                        Name      => $Item->{Name},
                        InputStrg => $InputString,
                        Counter   => $Counter,
                    },
                );
            }

            for my $Item ( @{$MappingFormatAttributes} ) {

                # create form input
                my $InputString = $Self->{LayoutObject}->ImportExportFormInputCreate(
                    Item   => $Item,
                    Prefix => 'Format::' . $Counter . '::',
                    Value  => $MappingFormatData->{ $Item->{Key} },
                );

                # output attribute row
                $Self->{LayoutObject}->Block(
                    Name => 'TemplateEdit4RowFormat',
                    Data => {
                        Name      => $Item->{Name},
                        InputStrg => $InputString,
                        Counter   => $Counter,
                    },
                );
            }

            $Counter++;
        }

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # template save (mapping)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateSave4' ) {

        # get template id
        my $TemplateID = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        my %Submit = (
            SubmitNext => 'TemplateEdit5',
            SubmitBack => 'TemplateEdit3',
            Reload     => 'TemplateEdit4',
            MappingAdd => 'TemplateEdit4',
        );

        # get submit action
        my $Subaction    = $Submit{Reload};
        my $SubmitButton = '';

        PARAM:
        for my $SubmitKey ( keys %Submit ) {
            next PARAM if !$Self->{ParamObject}->GetParam( Param => $SubmitKey );

            $Subaction    = $Submit{$SubmitKey};
            $SubmitButton = $SubmitKey;
            last PARAM;
        }

        # get mapping data list
        my $MappingList = $Self->{ImportExportObject}->MappingList(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # get object attributes
        my $MappingObjectAttributes = $Self->{ImportExportObject}->MappingObjectAttributesGet(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # get format attributes
        my $MappingFormatAttributes = $Self->{ImportExportObject}->MappingFormatAttributesGet(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        my $Counter = 0;
        MAPPINGID:
        for my $MappingID ( @{$MappingList} ) {

            # get object attribute values
            my %ObjectAttributeValues;
            for my $Item ( @{$MappingObjectAttributes} ) {

                # get object form data
                $ObjectAttributeValues{ $Item->{Key} }
                    = $Self->{LayoutObject}->ImportExportFormDataGet(
                    Item   => $Item,
                    Prefix => 'Object::' . $Counter . '::',
                    );
            }

            # save the mapping object data
            $Self->{ImportExportObject}->MappingObjectDataSave(
                MappingID         => $MappingID,
                MappingObjectData => \%ObjectAttributeValues,
                UserID            => $Self->{UserID},
            );

            # get format attribute values
            my %FormatAttributeValues;
            for my $Item ( @{$MappingFormatAttributes} ) {

                # get format form data
                $FormatAttributeValues{ $Item->{Key} }
                    = $Self->{LayoutObject}->ImportExportFormDataGet(
                    Item   => $Item,
                    Prefix => 'Format::' . $Counter . '::',
                    );
            }

            # save the mapping format data
            $Self->{ImportExportObject}->MappingFormatDataSave(
                MappingID         => $MappingID,
                MappingFormatData => \%FormatAttributeValues,
                UserID            => $Self->{UserID},
            );

            $Counter++;
        }

        MAPPINGID:
        for my $MappingID ( @{$MappingList} ) {

            # delete this mapping row
            if ( $Self->{ParamObject}->GetParam( Param => "MappingDelete::$MappingID" ) ) {
                $Self->{ImportExportObject}->MappingDelete(
                    MappingID  => $MappingID,
                    TemplateID => $TemplateID,
                    UserID     => $Self->{UserID},
                );

                next MAPPINGID;
            }

            # move mapping data row up
            if ( $Self->{ParamObject}->GetParam( Param => "MappingUp::$MappingID" ) ) {
                $Self->{ImportExportObject}->MappingUp(
                    MappingID  => $MappingID,
                    TemplateID => $TemplateID,
                    UserID     => $Self->{UserID},
                );

                next MAPPINGID;
            }

            # move mapping data row down
            if ( $Self->{ParamObject}->GetParam( Param => "MappingDown::$MappingID" ) ) {
                $Self->{ImportExportObject}->MappingDown(
                    MappingID  => $MappingID,
                    TemplateID => $TemplateID,
                    UserID     => $Self->{UserID},
                );

                next MAPPINGID;
            }
        }

        # add a new mapping row
        if ( $SubmitButton eq 'MappingAdd' ) {
            $Self->{ImportExportObject}->MappingAdd(
                TemplateID => $TemplateID,
                UserID     => $Self->{UserID},
            );
        }

        return $Self->{LayoutObject}->Redirect(
            OP => "Action=$Self->{Action}&Subaction=$Subaction&TemplateID=$TemplateID",
        );
    }

    # ------------------------------------------------------------ #
    # template edit (search)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateEdit5' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # get search data
        my $SearchData = $Self->{ImportExportObject}->SearchDataGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # create rescrict export string
        my $RestrictExportStrg = $Self->{LayoutObject}->ImportExportFormInputCreate(
            Item => {
                Key   => 'RestrictExport',
                Input => {
                    Type => 'Checkbox',
                },
            },
            Value => scalar keys %{$SearchData},
        );

        # output list
        $Self->{LayoutObject}->Block(
            Name => 'TemplateEdit5',
            Data => {
                %{$TemplateData},
                RestrictExportStrg => $RestrictExportStrg,
            },
        );

        # get search attributes
        my $SearchAttributeList = $Self->{ImportExportObject}->SearchAttributesGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        # output object attributes
        for my $Item ( @{$SearchAttributeList} ) {

            # create form input
            my $InputString = $Self->{LayoutObject}->ImportExportFormInputCreate(
                Item  => $Item,
                Value => $SearchData->{ $Item->{Key} },
            );

            # output attribute row
            $Self->{LayoutObject}->Block(
                Name => 'TemplateEdit5Row',
                Data => {
                    Name => $Item->{Name} || '',
                    InputStrg => $InputString,
                },
            );
        }

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # template save (search)
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateSave5' ) {

        # get template id
        my $TemplateID = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        my %Submit = (
            SubmitNext => 'Overview',
            SubmitBack => 'TemplateEdit4',
            Reload     => 'TemplateEdit5',
        );

        # get submit action
        my $Subaction = $Submit{Reload};

        PARAM:
        for my $SubmitKey ( keys %Submit ) {
            next PARAM if !$Self->{ParamObject}->GetParam( Param => $SubmitKey );

            $Subaction = $Submit{$SubmitKey};
            last PARAM;
        }

        # delete all search restrictions
        if ( !$Self->{ParamObject}->GetParam( Param => 'RestrictExport' ) ) {

            # delete all search data
            $Self->{ImportExportObject}->SearchDataDelete(
                TemplateID => $TemplateID,
                UserID     => $Self->{UserID},
            );

            return $Self->{LayoutObject}->Redirect(
                OP => "Action=$Self->{Action}&Subaction=$Subaction&TemplateID=$TemplateID",
            );
        }

        # get search attributes
        my $SearchAttributeList = $Self->{ImportExportObject}->SearchAttributesGet(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # get attribute values from form
        my %AttributeValues;
        for my $Item ( @{$SearchAttributeList} ) {

            # get form data
            $AttributeValues{ $Item->{Key} } = $Self->{LayoutObject}->ImportExportFormDataGet(
                Item => $Item,
            );

            # reload form if value is required
            if ( $Item->{Form}->{Invalid} ) {
                $Subaction = $Submit{Reload};
            }
        }

        # save the search data
        $Self->{ImportExportObject}->SearchDataSave(
            TemplateID => $TemplateID,
            SearchData => \%AttributeValues,
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->Redirect(
            OP => "Action=$Self->{Action}&Subaction=$Subaction&TemplateID=$TemplateID",
        );
    }

    # ------------------------------------------------------------ #
    # template delete
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TemplateDelete' ) {

        # get template id
        my $TemplateID = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # delete template from database
        $Self->{ImportExportObject}->TemplateDelete(
            TemplateID => $TemplateID,
            UserID     => $Self->{UserID},
        );

        # redirect to overview
        return $Self->{LayoutObject}->Redirect( OP => "Action=$Self->{Action}" );
    }

    # ------------------------------------------------------------ #
    # import information
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ImportInformation' ) {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            SelectedID   => $TemplateData->{Object},
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            SelectedID   => $TemplateData->{Format},
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # output list
        $Self->{LayoutObject}->Block(
            Name => 'ImportInformation',
            Data => {
                %{$TemplateData},
            },
        );

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # import
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Import' ) {

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # get source file
        my %SourceFile = $Self->{ParamObject}->GetUploadAll(
            Param  => 'SourceFile',
            Source => 'String',
        );

        $SourceFile{Content} ||= '';

        # import data
        my $Result = $Self->{ImportExportObject}->Import(
            TemplateID    => $TemplateData->{TemplateID},
            SourceContent => \$SourceFile{Content},
            UserID        => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError(
            Message => 'Error occurred. Import impossible! See Syslog for details.',
        ) if !$Result;

        return $Self->{LayoutObject}->Redirect(
            OP =>
                "Action=$Self->{Action}&Subaction=Overview&TemplateID=$TemplateData->{TemplateID}",
        );
    }

    # ------------------------------------------------------------ #
    # export
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Export' ) {

        # get params
        my $TemplateData = {};
        $TemplateData->{TemplateID} = $Self->{ParamObject}->GetParam( Param => 'TemplateID' );

        # get template data
        $TemplateData = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError( Message => 'Template not found!' )
            if !$TemplateData->{TemplateID};

        # export data
        my $Result = $Self->{ImportExportObject}->Export(
            TemplateID => $TemplateData->{TemplateID},
            UserID     => $Self->{UserID},
        );

        return $Self->{LayoutObject}->FatalError(
            Message => 'Error occurred. Export impossible! See Syslog for details.',
        ) if !$Result;

        my $FileContent = join "\n", @{ $Result->{DestinationContent} };

        return $Self->{LayoutObject}->Attachment(
            Type        => 'attachment',
            Filename    => 'Export.csv',
            ContentType => 'text/csv',
            Content     => $FileContent,
        );
    }

    # ------------------------------------------------------------ #
    # overview
    # ------------------------------------------------------------ #
    else {

        # get object list
        my $ObjectList = $Self->{ImportExportObject}->ObjectList();

        return $Self->{LayoutObject}->FatalError( Message => 'No object backend found!' )
            if !$ObjectList;

        # get format list
        my $FormatList = $Self->{ImportExportObject}->FormatList();

        return $Self->{LayoutObject}->FatalError( Message => 'No format backend found!' )
            if !$FormatList;

        # generate ObjectOptionStrg
        my $ObjectOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $ObjectList,
            Name         => 'Object',
            PossibleNone => 1,
            Translation  => 1,
        );

        # generate FormatOptionStrg
        my $FormatOptionStrg = $Self->{LayoutObject}->BuildSelection(
            Data         => $FormatList,
            Name         => 'Format',
            PossibleNone => 1,
            Translation  => 1,
        );

        # output overview
        $Self->{LayoutObject}->Block(
            Name => 'Overview',
            Data => {
                %Param,
                ObjectOptionStrg => $ObjectOptionStrg,
                FormatOptionStrg => $FormatOptionStrg,
            },
        );

        # get valid list
        my %ValidList = $Self->{ValidObject}->ValidList();

        my $EmptyDatabase = 1;

        CLASS:
        for my $Object ( sort { $ObjectList->{$a} cmp $ObjectList->{$b} } keys %{$ObjectList} ) {

            # get template list
            my $TemplateList = $Self->{ImportExportObject}->TemplateList(
                Object => $Object,
                UserID => $Self->{UserID},
            );

            next CLASS if !$TemplateList;
            next CLASS if ref $TemplateList ne 'ARRAY';
            next CLASS if !@{$TemplateList};

            $EmptyDatabase = 0;

            # output list
            $Self->{LayoutObject}->Block(
                Name => 'OverviewList',
                Data => {
                    ObjectName => $ObjectList->{$Object},
                },
            );

            my $CssClass = '';
            for my $TemplateID ( @{$TemplateList} ) {

                # set output object
                $CssClass = $CssClass eq 'searchactive' ? 'searchpassive' : 'searchactive';

                # get template data
                my $TemplateData = $Self->{ImportExportObject}->TemplateGet(
                    TemplateID => $TemplateID,
                    UserID     => $Self->{UserID},
                );

                # output row
                $Self->{LayoutObject}->Block(
                    Name => 'OverviewListRow',
                    Data => {
                        %{$TemplateData},
                        FormatName => $FormatList->{ $TemplateData->{Format} },
                        CssClass   => $CssClass,
                        Valid      => $ValidList{ $TemplateData->{ValidID} },
                    },
                );
            }
        }

        # output an empty list
        if ($EmptyDatabase) {

            # output list
            $Self->{LayoutObject}->Block(
                Name => 'OverviewList',
                Data => {
                    ObjectName => 'Template',
                },
            );
        }

        # output header and navbar
        my $Output = $Self->{LayoutObject}->Header();
        $Output .= $Self->{LayoutObject}->NavigationBar();

        # start template output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminImportExport',
            Data         => \%Param,
        );

        $Output .= $Self->{LayoutObject}->Footer();
        return $Output;
    }
}

1;

IyAtLQojIEtlcm5lbC9PdXRwdXQvSFRNTC9JbXBvcnRFeHBvcnRMYXlvdXRDaGVja2JveC5wbSAtIGxheW91dCBiYWNrZW5kIG1vZHVsZQojIENvcHlyaWdodCAoQykgMjAwMS0yMDA4IE9UUlMgQUcsIGh0dHA6Ly9vdHJzLm9yZy8KIyAtLQojICRJZDogSW1wb3J0RXhwb3J0TGF5b3V0Q2hlY2tib3gucG0sdiAxLjMgMjAwOC8wNC8wNCAxMDoyMTo1OSBtaCBFeHAgJAojIC0tCiMgVGhpcyBzb2Z0d2FyZSBjb21lcyB3aXRoIEFCU09MVVRFTFkgTk8gV0FSUkFOVFkuIEZvciBkZXRhaWxzLCBzZWUKIyB0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChHUEwpLiBJZiB5b3UKIyBkaWQgbm90IHJlY2VpdmUgdGhpcyBmaWxlLCBzZWUgaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAudHh0LgojIC0tCgpwYWNrYWdlIEtlcm5lbDo6T3V0cHV0OjpIVE1MOjpJbXBvcnRFeHBvcnRMYXlvdXRDaGVja2JveDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSB2YXJzIHF3KCRWRVJTSU9OKTsKJFZFUlNJT04gPSBxdygkUmV2aXNpb246IDEuMyAkKSBbMV07Cgo9aGVhZDEgTkFNRQoKS2VybmVsOjpPdXRwdXQ6OkhUTUw6OkltcG9ydEV4cG9ydExheW91dENoZWNrYm94IC0gbGF5b3V0IGJhY2tlbmQgbW9kdWxlCgo9aGVhZDEgU1lOT1BTSVMKCkFsbCBsYXlvdXQgZnVuY3Rpb25zIGZvciBjaGVja2JveCBlbGVtZW50cwoKPW92ZXIgNAoKPWN1dAoKPWl0ZW0gbmV3KCkKCmNyZWF0ZSBhbiBvYmplY3QKCiAgICAkQmFja2VuZE9iamVjdCA9IEtlcm5lbDo6T3V0cHV0OjpIVE1MOjpJbXBvcnRFeHBvcnRMYXlvdXRDaGVja2JveC0+bmV3KAogICAgICAgICVQYXJhbSwKICAgICk7Cgo9Y3V0CgpzdWIgbmV3IHsKICAgIG15ICggJFR5cGUsICVQYXJhbSApID0gQF87CgogICAgIyBhbGxvY2F0ZSBuZXcgaGFzaCBmb3Igb2JqZWN0CiAgICBteSAkU2VsZiA9IHt9OwogICAgYmxlc3MoICRTZWxmLCAkVHlwZSApOwoKICAgICMgY2hlY2sgbmVlZGVkIG9iamVjdHMKICAgIGZvciBteSAkT2JqZWN0IChxdyhDb25maWdPYmplY3QgTG9nT2JqZWN0IE1haW5PYmplY3QgUGFyYW1PYmplY3QgTGF5b3V0T2JqZWN0KSkgewogICAgICAgICRTZWxmLT57JE9iamVjdH0gPSAkUGFyYW17JE9iamVjdH0gfHwgZGllICJHb3Qgbm8gJE9iamVjdCEiOwogICAgfQoKICAgIHJldHVybiAkU2VsZjsKfQoKPWl0ZW0gRm9ybUlucHV0Q3JlYXRlKCkKCmNyZWF0ZSBhIGlucHV0IHN0cmluZwoKICAgIG15ICRWYWx1ZSA9ICRCYWNrZW5kT2JqZWN0LT5Gb3JtSW5wdXRDcmVhdGUoCiAgICAgICAgSXRlbSAgID0+ICRJdGVtUmVmLAogICAgICAgIFByZWZpeCA9PiAnUHJlZml4OjonLCAgIyAob3B0aW9uYWwpCiAgICAgICAgVmFsdWUgID0+ICdWYWx1ZScsICAgICAjIChvcHRpb25hbCkKICAgICk7Cgo9Y3V0CgpzdWIgRm9ybUlucHV0Q3JlYXRlIHsKICAgIG15ICggJFNlbGYsICVQYXJhbSApID0gQF87CgogICAgIyBjaGVjayBuZWVkZWQgc3R1ZmYKICAgIGlmICggISRQYXJhbXtJdGVtfSApIHsKICAgICAgICAkU2VsZi0+e0xvZ09iamVjdH0tPkxvZyggUHJpb3JpdHkgPT4gJ2Vycm9yJywgTWVzc2FnZSA9PiAnTmVlZCBJdGVtIScgKTsKICAgICAgICByZXR1cm47CiAgICB9CgogICAgJFBhcmFte1ByZWZpeH0gfHw9ICcnOwoKICAgIG15ICRTdHJpbmcgPSAiPGlucHV0IHR5cGU9XCJjaGVja2JveFwiIG5hbWU9XCIkUGFyYW17UHJlZml4fSRQYXJhbXtJdGVtfS0+e0tleX1cIiAiOwoKICAgIGlmICggJFBhcmFte1ZhbHVlfSApIHsKICAgICAgICAkU3RyaW5nIC49ICJjaGVja2VkICI7CiAgICB9CgogICAgJFN0cmluZyAuPSAiPiAiOwoKICAgIHJldHVybiAkU3RyaW5nOwp9Cgo9aXRlbSBGb3JtRGF0YUdldCgpCgpnZXQgZm9ybSBkYXRhCgogICAgbXkgJEZvcm1EYXRhID0gJEJhY2tlbmRPYmplY3QtPkZvcm1EYXRhR2V0KAogICAgICAgIEl0ZW0gICA9PiAkSXRlbVJlZiwKICAgICAgICBQcmVmaXggPT4gJ1ByZWZpeDo6JywgICMgKG9wdGlvbmFsKQogICAgKTsKCj1jdXQKCnN1YiBGb3JtRGF0YUdldCB7CiAgICBteSAoICRTZWxmLCAlUGFyYW0gKSA9IEBfOwoKICAgICMgY2hlY2sgbmVlZGVkIHN0dWZmCiAgICBpZiAoICEkUGFyYW17SXRlbX0gKSB7CiAgICAgICAgJFNlbGYtPntMb2dPYmplY3R9LT5Mb2coIFByaW9yaXR5ID0+ICdlcnJvcicsIE1lc3NhZ2UgPT4gJ05lZWQgSXRlbSEnICk7CiAgICAgICAgcmV0dXJuOwogICAgfQoKICAgICRQYXJhbXtQcmVmaXh9IHx8PSAnJzsKCiAgICAjIGdldCBmb3JtIGRhdGEKICAgIG15ICRGb3JtRGF0YSA9ICRTZWxmLT57UGFyYW1PYmplY3R9LT5HZXRQYXJhbSgKICAgICAgICBQYXJhbSA9PiAkUGFyYW17UHJlZml4fSAuICRQYXJhbXtJdGVtfS0+e0tleX0sCiAgICApOwoKICAgIHJldHVybiAkRm9ybURhdGE7Cn0KCjE7Cgo9YmFjawoKPWhlYWQxIFRFUk1TIEFORCBDT05ESVRJT05TCgpUaGlzIHNvZnR3YXJlIGlzIHBhcnQgb2YgdGhlIE9UUlMgcHJvamVjdCAoaHR0cDovL290cnMub3JnLykuCgpUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQp0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChHUEwpLiBJZiB5b3UKZGlkIG5vdCByZWNlaXZlIHRoaXMgZmlsZSwgc2VlIGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy9ncGwtMi4wLnR4dC4KCj1jdXQKCj1oZWFkMSBWRVJTSU9OCgokUmV2aXNpb246IDEuMyAkICREYXRlOiAyMDA4LzA0LzA0IDEwOjIxOjU5ICQKCj1jdXQK
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
# --
# AdminImportExport.dtl - provides HTML form for AdminImportExport
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: AdminImportExport.dtl,v 1.15 2008/02/12 10:31:43 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

<!-- dtl:block:Overview -->
<table border="0" width="100%" cellspacing="0" cellpadding="3">
  <tr>
    <td colspan="2" class="mainhead">
      $Env{"Box0"}$Text{"Import/Export Management"}$Env{"Box1"}
    </td>
  </tr>
  <tr>
    <td width="30%" class="mainbody">
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateEdit1">
        <input type="hidden" name="TemplateID" value="NEW">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Add mapping template"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table>
                <tr>
                  <td class="contentkey" width="100">$Text{"Object"}: </td>
                  <td class="contentvalue">$Data{"ObjectOptionStrg"}</td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Format"}: </td>
                  <td class="contentvalue">$Data{"FormatOptionStrg"}</td>
                </tr>
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Add"}">
            </td>
          </tr>
        </table>
      </form>
    </td>
    <td width="70%" class="mainbody">
<!-- dtl:block:OverviewList -->
      <table width="100%" cellspacing="0" cellpadding="4">
        <tr>
          <td class="contenthead">$Text{"$QData{"ObjectName"}"}:</td>
        </tr>
        <tr>
          <td class="contentbody">
            <table width="100%" border="0" cellspacing="0" cellpadding="3">
              <tr>
                <td class="contentkey">$Text{"Number"}</td>
                <td class="contentkey">$Text{"Name"}</td>
                <td class="contentkey">$Text{"Format"}</td>
                <td align="center" class="contentkey">$Text{"valid"}/$Text{"invalid"}</td>
                <td align="center" class="contentkey" width="90">$Text{"Delete"}</td>
                <td align="center" class="contentkey" width="90">$Text{"Start Import"}</td>
                <td align="center" class="contentkey" width="90">$Text{"Start Export"}</td>
              </tr>
<!-- dtl:block:OverviewListRow -->
              <tr>
                <td class="$QData{"CssClass"}">
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=TemplateEdit1&TemplateID=$QData{"TemplateID"}">
                  $QData{"Number"}
                  </a>
                </td>
                <td class="$QData{"CssClass"}">$QData{"Name"}</td>
                <td class="$QData{"CssClass"}">$Text{"$QData{"FormatName"}"}</td>
                <td align="center" class="$QData{"CssClass"}">$Text{"$QData{"Valid"}"}</td>
                <td align="center" class="$QData{"CssClass"}">
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=TemplateDelete&TemplateID=$QData{"TemplateID"}">
                  $Text{"x"}
                  </a>
                </td>
                <td align="center" class="$QData{"CssClass"}">
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=ImportInformation&TemplateID=$QData{"TemplateID"}">
                  $Text{"x"}
                  </a>
                </td>
                <td align="center" class="$QData{"CssClass"}">
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=Export&TemplateID=$QData{"TemplateID"}">
                  $Text{"x"}
                  </a>
                </td>
              </tr>
<!-- dtl:block:OverviewListRow -->
            </table>
            <br>
          </td>
        </tr>
        <tr>
          <td class="contentfooter">
            &nbsp;
          </td>
        </tr>
      </table>
      <br>
<!-- dtl:block:OverviewList -->
<!-- dtl:block:TemplateEdit1 -->
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateSave1">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Step"} 1 $Text{"of"} 5 - $Text{"Edit common information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">
                    <input type="text" name="Name" value="$QData{"Name"}" size="45" maxlength="200">
                  </td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Object"}: </td>
                  <td class="contentvalue">
                    $QData{"ObjectName"}
                    <input type="hidden" name="Object" value="$QData{"Object"}">
                  </td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Format"}: </td>
                  <td class="contentvalue">
                    $QData{"FormatName"}
                    <input type="hidden" name="Format" value="$QData{"Format"}">
                  </td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Valid"}: </td>
                  <td class="contentvalue">$Data{"ValidOptionStrg"}</td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Comment"}: </td>
                  <td class="contentvalue">
                    <input type="text" name="Comment" value="$QData{"Comment"}" size="50" maxlength="200">
                  </td>
                </tr>
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" name="SubmitNext" value="$Text{"Next..."}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:TemplateEdit1 -->
<!-- dtl:block:TemplateEdit2 -->
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateSave2">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Step"} 2 $Text{"of"} 5 - $Text{"Edit object information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">$QData{"Name"}</td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Object"}: </td>
                  <td class="contentvalue">$QData{"ObjectName"}</td>
                </tr>
<!-- dtl:block:TemplateEdit2Row -->
                <tr>
                  <td class="contentkey">$Text{"$QData{"Name"}"}:
<!-- dtl:block:TemplateEdit2RowRequired -->
                    <font color="red" title="$Text{"Required"}">*</font>
<!-- dtl:block:TemplateEdit2RowRequired -->
                    &nbsp;
                  </td>
                  <td class="contentvalue">$Data{"InputStrg"}</td>
                </tr>
<!-- dtl:block:TemplateEdit2Row -->
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" name="SubmitBack" value="$Text{"...Back"}">&nbsp;
              <input class="button" type="submit" name="SubmitNext" value="$Text{"Next..."}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:TemplateEdit2 -->
<!-- dtl:block:TemplateEdit3 -->
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateSave3">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Step"} 3 $Text{"of"} 5 - $Text{"Edit format information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">$QData{"Name"}</td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Format"}: </td>
                  <td class="contentvalue">$QData{"FormatName"}</td>
                </tr>
<!-- dtl:block:TemplateEdit3Row -->
                <tr>
                  <td class="contentkey">$Text{"$QData{"Name"}"}:
<!-- dtl:block:TemplateEdit3RowRequired -->
                    <font color="red" title="$Text{"Required"}">*</font>
<!-- dtl:block:TemplateEdit3RowRequired -->
                    &nbsp;
                  </td>
                  <td class="contentvalue">$Data{"InputStrg"}</td>
                </tr>
<!-- dtl:block:TemplateEdit3Row -->
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" name="SubmitBack" value="$Text{"...Back"}">&nbsp;
              <input class="button" type="submit" name="SubmitNext" value="$Text{"Next..."}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:TemplateEdit3 -->
<!-- dtl:block:TemplateEdit4 -->
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateSave4">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Step"} 4 $Text{"of"} 5 - $Text{"Edit mapping information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">$QData{"Name"}</td>
                </tr>
              </table>
              <br>
              <table border="0" cellspacing="0" cellpadding="2" width="100%">
                <tr>
                  <td class="contentkey">$QData{"ObjectName"}</td>
                  <td class="contentkey">$QData{"FormatName"}</td>
                  <td class="contentkey">&nbsp;</td>
                </tr>
                <br>
                <tr>
                  <td class="contentvalue" colspan="3"><hr width="100%"></td>
                </tr>
<!-- dtl:block:TemplateEdit4Row -->
                <tr>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="3">
<!-- dtl:block:TemplateEdit4RowObject -->
                      <tr>
                        <td class="contentkey">$Text{"$QData{"Name"}"}: </td>
                        <td class="contentvalue">$Data{"InputStrg"}</td>
                      </tr>
<!-- dtl:block:TemplateEdit4RowObject -->
                    </table>
                  </td>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="3">
<!-- dtl:block:TemplateEdit4RowFormat -->
                      <tr>
                        <td class="contentkey">$Text{"$QData{"Name"}"}: </td>
                        <td class="contentvalue">$Data{"InputStrg"}</td>
                      </tr>
<!-- dtl:block:TemplateEdit4RowFormat -->
                    </table>
                  </td>
                  <td align="right">
                    <input class="button" type="submit" name="MappingUp::$QData{"MappingID"}" value="$Text{"Up"}">
                    <input class="button" type="submit" name="MappingDown::$QData{"MappingID"}" value="$Text{"Down"}">
                    &nbsp;&nbsp;&nbsp;
                    <input class="button" type="submit" name="MappingDelete::$QData{"MappingID"}" value="$Text{"Delete"}">
                  </td>
                </tr>
                <tr>
                  <td class="contentvalue" colspan="3"><hr width="100%"></td>
                </tr>
<!-- dtl:block:TemplateEdit4Row -->
                <tr>
                  <td class="contentvalue" colspan="3">
                    <input class="button" type="submit" name="MappingAdd" value="$Text{"Add"}">
                  </td>
                </tr>
              </table>
              <br>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" name="SubmitBack" value="$Text{"...Back"}">&nbsp;
              <input class="button" type="submit" name="SubmitNext" value="$Text{"Next..."}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:TemplateEdit4 -->
<!-- dtl:block:TemplateEdit5 -->
      <form action="$Env{"CGIHandle"}" method="get">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="TemplateSave5">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Step"} 5 $Text{"of"} 5 - $Text{"Edit search information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">$QData{"Name"}</td>
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Restrict export per search"}: </td>
                  <td class="contentvalue">$Data{"RestrictExportStrg"}</td>
                </tr>
              </table>
            </td>
          </tr>
          <tr>
            <td class="contenthead">&nbsp;</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
<!-- dtl:block:TemplateEdit5Row -->
                <tr>
                  <td class="contentkey">$Text{"$QData{"Name"}"}:
                    &nbsp;
                  </td>
                  <td class="contentvalue">$Data{"InputStrg"}</td>
                </tr>
<!-- dtl:block:TemplateEdit5Row -->
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" name="SubmitBack" value="$Text{"...Back"}">&nbsp;
              <input class="button" type="submit" name="SubmitNext" value="$Text{"Finish"}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:TemplateEdit5 -->
<!-- dtl:block:ImportInformation -->
      <form action="$Env{"CGIHandle"}" method="post" enctype="multipart/form-data">
        <input type="hidden" name="Action" value="$Env{"Action"}">
        <input type="hidden" name="Subaction" value="Import">
        <input type="hidden" name="TemplateID" value="$QData{"TemplateID"}">
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Import information"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey" width="150">$Text{"Name"}: </td>
                  <td class="contentvalue">$QData{"Name"}</td>
                </tr>
                <tr>
                  <td class="contentkey" width="150">$Text{"Source File"}: </td>
                  <td class="contentvalue">
                    <input type="file" name="SourceFile" size="40" class="fixed">
                  </td>
                </tr>
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Start Import"}">
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:ImportInformation -->
    </td>
  </tr>
</table>
<!-- dtl:block:Overview -->

# --
# Kernel/System/ImportExport.pm - all import and export functions
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: ImportExport.pm,v 1.26 2008/04/17 11:29:04 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ImportExport;

use strict;
use warnings;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.26 $) [1];

=head1 NAME

Kernel::System::ImportExport - import, export lib

=head1 SYNOPSIS

All import and export functions.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::DB;
    use Kernel::System::ImportExport;
    use Kernel::System::Log;
    use Kernel::System::Main;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ImportExportObject = Kernel::System::ImportExport->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
        EncodeObject => $EncodeObject,
    );

=cut

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {};
    bless( $Self, $Type );

    # check needed objects
    for my $Object (qw(ConfigObject LogObject DBObject MainObject EncodeObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    return $Self;
}

=item TemplateList()

return a list of templates as array reference

    my $TemplateList = $ImportExportObject->TemplateList(
        Object => 'Ticket',  # (optional)
        Format => 'CSV'      # (optional)
        UserID => 1,
    );

=cut

sub TemplateList {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    if ( !$Param{UserID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need UserID!',
        );
        return;
    }

    # quote
    for my $Argument (qw(Object Format)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument} ) || '';
    }
    $Param{UserID} = $Self->{DBObject}->Quote( $Param{UserID}, 'Integer' );

    # create sql string
    my $SQL = 'SELECT id FROM imexport_template WHERE 1=1 ';

    if ( $Param{Object} ) {
        $SQL .= "AND imexport_object = '$Param{Object}' ";
    }
    if ( $Param{Format} ) {
        $SQL .= "AND imexport_format = '$Param{Format}' ";
    }

    # add order option
    $SQL .= 'ORDER BY id';

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my @TemplateList;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        push @TemplateList, $Row[0];
    }

    return \@TemplateList;
}

=item TemplateGet()

get a import export template

Return
    $TemplateData{TemplateID}
    $TemplateData{Number}
    $TemplateData{Object}
    $TemplateData{Format}
    $TemplateData{Name}
    $TemplateData{ValidID}
    $TemplateData{Comment}
    $TemplateData{CreateTime}
    $TemplateData{CreateBy}
    $TemplateData{ChangeTime}
    $TemplateData{ChangeBy}

    my $TemplateDataRef = $ImportExportObject->TemplateGet(
        TemplateID => 3,
        UserID     => 1,
    );

=cut

sub TemplateGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{TemplateID} = $Self->{DBObject}->Quote( $Param{TemplateID}, 'Integer' );

    # check if result is already cached
    return $Self->{Cache}->{TemplateGet}->{ $Param{TemplateID} }
        if $Self->{Cache}->{TemplateGet}->{ $Param{TemplateID} };

    # create sql string
    my $SQL = "SELECT id, imexport_object, imexport_format, name, valid_id, comments, "
        . "create_time, create_by, change_time, change_by FROM imexport_template WHERE "
        . "id = $Param{TemplateID}";

    # ask database
    $Self->{DBObject}->Prepare(
        SQL   => $SQL,
        Limit => 1,
    );

    # fetch the result
    my %TemplateData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $TemplateData{TemplateID} = $Row[0];
        $TemplateData{Object}     = $Row[1];
        $TemplateData{Format}     = $Row[2];
        $TemplateData{Name}       = $Row[3];
        $TemplateData{ValidID}    = $Row[4];
        $TemplateData{Comment}    = $Row[5] || '';
        $TemplateData{CreateTime} = $Row[6];
        $TemplateData{CreateBy}   = $Row[7];
        $TemplateData{ChangeTime} = $Row[8];
        $TemplateData{ChangeBy}   = $Row[9];

        $TemplateData{Number} = sprintf "%06d", $TemplateData{TemplateID};
    }

    # cache the result
    $Self->{Cache}->{TemplateGet}->{ $Param{TemplateID} } = \%TemplateData;

    return \%TemplateData;
}

=item TemplateAdd()

add a new import/export template

    my $TemplateID = $ImportExportObject->TemplateAdd(
        Object  => 'Ticket',
        Format  => 'CSV',
        Name    => 'Template Name',
        ValidID => 1,
        Comment => 'Comment',       # (optional)
        UserID  => 1,
    );

=cut

sub TemplateAdd {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(Object Format Name ValidID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # set default values
    $Param{Comment} = $Param{Comment} || '';

    # quote
    for my $Argument (qw(Object Format Name Functionality Comment)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument} );
    }
    for my $Argument (qw(ValidID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    # cleanup given params (replace it with StringClean() in OTRS 2.3 and later)
    for my $Argument (qw(Object Format)) {
        $Self->_StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
            RemoveAllSpaces   => 1,
        );
    }
    for my $Argument (qw(Name Comment)) {
        $Self->_StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # find exiting template with same name
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id FROM imexport_template "
            . "WHERE imexport_object = '$Param{Object}' AND name = '$Param{Name}'",
        Limit => 1,
    );

    # fetch the result
    my $NoAdd;
    while ( $Self->{DBObject}->FetchrowArray() ) {
        $NoAdd = 1;
    }

    # abort insert of new template, if template name already exists
    if ($NoAdd) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Can't add new template! Template with same name already exists in this object.",
        );
        return;
    }

    # insert new template
    return if !$Self->{DBObject}->Do(
        SQL => "INSERT INTO imexport_template "
            . "(imexport_object, imexport_format, name, valid_id, comments, "
            . "create_time, create_by, change_time, change_by) VALUES "
            . "('$Param{Object}', '$Param{Format}', "
            . "'$Param{Name}', $Param{ValidID}, '$Param{Comment}', "
            . "current_timestamp, $Param{UserID}, current_timestamp, $Param{UserID})"
    );

    # find id of new template
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id FROM imexport_template "
            . "WHERE imexport_object = '$Param{Object}' AND name = '$Param{Name}'",
        Limit => 1,
    );

    # fetch the result
    my $TemplateID;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $TemplateID = $Row[0];
    }

    return $TemplateID;
}

=item TemplateUpdate()

update a existing import/export template

    my $True = $ImportExportObject->TemplateUpdate(
        TemplateID => 123,
        Name       => 'Template Name',
        ValidID    => 1,
        Comment    => 'Comment',        # (optional)
        UserID     => 1,
    );

=cut

sub TemplateUpdate {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID Name ValidID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # set default values
    $Param{Comment} = $Param{Comment} || '';

    # quote
    for my $Argument (qw(Name Comment)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument} );
    }
    for my $Argument (qw(TemplateID ValidID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    # cleanup given params (replace it with StringClean() in OTRS 2.3 and later)
    for my $Argument (qw(Name Comment)) {
        $Self->_StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # get the object of this template id
    $Self->{DBObject}->Prepare(
        SQL => "SELECT imexport_object FROM imexport_template "
            . "WHERE id = $Param{TemplateID}",
        Limit => 1,
    );

    # fetch the result
    my $Object;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $Object = $Row[0];
    }

    if ( !$Object ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Can't update template! I can't find the template.",
        );
        return;
    }

    # find exiting template with same name
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id FROM imexport_template "
            . "WHERE imexport_object = '$Object' AND name = '$Param{Name}'",
        Limit => 1,
    );

    # fetch the result
    my $Update = 1;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        if ( $Param{TemplateID} ne $Row[0] ) {
            $Update = 0;
        }
    }

    if ( !$Update ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Can't update template! Template with same name already exists in this object.",
        );
        return;
    }

    # reset cache
    delete $Self->{Cache}->{TemplateGet}->{ $Param{TemplateID} };

    # update template
    return $Self->{DBObject}->Do(
        SQL => "UPDATE imexport_template SET name = '$Param{Name}',"
            . "valid_id = $Param{ValidID}, comments = '$Param{Comment}', "
            . "change_time = current_timestamp, change_by = $Param{UserID} "
            . "WHERE id = $Param{TemplateID}",
    );
}

=item TemplateDelete()

delete existing import/export templates

    my $True = $ImportExportObject->TemplateDelete(
        TemplateID => 123,
        UserID     => 1,
    );

    or

    my $True = $ImportExportObject->TemplateDelete(
        TemplateID => [1,44,166,5],
        UserID     => 1,
    );

=cut

sub TemplateDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{TemplateID} ) {
        $Param{TemplateID} = [ $Param{TemplateID} ];
    }
    elsif ( ref $Param{TemplateID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'TemplateID must be an array reference or a string!',
        );
        return;
    }

    # delete existing search data
    $Self->SearchDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # delete all mapping data
    for my $TemplateID ( @{ $Param{TemplateID} } ) {
        $Self->MappingDelete(
            TemplateID => $TemplateID,
            UserID     => $Param{UserID},
        );
    }

    # delete existing format data
    $Self->FormatDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # delete existing object data
    $Self->ObjectDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # quote
    for my $TemplateID ( @{ $Param{TemplateID} } ) {
        $TemplateID = $Self->{DBObject}->Quote( $TemplateID, 'Integer' );
    }

    # create the template id string
    my $TemplateIDString = join ',', @{ $Param{TemplateID} };

    # reset cache
    delete $Self->{Cache}->{TemplateGet};

    # delete templates
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_template WHERE id IN ( $TemplateIDString )",
    );
}

=item ObjectList()

return a list of available objects as hash reference

    my $ObjectList = $ImportExportObject->ObjectList();

=cut

sub ObjectList {
    my ( $Self, %Param ) = @_;

    # get config
    my $ModuleList = $Self->{ConfigObject}->Get('ImportExport::ObjectBackendRegistration');

    return if !$ModuleList;
    return if ref $ModuleList ne 'HASH';

    # create the object list
    my $ObjectList = {};
    for my $Module ( sort keys %{$ModuleList} ) {
        $ObjectList->{$Module} = $ModuleList->{$Module}->{Name};
    }

    return $ObjectList;
}

=item ObjectAttributesGet()

get the attributes of an object backend as array/hash reference

    my $Attributes = $ImportExportObject->ObjectAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub ObjectAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Object} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load backend
    my $Backend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::ObjectBackend::$TemplateData->{Object}",
    );

    return if !$Backend;

    # get an attribute list of the object
    my $Attributes = $Backend->ObjectAttributesGet(
        %Param,
        UserID => $Param{UserID},
    );

    return $Attributes;
}

=item ObjectDataGet()

get the object data from a template

    my $ObjectDataRef = $ImportExportObject->ObjectDataGet(
        TemplateID => 3,
        UserID     => 1,
    );

=cut

sub ObjectDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{TemplateID} = $Self->{DBObject}->Quote( $Param{TemplateID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT data_key, data_value FROM imexport_object WHERE "
        . "template_id = $Param{TemplateID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my %ObjectData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $ObjectData{ $Row[0] } = $Row[1];
    }

    return \%ObjectData;
}

=item ObjectDataSave()

save the object data of a template

    my $True = $ImportExportObject->ObjectDataSave(
        TemplateID => 123,
        ObjectData => $HashRef,
        UserID     => 1,
    );

=cut

sub ObjectDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID ObjectData UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( ref $Param{ObjectData} ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'ObjectData must be an hash reference!',
        );
        return;
    }

    # delete existing object data
    $Self->ObjectDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    DATAKEY:
    for my $DataKey ( keys %{ $Param{ObjectData} } ) {

        # quote
        my $QDataKey   = $Self->{DBObject}->Quote($DataKey);
        my $QDataValue = $Self->{DBObject}->Quote( $Param{ObjectData}->{$DataKey} );

        next DATAKEY if !defined $QDataKey;
        next DATAKEY if !defined $QDataValue;

        # insert one row
        $Self->{DBObject}->Do(
            SQL => "INSERT INTO imexport_object "
                . "(template_id, data_key, data_value) VALUES "
                . "($Param{TemplateID}, '$QDataKey', '$QDataValue')"
        );
    }

    return 1;
}

=item ObjectDataDelete()

delete the existing object data of a template

    my $True = $ImportExportObject->ObjectDataDelete(
        TemplateID => 123,
        UserID     => 1,
    );

    or

    my $True = $ImportExportObject->ObjectDataDelete(
        TemplateID => [1,44,166,5],
        UserID     => 1,
    );

=cut

sub ObjectDataDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{TemplateID} ) {
        $Param{TemplateID} = [ $Param{TemplateID} ];
    }
    elsif ( ref $Param{TemplateID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'TemplateID must be an array reference or a string!',
        );
        return;
    }

    # quote
    for my $TemplateID ( @{ $Param{TemplateID} } ) {
        $TemplateID = $Self->{DBObject}->Quote( $TemplateID, 'Integer' );
    }

    # create the template id string
    my $TemplateIDString = join ',', @{ $Param{TemplateID} };

    # delete templates
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_object WHERE template_id IN ( $TemplateIDString )",
    );
}

=item FormatList()

return a list of available formats as hash reference

    my $FormatList = $ImportExportObject->FormatList();

=cut

sub FormatList {
    my ( $Self, %Param ) = @_;

    # get config
    my $ModuleList = $Self->{ConfigObject}->Get('ImportExport::FormatBackendRegistration');

    return if !$ModuleList;
    return if ref $ModuleList ne 'HASH';

    # create the format list
    my $FormatList = {};
    for my $Module ( sort keys %{$ModuleList} ) {
        $FormatList->{$Module} = $ModuleList->{$Module}->{Name};
    }

    return $FormatList;
}

=item FormatAttributesGet()

get the attributes of a format backend as array/hash reference

    my $Attributes = $ImportExportObject->FormatAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub FormatAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Format} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load backend
    my $Backend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::FormatBackend::$TemplateData->{Format}",
    );

    return if !$Backend;

    # get an attribute list of the format
    my $Attributes = $Backend->FormatAttributesGet(
        %Param,
        UserID => $Param{UserID},
    );

    return $Attributes;
}

=item FormatDataGet()

get the format data from a template

    my $FormatDataRef = $ImportExportObject->FormatDataGet(
        TemplateID => 3,
        UserID     => 1,
    );

=cut

sub FormatDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{TemplateID} = $Self->{DBObject}->Quote( $Param{TemplateID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT data_key, data_value FROM imexport_format WHERE "
        . "template_id = $Param{TemplateID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my %FormatData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $FormatData{ $Row[0] } = $Row[1];
    }

    return \%FormatData;
}

=item FormatDataSave()

save the format data of a template

    my $True = $ImportExportObject->FormatDataSave(
        TemplateID => 123,
        FormatData => $HashRef,
        UserID     => 1,
    );

=cut

sub FormatDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID FormatData UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( ref $Param{FormatData} ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'FormatData must be an hash reference!',
        );
        return;
    }

    # delete existing format data
    $Self->FormatDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    DATAKEY:
    for my $DataKey ( keys %{ $Param{FormatData} } ) {

        # quote
        my $QDataKey   = $Self->{DBObject}->Quote($DataKey);
        my $QDataValue = $Self->{DBObject}->Quote( $Param{FormatData}->{$DataKey} );

        next DATAKEY if !defined $QDataKey;
        next DATAKEY if !defined $QDataValue;

        # insert one row
        $Self->{DBObject}->Do(
            SQL => "INSERT INTO imexport_format "
                . "(template_id, data_key, data_value) VALUES "
                . "($Param{TemplateID}, '$QDataKey', '$QDataValue')"
        );
    }

    return 1;
}

=item FormatDataDelete()

delete the existing format data of a template

    my $True = $ImportExportObject->FormatDataDelete(
        TemplateID => 123,
        UserID     => 1,
    );

    or

    my $True = $ImportExportObject->FormatDataDelete(
        TemplateID => [1,44,166,5],
        UserID     => 1,
    );

=cut

sub FormatDataDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{TemplateID} ) {
        $Param{TemplateID} = [ $Param{TemplateID} ];
    }
    elsif ( ref $Param{TemplateID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'TemplateID must be an array reference or a string!',
        );
        return;
    }

    # quote
    for my $TemplateID ( @{ $Param{TemplateID} } ) {
        $TemplateID = $Self->{DBObject}->Quote( $TemplateID, 'Integer' );
    }

    # create the template id string
    my $TemplateIDString = join ',', @{ $Param{TemplateID} };

    # delete templates
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_format WHERE template_id IN ( $TemplateIDString )",
    );
}

=item MappingList()

return a list of mapping data ids sorted by position as array reference

    my $MappingList = $ImportExportObject->MappingList(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub MappingList {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{TemplateID} = $Self->{DBObject}->Quote( $Param{TemplateID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT id FROM imexport_mapping WHERE "
        . "template_id = $Param{TemplateID} ORDER BY position";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my @MappingList;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        push @MappingList, $Row[0];
    }

    return \@MappingList;
}

=item MappingAdd()

add a new mapping data row

    my $MappingID = $ImportExportObject->MappingAdd(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub MappingAdd {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    for my $Argument (qw(TemplateID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    # find maximum position
    $Self->{DBObject}->Prepare(
        SQL => "SELECT max(position) FROM imexport_mapping "
            . "WHERE template_id = $Param{TemplateID}",
        Limit => 1,
    );

    # fetch the result
    my $NewPosition = 0;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {

        if ( defined $Row[0] ) {
            $NewPosition = $Row[0];
            $NewPosition++;
        }
    }

    # insert a new mapping data row
    return if !$Self->{DBObject}->Do(
        SQL => "INSERT INTO imexport_mapping "
            . "(template_id, position) VALUES "
            . "($Param{TemplateID}, $NewPosition)"
    );

    # find id of new mapping data row
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id FROM imexport_mapping "
            . "WHERE template_id = $Param{TemplateID} AND position = $NewPosition",
        Limit => 1,
    );

    # fetch the result
    my $MappingID;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $MappingID = $Row[0];
    }

    return $MappingID;
}

=item MappingDelete()

delete existing mapping data rows

    my $True = $ImportExportObject->MappingDelete(
        MappingID  => 123,
        TemplateID => 321,
        UserID     => 1,
    );

    or

    my $True = $ImportExportObject->MappingDelete(
        TemplateID => 321,
        UserID     => 1,
    );

=cut

sub MappingDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    for my $Argument (qw(TemplateID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    if ( defined $Param{MappingID} ) {

        # delete existing object mapping data
        $Self->MappingObjectDataDelete(
            MappingID => $Param{MappingID},
            UserID    => $Param{UserID},
        );

        # delete existing format mapping data
        $Self->MappingFormatDataDelete(
            MappingID => $Param{MappingID},
            UserID    => $Param{UserID},
        );

        # quote
        $Param{MappingID} = $Self->{DBObject}->Quote( $Param{MappingID}, 'Integer' );

        # delete one mapping row
        $Self->{DBObject}->Do(
            SQL => "DELETE FROM imexport_mapping WHERE id = $Param{MappingID}",
        );

        # rebuild mapping positions
        $Self->MappingPositionRebuild(
            TemplateID => $Param{TemplateID},
            UserID     => $Param{UserID},
        );

        return 1;
    }
    else {

        # get mapping list
        my $MappingList = $Self->MappingList(
            TemplateID => $Param{TemplateID},
            UserID     => $Param{UserID},
        );

        for my $MappingID ( @{$MappingList} ) {

            # delete existing object mapping data
            $Self->MappingObjectDataDelete(
                MappingID => $MappingID,
                UserID    => $Param{UserID},
            );

            # delete existing format mapping data
            $Self->MappingFormatDataDelete(
                MappingID => $MappingID,
                UserID    => $Param{UserID},
            );
        }

        # delete all mapping rows of this template
        return $Self->{DBObject}->Do(
            SQL => "DELETE FROM imexport_mapping WHERE template_id = $Param{TemplateID}",
        );
    }
}

=item MappingUp()

move an mapping data row up

    my $True = $ImportExportObject->MappingUp(
        MappingID  => 123,
        TemplateID => 321,
        UserID     => 1,
    );

=cut

sub MappingUp {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # get mapping data list
    my $MappingList = $Self->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    return 1 if $Param{MappingID} == $MappingList->[0];

    # quote
    for my $Argument (qw(MappingID TemplateID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    # get position
    my $SQL = "SELECT position FROM imexport_mapping WHERE id = $Param{MappingID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my $Position;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $Position = $Row[0];
    }

    return 1 if !$Position;

    my $PositionUpper = $Position - 1;

    # update positions
    $Self->{DBObject}->Do(
        SQL => "UPDATE imexport_mapping SET position = $Position "
            . "WHERE template_id = $Param{TemplateID} AND position = $PositionUpper",
    );
    $Self->{DBObject}->Do(
        SQL => "UPDATE imexport_mapping SET position = $PositionUpper "
            . "WHERE id = $Param{MappingID}",
    );

    return 1;
}

=item MappingDown()

move an mapping data row down

    my $True = $ImportExportObject->MappingDown(
        MappingID  => 123,
        TemplateID => 321,
        UserID     => 1,
    );

=cut

sub MappingDown {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # get mapping data list
    my $MappingList = $Self->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    return 1 if $Param{MappingID} == $MappingList->[-1];

    # quote
    for my $Argument (qw(MappingID TemplateID UserID)) {
        $Param{$Argument} = $Self->{DBObject}->Quote( $Param{$Argument}, 'Integer' );
    }

    # get position
    my $SQL = "SELECT position FROM imexport_mapping WHERE id = $Param{MappingID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my $Position;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $Position = $Row[0];
    }

    my $PositionDown = $Position + 1;

    # update positions
    $Self->{DBObject}->Do(
        SQL => "UPDATE imexport_mapping SET position = $Position "
            . "WHERE template_id = $Param{TemplateID} AND position = $PositionDown",
    );
    $Self->{DBObject}->Do(
        SQL => "UPDATE imexport_mapping SET position = $PositionDown "
            . "WHERE id = $Param{MappingID}",
    );

    return 1;
}

=item MappingPositionRebuild()

rebuild the positions of a mapping list

    my $True = $ImportExportObject->MappingPositionRebuild(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub MappingPositionRebuild {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # get mapping data list
    my $MappingList = $Self->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # update position
    my $Counter = 0;
    for my $MappingID ( @{$MappingList} ) {
        $Self->{DBObject}->Do(
            SQL => "UPDATE imexport_mapping SET position = $Counter "
                . "WHERE id = $MappingID",
        );
        $Counter++;
    }

    return 1;
}

=item MappingObjectAttributesGet()

get the attributes of an object backend as array/hash reference

    my $Attributes = $ImportExportObject->MappingObjectAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub MappingObjectAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Object} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load backend
    my $Backend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::ObjectBackend::$TemplateData->{Object}",
    );

    return if !$Backend;

    # get an attribute list of the object
    my $Attributes = $Backend->MappingObjectAttributesGet(
        %Param,
        UserID => $Param{UserID},
    );

    return $Attributes;
}

=item MappingObjectDataDelete()

delete the existing object data of a mapping

    my $True = $ImportExportObject->MappingObjectDataDelete(
        MappingID => 123,
        UserID    => 1,
    );

    or

    my $True = $ImportExportObject->MappingObjectDataDelete(
        MappingID => [1,44,166,5],
        UserID    => 1,
    );

=cut

sub MappingObjectDataDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{MappingID} ) {
        $Param{MappingID} = [ $Param{MappingID} ];
    }
    elsif ( ref $Param{MappingID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'MappingID must be an array reference or a string!',
        );
        return;
    }

    # quote
    for my $MappingID ( @{ $Param{MappingID} } ) {
        $MappingID = $Self->{DBObject}->Quote( $MappingID, 'Integer' );
    }

    # create the mapping id string
    my $MappingIDString = join ',', @{ $Param{MappingID} };

    # delete mapping object data
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_mapping_object WHERE mapping_id IN ( $MappingIDString )",
    );
}

=item MappingObjectDataSave()

save the object data of a mapping

    my $True = $ImportExportObject->MappingObjectDataSave(
        MappingID         => 123,
        MappingObjectData => $HashRef,
        UserID            => 1,
    );

=cut

sub MappingObjectDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID MappingObjectData UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( ref $Param{MappingObjectData} ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'MappingObjectData must be an hash reference!',
        );
        return;
    }

    # delete existing object mapping data
    $Self->MappingObjectDataDelete(
        MappingID => $Param{MappingID},
        UserID    => $Param{UserID},
    );

    DATAKEY:
    for my $DataKey ( keys %{ $Param{MappingObjectData} } ) {

        # quote
        my $QDataKey   = $Self->{DBObject}->Quote($DataKey);
        my $QDataValue = $Self->{DBObject}->Quote( $Param{MappingObjectData}->{$DataKey} );

        next DATAKEY if !defined $QDataKey;
        next DATAKEY if !defined $QDataValue;

        # insert one mapping object row
        $Self->{DBObject}->Do(
            SQL => "INSERT INTO imexport_mapping_object "
                . "(mapping_id, data_key, data_value) VALUES "
                . "($Param{MappingID}, '$QDataKey', '$QDataValue')"
        );
    }

    return 1;
}

=item MappingObjectDataGet()

get the object data of a mapping

    my $ObjectDataRef = $ImportExportObject->MappingObjectDataGet(
        MappingID => 123,
        UserID    => 1,
    );

=cut

sub MappingObjectDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{MappingID} = $Self->{DBObject}->Quote( $Param{MappingID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT data_key, data_value FROM imexport_mapping_object WHERE "
        . "mapping_id = $Param{MappingID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my %MappingObjectData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $MappingObjectData{ $Row[0] } = $Row[1];
    }

    return \%MappingObjectData;
}

=item MappingFormatAttributesGet()

get the attributes of an format backend as array/hash reference

    my $Attributes = $ImportExportObject->MappingFormatAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub MappingFormatAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Format} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load backend
    my $Backend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::FormatBackend::$TemplateData->{Format}",
    );

    return if !$Backend;

    # get an attribute list of the format
    my $Attributes = $Backend->MappingFormatAttributesGet(
        %Param,
        UserID => $Param{UserID},
    );

    return $Attributes;
}

=item MappingFormatDataDelete()

delete the existing format data of a mapping

    my $True = $ImportExportObject->MappingFormatDataDelete(
        MappingID => 123,
        UserID    => 1,
    );

    or

    my $True = $ImportExportObject->MappingFormatDataDelete(
        MappingID => [1,44,166,5],
        UserID    => 1,
    );

=cut

sub MappingFormatDataDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{MappingID} ) {
        $Param{MappingID} = [ $Param{MappingID} ];
    }
    elsif ( ref $Param{MappingID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'MappingID must be an array reference or a string!',
        );
        return;
    }

    # quote
    for my $MappingID ( @{ $Param{MappingID} } ) {
        $MappingID = $Self->{DBObject}->Quote( $MappingID, 'Integer' );
    }

    # create the mapping id string
    my $MappingIDString = join ',', @{ $Param{MappingID} };

    # delete mapping format data
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_mapping_format WHERE mapping_id IN ( $MappingIDString )",
    );
}

=item MappingFormatDataSave()

save the format data of a mapping

    my $True = $ImportExportObject->MappingFormatDataSave(
        MappingID         => 123,
        MappingFormatData => $HashRef,
        UserID            => 1,
    );

=cut

sub MappingFormatDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID MappingFormatData UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( ref $Param{MappingFormatData} ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'MappingFormatData must be an hash reference!',
        );
        return;
    }

    # delete existing format mapping data
    $Self->MappingFormatDataDelete(
        MappingID => $Param{MappingID},
        UserID    => $Param{UserID},
    );

    DATAKEY:
    for my $DataKey ( keys %{ $Param{MappingFormatData} } ) {

        # quote
        my $QDataKey   = $Self->{DBObject}->Quote($DataKey);
        my $QDataValue = $Self->{DBObject}->Quote( $Param{MappingFormatData}->{$DataKey} );

        next DATAKEY if !defined $QDataKey;
        next DATAKEY if !defined $QDataValue;

        # insert one mapping format row
        $Self->{DBObject}->Do(
            SQL => "INSERT INTO imexport_mapping_format "
                . "(mapping_id, data_key, data_value) VALUES "
                . "($Param{MappingID}, '$QDataKey', '$QDataValue')"
        );
    }

    return 1;
}

=item MappingFormatDataGet()

get the format data of a mapping

    my $ObjectDataRef = $ImportExportObject->MappingFormatDataGet(
        MappingID => 123,
        UserID    => 1,
    );

=cut

sub MappingFormatDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(MappingID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{MappingID} = $Self->{DBObject}->Quote( $Param{MappingID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT data_key, data_value FROM imexport_mapping_format WHERE "
        . "mapping_id = $Param{MappingID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my %MappingFormatData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $MappingFormatData{ $Row[0] } = $Row[1];
    }

    return \%MappingFormatData;
}

=item SearchAttributesGet()

get the search attributes of a object backend as array/hash reference

    my $Attributes = $ImportExportObject->SearchAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub SearchAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Object} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load backend
    my $Backend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::ObjectBackend::$TemplateData->{Object}",
    );

    return if !$Backend;

    # get an search attribute list of an object
    my $Attributes = $Backend->SearchAttributesGet(
        %Param,
        UserID => $Param{UserID},
    );

    return $Attributes;
}

=item SearchDataGet()

get the search data from a template

    my $SearchDataRef = $ImportExportObject->SearchDataGet(
        TemplateID => 3,
        UserID     => 1,
    );

=cut

sub SearchDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # quote
    $Param{TemplateID} = $Self->{DBObject}->Quote( $Param{TemplateID}, 'Integer' );

    # create sql string
    my $SQL = "SELECT data_key, data_value FROM imexport_search WHERE "
        . "template_id = $Param{TemplateID}";

    # ask database
    $Self->{DBObject}->Prepare( SQL => $SQL );

    # fetch the result
    my %SearchData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $SearchData{ $Row[0] } = $Row[1];
    }

    return \%SearchData;
}

=item SearchDataSave()

save the search data of a template

    my $True = $ImportExportObject->SearchDataSave(
        TemplateID => 123,
        SearchData => $HashRef,
        UserID     => 1,
    );

=cut

sub SearchDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID SearchData UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( ref $Param{SearchData} ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'SearchData must be an hash reference!',
        );
        return;
    }

    # delete existing search data
    $Self->SearchDataDelete(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    DATAKEY:
    for my $DataKey ( keys %{ $Param{SearchData} } ) {

        # quote
        my $QDataKey   = $Self->{DBObject}->Quote($DataKey);
        my $QDataValue = $Self->{DBObject}->Quote( $Param{SearchData}->{$DataKey} );

        next DATAKEY if !$QDataKey;
        next DATAKEY if !$QDataValue;

        # insert one row
        $Self->{DBObject}->Do(
            SQL => "INSERT INTO imexport_search "
                . "(template_id, data_key, data_value) VALUES "
                . "($Param{TemplateID}, '$QDataKey', '$QDataValue')"
        );
    }

    return 1;
}

=item SearchDataDelete()

delete the existing search data of a template

    my $True = $ImportExportObject->SearchDataDelete(
        TemplateID => 123,
        UserID     => 1,
    );

    or

    my $True = $ImportExportObject->SearchDataDelete(
        TemplateID => [1,44,166,5],
        UserID     => 1,
    );

=cut

sub SearchDataDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    if ( !ref $Param{TemplateID} ) {
        $Param{TemplateID} = [ $Param{TemplateID} ];
    }
    elsif ( ref $Param{TemplateID} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'TemplateID must be an array reference or a string!',
        );
        return;
    }

    # quote
    for my $TemplateID ( @{ $Param{TemplateID} } ) {
        $TemplateID = $Self->{DBObject}->Quote( $TemplateID, 'Integer' );
    }

    # create the template id string
    my $TemplateIDString = join ',', @{ $Param{TemplateID} };

    # delete templates
    return $Self->{DBObject}->Do(
        SQL => "DELETE FROM imexport_search WHERE template_id IN ( $TemplateIDString )",
    );
}

=item Export()

export function

    my $ResultRef = $ImportExportObject->Export(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

sub Export {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Object} || !$TemplateData->{Format} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load object backend
    my $ObjectBackend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::ObjectBackend::$TemplateData->{Object}",
    );

    return if !$ObjectBackend;

    # load format backend
    my $FormatBackend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::FormatBackend::$TemplateData->{Format}",
    );

    return if !$FormatBackend;

    # get export data
    my $ExportData = $ObjectBackend->ExportDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    my %Result;
    $Result{Success}            = 0;
    $Result{Failed}             = 0;
    $Result{DestinationContent} = [];

    EXPORTDATAROW:
    for my $ExportDataRow ( @{$ExportData} ) {

        # export one row
        my $DestinationContentRow = $FormatBackend->ExportDataSave(
            TemplateID    => $Param{TemplateID},
            ExportDataRow => $ExportDataRow,
            UserID        => $Param{UserID},
        );

        if ( !defined $DestinationContentRow ) {
            $Result{Failed}++;
            next EXPORTDATAROW;
        }

        # add row to destination content
        push @{ $Result{DestinationContent} }, $DestinationContentRow;
        $Result{Success}++;
    }

    # log result
    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => "Export of $Result{Failed} records ($TemplateData->{Object}): failed!",
    );
    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => "Export of $Result{Success} records ($TemplateData->{Object}): success!",
    );

    return \%Result;
}

=item Import()

import function

    my $ResultRef = $ImportExportObject->Import(
        TemplateID    => 123,
        SourceContent => $StringRef,  # (optional)
        UserID        => 1,
    );

=cut

sub Import {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # get template data
    my $TemplateData = $Self->TemplateGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check template data
    if ( !$TemplateData || !$TemplateData->{Object} || !$TemplateData->{Format} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Template with ID $Param{TemplateID} not complete!",
        );
        return;
    }

    # load object backend
    my $ObjectBackend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::ObjectBackend::$TemplateData->{Object}",
    );

    return if !$ObjectBackend;

    # load format backend
    my $FormatBackend = $Self->_LoadBackend(
        Module => "Kernel::System::ImportExport::FormatBackend::$TemplateData->{Format}",
    );

    return if !$FormatBackend;

    # get import data
    my $ImportData = $FormatBackend->ImportDataGet(
        TemplateID    => $Param{TemplateID},
        SourceContent => $Param{SourceContent},
        UserID        => $Param{UserID},
    );

    return if !$ImportData;

    my %Result;
    $Result{Success} = 0;
    $Result{Failed}  = 0;

    IMPORTDATAROW:
    for my $ImportDataRow ( @{$ImportData} ) {

        # import one row
        my $Success = $ObjectBackend->ImportDataSave(
            TemplateID    => $Param{TemplateID},
            ImportDataRow => $ImportDataRow,
            UserID        => $Param{UserID},
        );

        if ( !$Success ) {
            $Result{Failed}++;
            next IMPORTDATAROW;
        }

        $Result{Success}++;
    }

    # log result
    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => "Import of $Result{Failed} records ($TemplateData->{Object}): failed!",
    );
    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => "Import of $Result{Success} records ($TemplateData->{Object}): success!",
    );

    return \%Result;
}

=item _LoadBackend()

to load a import/export backend module

    $HashRef = $ImportExportObject->_LoadBackend(
        Module => 'Kernel::System::ImportExport::ObjectBackend::Ticket',
    );

=cut

sub _LoadBackend {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    if ( !$Param{Module} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Module!'
        );
        return;
    }

    # check if object is already cached
    return $Self->{Cache}->{LoadBackend}->{ $Param{Module} }
        if $Self->{Cache}->{LoadBackend}->{ $Param{Module} };

    # load object backend module
    if ( !$Self->{MainObject}->Require( $Param{Module} ) ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't load backend module $Param{Module}!"
        );
        return;
    }

    # create new instance
    my $BackendObject = $Param{Module}->new(
        %{$Self},
        %Param,
        ImportExportObject => $Self,
    );

    if ( !$BackendObject ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't create a new instance of backend module $Param{Module}!",
        );
        return;
    }

    # cache the object
    $Self->{Cache}->{LoadBackend}->{ $Param{Module} } = $BackendObject;

    return $BackendObject;
}

=item _StringClean()

DON'T USE THIS INTERNAL FUNCTION IN OTHER MODULES!

This function can be replaced with Kernel::System::CheckItem::StringClean() in OTRS 2.3 and later!

clean a given string

    my $Error = $CheckItemObject->_StringClean(
        StringRef         => \'String',
        TrimLeft          => 0,  # (optional) default 1
        TrimRight         => 0,  # (optional) default 1
        RemoveAllNewlines => 1,  # (optional) default 0
        RemoveAllTabs     => 1,  # (optional) default 0
        RemoveAllSpaces   => 1,  # (optional) default 0
    );

=cut

sub _StringClean {
    my ( $Self, %Param ) = @_;

    if ( !$Param{StringRef} || ref $Param{StringRef} ne 'SCALAR' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need a scalar reference!'
        );
        return;
    }

    return 1 if !${ $Param{StringRef} };

    # set default values
    $Param{TrimLeft}  = defined $Param{TrimLeft}  ? $Param{TrimLeft}  : 1;
    $Param{TrimRight} = defined $Param{TrimRight} ? $Param{TrimRight} : 1;

    my %TrimAction = (
        RemoveAllNewlines => qr{ [\n\r\f] }xms,
        RemoveAllTabs     => qr{ \t       }xms,
        RemoveAllSpaces   => qr{ [ ]      }xms,
        TrimLeft          => qr{ \A \s+   }xms,
        TrimRight         => qr{ \s+ \z   }xms,
    );

    ACTION:
    for my $Action ( sort keys %TrimAction ) {
        next ACTION if !$Param{$Action};

        ${ $Param{StringRef} } =~ s{ $TrimAction{$Action} }{}xmsg;
    }

    return 1;
}

1;

=back

=head1 TERMS AND CONDITIONS

This Software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.26 $ $Date: 2008/04/17 11:29:04 $

=cut

# --
# Kernel/System/ImportExport/FormatBackend/CSV.pm - import/export backend for CSV
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: CSV.pm,v 1.22.2.1 2008/07/27 18:39:13 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ImportExport::FormatBackend::CSV;

use strict;
use warnings;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.22.2.1 $) [1];

=head1 NAME

Kernel::System::ImportExport::FormatBackend::CSV - import/export backend for CSV

=head1 SYNOPSIS

All functions to import and export a csv format

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::DB;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::ImportExport::FormatBackend::CSV;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $BackendObject = Kernel::System::ImportExport::FormatBackend::CSV->new(
        ConfigObject       => $ConfigObject,
        LogObject          => $LogObject,
        DBObject           => $DBObject,
        MainObject         => $MainObject,
        EncodeObject       => $EncodeObject,
        ImportExportObject => $ImportExportObject,
    );

=cut

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {};
    bless( $Self, $Type );

    # check needed objects
    for my $Object (qw(ConfigObject LogObject DBObject MainObject EncodeObject ImportExportObject))
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    if ( !$Self->{MainObject}->Require('Text::CSV') ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "CPAN module Text::CSV is required to use the CSV import/export module!",
        );
        return;
    }

    # define available seperators
    $Self->{AvailableSeperators} = {
        Tabulator => "\t",
        Semicolon => ';',
        Colon     => ':',
        Dot       => '.',
    };

    return $Self;
}

=item FormatAttributesGet()

get the format attributes of a format as array/hash reference

    my $Attributes = $FormatBackend->FormatAttributesGet(
        UserID => 1,
    );

=cut

sub FormatAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    if ( !$Param{UserID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => 'Need UserID!' );
        return;
    }

    my $Attributes = [
        {
            Key   => 'ColumnSeperator',
            Name  => 'Column Seperator',
            Input => {
                Type => 'Selection',
                Data => {
                    Tabulator => 'Tabulator (TAB)',
                    Semicolon => 'Semicolon (;)',
                    Colon     => 'Colon (:)',
                    Dot       => 'Dot (.)',
                },
                Required     => 1,
                Translation  => 1,
                PossibleNone => 1,
            },
        },
        {
            Key   => 'Charset',
            Name  => 'Charset',
            Input => {
                Type         => 'Text',
                ValueDefault => 'UTF-8',
                Required     => 1,
                Translation  => 0,
                Size         => 20,
                MaxLength    => 20,
            },
        },
    ];

    return $Attributes;
}

=item MappingFormatAttributesGet()

get the mapping attributes of an format as array/hash reference

    my $Attributes = $FormatBackend->MappingFormatAttributesGet(
        UserID => 1,
    );

=cut

sub MappingFormatAttributesGet {
    my ( $Self, %Param ) = @_;

    # check needed object
    if ( !$Param{UserID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => 'Need UserID!' );
        return;
    }

    my $Attributes = [
        {
            Key   => 'Column',
            Name  => 'Column',
            Input => {
                Type     => 'DTL',
                Data     => '$QData{"Counter"}',
                Required => 0,
            },
        },
    ];

    return $Attributes;
}

=item ImportDataGet()

get import data as 2D-array reference

    my $ImportData = $FormatBackend->ImportDataGet(
        TemplateID    => 123,
        SourceContent => $StringRef,  # (optional)
        UserID        => 1,
    );

=cut

sub ImportDataGet {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    return [] if !defined $Param{SourceContent};

    # check source content
    if ( ref $Param{SourceContent} ne 'SCALAR' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'SourceContent must be a scalar reference',
        );
        return;
    }

    # get format data
    my $FormatData = $Self->{ImportExportObject}->FormatDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check format data
    if ( !$FormatData || ref $FormatData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No format data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get charset
    my $Charset = $FormatData->{Charset} ||= '';
    $Charset =~ s{ \s* (utf-8|utf8) \s* }{UTF-8}xmsi;

    # check the charset
    if ( !$Charset ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid charset found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get charset
    $FormatData->{ColumnSeperator} ||= '';
    my $Seperator = $Self->{AvailableSeperators}->{ $FormatData->{ColumnSeperator} } || '';

    # check the seperator
    if ( !$Seperator ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid seperator found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the parser object
    my $ParseObject = Text::CSV->new(
        {
            quote_char          => '"',
            escape_char         => '"',
            sep_char            => $Seperator,
            eol                 => '',
            always_quote        => 1,
            binary              => 1,
            keep_meta_info      => 0,
            allow_loose_quotes  => 0,
            allow_loose_escapes => 0,
            allow_whitespace    => 0,
            blank_is_undef      => 0,
            verbatim            => 0,
        }
    );

    # create an in memory temp file and open it
    my $FileContent;
    open my $FH, '+<', \$FileContent;

    # write source content
    print $FH ${ $Param{SourceContent} };

    # rewind file handle
    seek $FH, 0, 0;

    # parse the content
    my @ImportData;
    while ( my $Column = $ParseObject->getline($FH) ) {
        push @ImportData, $Column;
    }

    # close the in memory file handle
    close $FH;

    return \@ImportData if $Charset ne 'UTF-8';

    # set utf8 flag
    for my $Row (@ImportData) {
        for my $Cell ( @{$Row} ) {
            Encode::_utf8_on($Cell);
        }
    }

    return \@ImportData;
}

=item ExportDataSave()

export one row of the export data

    my $DestinationContent = $FormatBackend->ExportDataSave(
        TemplateID    => 123,
        ExportDataRow => $ArrayRef,
        UserID        => 1,
    );

=cut

sub ExportDataSave {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(TemplateID ExportDataRow UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check export data row
    if ( ref $Param{ExportDataRow} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'ExportDataRow must be an array reference',
        );
        return;
    }

    # get format data
    my $FormatData = $Self->{ImportExportObject}->FormatDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check format data
    if ( !$FormatData || ref $FormatData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No format data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get charset
    my $Charset = $FormatData->{Charset} ||= '';
    $Charset =~ s{ \s* (utf-8|utf8) \s* }{UTF-8}xmsi;

    # check the charset
    if ( !$Charset ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid charset found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get charset
    $FormatData->{ColumnSeperator} ||= '';
    my $Seperator = $Self->{AvailableSeperators}->{ $FormatData->{ColumnSeperator} } || '';

    # check the seperator
    if ( !$Seperator ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid seperator found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the parser object
    my $ParseObject = Text::CSV->new(
        {
            quote_char          => '"',
            escape_char         => '"',
            sep_char            => $Seperator,
            eol                 => '',
            always_quote        => 1,
            binary              => 1,
            keep_meta_info      => 0,
            allow_loose_quotes  => 0,
            allow_loose_escapes => 0,
            allow_whitespace    => 0,
            blank_is_undef      => 0,
            verbatim            => 0,
        }
    );

    if ( !$ParseObject->combine( @{ $Param{ExportDataRow} } ) ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't combine the export data to a string!",
        );
        return;
    }

    # create the CSV string
    my $String = $ParseObject->string;

    return $String if $Charset ne 'UTF-8';

    # set utf8 flag
    Encode::_utf8_on($String);

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.22.2.1 $ $Date: 2008/07/27 18:39:13 $

=cut

# --
# ImportExport.t - all general import export tests
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: ImportExport.t,v 1.14 2008/04/07 10:16:36 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

use strict;
use warnings;
use utf8;

use vars qw($Self);

use Kernel::System::Encode;
use Kernel::System::ImportExport;
use Kernel::System::User;

$Self->{EncodeObject}       = Kernel::System::Encode->new( %{$Self} );
$Self->{ImportExportObject} = Kernel::System::ImportExport->new( %{$Self} );
$Self->{UserObject}         = Kernel::System::User->new( %{$Self} );

# ------------------------------------------------------------ #
# make preparations
# ------------------------------------------------------------ #

# create needed users
my @UserIDs;
{

    # disable email checks to create new user
    my $CheckEmailAddressesOrg = $Self->{ConfigObject}->Get('CheckEmailAddresses') || 1;
    $Self->{ConfigObject}->Set(
        Key   => 'CheckEmailAddresses',
        Value => 0,
    );

    for my $Counter ( 1 .. 2 ) {

        # create new users for the tests
        my $UserID = $Self->{UserObject}->UserAdd(
            UserFirstname => 'ImportExport' . $Counter,
            UserLastname  => 'UnitTest',
            UserLogin     => 'UnitTest-ImportExport-' . $Counter . int rand 1_000_000,
            UserEmail     => 'UnitTest-ImportExport-' . $Counter . '@localhost',
            ValidID       => 1,
            ChangeUserID  => 1,
        );

        push @UserIDs, $UserID;
    }

    # restore original email check param
    $Self->{ConfigObject}->Set(
        Key   => 'CheckEmailAddresses',
        Value => $CheckEmailAddressesOrg,
    );
}

# create needed random template names
my @TemplateName;

for my $Counter ( 1 .. 5 ) {

    push @TemplateName, 'UnitTest' . int rand 1_000_000;
}

# create needed random object names
my @ObjectName;
push @ObjectName, 'UnitTest' . int rand 1_000_000;

# create needed format names
my @FormatName = ('CSV');

# get original template list for later checks (all elements)
my $TemplateList1All = $Self->{ImportExportObject}->TemplateList(
    UserID => 1,
);

# get original template list for later checks (all elements)
my $TemplateList1Object = $Self->{ImportExportObject}->TemplateList(
    Object => $ObjectName[0],
    UserID => 1,
);

# ------------------------------------------------------------ #
# define general tests
# ------------------------------------------------------------ #

my $ItemData = [

    # this template is NOT complete and must not be added
    {
        Add => {
            Format  => $FormatName[0],
            Name    => $TemplateName[0],
            ValidID => 1,
            UserID  => 1,
        },
    },

    # this template is NOT complete and must not be added
    {
        Add => {
            Object  => $ObjectName[0],
            Name    => $TemplateName[0],
            ValidID => 1,
            UserID  => 1,
        },
    },

    # this template is NOT complete and must not be added
    {
        Add => {
            Object  => $ObjectName[0],
            Format  => $FormatName[0],
            ValidID => 1,
            UserID  => 1,
        },
    },

    # this template is NOT complete and must not be added
    {
        Add => {
            Object => $ObjectName[0],
            Format => $FormatName[0],
            Name   => $TemplateName[0],
            UserID => 1,
        },
    },

    # this template is NOT complete and must not be added
    {
        Add => {
            Object  => $ObjectName[0],
            Format  => $FormatName[0],
            Name    => $TemplateName[0],
            ValidID => 1,
        },
    },

    # this template must be inserted sucessfully
    {
        Add => {
            Object  => $ObjectName[0],
            Format  => $FormatName[0],
            Name    => $TemplateName[0],
            ValidID => 1,
            UserID  => 1,
        },
        AddGet => {
            Object   => $ObjectName[0],
            Format   => $FormatName[0],
            Name     => $TemplateName[0],
            ValidID  => 1,
            Comment  => '',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },

    # this template have the same name as one test before and must not be added
    {
        Add => {
            Object  => $ObjectName[0],
            Format  => $FormatName[0],
            Name    => $TemplateName[0],
            ValidID => 1,
            UserID  => 1,
        },
    },

    # this template must be inserted sucessfully
    {
        Add => {
            Object  => $ObjectName[0],
            Format  => $FormatName[0],
            Name    => $TemplateName[1],
            ValidID => 1,
            Comment => 'TestComment',
            UserID  => 1,
        },
        AddGet => {
            Object   => $ObjectName[0],
            Format   => $FormatName[0],
            Name     => $TemplateName[1],
            ValidID  => 1,
            Comment  => 'TestComment',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },

    # the template one add-test before must be NOT updated (template update arguments NOT complete)
    {
        Update => {
            ValidID => 2,
            UserID  => $UserIDs[0],
        },
    },

    # the template one add-test before must be NOT updated (template update arguments NOT complete)
    {
        Update => {
            Name   => $TemplateName[1] . 'UPDATE1',
            UserID => $UserIDs[0],
        },
    },

    # the template one add-test before must be NOT updated (template update arguments NOT complete)
    {
        Update => {
            Name    => $TemplateName[1] . 'UPDATE2',
            ValidID => 2,
        },
    },

    # the template one add-test before must be updated (template update arguments are complete)
    {
        Update => {
            Name    => $TemplateName[1] . 'UPDATE3',
            Comment => 'TestComment UPDATE3',
            ValidID => 2,
            UserID  => $UserIDs[0],
        },
        UpdateGet => {
            Name     => $TemplateName[1] . 'UPDATE3',
            ValidID  => 2,
            Comment  => 'TestComment UPDATE3',
            CreateBy => 1,
            ChangeBy => $UserIDs[0],
        },
    },

    # the template one add-test before must be updated (template update arguments are complete)
    {
        Update => {
            Name    => $TemplateName[1] . 'UPDATE4',
            ValidID => 1,
            Comment => '',
            UserID  => 1,
        },
        UpdateGet => {
            Name     => $TemplateName[1] . 'UPDATE4',
            ValidID  => 1,
            Comment  => '',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },

    # this template must be inserted sucessfully (check string cleaner function)
    {
        Add => {
            Object  => " \t \n \r " . $ObjectName[0] . " \t \n \r ",
            Format  => " \t \n \r " . $FormatName[0] . " \t \n \r ",
            Name    => " \t \n \r " . $TemplateName[2] . " \t \n \r ",
            ValidID => 1,
            Comment => " \t \n \r Test Comment \t \n \r ",
            UserID  => 1,
        },
        AddGet => {
            Object   => $ObjectName[0],
            Format   => $FormatName[0],
            Name     => $TemplateName[2],
            ValidID  => 1,
            Comment  => 'Test Comment',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },

    # the template one add-test before must be updated (check string cleaner function)
    {
        Update => {
            Name    => " \t \n \r " . $TemplateName[2] . "UPDATE1 \t \n \r ",
            ValidID => 1,
            Comment => " \t \n \r Test Comment UPDATE1 \t \n \r ",
            UserID  => 1,
        },
        UpdateGet => {
            Name     => $TemplateName[2] . 'UPDATE1',
            ValidID  => 1,
            Comment  => 'Test Comment UPDATE1',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },

    # this template must be inserted sucessfully (unicode checks)
    {
        Add => {
            Object  => ' ƕ Ƙ ' . $ObjectName[0] . ' Ƶ ƻ ',
            Format  => ' Ǔ ǣ ' . $FormatName[0] . ' ǥ Ǯ ',
            Name    => ' Ƿ Ȝ ' . $TemplateName[3] . ' Ȟ Ƞ ',
            ValidID => 2,
            Comment => ' Ѡ Ѥ TestComment5 Ϡ Ω ',
            UserID  => 1,
        },
        AddGet => {
            Object   => 'ƕƘ' . $ObjectName[0] . 'Ƶƻ',
            Format   => 'Ǔǣ' . $FormatName[0] . 'ǥǮ',
            Name     => 'Ƿ Ȝ ' . $TemplateName[3] . ' Ȟ Ƞ',
            ValidID  => 2,
            Comment  => 'Ѡ Ѥ TestComment5 Ϡ Ω',
            CreateBy => 1,
            ChangeBy => 1,
        },
    },
];

# ------------------------------------------------------------ #
# run general tests
# ------------------------------------------------------------ #

my $TestCount = 1;
my @AddedTemplateIDs;

TEMPLATE:
for my $Item ( @{$ItemData} ) {

    if ( $Item->{Add} ) {

        # add new template
        my $TemplateID = $Self->{ImportExportObject}->TemplateAdd( %{ $Item->{Add} } );

        if ($TemplateID) {
            push @AddedTemplateIDs, $TemplateID;
        }

        # check if template was added successfully or not
        if ( $Item->{AddGet} ) {
            $Self->True(
                $TemplateID,
                "Test $TestCount: TemplateAdd() - TemplateKey: $TemplateID"
            );
        }
        else {
            $Self->False( $TemplateID, "Test $TestCount: TemplateAdd()" );
        }
    }

    if ( $Item->{AddGet} ) {

        # get template data to check the values after template was added
        my $TemplateGet = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $AddedTemplateIDs[-1],
            UserID => $Item->{Add}->{UserID} || 1,
        );

        # check template data after creation of template
        for my $TemplateAttribute ( keys %{ $Item->{AddGet} } ) {
            $Self->Is(
                $TemplateGet->{$TemplateAttribute} || '',
                $Item->{AddGet}->{$TemplateAttribute} || '',
                "Test $TestCount: TemplateGet() - $TemplateAttribute",
            );
        }
    }

    if ( $Item->{Update} ) {

        # check last template id varaible
        if ( !$AddedTemplateIDs[-1] ) {
            $Self->False(
                1,
                "Test $TestCount: NO LAST ITEM ID GIVEN. Please add a template first."
            );
            last TEMPLATE;
        }

        # update the template
        my $UpdateSucess = $Self->{ImportExportObject}->TemplateUpdate(
            %{ $Item->{Update} },
            TemplateID => $AddedTemplateIDs[-1],
        );

        # check if template was updated successfully or not
        if ( $Item->{UpdateGet} ) {
            $Self->True(
                $UpdateSucess,
                "Test $TestCount: TemplateUpdate() - TemplateKey: $AddedTemplateIDs[-1]",
            );
        }
        else {
            $Self->False(
                $UpdateSucess,
                "Test $TestCount: TemplateUpdate()",
            );
        }
    }

    if ( $Item->{UpdateGet} ) {

        # get template data to check the values after the update
        my $TemplateGet = $Self->{ImportExportObject}->TemplateGet(
            TemplateID => $AddedTemplateIDs[-1],
            UserID => $Item->{Update}->{UserID} || 1,
        );

        # check template data after update
        for my $TemplateAttribute ( keys %{ $Item->{UpdateGet} } ) {
            $Self->Is(
                $TemplateGet->{$TemplateAttribute} || '',
                $Item->{UpdateGet}->{$TemplateAttribute} || '',
                "Test $TestCount: TemplateGet() - $TemplateAttribute",
            );
        }
    }
}
continue {

    # increment the counter
    $TestCount++;
}

# ------------------------------------------------------------ #
# TemplateList test 1 (check array references)
# ------------------------------------------------------------ #

# list must be an empty array reference
$Self->True(
    ref $TemplateList1All eq 'ARRAY' && ref $TemplateList1Object eq 'ARRAY',
    "Test $TestCount: TemplateList() - array references",
);

$TestCount++;

# ------------------------------------------------------------ #
# TemplateList test 2 (list must be empty)
# ------------------------------------------------------------ #

# list must be an empty list
$Self->True(
    scalar @{$TemplateList1Object} eq 0,
    "Test $TestCount: TemplateList() - empty list",
);

$TestCount++;

# ------------------------------------------------------------ #
# TemplateList test 2 (check correct number of new items)
# ------------------------------------------------------------ #

# get template list with all elements
my $TemplateList2 = $Self->{ImportExportObject}->TemplateList(
    UserID => 1,
);

# list must be an array reference
$Self->True(
    ref $TemplateList2 eq 'ARRAY',
    "Test $TestCount: TemplateList() - array reference",
);

my $TemplateListCount = scalar @{$TemplateList2} - scalar @{$TemplateList1All};

# check correct number of new items
$Self->True(
    $TemplateListCount eq scalar @AddedTemplateIDs,
    "Test $TestCount: TemplateList() - correct number of new items",
);

$TestCount++;

# ------------------------------------------------------------ #
# TemplateDelete test 1 (add one template and delete it)
# ------------------------------------------------------------ #

# get template list with all elements
my $TemplateDelete1List1 = $Self->{ImportExportObject}->TemplateList(
    Object => $ObjectName[0],
    UserID => 1,
);

# add a test template
my $TemplateDeleteID = $Self->{ImportExportObject}->TemplateAdd(
    Object  => $ObjectName[0],
    Format  => $FormatName[0],
    Name    => $TemplateName[4],
    ValidID => 1,
    UserID  => 1,
);

# get template list with all elements
my $TemplateDelete1List2 = $Self->{ImportExportObject}->TemplateList(
    Object => $ObjectName[0],
    UserID => 1,
);

# list must have one more element
$Self->True(
    scalar @{$TemplateDelete1List1} eq ( scalar @{$TemplateDelete1List2} ) - 1,
    "Test $TestCount: TemplateDelete() - number of listed elements",
);

# delete the new template
my $TemplateDelete1 = $Self->{ImportExportObject}->TemplateDelete(
    TemplateID => $TemplateDeleteID,
    UserID     => 1,
);

# list must be successfull
$Self->True(
    $TemplateDelete1,
    "Test $TestCount: TemplateDelete()",
);

# get template list with all elements
my $TemplateDelete1List3 = $Self->{ImportExportObject}->TemplateList(
    Object => $ObjectName[0],
    UserID => 1,
);

# list must have the original number of elements
$Self->True(
    scalar @{$TemplateDelete1List1} eq scalar @{$TemplateDelete1List3},
    "Test $TestCount: TemplateDelete() - number of listed elements",
);

$TestCount++;

# ------------------------------------------------------------ #
# TemplateDelete test 2 (delete all unittest templates)
# ------------------------------------------------------------ #

for my $TemplateID (@AddedTemplateIDs) {

    # delete the template
    my $Success = $Self->{ImportExportObject}->TemplateDelete(
        TemplateID => $TemplateID,
        UserID     => 1,
    );

    # check success
    $Self->True(
        $Success,
        "Test $TestCount: TemplateDelete() TemplateID $TemplateID",
    );

    $TestCount++;
}

# ------------------------------------------------------------ #
# ObjectList test 1 (check general functionality)
# ------------------------------------------------------------ #

# define test list
my $ObjectList1TestList = {
    UnitTest1 => {
        Module => 'Kernel::System::ImportExport::ObjectBackend::UnitTest1',
        Name   => 'Unit Test 1',
    },
    UnitTest2 => {
        Module => 'Kernel::System::ImportExport::ObjectBackend::UnitTest2',
        Name   => 'Unit Test 2',
    },
};

# get original object list
my $ObjectListOrg = $Self->{ConfigObject}->Get('ImportExport::ObjectBackendRegistration');

# set test list
$Self->{ConfigObject}->Set(
    Key   => 'ImportExport::ObjectBackendRegistration',
    Value => $ObjectList1TestList,
);

# get object list
my $ObjectList1 = $Self->{ImportExportObject}->ObjectList();

# list must be a hash reference
$Self->True(
    ref $ObjectList1 eq 'HASH',
    "Test $TestCount: ObjectList() - hash reference",
);

# check the list
KEY:
for my $Key ( keys %{$ObjectList1} ) {

    if ( !$ObjectList1TestList->{$Key} ) {
        $ObjectList1TestList->{Dummy} = 1;
    }

    next KEY if $ObjectList1->{$Key} ne $ObjectList1TestList->{$Key}->{Name};

    delete $ObjectList1TestList->{$Key};
}

$Self->True(
    !%{$ObjectList1TestList},
    "Test $TestCount: ObjectList() - content is valid",
);

# restore original object list
$Self->{ConfigObject}->Set(
    Key   => 'ImportExport::ObjectBackendRegistration',
    Value => $ObjectListOrg,
);

$TestCount++;

# ------------------------------------------------------------ #
# FormatList test 1 (check general functionality)
# ------------------------------------------------------------ #

# define test list
my $FormatList1TestList = {
    UnitTest1 => {
        Module => 'Kernel::System::ImportExport::FormatBackend::UnitTest1',
        Name   => 'Unit Test 1',
    },
    UnitTest2 => {
        Module => 'Kernel::System::ImportExport::FormatBackend::UnitTest2',
        Name   => 'Unit Test 2',
    },
};

# get original format list
my $FormatListOrg = $Self->{ConfigObject}->Get('ImportExport::FormatBackendRegistration');

# set test list
$Self->{ConfigObject}->Set(
    Key   => 'ImportExport::FormatBackendRegistration',
    Value => $FormatList1TestList,
);

# get format list
my $FormatList1 = $Self->{ImportExportObject}->FormatList();

# list must be a hash reference
$Self->True(
    ref $FormatList1 eq 'HASH',
    "Test $TestCount: FormatList() - hash reference",
);

# check the list
KEY:
for my $Key ( keys %{$FormatList1} ) {

    if ( !$FormatList1TestList->{$Key} ) {
        $FormatList1TestList->{Dummy} = 1;
    }

    next KEY if $FormatList1->{$Key} ne $FormatList1TestList->{$Key}->{Name};

    delete $FormatList1TestList->{$Key};
}

$Self->True(
    !%{$FormatList1TestList},
    "Test $TestCount: FormatList() - content is valid",
);

# restore original format list
$Self->{ConfigObject}->Set(
    Key   => 'ImportExport::FormatBackendRegistration',
    Value => $FormatListOrg,
);

$TestCount++;

1;

# --
# ImportExportFormatCSV.t - all import export tests for the CSV format backend
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# --
# $Id: ImportExportFormatCSV.t,v 1.7 2008/04/14 15:02:21 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

use strict;
use warnings;
use utf8;

use vars qw($Self);

use Data::Dumper;
use Kernel::System::Encode;
use Kernel::System::ImportExport;
use Kernel::System::ImportExport::FormatBackend::CSV;

$Self->{EncodeObject}        = Kernel::System::Encode->new( %{$Self} );
$Self->{ImportExportObject}  = Kernel::System::ImportExport->new( %{$Self} );
$Self->{FormatBackendObject} = Kernel::System::ImportExport::FormatBackend::CSV->new( %{$Self} );

# ------------------------------------------------------------ #
# make preparations
# ------------------------------------------------------------ #

# get home directory
$Self->{Home} = $Self->{ConfigObject}->Get('Home');

# add some test templates for later checks
my @TemplateIDs;
for ( 1 .. 30 ) {

    # add a test template for later checks
    my $TemplateID = $Self->{ImportExportObject}->TemplateAdd(
        Object  => 'UnitTest' . int rand 1_000_000,
        Format  => 'CSV',
        Name    => 'UnitTest' . int rand 1_000_000,
        ValidID => 1,
        UserID  => 1,
    );

    push @TemplateIDs, $TemplateID;
}

my $TestCount = 1;

# ------------------------------------------------------------ #
# FormatList test 1 (check CSV item)
# ------------------------------------------------------------ #

# get format list
my $FormatList1 = $Self->{ImportExportObject}->FormatList();

# check format list
$Self->True(
    $FormatList1 && ref $FormatList1 eq 'HASH' && $FormatList1->{CSV},
    "Test $TestCount: FormatList() - CSV exists",
);

$TestCount++;

# ------------------------------------------------------------ #
# FormatAttributesGet test 1 (check attribute hash)
# ------------------------------------------------------------ #

# get format attributes
my $FormatAttributesGet1 = $Self->{ImportExportObject}->FormatAttributesGet(
    TemplateID => $TemplateIDs[0],
    UserID     => 1,
);

# check format attribute reference
$Self->True(
    $FormatAttributesGet1 && ref $FormatAttributesGet1 eq 'ARRAY',
    "Test $TestCount: FormatAttributesGet() - check array reference",
);

# define the reference hash
my $FormatAttributesGet1Reference = [
    {
        Key   => 'ColumnSeperator',
        Name  => 'Column Seperator',
        Input => {
            Type => 'Selection',
            Data => {
                Tabulator => 'Tabulator (TAB)',
                Semicolon => 'Semicolon (;)',
                Colon     => 'Colon (:)',
                Dot       => 'Dot (.)',
            },
            Required     => 1,
            Translation  => 1,
            PossibleNone => 1,
        },
    },
    {
        Key   => 'Charset',
        Name  => 'Charset',
        Input => {
            Type         => 'Text',
            ValueDefault => 'UTF-8',
            Required     => 1,
            Translation  => 0,
            Size         => 20,
            MaxLength    => 20,
        },
    },
];

# turn off all pretty print
$Data::Dumper::Indent = 0;

# dump the list from FormatAttributesGet()
my $FormatAttributesGetDump1 = Data::Dumper::Dumper($FormatAttributesGet1);

# dump the reference table
my $FormatAttributesRefDump1 = Data::Dumper::Dumper($FormatAttributesGet1Reference);

$Self->True(
    $FormatAttributesGetDump1 eq $FormatAttributesRefDump1,
    "Test $TestCount: FormatAttributesGet() - attributes of the row are identical",
);

$TestCount++;

# ------------------------------------------------------------ #
# FormatAttributesGet test 2 (check with non existing template)
# ------------------------------------------------------------ #

# get format attributes
my $FormatAttributesGet2 = $Self->{ImportExportObject}->FormatAttributesGet(
    TemplateID => $TemplateIDs[-1] + 1,
    UserID     => 1,
);

# check false return
$Self->False(
    $FormatAttributesGet2,
    "Test $TestCount: FormatAttributesGet() - check false return",
);

$TestCount++;

# ------------------------------------------------------------ #
# MappingFormatAttributesGet test 1 (check attribute hash)
# ------------------------------------------------------------ #

# get mapping format attributes
my $MappingFormatAttributesGet1 = $Self->{ImportExportObject}->MappingFormatAttributesGet(
    TemplateID => $TemplateIDs[0],
    UserID     => 1,
);

# check mapping format attribute reference
$Self->True(
    $MappingFormatAttributesGet1 && ref $MappingFormatAttributesGet1 eq 'ARRAY',
    "Test $TestCount: MappingFormatAttributesGet() - check array reference",
);

# define the reference hash
my $MappingFormatAttributesGet1Reference = [
    {
        Key   => 'Column',
        Name  => 'Column',
        Input => {
            Type     => 'DTL',
            Data     => '$QData{"Counter"}',
            Required => 0,
        },
    },
];

# turn off all pretty print
$Data::Dumper::Indent = 0;

# dump the list from MappingFormatAttributesGet()
my $MappingFormatAttributesGetDump1 = Data::Dumper::Dumper($MappingFormatAttributesGet1);

# dump the reference table
my $MappingFormatAttributesRefDump1 = Data::Dumper::Dumper($MappingFormatAttributesGet1Reference);

$Self->True(
    $MappingFormatAttributesGetDump1 eq $MappingFormatAttributesRefDump1,
    "Test $TestCount: MappingFormatAttributesGet() - attributes of the row are identical",
);

$TestCount++;

# ------------------------------------------------------------ #
# MappingFormatAttributesGet test 2 (check with non existing template)
# ------------------------------------------------------------ #

# get mapping format attributes
my $MappingFormatAttributesGet2 = $Self->{ImportExportObject}->MappingFormatAttributesGet(
    TemplateID => $TemplateIDs[-1] + 1,
    UserID     => 1,
);

# check false return
$Self->False(
    $MappingFormatAttributesGet2,
    "Test $TestCount: MappingFormatAttributesGet() - check false return",
);

$TestCount++;

# ------------------------------------------------------------ #
# define general ImportDataGet tests
# ------------------------------------------------------------ #

my $ImportDataTests = [

    # ImportDataGet doesn't contains all data (check required attributes)
    {
        SourceImportData => {
            ImportDataGet => {
                UserID => 1,
            },
        },
    },

    # ImportDataGet doesn't contains all data (check required attributes)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID => $TemplateIDs[1],
            },
        },
    },

    # no source content are given (empty array reference must be returned)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID => $TemplateIDs[1],
                UserID     => 1,
            },
        },
        ReferenceImportData => [],
    },

    # source content must be a scalar reference (check return false)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID    => $TemplateIDs[1],
                SourceContent => [],
                UserID        => 1,
            },
        },
    },

    # source content must be a scalar reference (check return false)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID    => $TemplateIDs[1],
                SourceContent => {},
                UserID        => 1,
            },
        },
    },

    # source content must be a scalar reference (check return false)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID    => $TemplateIDs[1],
                SourceContent => '',
                UserID        => 1,
            },
        },
    },

    # no existing template id is given (check return false)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID    => $TemplateIDs[-1] + 1,
                SourceContent => \do {'Dummy'},
                UserID        => 1,
            },
        },
    },

    # no column seperator and charset are given (check return false)
    {
        SourceImportData => {
            ImportDataGet => {
                TemplateID    => $TemplateIDs[2],
                SourceContent => \do {'Dummy'},
                UserID        => 1,
            },
        },
    },

    # no column seperator is given (check return false)
    {
        SourceImportData => {
            FormatData => {
                Charset => 'UTF-8',
            },
            ImportDataGet => {
                TemplateID    => $TemplateIDs[2],
                SourceContent => \do {'Dummy'},
                UserID        => 1,
            },
        },
    },

    # no charset is given (check return false)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Dummy',
            },
            ImportDataGet => {
                TemplateID    => $TemplateIDs[2],
                SourceContent => \do {'Dummy'},
                UserID        => 1,
            },
        },
    },

    # invalid column seperator is given (check return false)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Dummy',
                Charset         => 'UTF-8',
            },
            ImportDataGet => {
                TemplateID    => $TemplateIDs[2],
                SourceContent => \do {'Dummy'},
                UserID        => 1,
            },
        },
    },

    # required values are given but source content is empty (empty array reference must be returned)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ImportDataGet => {
                TemplateID    => $TemplateIDs[3],
                SourceContent => \do {''},
                UserID        => 1,
            },
        },
        ReferenceImportData => [],
    },

    # source content is only a string with spaces (one cell array with the spaces must be returned)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ImportDataGet => {
                TemplateID    => $TemplateIDs[4],
                SourceContent => \do {'  '},
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            ['  '],
        ],
    },

    # all required values are given (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
            [ 'Row2-Col1', 'Row2-Col2', 'Row2-Col3' ],
            [ 'Row3-Col1', 'Row3-Col2', 'Row3-Col3' ],
        ],
    },

    # all required values are given, but Tabulator is used as seperator (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            ['Row1-Col1;Row1-Col2;Row1-Col3'],
            ['Row2-Col1;Row2-Col2;Row2-Col3'],
            ['Row3-Col1;Row3-Col2;Row3-Col3'],
        ],
    },

    # all required values are given (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
            [ 'Row2-Col1', 'Row2-Col2', 'Row2-Col3' ],
            [ 'Row3-Col1', 'Row3-Col2', 'Row3-Col3' ],
        ],
    },

    # all required values are given, but Semicolon is used as seperator (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            ["Row1-Col1\tRow1-Col2\tRow1-Col3"],
            ["Row2-Col1\tRow2-Col2\tRow2-Col3"],
            ["Row3-Col1\tRow3-Col2\tRow3-Col3"],
        ],
    },

    # all required values are given (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
            [ 'Row2-Col1', 'Row2-Col2', 'Row2-Col3' ],
            [ 'Row3-Col1', 'Row3-Col2', 'Row3-Col3' ],
        ],
    },

    # all required values are given (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
            [ 'Row2-Col1', 'Row2-Col2', 'Row2-Col3' ],
            [ 'Row3-Col1', 'Row3-Col2', 'Row3-Col3' ],
        ],
    },

    # all required values are given (check the parsed content)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV001-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[5],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
            [ 'Row2-Col1', 'Row2-Col2', 'Row2-Col3' ],
            [ 'Row3-Col1', 'Row3-Col2', 'Row3-Col3' ],
        ],
    },

    # all required values are given (newline checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV002-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[6],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ "\nTest 1 - 1", "Test 1 - 2",   "Test 1\n- 3",  'Test \n\t\r\s' ],
            [ "Test 2 \n- 1", "Te\nst 2 - 2", "Test 2 - 3\n", '' ],
        ],
    },

    # all required values are given (newline checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV002-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[6],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ "\nTest 1 - 1", 'Test 1 - 2',   "Test 1\n- 3",  'Test \n\t\r\s' ],
            [ "Test 2 \n- 1", "Te\nst 2 - 2", "Test 2 - 3\n", '' ],
        ],
    },

    # all required values are given (newline checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV002-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[6],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ "\nTest 1 - 1", "Test 1 - 2",   "Test 1\n- 3",  'Test \n\t\r\s' ],
            [ "Test 2 \n- 1", "Te\nst 2 - 2", "Test 2 - 3\n", '' ],
        ],
    },

    # all required values are given (newline checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV002-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[6],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ "\nTest 1 - 1", "Test 1 - 2",   "Test 1\n- 3",  'Test \n\t\r\s' ],
            [ "Test 2 \n- 1", "Te\nst 2 - 2", "Test 2 - 3\n", '' ],
        ],
    },

    # all required values are given (newline checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV002-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[6],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ "\nTest 1 - 1", "Test 1 - 2",   "Test 1\n- 3",  'Test \n\t\r\s' ],
            [ "Test 2 \n- 1", "Te\nst 2 - 2", "Test 2 - 3\n", '' ],
        ],
    },

    # all required values are given (spaces checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV003-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[7],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ '  Test  ', '    ', 'Test  ' ],
            [ '    Test', '',     'Test' ],
            [ '',         '',     ' ' ],
        ],
    },

    # all required values are given (spaces checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV003-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[7],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ '  Test  ', '    ', 'Test  ' ],
            [ '    Test', '',     'Test' ],
            [ '',         '',     ' ' ],
        ],
    },

    # all required values are given (spaces checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV003-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[7],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ '  Test  ', '    ', 'Test  ' ],
            [ '    Test', '',     'Test' ],
            [ '',         '',     ' ' ],
        ],
    },

    # all required values are given (spaces checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV003-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[7],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ '  Test  ', '    ', 'Test  ' ],
            [ '    Test', '',     'Test' ],
            [ '',         '',     ' ' ],
        ],
    },

    # all required values are given (spaces checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV003-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[7],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ '  Test  ', '    ', 'Test  ' ],
            [ '    Test', '',     'Test' ],
            [ '',         '',     ' ' ],
        ],
    },

    # all required values are given (special character checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV004-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[8],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Test;:_°^!"§$%&/()=?´`*+Test', '><@~\'}{[]\\' ],
            [ '"";;::..--__##',                  '' ],
        ],
    },

    # all required values are given (special character checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV004-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[8],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Test;:_°^!"§$%&/()=?´`*+Test', '><@~\'}{[]\\' ],
            [ '"";;::..--__##',                  '' ],
        ],
    },

    # all required values are given (special character checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV004-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[8],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Test;:_°^!"§$%&/()=?´`*+Test', '><@~\'}{[]\\' ],
            [ '"";;::..--__##',                  '' ],
        ],
    },

    # all required values are given (special character checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV004-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[8],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Test;:_°^!"§$%&/()=?´`*+Test', '><@~\'}{[]\\' ],
            [ '"";;::..--__##',                  '' ],
        ],
    },

    # all required values are given (special character checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV004-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[8],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'Test;:_°^!"§$%&/()=?´`*+Test', '><@~\'}{[]\\' ],
            [ '"";;::..--__##',                  '' ],
        ],
    },

    # all required values are given (ISO-8859 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV005-MSExcel-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[9],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'üöäß', 'ÜÖÄ' ],
            [ 'ßäöü', 'ÄÖÜ' ],
        ],
    },

    # all required values are given (ISO-8859 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV005-MSExcel-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[9],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'üöäß', 'ÜÖÄ' ],
            [ 'ßäöü', 'ÄÖÜ' ],
        ],
    },

    # all required values are given (ISO-8859 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV005-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[9],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'üöäß', 'ÜÖÄ' ],
            [ 'ßäöü', 'ÄÖÜ' ],
        ],
    },

    # all required values are given (ISO-8859 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV005-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[9],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'üöäß', 'ÜÖÄ' ],
            [ 'ßäöü', 'ÄÖÜ' ],
        ],
    },

    # all required values are given (ISO-8859 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            SourceFile    => 'ImportExportFormatCSV005-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[9],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'üöäß', 'ÜÖÄ' ],
            [ 'ßäöü', 'ÄÖÜ' ],
        ],
    },

    # all required values are given (UTF-8 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            SourceFile    => 'ImportExportFormatCSV006-OpenOffice-Semicolon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[10],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'ʩ ʬ ʮ',     ' ʡ ˤ Ό ' ],
            [ '  Η ϗ Ϡ  ', 'Ά Λ Ξ' ],
        ],
    },

    # all required values are given (UTF-8 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'UTF-8',
            },
            SourceFile    => 'ImportExportFormatCSV006-OpenOffice-Tabulator.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[10],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'ʩ ʬ ʮ',     ' ʡ ˤ Ό ' ],
            [ '  Η ϗ Ϡ  ', 'Ά Λ Ξ' ],
        ],
    },

    # all required values are given (UTF-8 checks)
    {
        SourceImportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'UTF-8',
            },
            SourceFile    => 'ImportExportFormatCSV006-OpenOffice-Colon.csv',
            ImportDataGet => {
                TemplateID    => $TemplateIDs[10],
                SourceContent => 'SourceFile',
                UserID        => 1,
            },
        },
        ReferenceImportData => [
            [ 'ʩ ʬ ʮ',     ' ʡ ˤ Ό ' ],
            [ '  Η ϗ Ϡ  ', 'Ά Λ Ξ' ],
        ],
    },
];

# ------------------------------------------------------------ #
# run general ImportDataGet tests
# ------------------------------------------------------------ #

TEST:
for my $Test ( @{$ImportDataTests} ) {

    # check SourceImportData attribute
    if ( !$Test->{SourceImportData} || ref $Test->{SourceImportData} ne 'HASH' ) {

        $Self->True(
            0,
            "Test $TestCount: No SourceImportData found for this test."
        );

        next TEST;
    }

    # set default ImportDataGet
    if ( !$Test->{SourceImportData}->{ImportDataGet} ) {
        $Test->{SourceImportData}->{ImportDataGet} = {};
    }

    # set source content
    if (
        $Test->{SourceImportData}->{SourceFile}
        && $Test->{SourceImportData}->{ImportDataGet}->{SourceContent}
        && $Test->{SourceImportData}->{ImportDataGet}->{SourceContent} eq 'SourceFile'
        )
    {

        my $SourceFile = $Test->{SourceImportData}->{SourceFile};

        # read source file
        my $SourceContent = $Self->{MainObject}->FileRead(
            Location => $Self->{Home} . '/scripts/test/sample/' . $SourceFile,
            Result   => 'SCALAR',
            Mode     => 'binmode',
        );

        $Test->{SourceImportData}->{ImportDataGet}->{SourceContent} = $SourceContent;
    }

    # set the format data
    if (
        $Test->{SourceImportData}->{FormatData}
        && ref $Test->{SourceImportData}->{FormatData} eq 'HASH'
        && $Test->{SourceImportData}->{ImportDataGet}->{TemplateID}
        )
    {

        # save format data
        $Self->{ImportExportObject}->FormatDataSave(
            TemplateID => $Test->{SourceImportData}->{ImportDataGet}->{TemplateID},
            FormatData => $Test->{SourceImportData}->{FormatData},
            UserID     => 1,
        );
    }

    # get import data
    my $ImportData = $Self->{FormatBackendObject}->ImportDataGet(
        %{ $Test->{SourceImportData}->{ImportDataGet} },
    );

    if ( !$Test->{ReferenceImportData} ) {

        $Self->False(
            $ImportData,
            "Test $TestCount: ImportDataGet() - return false"
        );

        next TEST;
    }

    if ( ref $ImportData ne 'ARRAY' ) {

        # check array reference
        $Self->True(
            0,
            "Test $TestCount: ImportDataGet() - return value is an array reference",
        );

        next TEST;
    }

    # check number of rows
    $Self->Is(
        scalar @{$ImportData},
        scalar @{ $Test->{ReferenceImportData} },
        "Test $TestCount: ImportDataGet() - same number of rows",
    );

    # check content of import data
    my $CounterRow = 0;
    ROW:
    for my $ImportRow ( @{$ImportData} ) {

        # extract reference row
        my $ReferenceRow = $Test->{ReferenceImportData}->[$CounterRow];

        if ( ref $ImportRow ne 'ARRAY' || ref $ReferenceRow ne 'ARRAY' ) {

            # check array reference
            $Self->True(
                0,
                "Test $TestCount: ImportDataGet() - import row and reference row matched",
            );

            next TEST;
        }

        # check number of columns
        $Self->Is(
            scalar @{$ImportRow},
            scalar @{$ReferenceRow},
            "Test $TestCount: ImportDataGet() - same number of columns",
        );

        my $CounterColumn = 0;
        for my $Cell ( @{$ImportRow} ) {

            # set content if values are undef
            if ( !defined $Cell ) {
                $Cell = 'UNDEF-unittest';
            }
            if ( !defined $ReferenceRow->[$CounterColumn] ) {
                $ReferenceRow->[$CounterColumn] = 'UNDEF-unittest';
            }

            # check cell data
            $Self->Is(
                $Cell,
                $ReferenceRow->[$CounterColumn],
                "Test $TestCount: ImportDataGet() ",
            );

            $CounterColumn++;
        }

        $CounterRow++;
    }
}
continue {
    $TestCount++;
}

# ------------------------------------------------------------ #
# define general ExportDataSave tests
# ------------------------------------------------------------ #

my $ExportDataTests = [

    # ExportDataSave doesn't contains all data (check required attributes)
    {
        SourceExportData => {
            ExportDataSave => {
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # ExportDataSave doesn't contains all data (check required attributes)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID => $TemplateIDs[20],
                UserID     => 1,
            },
        },
    },

    # ExportDataSave doesn't contains all data (check required attributes)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID    => $TemplateIDs[20],
                ExportDataRow => ['Dummy'],
            },
        },
    },

    # export data row must be an array reference (check return false)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID    => $TemplateIDs[20],
                ExportDataRow => '',
                UserID        => 1,
            },
        },
    },

    # export data row must be an array reference (check return false)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID    => $TemplateIDs[20],
                ExportDataRow => {},
                UserID        => 1,
            },
        },
    },

    # no existing template id is given (check return false)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID    => $TemplateIDs[-1] + 1,
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # no column seperator and charset are given (check return false)
    {
        SourceExportData => {
            ExportDataSave => {
                TemplateID    => $TemplateIDs[21],
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # no column seperator is given (check return false)
    {
        SourceExportData => {
            FormatData => {
                Charset => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[21],
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # no charset is given (check return false)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dummy',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[21],
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # invalid column seperator is given (check return false)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dummy',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[21],
                ExportDataRow => ['Dummy'],
                UserID        => 1,
            },
        },
    },

    # export data are one cells with empty strings (one empty cell must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [''],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '""',
    },

    # export data are one cells with empty strings (one empty cell must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [''],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '""',
    },

    # export data are one cells with empty strings (one empty cell must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [''],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '""',
    },

    # export data are one cells with empty strings (one empty cell must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [''],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '""',
    },

    # export data are three cells with empty strings (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ '', '', '' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"";"";""',
    },

    # export data are three cells with empty strings (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ '', '', '' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => "\"\"\t\"\"\t\"\"",
    },

    # export data are three cells with empty strings (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ '', '', '' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"":"":""',
    },

    # export data are three cells with empty strings (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ '', '', '' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '""."".""',
    },

    # export data are three cells with empty and undef content (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ undef, '', undef ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => ';"";',
    },

    # export data are three cells with empty and undef content (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ undef, '', undef ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => "\t\"\"\t",
    },

    # export data are three cells with empty and undef content (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ undef, '', undef ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => ':"":',
    },

    # export data are three cells with empty and undef content (three empty cells must be returned)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[22],
                ExportDataRow => [ undef, '', undef ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '."".',
    },

    # all required values are given (check the parsed content)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[23],
                ExportDataRow => [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"Row1-Col1";"Row1-Col2";"Row1-Col3"',
    },

    # all required values are given (check the parsed content)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[23],
                ExportDataRow => [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => "\"Row1-Col1\"\t\"Row1-Col2\"\t\"Row1-Col3\"",
    },

    # all required values are given (check the parsed content)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[23],
                ExportDataRow => [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"Row1-Col1":"Row1-Col2":"Row1-Col3"',
    },

    # all required values are given (check the parsed content)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[23],
                ExportDataRow => [ 'Row1-Col1', 'Row1-Col2', 'Row1-Col3' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"Row1-Col1"."Row1-Col2"."Row1-Col3"',
    },

    # all required values are given (newline checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ "\nTest 1", "Test \n 2", 'Test 3 \n\t\r\s', "Test 4\n" ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => qq{"\nTest 1";"Test \n 2";"Test 3 \\n\\t\\r\\s";"Test 4\n"},
    },

    # all required values are given (newline checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ "\nTest 1", "Test \n 2", 'Test 3 \n\t\r\s', "Test 4\n" ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent =>
            qq{"\nTest 1"\t"Test \n 2"\t"Test 3 \\n\\t\\r\\s"\t"Test 4\n"},
    },

    # all required values are given (newline checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ "\nTest 1", "Test \n 2", 'Test 3 \n\t\r\s', "Test 4\n" ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => qq{"\nTest 1":"Test \n 2":"Test 3 \\n\\t\\r\\s":"Test 4\n"},
    },

    # all required values are given (newline checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ "\nTest 1", "Test \n 2", 'Test 3 \n\t\r\s', "Test 4\n" ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => qq{"\nTest 1"."Test \n 2"."Test 3 \\n\\t\\r\\s"."Test 4\n"},
    },

    # all required values are given (spaces checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ '  Test  ', '    ', 'Test  ', '    Test', '', 'Test', '', ' ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"  Test  ";"    ";"Test  ";"    Test";"";"Test";"";" "',
    },

    # all required values are given (spaces checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ '  Test  ', '    ', 'Test  ', '    Test', '', 'Test', '', ' ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent =>
            "\"  Test  \"\t\"    \"\t\"Test  \"\t\"    Test\"\t\"\"\t\"Test\"\t\"\"\t\" \"",
    },

    # all required values are given (spaces checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ '  Test  ', '    ', 'Test  ', '    Test', '', 'Test', '', ' ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"  Test  ":"    ":"Test  ":"    Test":"":"Test":"":" "',
    },

    # all required values are given (spaces checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[24],
                ExportDataRow => [ '  Test  ', '    ', 'Test  ', '    Test', '', 'Test', '', ' ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '"  Test  "."    "."Test  "."    Test".""."Test".""." "',
    },

    # all required values are given (special character checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[25],
                ExportDataRow => [
                    'Test;:_^!"$%&/()=?`*+Test',
                    '><@~\'}{[]\\',
                    '',
                    '"";;::..--__##'
                ],
                UserID => 1,
            },
        },
        ReferenceDestinationContent =>
            '"Test;:_^!""$%&/()=?`*+Test";"><@~\'}{[]\";"";""""";;::..--__##"'
    },

    # all required values are given (special character checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[25],
                ExportDataRow => [
                    'Test;:_^!"$%&/()=?`*+Test',
                    '><@~\'}{[]\\',
                    '',
                    '"";;::..--__##'
                ],
                UserID => 1,
            },
        },
        ReferenceDestinationContent =>
            '"Test;:_^!""$%&/()=?`*+Test"'
            . "\t"
            . '"><@~\'}{[]\\"'
            . "\t"
            . '""'
            . "\t"
            . '""""";;::..--__##"',
    },

    # all required values are given (special character checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[25],
                ExportDataRow => [
                    'Test;:_^!"$%&/()=?`*+Test',
                    '><@~\'}{[]\\',
                    '',
                    '"";;::..--__##'
                ],
                UserID => 1,
            },
        },
        ReferenceDestinationContent =>
            '"Test;:_^!""$%&/()=?`*+Test":"><@~\'}{[]\":"":""""";;::..--__##"',
    },

    # all required values are given (special character checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'ISO-8859-1',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[25],
                ExportDataRow => [
                    'Test;:_^!"$%&/()=?`*+Test',
                    '><@~\'}{[]\\',
                    '',
                    '"";;::..--__##'
                ],
                UserID => 1,
            },
        },
        ReferenceDestinationContent =>
            '"Test;:_^!""$%&/()=?`*+Test"."><@~\'}{[]\\"."".""""";;::..--__##"',
    },

    # all required values are given (UTF-8 checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Semicolon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[26],
                ExportDataRow => [ ' Ѫ Ѭ Ѳ', 'ѯ Ѵ ѿ', '҂ Ҋ Җ ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '" Ѫ Ѭ Ѳ";"ѯ Ѵ ѿ";"҂ Ҋ Җ "',
    },

    # all required values are given (UTF-8 checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Tabulator',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[26],
                ExportDataRow => [ ' Ѫ Ѭ Ѳ', 'ѯ Ѵ ѿ', '҂ Ҋ Җ ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => "\" Ѫ Ѭ Ѳ\"\t\"ѯ Ѵ ѿ\"\t\"҂ Ҋ Җ \"",
    },

    # all required values are given (UTF-8 checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Colon',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[26],
                ExportDataRow => [ ' Ѫ Ѭ Ѳ', 'ѯ Ѵ ѿ', '҂ Ҋ Җ ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '" Ѫ Ѭ Ѳ":"ѯ Ѵ ѿ":"҂ Ҋ Җ "',
    },

    # all required values are given (UTF-8 checks)
    {
        SourceExportData => {
            FormatData => {
                ColumnSeperator => 'Dot',
                Charset         => 'UTF-8',
            },
            ExportDataSave => {
                TemplateID    => $TemplateIDs[26],
                ExportDataRow => [ ' Ѫ Ѭ Ѳ', 'ѯ Ѵ ѿ', '҂ Ҋ Җ ' ],
                UserID        => 1,
            },
        },
        ReferenceDestinationContent => '" Ѫ Ѭ Ѳ"."ѯ Ѵ ѿ"."҂ Ҋ Җ "',
    },
];

# ------------------------------------------------------------ #
# run general ExportDataSave tests
# ------------------------------------------------------------ #

TEST:
for my $Test ( @{$ExportDataTests} ) {

    # check SourceExportData attribute
    if ( !$Test->{SourceExportData} || ref $Test->{SourceExportData} ne 'HASH' ) {

        $Self->True(
            0,
            "Test $TestCount: No SourceExportData found for this test."
        );

        next TEST;
    }

    # set default ExportDataSave
    if ( !$Test->{SourceExportData}->{ExportDataSave} ) {
        $Test->{SourceExportData}->{ExportDataSave} = {};
    }

    # set the format data
    if (
        $Test->{SourceExportData}->{FormatData}
        && ref $Test->{SourceExportData}->{FormatData} eq 'HASH'
        && $Test->{SourceExportData}->{ExportDataSave}->{TemplateID}
        )
    {

        # save format data
        $Self->{ImportExportObject}->FormatDataSave(
            TemplateID => $Test->{SourceExportData}->{ExportDataSave}->{TemplateID},
            FormatData => $Test->{SourceExportData}->{FormatData},
            UserID     => 1,
        );
    }

    # get export data row
    my $ExportString = $Self->{FormatBackendObject}->ExportDataSave(
        %{ $Test->{SourceExportData}->{ExportDataSave} },
    );

    if ( !defined $Test->{ReferenceDestinationContent} ) {

        $Self->True(
            !defined $ExportString,
            "Test $TestCount: ExportDataSave() - return false"
        );

        next TEST;
    }

    if ( !defined $ExportString ) {

        $Self->True(
            !defined $Test->{ReferenceDestinationContent},
            "Test $TestCount: ExportDataSave() - return false"
        );

        next TEST;
    }

    if ( !$Test->{SourceExportData}->{ExportDataSave}->{ExportDataRow} ) {

        $Self->True(
            defined $ExportString,
            "Test $TestCount: ExportDataSave() - return false"
        );

        next TEST;
    }

    # check the export string
    $Self->Is(
        $ExportString,
        $Test->{ReferenceDestinationContent},
        "Test $TestCount: ExportDataSave()",
    );
}
continue {
    $TestCount++;
}

# ------------------------------------------------------------ #
# clean the system
# ------------------------------------------------------------ #

# delete the test templates
$Self->{ImportExportObject}->TemplateDelete(
    TemplateID => \@TemplateIDs,
    UserID     => 1,
);

1;

Um93MS1Db2wxO1JvdzEtQ29sMjtSb3cxLUNvbDMNClJvdzItQ29sMTtSb3cyLUNvbDI7Um93Mi1Db2wzDQpSb3czLUNvbDE7Um93My1Db2wyO1JvdzMtQ29sMw0K
Um93MS1Db2wxCVJvdzEtQ29sMglSb3cxLUNvbDMNClJvdzItQ29sMQlSb3cyLUNvbDIJUm93Mi1Db2wzDQpSb3czLUNvbDEJUm93My1Db2wyCVJvdzMtQ29sMw0K
IlJvdzEtQ29sMSI6IlJvdzEtQ29sMiI6IlJvdzEtQ29sMyINCiJSb3cyLUNvbDEiOiJSb3cyLUNvbDIiOiJSb3cyLUNvbDMiDQoiUm93My1Db2wxIjoiUm93My1Db2wyIjoiUm93My1Db2wzIg0K
IlJvdzEtQ29sMSI7IlJvdzEtQ29sMiI7IlJvdzEtQ29sMyINCiJSb3cyLUNvbDEiOyJSb3cyLUNvbDIiOyJSb3cyLUNvbDMiDQoiUm93My1Db2wxIjsiUm93My1Db2wyIjsiUm93My1Db2wzIg0K
IlJvdzEtQ29sMSIJIlJvdzEtQ29sMiIJIlJvdzEtQ29sMyINCiJSb3cyLUNvbDEiCSJSb3cyLUNvbDIiCSJSb3cyLUNvbDMiDQoiUm93My1Db2wxIgkiUm93My1Db2wyIgkiUm93My1Db2wzIg0K
IgpUZXN0IDEgLSAxIjtUZXN0IDEgLSAyOyJUZXN0IDEKLSAzIjtUZXN0IFxuXHRcclxzDQoiVGVzdCAyIAotIDEiOyJUZQpzdCAyIC0gMiI7IlRlc3QgMiAtIDMKIjsNCg==
IgpUZXN0IDEgLSAxIglUZXN0IDEgLSAyCSJUZXN0IDEKLSAzIglUZXN0IFxuXHRcclxzDQoiVGVzdCAyIAotIDEiCSJUZQpzdCAyIC0gMiIJIlRlc3QgMiAtIDMKIgkNCg==
IgpUZXN0IDEgLSAxIjoiVGVzdCAxIC0gMiI6IlRlc3QgMQotIDMiOiJUZXN0IFxuXHRcclxzIg0KIlRlc3QgMiAKLSAxIjoiVGUKc3QgMiAtIDIiOiJUZXN0IDIgLSAzCiI6DQo=
IgpUZXN0IDEgLSAxIjsiVGVzdCAxIC0gMiI7IlRlc3QgMQotIDMiOyJUZXN0IFxuXHRcclxzIg0KIlRlc3QgMiAKLSAxIjsiVGUKc3QgMiAtIDIiOyJUZXN0IDIgLSAzCiI7DQo=
IgpUZXN0IDEgLSAxIgkiVGVzdCAxIC0gMiIJIlRlc3QgMQotIDMiCSJUZXN0IFxuXHRcclxzIg0KIlRlc3QgMiAKLSAxIgkiVGUKc3QgMiAtIDIiCSJUZXN0IDIgLSAzCiIJDQo=
ICBUZXN0ICA7ICAgIDtUZXN0ICANCiAgICBUZXN0OztUZXN0DQo7OyANCg==
ICBUZXN0ICAJICAgIAlUZXN0ICANCiAgICBUZXN0CQlUZXN0DQoJCSANCg==
IiAgVGVzdCAgIjoiICAgICI6IlRlc3QgICINCiIgICAgVGVzdCI6OiJUZXN0Ig0KOjoiICINCg==
IiAgVGVzdCAgIjsiICAgICI7IlRlc3QgICINCiIgICAgVGVzdCI7OyJUZXN0Ig0KOzsiICINCg==
IiAgVGVzdCAgIgkiICAgICIJIlRlc3QgICINCiIgICAgVGVzdCIJCSJUZXN0Ig0KCQkiICINCg==
IlRlc3Q7Ol+wXiEiIqckJSYvKCk9P7RgKitUZXN0Ijs+PEB+J317W11cDQoiIiIiIjs7OjouLi0tX18jIyI7DQo=
IlRlc3Q7Ol+wXiEiIqckJSYvKCk9P7RgKitUZXN0Igk+PEB+J317W11cDQoiIiIiIjs7OjouLi0tX18jIyIJDQo=
IlRlc3Q7Ol+wXiEiIqckJSYvKCk9P7RgKitUZXN0IjoiPjxAfid9e1tdXCINCiIiIiIiOzs6Oi4uLS1fXyMjIjoNCg==
IlRlc3Q7Ol+wXiEiIqckJSYvKCk9P7RgKitUZXN0IjsiPjxAfid9e1tdXCINCiIiIiIiOzs6Oi4uLS1fXyMjIjsNCg==
IlRlc3Q7Ol+wXiEiIqckJSYvKCk9P7RgKitUZXN0IgkiPjxAfid9e1tdXCINCiIiIiIiOzs6Oi4uLS1fXyMjIgkNCg==
/Pbk3zvc1sQNCt/k9vw7xNbcDQo=
/Pbk3wnc1sQNCt/k9vwJxNbcDQo=
Ivz25N8iOiLc1sQiDQoi3+T2/CI6IsTW3CINCg==
Ivz25N8iOyLc1sQiDQoi3+T2/CI7IsTW3CINCg==
Ivz25N8iCSLc1sQiDQoi3+T2/CIJIsTW3CINCg==
IsqpIMqsIMquIjsiIMqhIMukIM6MICINCiIgIM6XIM+XIM+gICAiOyLOhiDOmyDOniINCg==
IsqpIMqsIMquIjoiIMqhIMukIM6MICINCiIgIM6XIM+XIM+gICAiOiLOhiDOmyDOniINCg==
IsqpIMqsIMquIgkiIMqhIMukIM6MICINCiIgIM6XIM+XIM+gICAiCSLOhiDOmyDOniINCg==