1869 lines
54 KiB
Perl
1869 lines
54 KiB
Perl
# --
|
|
# Copyright (C) 2001-2019 OTRS AG, https://otrs.com/
|
|
# --
|
|
# 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 https://www.gnu.org/licenses/gpl-3.0.txt.
|
|
# --
|
|
|
|
package Kernel::Modules::AdminImportExport;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use Kernel::Language qw(Translatable);
|
|
|
|
our $ObjectManagerDisabled = 1;
|
|
|
|
sub new {
|
|
my ( $Type, %Param ) = @_;
|
|
|
|
# allocate new hash for object
|
|
my $Self = {%Param};
|
|
bless( $Self, $Type );
|
|
|
|
return $Self;
|
|
}
|
|
|
|
sub Run {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
# get needed objects
|
|
my $ImportExportObject = $Kernel::OM->Get('Kernel::System::ImportExport');
|
|
my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template edit (common)
|
|
# ------------------------------------------------------------ #
|
|
if ( $Self->{Subaction} eq 'TemplateEdit1' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get params
|
|
my $TemplateData;
|
|
my $TemplateID = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
my $SaveContinue = $ParamObject->GetParam( Param => 'SubmitNext' );
|
|
|
|
if ( !$SaveContinue ) {
|
|
|
|
# if needed new form
|
|
if ( !$TemplateID ) {
|
|
return $Self->_MaskTemplateEdit1(
|
|
New => 1,
|
|
%Param,
|
|
);
|
|
}
|
|
|
|
# if there is template id
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# if edit
|
|
if ( $TemplateData->{TemplateID} ) {
|
|
return $Self->_MaskTemplateEdit1( %Param, %{$TemplateData} );
|
|
}
|
|
}
|
|
|
|
# if save & continue
|
|
my %ServerError;
|
|
|
|
# get all data for params and check for errors
|
|
for my $Param (qw(Comment Object Format Name ValidID TemplateID)) {
|
|
$TemplateData->{$Param} = $ParamObject->GetParam( Param => $Param ) || '';
|
|
}
|
|
|
|
# is a new template?
|
|
my $New;
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$New = 1;
|
|
}
|
|
|
|
# check needed fields
|
|
# for new templates
|
|
if ($New) {
|
|
|
|
if ( !$TemplateData->{Object} ) {
|
|
$ServerError{Object} = 1;
|
|
}
|
|
|
|
if ( !$TemplateData->{Format} ) {
|
|
$ServerError{Format} = 1;
|
|
}
|
|
|
|
}
|
|
|
|
# for all templates
|
|
if ( !$TemplateData->{Name} ) {
|
|
$ServerError{Name} = 1;
|
|
}
|
|
|
|
# if some error
|
|
if ( $ServerError{Format} || $ServerError{Object} || $ServerError{Name} ) {
|
|
return $Self->_MaskTemplateEdit1(
|
|
ServerError => \%ServerError,
|
|
New => $New,
|
|
%{$TemplateData},
|
|
);
|
|
}
|
|
|
|
# save to database
|
|
my $Success;
|
|
|
|
if ($New) {
|
|
$TemplateData->{TemplateID} = $ImportExportObject->TemplateAdd(
|
|
%{$TemplateData},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
$Success = $TemplateData->{TemplateID};
|
|
}
|
|
else {
|
|
$Success = $ImportExportObject->TemplateUpdate(
|
|
UserID => $Self->{UserID},
|
|
%{$TemplateData},
|
|
);
|
|
}
|
|
|
|
if ( !$Success ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Can\'t insert/update template!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP =>
|
|
"Action=$Self->{Action};Subaction=TemplateEdit2;TemplateID=$TemplateData->{TemplateID}",
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template edit (object)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateEdit2' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get template id
|
|
my $TemplateID = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
if ( !$TemplateID ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Needed TemplateID!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
my $SubmitNext = $ParamObject->GetParam( Param => 'SubmitNext' );
|
|
|
|
if ( !$SubmitNext ) {
|
|
return $Self->_MaskTemplateEdit2( TemplateID => $TemplateID );
|
|
}
|
|
|
|
# save template starts here
|
|
|
|
# get object attributes
|
|
my $ObjectAttributeList = $ImportExportObject->ObjectAttributesGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
my %AttributeValues;
|
|
|
|
my $Error = 0;
|
|
my %ServerError;
|
|
my %DataTypeError;
|
|
|
|
# get attribute values from form
|
|
for my $Item ( @{$ObjectAttributeList} ) {
|
|
|
|
# get form data
|
|
$AttributeValues{ $Item->{Key} } = $LayoutObject->ImportExportFormDataGet(
|
|
Item => $Item,
|
|
);
|
|
|
|
# reload form if value is required and is not there
|
|
if ( $Item->{Form}->{Invalid} ) {
|
|
$ServerError{ $Item->{Name} } = 1;
|
|
$Error = 1;
|
|
}
|
|
|
|
if ( $AttributeValues{ $Item->{Key} } ) {
|
|
|
|
# look for regexp for data type allowed
|
|
if (
|
|
$Item->{Input}->{Regex}
|
|
&&
|
|
!$AttributeValues{ $Item->{Key} } =~ $Item->{Input}->{Regex}
|
|
)
|
|
{
|
|
|
|
$DataTypeError{ $Item->{Name} } = 1;
|
|
$Error = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
# reload with server errors
|
|
if ($Error) {
|
|
return $Self->_MaskTemplateEdit2(
|
|
ServerError => \%ServerError,
|
|
DataTypeError => \%DataTypeError,
|
|
TemplateDataForm => \%AttributeValues,
|
|
TemplateID => $TemplateID,
|
|
);
|
|
}
|
|
|
|
# save the object data
|
|
$ImportExportObject->ObjectDataSave(
|
|
TemplateID => $TemplateID,
|
|
ObjectData => \%AttributeValues,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=$Self->{Action};Subaction=TemplateEdit3;TemplateID=$TemplateID",
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template edit (format)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateEdit3' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get template id
|
|
my $TemplateID = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
if ( !$TemplateID ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Needed TemplateID!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
my $SubmitNext = $ParamObject->GetParam( Param => 'SubmitNext' );
|
|
|
|
if ( !$SubmitNext ) {
|
|
return $Self->_MaskTemplateEdit3( TemplateID => $TemplateID );
|
|
}
|
|
|
|
# save starting here
|
|
|
|
# get format attributes
|
|
my $FormatAttributeList = $ImportExportObject->FormatAttributesGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get format data
|
|
my $FormatData = $ImportExportObject->FormatDataGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
my $Error = 0;
|
|
my %ServerError;
|
|
|
|
# get attribute values from form
|
|
my %AttributeValues;
|
|
for my $Item ( @{$FormatAttributeList} ) {
|
|
|
|
# get form data
|
|
$AttributeValues{ $Item->{Key} } = $LayoutObject->ImportExportFormDataGet(
|
|
Item => $Item,
|
|
);
|
|
|
|
# reload form if value is required
|
|
if ( $Item->{Form}->{Invalid} ) {
|
|
$ServerError{ $Item->{Name} } = 1;
|
|
$Error = 1;
|
|
}
|
|
}
|
|
|
|
# reload with server errors
|
|
if ($Error) {
|
|
return $Self->_MaskTemplateEdit3(
|
|
ServerError => \%ServerError,
|
|
TemplateID => $TemplateID,
|
|
);
|
|
}
|
|
|
|
# save the format data
|
|
$ImportExportObject->FormatDataSave(
|
|
TemplateID => $TemplateID,
|
|
FormatData => \%AttributeValues,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=$Self->{Action};Subaction=TemplateEdit4;TemplateID=$TemplateID",
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template edit (mapping)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateEdit4' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get params
|
|
my $TemplateData = {};
|
|
$TemplateData->{TemplateID} = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# generate ObjectOptionStrg
|
|
my $ObjectOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $ObjectList,
|
|
Name => 'Object',
|
|
SelectedID => $TemplateData->{Object},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# generate FormatOptionStrg
|
|
my $FormatOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $FormatList,
|
|
Name => 'Format',
|
|
SelectedID => $TemplateData->{Format},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => {
|
|
%Param,
|
|
ObjectOptionStrg => $ObjectOptionStrg,
|
|
FormatOptionStrg => $FormatOptionStrg,
|
|
},
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'TemplateEdit4',
|
|
Value => 1,
|
|
);
|
|
|
|
# output headline
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4',
|
|
Data => {
|
|
%{$TemplateData},
|
|
ObjectName => $ObjectList->{ $TemplateData->{Object} },
|
|
FormatName => $FormatList->{ $TemplateData->{Format} },
|
|
},
|
|
);
|
|
|
|
# get mapping data list
|
|
my $MappingList = $ImportExportObject->MappingList(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get object attributes
|
|
my $MappingObjectAttributes = $ImportExportObject->MappingObjectAttributesGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get format attributes
|
|
my $MappingFormatAttributes = $ImportExportObject->MappingFormatAttributesGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# create headers for object and add common headers
|
|
my @Headers;
|
|
|
|
for my $Header ( @{$MappingObjectAttributes} ) {
|
|
push @Headers, $Header->{Name};
|
|
}
|
|
|
|
for my $CommonHeader ( 'Column', 'Up', 'Down', 'Delete' ) {
|
|
push @Headers, $CommonHeader;
|
|
}
|
|
|
|
for my $Header (@Headers) {
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4TableHeader',
|
|
Data => {
|
|
Header => $Header,
|
|
},
|
|
);
|
|
}
|
|
|
|
# to use in colspan for 'no data found' message
|
|
my $HeaderCounter = @Headers;
|
|
|
|
my $EmptyMap = 1;
|
|
my $AttributeRowCounter = 0;
|
|
for my $MappingID ( @{$MappingList} ) {
|
|
|
|
$EmptyMap = 0;
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4Row',
|
|
Data => {
|
|
MappingID => $MappingID,
|
|
},
|
|
);
|
|
|
|
# get mapping object data
|
|
my $MappingObjectData = $ImportExportObject->MappingObjectDataGet(
|
|
MappingID => $MappingID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get mapping format data
|
|
my $MappingFormatData = $ImportExportObject->MappingFormatDataGet(
|
|
MappingID => $MappingID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
for my $Item ( @{$MappingObjectAttributes} ) {
|
|
|
|
# create form input
|
|
my $InputString = $LayoutObject->ImportExportFormInputCreate(
|
|
Item => $Item,
|
|
Prefix => 'Object::' . $AttributeRowCounter . '::',
|
|
Value => $MappingObjectData->{ $Item->{Key} },
|
|
ID => $Item->{Key} . $AttributeRowCounter,
|
|
);
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4Column',
|
|
Data => {
|
|
Name => $Item->{Name},
|
|
ID => 'Object::' . $AttributeRowCounter . '::' . $Item->{Key},
|
|
InputStrg => $InputString,
|
|
Counter => $AttributeRowCounter,
|
|
},
|
|
);
|
|
}
|
|
|
|
for my $Item ( @{$MappingFormatAttributes} ) {
|
|
|
|
# output column counter
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4MapNumberColumn',
|
|
Data => {
|
|
Counter => $AttributeRowCounter,
|
|
},
|
|
);
|
|
}
|
|
|
|
# hide the up button for first element and down button for the last element
|
|
my $UpBlock;
|
|
my $DownBlock;
|
|
my $NumberOfElements = @{$MappingList};
|
|
|
|
if ( $AttributeRowCounter == 0 ) {
|
|
$UpBlock = 'TemplateEdit4NoUpButton';
|
|
}
|
|
else {
|
|
$UpBlock = 'TemplateEdit4UpButton';
|
|
}
|
|
|
|
# check if this is the last element
|
|
if ( $AttributeRowCounter == ( $NumberOfElements - 1 ) ) {
|
|
$DownBlock = 'TemplateEdit4NoDownButton';
|
|
}
|
|
else {
|
|
$DownBlock = 'TemplateEdit4DownButton';
|
|
}
|
|
|
|
# up button block
|
|
$LayoutObject->Block(
|
|
Name => $UpBlock,
|
|
Data => { MappingID => $MappingID },
|
|
);
|
|
|
|
# down button block
|
|
$LayoutObject->Block(
|
|
Name => $DownBlock,
|
|
Data => { MappingID => $MappingID },
|
|
);
|
|
|
|
$AttributeRowCounter++;
|
|
}
|
|
|
|
# output an empty list
|
|
if ($EmptyMap) {
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit4NoMapFound',
|
|
Data => {
|
|
Columns => $HeaderCounter,
|
|
},
|
|
);
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template save (mapping)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateSave4' ) {
|
|
|
|
# get template id
|
|
my $TemplateID = $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 ( sort keys %Submit ) {
|
|
next PARAM if !$ParamObject->GetParam( Param => $SubmitKey );
|
|
|
|
$Subaction = $Submit{$SubmitKey};
|
|
$SubmitButton = $SubmitKey;
|
|
last PARAM;
|
|
}
|
|
|
|
# get mapping data list
|
|
my $MappingList = $ImportExportObject->MappingList(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get object attributes
|
|
my $MappingObjectAttributes = $ImportExportObject->MappingObjectAttributesGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get format attributes
|
|
my $MappingFormatAttributes = $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} } = $LayoutObject->ImportExportFormDataGet(
|
|
Item => $Item,
|
|
Prefix => 'Object::' . $Counter . '::',
|
|
);
|
|
}
|
|
|
|
# save the mapping object data
|
|
$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} } = $LayoutObject->ImportExportFormDataGet(
|
|
Item => $Item,
|
|
Prefix => 'Format::' . $Counter . '::',
|
|
);
|
|
}
|
|
|
|
# save the mapping format data
|
|
$ImportExportObject->MappingFormatDataSave(
|
|
MappingID => $MappingID,
|
|
MappingFormatData => \%FormatAttributeValues,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
$Counter++;
|
|
}
|
|
|
|
MAPPINGID:
|
|
for my $MappingID ( @{$MappingList} ) {
|
|
|
|
# delete this mapping row
|
|
if ( $ParamObject->GetParam( Param => "MappingDelete::$MappingID" ) ) {
|
|
$ImportExportObject->MappingDelete(
|
|
MappingID => $MappingID,
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
next MAPPINGID;
|
|
}
|
|
|
|
# move mapping data row up
|
|
if ( $ParamObject->GetParam( Param => "MappingUp::$MappingID" ) ) {
|
|
$ImportExportObject->MappingUp(
|
|
MappingID => $MappingID,
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
next MAPPINGID;
|
|
}
|
|
|
|
# move mapping data row down
|
|
if ( $ParamObject->GetParam( Param => "MappingDown::$MappingID" ) ) {
|
|
$ImportExportObject->MappingDown(
|
|
MappingID => $MappingID,
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
next MAPPINGID;
|
|
}
|
|
}
|
|
|
|
# add a new mapping row
|
|
if ( $SubmitButton eq 'MappingAdd' ) {
|
|
$ImportExportObject->MappingAdd(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
}
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=$Self->{Action};Subaction=$Subaction;TemplateID=$TemplateID",
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template edit (search)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateEdit5' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get params
|
|
my $TemplateData = {};
|
|
$TemplateData->{TemplateID} = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# generate ObjectOptionStrg
|
|
my $ObjectOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $ObjectList,
|
|
Name => 'Object',
|
|
SelectedID => $TemplateData->{Object},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# generate FormatOptionStrg
|
|
my $FormatOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $FormatList,
|
|
Name => 'Format',
|
|
SelectedID => $TemplateData->{Format},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => {
|
|
%Param,
|
|
ObjectOptionStrg => $ObjectOptionStrg,
|
|
FormatOptionStrg => $FormatOptionStrg,
|
|
},
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
# get search data
|
|
my $SearchData = $ImportExportObject->SearchDataGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# create rescrict export string
|
|
my $RestrictExportStrg = $LayoutObject->ImportExportFormInputCreate(
|
|
Item => {
|
|
Key => 'RestrictExport',
|
|
Input => {
|
|
Type => 'Checkbox',
|
|
},
|
|
},
|
|
Value => scalar keys %{$SearchData},
|
|
);
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit5',
|
|
Data => {
|
|
%{$TemplateData},
|
|
RestrictExportStrg => $RestrictExportStrg,
|
|
},
|
|
);
|
|
|
|
# get search attributes
|
|
my $SearchAttributeList = $ImportExportObject->SearchAttributesGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# output object attributes
|
|
for my $Item ( @{$SearchAttributeList} ) {
|
|
|
|
# create form input
|
|
my $InputString = $LayoutObject->ImportExportFormInputCreate(
|
|
Item => $Item,
|
|
Value => $SearchData->{ $Item->{Key} },
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit5Element',
|
|
Data => {
|
|
Name => $Item->{Name} || '',
|
|
InputStrg => $InputString,
|
|
ID => $Item->{Key},
|
|
},
|
|
);
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template save (search)
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateSave5' ) {
|
|
|
|
# get template id
|
|
my $TemplateID = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
my %Submit = (
|
|
SubmitNext => 'Overview',
|
|
SubmitBack => 'TemplateEdit4',
|
|
Reload => 'TemplateEdit5',
|
|
);
|
|
|
|
# get submit action
|
|
my $Subaction = $Submit{Reload};
|
|
|
|
PARAM:
|
|
for my $SubmitKey ( sort keys %Submit ) {
|
|
next PARAM if !$ParamObject->GetParam( Param => $SubmitKey );
|
|
|
|
$Subaction = $Submit{$SubmitKey};
|
|
last PARAM;
|
|
}
|
|
|
|
# delete all search restrictions
|
|
if ( !$ParamObject->GetParam( Param => 'RestrictExport' ) ) {
|
|
|
|
# delete all search data
|
|
$ImportExportObject->SearchDataDelete(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=$Self->{Action};Subaction=$Subaction;TemplateID=$TemplateID",
|
|
);
|
|
}
|
|
|
|
# get search attributes
|
|
my $SearchAttributeList = $ImportExportObject->SearchAttributesGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get attribute values from form
|
|
my %AttributeValues;
|
|
for my $Item ( @{$SearchAttributeList} ) {
|
|
|
|
# get form data
|
|
$AttributeValues{ $Item->{Key} } = $LayoutObject->ImportExportFormDataGet(
|
|
Item => $Item,
|
|
);
|
|
|
|
# reload form if value is required
|
|
if ( $Item->{Form}->{Invalid} ) {
|
|
$Subaction = $Submit{Reload};
|
|
}
|
|
}
|
|
|
|
# save the search data
|
|
$ImportExportObject->SearchDataSave(
|
|
TemplateID => $TemplateID,
|
|
SearchData => \%AttributeValues,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=$Self->{Action};Subaction=$Subaction;TemplateID=$TemplateID",
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# template delete
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'TemplateDelete' ) {
|
|
|
|
# get template id
|
|
my $TemplateID = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# delete template from database
|
|
my $Delete = $ImportExportObject->TemplateDelete(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'text/html',
|
|
Content => ($Delete) ? $TemplateID : 0,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# import information
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'ImportInformation' ) {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get params
|
|
my $TemplateData = {};
|
|
$TemplateData->{TemplateID} = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# generate ObjectOptionStrg
|
|
my $ObjectOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $ObjectList,
|
|
Name => 'Object',
|
|
SelectedID => $TemplateData->{Object},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# generate FormatOptionStrg
|
|
my $FormatOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $FormatList,
|
|
Name => 'Format',
|
|
SelectedID => $TemplateData->{Format},
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => {
|
|
%Param,
|
|
ObjectOptionStrg => $ObjectOptionStrg,
|
|
FormatOptionStrg => $FormatOptionStrg,
|
|
},
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'ImportInformation',
|
|
Data => {
|
|
%{$TemplateData},
|
|
},
|
|
);
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# import
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'Import' ) {
|
|
|
|
# get params
|
|
my $TemplateData = {};
|
|
$TemplateData->{TemplateID} = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get source file
|
|
my %SourceFile = $ParamObject->GetUploadAll(
|
|
Param => 'SourceFile',
|
|
Source => 'String',
|
|
);
|
|
|
|
$SourceFile{Content} ||= '';
|
|
|
|
# import data
|
|
my $Result = $ImportExportObject->Import(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
SourceContent => \$SourceFile{Content},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$Result ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Error occurred. Import impossible! See Syslog for details.'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# output import results
|
|
$LayoutObject->Block(
|
|
Name => 'ImportResult',
|
|
Data => {
|
|
%{$Result},
|
|
},
|
|
);
|
|
|
|
# get all return codes and collect the duplicate names
|
|
my @DuplicateNames;
|
|
RETURNCODE:
|
|
for my $RetCode ( sort keys %{ $Result->{RetCode} } ) {
|
|
|
|
# just get the duplicate name
|
|
if ( $RetCode =~ m{ \A DuplicateName \s+ (.+) }xms ) {
|
|
push @DuplicateNames, $1;
|
|
}
|
|
else {
|
|
$LayoutObject->Block(
|
|
Name => 'ImportResultReturnCode',
|
|
Data => {
|
|
ReturnCodeName => $RetCode,
|
|
ReturnCodeCount => $Result->{RetCode}->{$RetCode},
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
# output duplicate names if neccessary
|
|
if (@DuplicateNames) {
|
|
|
|
my $DuplicateNamesString = join ', ', @DuplicateNames;
|
|
|
|
$LayoutObject->Block(
|
|
Name => 'ImportResultDuplicateNames',
|
|
Data => {
|
|
DuplicateNames => $DuplicateNamesString,
|
|
},
|
|
);
|
|
}
|
|
|
|
# output last processed line mumber of import file
|
|
if ( $Result->{Failed} ) {
|
|
$LayoutObject->Block(
|
|
Name => 'ImportResultLastLineNumber',
|
|
Data => {
|
|
LastLineNumber => $Result->{Counter},
|
|
},
|
|
);
|
|
}
|
|
|
|
# start output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => {
|
|
%Param,
|
|
},
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# export
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'Export' ) {
|
|
|
|
# get params
|
|
my $TemplateData = {};
|
|
$TemplateData->{TemplateID} = $ParamObject->GetParam( Param => 'TemplateID' );
|
|
|
|
# get template data
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# export data
|
|
my $Result = $ImportExportObject->Export(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$Result ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Error occurred. Export impossible! See Syslog for details.'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
my $FileContent = join "\n", @{ $Result->{DestinationContent} };
|
|
|
|
return $LayoutObject->Attachment(
|
|
Type => 'attachment',
|
|
Filename => 'Export.csv',
|
|
ContentType => 'text/csv',
|
|
Content => $FileContent,
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# overview
|
|
# ------------------------------------------------------------ #
|
|
else {
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
# show a note that the user needs to insatll any module that provides an import/export backend.
|
|
if ( !$ObjectList ) {
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => {
|
|
%Param,
|
|
},
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'NoteObjectBackend' );
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => {
|
|
%Param,
|
|
},
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionAdd' );
|
|
$LayoutObject->Block( Name => 'NoteCreateTemplate' );
|
|
|
|
$LayoutObject->Block(
|
|
Name => 'OverviewResult',
|
|
Data => \%Param,
|
|
);
|
|
|
|
# get valid list
|
|
my %ValidList = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
|
|
|
|
my $EmptyDatabase = 1;
|
|
|
|
CLASS:
|
|
for my $Object ( sort { $ObjectList->{$a} cmp $ObjectList->{$b} } keys %{$ObjectList} ) {
|
|
|
|
# get template list
|
|
my $TemplateList = $ImportExportObject->TemplateList(
|
|
Object => $Object,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateList || ref $TemplateList ne 'ARRAY' || !@{$TemplateList} ) {
|
|
next CLASS;
|
|
}
|
|
|
|
$EmptyDatabase = 0;
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'OverviewList',
|
|
Data => {
|
|
ObjectName => $ObjectList->{$Object},
|
|
},
|
|
);
|
|
|
|
for my $TemplateID ( @{$TemplateList} ) {
|
|
|
|
# get template data
|
|
my $TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# output row
|
|
$LayoutObject->Block(
|
|
Name => 'OverviewListRow',
|
|
Data => {
|
|
%{$TemplateData},
|
|
FormatName => $FormatList->{ $TemplateData->{Format} },
|
|
Valid => $ValidList{ $TemplateData->{ValidID} },
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
# output an empty list
|
|
if ($EmptyDatabase) {
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'OverviewList',
|
|
Data => {
|
|
ObjectName => Translatable('Template List'),
|
|
},
|
|
);
|
|
$LayoutObject->Block( Name => 'NoDataFoundMsg' );
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
}
|
|
|
|
sub _MaskTemplateEdit1 {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my %ServerError;
|
|
if ( $Param{ServerError} ) {
|
|
%ServerError = %{ $Param{ServerError} };
|
|
}
|
|
|
|
# get layout object
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
# generate ValidOptionStrg
|
|
my %ValidList = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
|
|
my %ValidListReverse = reverse %ValidList;
|
|
my $ValidOptionStrg = $LayoutObject->BuildSelection(
|
|
Name => 'ValidID',
|
|
Data => \%ValidList,
|
|
SelectedID => $Param{ValidID} || $ValidListReverse{valid},
|
|
Class => 'Modernize',
|
|
);
|
|
|
|
my $Class = ' Validate_Required ';
|
|
|
|
if ( $ServerError{Name} ) {
|
|
$Class .= 'ServerError';
|
|
}
|
|
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit1',
|
|
Data => {
|
|
%Param,
|
|
ValidOptionStrg => $ValidOptionStrg,
|
|
NameClass => $Class,
|
|
},
|
|
);
|
|
|
|
if ( $Param{TemplateID} ) {
|
|
$LayoutObject->Block(
|
|
Name => 'EditObjectFormat',
|
|
Data => {
|
|
%Param,
|
|
ObjectName => $Param{Object},
|
|
FormatName => $Param{Format},
|
|
},
|
|
);
|
|
}
|
|
|
|
if ( $Param{New} ) {
|
|
|
|
# get ImportExport object
|
|
my $ImportExportObject = $Kernel::OM->Get('Kernel::System::ImportExport');
|
|
|
|
# get object list
|
|
my $ObjectList = $ImportExportObject->ObjectList();
|
|
|
|
if ( !$ObjectList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No object backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get format list
|
|
my $FormatList = $ImportExportObject->FormatList();
|
|
|
|
if ( !$FormatList ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('No format backend found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
$Class = ' Validate_Required ';
|
|
|
|
if ( $ServerError{Object} ) {
|
|
$Class .= 'ServerError';
|
|
}
|
|
|
|
# generate ObjectOptionStrg
|
|
my $ObjectOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $ObjectList,
|
|
Name => 'Object',
|
|
SelectedID => $Param{Object} || '',
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => $Class . ' Modernize',
|
|
);
|
|
|
|
$Class = ' Validate_Required ';
|
|
if ( $ServerError{Format} ) {
|
|
$Class .= 'ServerError';
|
|
}
|
|
|
|
# generate FormatOptionStrg
|
|
my $FormatOptionStrg = $LayoutObject->BuildSelection(
|
|
Data => $FormatList,
|
|
Name => 'Format',
|
|
SelectedID => $Param{Format} || '',
|
|
PossibleNone => 1,
|
|
Translation => 1,
|
|
Class => $Class . ' Modernize',
|
|
);
|
|
|
|
$LayoutObject->Block(
|
|
Name => 'NewObjectFormat',
|
|
Data => {
|
|
ObjectOption => $ObjectOptionStrg,
|
|
FormatOption => $FormatOptionStrg,
|
|
},
|
|
);
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
}
|
|
|
|
sub _MaskTemplateEdit2 {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my %ServerError;
|
|
if ( $Param{ServerError} ) {
|
|
%ServerError = %{ $Param{ServerError} };
|
|
}
|
|
|
|
my %DataTypeError;
|
|
if ( $Param{DataTypeError} ) {
|
|
%DataTypeError = %{ $Param{DataTypeError} };
|
|
}
|
|
|
|
# get layout object
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
|
|
my $TemplateID;
|
|
if ( $Param{TemplateID} ) {
|
|
$TemplateID = $Param{TemplateID};
|
|
}
|
|
else {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Needed TemplateID!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get ImportExport object
|
|
my $ImportExportObject = $Kernel::OM->Get('Kernel::System::ImportExport');
|
|
|
|
# get template data
|
|
my $TemplateData;
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'BackURL',
|
|
Value => "Action=$Self->{Action};Subaction=TemplateEdit1;TemplateID=$TemplateID",
|
|
);
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'BaseLink',
|
|
Value => $LayoutObject->{Baselink},
|
|
);
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'TemplateOverview',
|
|
Value => 1,
|
|
);
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit2',
|
|
Data => $TemplateData,
|
|
);
|
|
|
|
# get object attributes
|
|
my $ObjectAttributeList = $ImportExportObject->ObjectAttributesGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get object data
|
|
my $ObjectData = $ImportExportObject->ObjectDataGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# javascript validation class per datatype
|
|
my %JSClass;
|
|
my %PredefinedErrorMessages;
|
|
|
|
$JSClass{Number} = 'Validate_Number';
|
|
$JSClass{NumberBiggerThanZero} = 'Validate_NumberBiggerThanZero';
|
|
$JSClass{Integer} = 'Validate_NumberInteger';
|
|
$JSClass{IntegerBiggerThanZero} = 'Validate_NumberIntegerBiggerThanZero';
|
|
|
|
$PredefinedErrorMessages{Number} = $LayoutObject->{LanguageObject}->Translate('number');
|
|
$PredefinedErrorMessages{NumberBiggerThanZero}
|
|
= $LayoutObject->{LanguageObject}->Translate('number bigger than zero');
|
|
$PredefinedErrorMessages{Integer} = $LayoutObject->{LanguageObject}->Translate('integer');
|
|
$PredefinedErrorMessages{IntegerBiggerThanZero}
|
|
= $LayoutObject->{LanguageObject}->Translate('integer bigger than zero');
|
|
|
|
# output object attributes
|
|
for my $Item ( @{$ObjectAttributeList} ) {
|
|
|
|
my $Class = ' ';
|
|
my $Value;
|
|
|
|
my $DataTypeError;
|
|
my $ErrorMessage;
|
|
|
|
if ( $Item->{Input}->{Required} ) {
|
|
$Class = 'Validate_Required';
|
|
$ErrorMessage = $LayoutObject->{LanguageObject}->Translate('Element required, please insert data');
|
|
}
|
|
|
|
if ( $Item->{Input}->{DataType} ) {
|
|
$Class .= " $JSClass{ $Item->{Input}->{DataType} }";
|
|
$ErrorMessage = $LayoutObject->{LanguageObject}->Translate(
|
|
'Invalid data, please insert a valid %s',
|
|
$PredefinedErrorMessages{ $Item->{Input}->{DataType} }
|
|
);
|
|
}
|
|
|
|
# get data from form or from database
|
|
# ServerError = show the wrong data in form
|
|
# !ServerError = show database data or new fields
|
|
|
|
if ( $Param{ServerError} || $Param{DataTypeError} ) {
|
|
$Value = $Param{TemplateDataForm}->{ $Item->{Key} };
|
|
}
|
|
else {
|
|
$Value = $ObjectData->{ $Item->{Key} };
|
|
}
|
|
|
|
# error area
|
|
|
|
# prepare different data & message per error
|
|
if ( $ServerError{ $Item->{Name} } || $DataTypeError{ $Item->{Name} } ) {
|
|
$Class .= ' ServerError';
|
|
}
|
|
|
|
# create form input
|
|
my $InputString = $LayoutObject->ImportExportFormInputCreate(
|
|
Item => $Item,
|
|
Class => $Class . ' Modernize',
|
|
Value => $Value,
|
|
);
|
|
|
|
# build id
|
|
my $ID;
|
|
if ( $Item->{Prefix} ) {
|
|
$ID = "$Item->{Prefix}$Item->{Key}";
|
|
}
|
|
else {
|
|
$ID = $Item->{Key};
|
|
}
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit2Element',
|
|
Data => {
|
|
Name => $Item->{Name} || '',
|
|
InputStrg => $InputString,
|
|
ID => $ID,
|
|
ErrorMessage => $ErrorMessage,
|
|
Mandatory => $Item->{Input}->{Required} ? 1 : 0,
|
|
},
|
|
);
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
|
|
}
|
|
|
|
sub _MaskTemplateEdit3 {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my %ServerError;
|
|
if ( $Param{ServerError} ) {
|
|
%ServerError = %{ $Param{ServerError} };
|
|
}
|
|
|
|
my $TemplateID;
|
|
if ( $Param{TemplateID} ) {
|
|
$TemplateID = $Param{TemplateID};
|
|
}
|
|
|
|
# get layout object
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
|
|
if ( !$TemplateID ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# get ImportExport object
|
|
my $ImportExportObject = $Kernel::OM->Get('Kernel::System::ImportExport');
|
|
|
|
# get template data
|
|
my $TemplateData;
|
|
$TemplateData = $ImportExportObject->TemplateGet(
|
|
TemplateID => $TemplateID,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$TemplateData->{TemplateID} ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Template not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
$Param{BackURL} = "Action=$Self->{Action};Subaction=TemplateEdit2;TemplateID=$TemplateID";
|
|
|
|
# output overview
|
|
$LayoutObject->Block(
|
|
Name => 'Overview',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'BackURL',
|
|
Value => $Param{BackURL},
|
|
);
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'BaseLink',
|
|
Value => $LayoutObject->{Baselink},
|
|
);
|
|
|
|
$LayoutObject->AddJSData(
|
|
Key => 'TemplateOverview',
|
|
Value => 1,
|
|
);
|
|
|
|
$LayoutObject->Block( Name => 'ActionList' );
|
|
$LayoutObject->Block( Name => 'ActionOverview' );
|
|
|
|
# output list
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit3',
|
|
Data => $TemplateData,
|
|
);
|
|
|
|
# get format attributes
|
|
my $FormatAttributeList = $ImportExportObject->FormatAttributesGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
# get format data
|
|
my $FormatData = $ImportExportObject->FormatDataGet(
|
|
TemplateID => $TemplateData->{TemplateID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( !$FormatData ) {
|
|
$LayoutObject->FatalError(
|
|
Message => Translatable('Format not found!'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
# output format attributes
|
|
for my $Item ( @{$FormatAttributeList} ) {
|
|
|
|
# build id
|
|
my $ID;
|
|
if ( $Item->{Prefix} ) {
|
|
$ID = "$Item->{Prefix}$Item->{Key}";
|
|
}
|
|
else {
|
|
$ID = "$Item->{Key}";
|
|
}
|
|
|
|
my $Class = ' ';
|
|
if ( $Item->{Input}->{Required} ) {
|
|
$Class = 'Validate_Required ';
|
|
}
|
|
|
|
if ( $ServerError{ $Item->{Name} } ) {
|
|
$Class .= ' ServerError';
|
|
}
|
|
|
|
# create form input
|
|
my $InputString = $LayoutObject->ImportExportFormInputCreate(
|
|
Item => $Item,
|
|
Class => $Class . ' Modernize',
|
|
Value => $FormatData->{ $Item->{Key} },
|
|
);
|
|
|
|
# output attribute row
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit3Element',
|
|
Data => {
|
|
Name => $Item->{Name} || '',
|
|
InputStrg => $InputString,
|
|
ID => $ID,
|
|
Mandatory => $Item->{Input}->{Required} ? 1 : 0,
|
|
},
|
|
);
|
|
|
|
# output required notice
|
|
if ( $Item->{Input}->{Required} ) {
|
|
$LayoutObject->Block(
|
|
Name => 'TemplateEdit3ElementRequired',
|
|
Data => {
|
|
Name => $Item->{Name} || '',
|
|
ID => $ID,
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
# output header and navbar
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# start template output
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AdminImportExport',
|
|
Data => \%Param,
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
return $Output;
|
|
|
|
}
|
|
|
|
1;
|