973 lines
32 KiB
Perl
973 lines
32 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::AgentPreferences;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
our $ObjectManagerDisabled = 1;
|
|
|
|
use Kernel::System::VariableCheck qw(:all);
|
|
use Kernel::Language qw(Translatable);
|
|
|
|
sub new {
|
|
my ( $Type, %Param ) = @_;
|
|
|
|
# allocate new hash for object
|
|
my $Self = {%Param};
|
|
bless( $Self, $Type );
|
|
|
|
return $Self;
|
|
}
|
|
|
|
sub Run {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
|
|
my $UserObject = $Kernel::OM->Get('Kernel::System::User');
|
|
my $EditUserID = $ParamObject->GetParam( Param => 'EditUserID' );
|
|
|
|
$Self->{CurrentUserID} = $Self->{UserID};
|
|
if (
|
|
$EditUserID
|
|
&& $Self->_CheckEditPreferencesPermission()
|
|
)
|
|
{
|
|
$Self->{CurrentUserID} = $EditUserID;
|
|
$Self->{EditingAnotherAgent} = ";EditUserID=$EditUserID";
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# update preferences via AJAX
|
|
# ------------------------------------------------------------ #
|
|
if ( $Self->{Subaction} eq 'UpdateAJAX' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $Key = $ParamObject->GetParam( Param => 'Key' );
|
|
my $Value = $ParamObject->GetParam( Param => 'Value' );
|
|
|
|
# update preferences
|
|
my $Success = $UserObject->SetPreferences(
|
|
UserID => $Self->{CurrentUserID},
|
|
Key => $Key,
|
|
Value => $Value,
|
|
);
|
|
|
|
# update session
|
|
if ($Success) {
|
|
$Kernel::OM->Get('Kernel::System::AuthSession')->UpdateSessionID(
|
|
SessionID => $Self->{SessionID},
|
|
Key => $Key,
|
|
Value => $Value,
|
|
);
|
|
}
|
|
my $JSON = $LayoutObject->JSONEncode(
|
|
Data => $Success,
|
|
);
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
|
|
Content => $JSON,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# update preferences
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'UpdateAJAXComplex' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $Message = '';
|
|
my $Priority = '';
|
|
my $ConfigNeedsReload = 0;
|
|
|
|
# check group param
|
|
my @Groups = $ParamObject->GetArray( Param => 'Group' );
|
|
if ( !@Groups ) {
|
|
return $LayoutObject->ErrorScreen(
|
|
Message => Translatable('Param Group is required!'),
|
|
);
|
|
}
|
|
|
|
my $SettingID = $ParamObject->GetParam( Param => 'SettingID' );
|
|
|
|
for my $Group (@Groups) {
|
|
|
|
# check preferences setting
|
|
my %Preferences = %{ $Kernel::OM->Get('Kernel::Config')->Get('PreferencesGroups') };
|
|
if ( !$Preferences{$Group} ) {
|
|
return $LayoutObject->ErrorScreen(
|
|
Message => $LayoutObject->{LanguageObject}->Translate( 'No such config for %s', $Group ),
|
|
);
|
|
}
|
|
|
|
# get user data
|
|
my %UserData = $UserObject->GetUserData( UserID => $Self->{CurrentUserID} );
|
|
my $Module = $Preferences{$Group}->{Module};
|
|
if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
|
|
return $LayoutObject->FatalError();
|
|
}
|
|
|
|
my $Object = $Module->new(
|
|
%{$Self},
|
|
UserID => $Self->{CurrentUserID},
|
|
UserObject => $UserObject,
|
|
ConfigItem => $Preferences{$Group},
|
|
Debug => $Self->{Debug},
|
|
);
|
|
my @Params = $Object->Param( UserData => \%UserData );
|
|
my %GetParam;
|
|
for my $ParamItem (@Params) {
|
|
my @Array = $ParamObject->GetArray(
|
|
Param => $ParamItem->{Name},
|
|
Raw => $ParamItem->{Raw} || 0,
|
|
);
|
|
if ( defined $ParamItem->{Name} ) {
|
|
$GetParam{ $ParamItem->{Name} } = \@Array;
|
|
}
|
|
}
|
|
|
|
if (
|
|
$Object->Run(
|
|
GetParam => \%GetParam,
|
|
UserData => \%UserData
|
|
)
|
|
)
|
|
{
|
|
$Message .= $Object->Message();
|
|
if ( $Preferences{$Group}->{NeedsReload} ) {
|
|
$ConfigNeedsReload = 1;
|
|
}
|
|
}
|
|
else {
|
|
$Priority .= 'Error';
|
|
$Message .= $Object->Error();
|
|
}
|
|
}
|
|
|
|
my $JSON = $LayoutObject->JSONEncode(
|
|
Data => {
|
|
'Message' => $Message,
|
|
'Priority' => $Priority,
|
|
'NeedsReload' => $ConfigNeedsReload
|
|
},
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
|
|
Content => $JSON,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# update preferences
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'Update' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $Message = '';
|
|
my $Priority = '';
|
|
|
|
# check group param
|
|
my @Groups = $ParamObject->GetArray( Param => 'Group' );
|
|
if ( !@Groups ) {
|
|
return $LayoutObject->ErrorScreen(
|
|
Message => Translatable('Param Group is required!'),
|
|
);
|
|
}
|
|
|
|
for my $Group (@Groups) {
|
|
|
|
# check preferences setting
|
|
my %Preferences = %{ $Kernel::OM->Get('Kernel::Config')->Get('PreferencesGroups') };
|
|
if ( !$Preferences{$Group} ) {
|
|
return $LayoutObject->ErrorScreen(
|
|
Message => $LayoutObject->{LanguageObject}->Translate( 'No such config for %s', $Group ),
|
|
);
|
|
}
|
|
|
|
# get user data
|
|
my %UserData = $UserObject->GetUserData( UserID => $Self->{CurrentUserID} );
|
|
my $Module = $Preferences{$Group}->{Module};
|
|
if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
|
|
return $LayoutObject->FatalError();
|
|
}
|
|
|
|
my $Object = $Module->new(
|
|
%{$Self},
|
|
UserID => $Self->{CurrentUserID},
|
|
UserObject => $UserObject,
|
|
ConfigItem => $Preferences{$Group},
|
|
Debug => $Self->{Debug},
|
|
);
|
|
my @Params = $Object->Param( UserData => \%UserData );
|
|
my %GetParam;
|
|
for my $ParamItem (@Params) {
|
|
my @Array = $ParamObject->GetArray(
|
|
Param => $ParamItem->{Name},
|
|
Raw => $ParamItem->{Raw} || 0,
|
|
);
|
|
if ( defined $ParamItem->{Name} ) {
|
|
$GetParam{ $ParamItem->{Name} } = \@Array;
|
|
}
|
|
}
|
|
|
|
if (
|
|
$Object->Run(
|
|
GetParam => \%GetParam,
|
|
UserData => \%UserData
|
|
)
|
|
)
|
|
{
|
|
$Message .= $Object->Message();
|
|
}
|
|
else {
|
|
$Priority .= 'Error';
|
|
$Message .= $Object->Error();
|
|
}
|
|
}
|
|
|
|
# check redirect
|
|
my $RedirectURL = $ParamObject->GetParam( Param => 'RedirectURL' );
|
|
if ($RedirectURL) {
|
|
return $LayoutObject->Redirect(
|
|
OP => $RedirectURL,
|
|
);
|
|
}
|
|
|
|
# redirect
|
|
return $LayoutObject->Redirect(
|
|
OP => "Action=AgentPreferences;Priority=$Priority;Message=$Message",
|
|
);
|
|
}
|
|
|
|
elsif ( $Self->{Subaction} eq 'SettingUpdate' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');
|
|
|
|
my $SettingName = $ParamObject->GetParam( Param => 'SettingName' ) || '';
|
|
my $EffectiveValueJSON = $ParamObject->GetParam( Param => 'EffectiveValue' );
|
|
|
|
my $EffectiveValue;
|
|
|
|
if ( !defined $EffectiveValueJSON ) {
|
|
$EffectiveValue = undef;
|
|
}
|
|
elsif (
|
|
!$EffectiveValueJSON
|
|
|| $EffectiveValueJSON eq '"0"'
|
|
|
|
)
|
|
{
|
|
$EffectiveValue = 0;
|
|
}
|
|
else {
|
|
$EffectiveValue = $Kernel::OM->Get('Kernel::System::JSON')->Decode(
|
|
Data => $EffectiveValueJSON,
|
|
);
|
|
}
|
|
|
|
my %Setting = $SysConfigObject->SettingGet(
|
|
Name => $SettingName,
|
|
OverriddenInXML => 1,
|
|
UserID => 1,
|
|
);
|
|
my $DataIsDifferent = DataIsDifferent(
|
|
Data1 => $EffectiveValue,
|
|
Data2 => $Setting{EffectiveValue},
|
|
);
|
|
|
|
if ( !$DataIsDifferent ) {
|
|
return $Self->_SettingReset( SettingName => $SettingName );
|
|
}
|
|
|
|
my %Result;
|
|
|
|
my %UpdateResult = $SysConfigObject->SettingUpdate(
|
|
Name => $SettingName,
|
|
EffectiveValue => $EffectiveValue,
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
UserID => $Self->{CurrentUserID},
|
|
);
|
|
|
|
if ( $UpdateResult{Error} ) {
|
|
$Result{Data}->{Error} = $UpdateResult{Error};
|
|
}
|
|
elsif ( !$SysConfigObject->can('UserConfigurationDeploy') ) { # OTRS Business Solution™
|
|
$Result{Data}->{Error} = $Kernel::OM->Get('Kernel::Language')->Translate(
|
|
"This feature is part of the %s. Please contact us at %s for an upgrade."
|
|
, 'OTRS Business Solution™'
|
|
, 'sales@otrs.com'
|
|
);
|
|
}
|
|
else {
|
|
|
|
# update successful, now deploy only this setting (if it's dirty)
|
|
my %UpdatedSetting = $SysConfigObject->SettingGet(
|
|
Name => $SettingName,
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
);
|
|
|
|
if ( $UpdatedSetting{IsDirty} ) {
|
|
my $DeploySuccess = $SysConfigObject->UserConfigurationDeploy(
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
Comments => Translatable('Updated user preferences'),
|
|
);
|
|
|
|
if ( !$DeploySuccess ) {
|
|
$Result{Data}->{Error} = $Kernel::OM->Get('Kernel::Language')->Translate(
|
|
"System was unable to deploy your changes.",
|
|
);
|
|
}
|
|
}
|
|
|
|
# reload setting with fresh data
|
|
%UpdatedSetting = $SysConfigObject->SettingGet(
|
|
Name => $SettingName,
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
);
|
|
|
|
my $GlobalEffectiveValue = $SysConfigObject->GlobalEffectiveValueGet(
|
|
SettingName => $SettingName,
|
|
);
|
|
|
|
my $IsModified = DataIsDifferent(
|
|
Data1 => \$UpdatedSetting{EffectiveValue},
|
|
Data2 => \$GlobalEffectiveValue,
|
|
) || 0;
|
|
|
|
$Result{Data}->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => \%UpdatedSetting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
$Result{Data}->{SettingData}->{IsModified} = $IsModified;
|
|
$Result{Data}->{SettingData}->{IsLockedByMe} = 1;
|
|
$Result{Data}->{SettingData}->{ExclusiveLockGUID} = 1;
|
|
}
|
|
|
|
# JSON response
|
|
my $JSON = $Kernel::OM->Get('Kernel::System::JSON')->Encode(
|
|
Data => \%Result,
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
|
|
Content => $JSON,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
elsif ( $Self->{Subaction} eq 'SettingReset' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');
|
|
|
|
my $SettingName = $ParamObject->GetParam( Param => 'SettingName' ) || '';
|
|
|
|
return $Self->_SettingReset( SettingName => $SettingName );
|
|
}
|
|
|
|
elsif ( $Self->{Subaction} eq 'SettingList' ) {
|
|
|
|
# challenge token check for write action
|
|
$LayoutObject->ChallengeTokenCheck();
|
|
|
|
my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');
|
|
my $RootNavigation = $ParamObject->GetParam( Param => 'RootNavigation' ) || '';
|
|
|
|
my @SettingList = $SysConfigObject->ConfigurationListGet(
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
IsValid => 1,
|
|
Navigation => $RootNavigation // undef,
|
|
OverriddenInXML => 1,
|
|
UserID => 1,
|
|
);
|
|
|
|
for my $Setting (@SettingList) {
|
|
|
|
# OverriddenFileName is used only in Admin interface.
|
|
delete $Setting->{OverriddenFileName};
|
|
|
|
# If the setting is overriden in the *.pm file, take it as default and update IsModified.
|
|
my $GlobalEffectiveValue = $SysConfigObject->GlobalEffectiveValueGet(
|
|
SettingName => $Setting->{Name},
|
|
);
|
|
|
|
my $IsModified = DataIsDifferent(
|
|
Data1 => \$Setting->{EffectiveValue},
|
|
Data2 => \$GlobalEffectiveValue,
|
|
) || 0;
|
|
|
|
$Setting->{IsModified} = $IsModified;
|
|
|
|
$Setting->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => $Setting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
}
|
|
|
|
my $Output = "<ul class='SettingsList Preferences'>\n";
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AgentPreferences/SettingsList',
|
|
Data => {
|
|
RootNavigation => $RootNavigation,
|
|
SettingList => \@SettingList,
|
|
},
|
|
);
|
|
$Output .= "</ul>\n";
|
|
|
|
return $LayoutObject->Attachment(
|
|
NoCache => 1,
|
|
ContentType => 'text/html',
|
|
Charset => $LayoutObject->{UserCharset},
|
|
Content => $Output || '',
|
|
Type => 'inline',
|
|
);
|
|
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# show preferences group
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'Group' ) {
|
|
|
|
# get header
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# get param
|
|
my $Message = $ParamObject->GetParam( Param => 'Message' ) || '';
|
|
my $Priority = $ParamObject->GetParam( Param => 'Priority' ) || '';
|
|
|
|
# add notification
|
|
if ( $Message && $Priority eq 'Error' ) {
|
|
$Output .= $LayoutObject->Notify(
|
|
Priority => $Priority,
|
|
Info => $Message,
|
|
);
|
|
}
|
|
elsif ($Message) {
|
|
$Output .= $LayoutObject->Notify(
|
|
Info => $Message,
|
|
);
|
|
}
|
|
|
|
# get user data
|
|
my %UserData = $UserObject->GetUserData( UserID => $Self->{CurrentUserID} );
|
|
$Output .= $Self->AgentPreferencesForm( UserData => \%UserData );
|
|
$Output .= $LayoutObject->Footer();
|
|
|
|
return $Output;
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# Return user favourite system configuration settings.
|
|
# ------------------------------------------------------------ #
|
|
elsif ( $Self->{Subaction} eq 'UserSystemConfigurationFavourites' ) {
|
|
|
|
my $Favourites = [];
|
|
my %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ( $UserPreferences{UserSystemConfigurationFavourites} ) {
|
|
$Favourites = $Kernel::OM->Get('Kernel::System::JSON')
|
|
->Decode( Data => $UserPreferences{UserSystemConfigurationFavourites} );
|
|
}
|
|
|
|
my $JSON = $Kernel::OM->Get('Kernel::System::JSON')->Encode(
|
|
Data => $Favourites,
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
|
|
Content => $JSON,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# show AJAX navigation tree
|
|
# ------------------------------------------------------------ #
|
|
if ( $Self->{Subaction} eq 'AJAXNavigationTree' ) {
|
|
|
|
my $Category = $ParamObject->GetParam( Param => 'Category' ) || '';
|
|
my $UserModificationActive = $ParamObject->GetParam( Param => 'UserModificationActive' ) || '0';
|
|
my $IsValid = $ParamObject->GetParam( Param => 'IsValid' ) // undef;
|
|
|
|
my %Tree = $Kernel::OM->Get('Kernel::System::SysConfig')->ConfigurationNavigationTree(
|
|
Action => 'AgentPreferences',
|
|
Category => $Category,
|
|
UserModificationActive => $UserModificationActive,
|
|
IsValid => $IsValid,
|
|
);
|
|
|
|
my $Output = $LayoutObject->Output(
|
|
TemplateFile => 'SystemConfiguration/NavigationTree',
|
|
Data => {
|
|
Tree => \%Tree,
|
|
},
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
NoCache => 1,
|
|
ContentType => 'text/html',
|
|
Charset => $LayoutObject->{UserCharset},
|
|
Content => $Output || '',
|
|
Type => 'inline',
|
|
);
|
|
}
|
|
|
|
# ------------------------------------------------------------ #
|
|
# show group overview
|
|
# ------------------------------------------------------------ #
|
|
else {
|
|
|
|
# get header
|
|
my $Output = $LayoutObject->Header();
|
|
$Output .= $LayoutObject->NavigationBar();
|
|
|
|
# get groups
|
|
my @PreferencesGroups = @{ $Kernel::OM->Get('Kernel::Config')->Get('AgentPreferencesGroups') };
|
|
if (@PreferencesGroups) {
|
|
@PreferencesGroups = sort { $a->{Prio} <=> $b->{Prio} } @PreferencesGroups;
|
|
}
|
|
|
|
my %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
|
|
UserID => $Self->{CurrentUserID},
|
|
);
|
|
|
|
$Output .= $LayoutObject->Output(
|
|
TemplateFile => 'AgentPreferencesOverview',
|
|
Data => {
|
|
Items => \@PreferencesGroups,
|
|
EditingAnotherAgent => $Self->{EditingAnotherAgent},
|
|
CurrentUserFullname => $UserObject->UserName( UserID => $Self->{CurrentUserID} ),
|
|
CurrentUserID => $Self->{CurrentUserID},
|
|
View => $UserPreferences{AgentPreferencesView} || 'Grid',
|
|
},
|
|
);
|
|
|
|
$Output .= $LayoutObject->Footer();
|
|
|
|
return $Output;
|
|
}
|
|
}
|
|
|
|
sub AgentPreferencesForm {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');
|
|
my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
|
|
|
|
my $GroupSelected = $ParamObject->GetParam( Param => 'Group' ) || 'UserProfile';
|
|
my $RootNavigation = $ParamObject->GetParam( Param => 'RootNavigation' ) || '';
|
|
my $EditUserID = $ParamObject->GetParam( Param => 'EditUserID' );
|
|
|
|
my @Path = $SysConfigObject->SettingNavigationToPath(
|
|
Navigation => $RootNavigation,
|
|
);
|
|
$Param{Path} = \@Path;
|
|
|
|
$Self->{CurrentUserID} = $Self->{UserID};
|
|
if (
|
|
$EditUserID
|
|
&& $Self->_CheckEditPreferencesPermission()
|
|
)
|
|
{
|
|
$Self->{EditingAnotherAgent} = ";EditUserID=$EditUserID";
|
|
$Self->{CurrentUserID} = $EditUserID;
|
|
}
|
|
|
|
# Show navigation in advanced group
|
|
if ( $GroupSelected eq 'Advanced' ) {
|
|
$Param{Navigation} = 1;
|
|
|
|
my @SettingList = $SysConfigObject->ConfigurationListGet(
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
IsValid => 1,
|
|
Navigation => $RootNavigation // undef,
|
|
OverriddenInXML => 1,
|
|
Translate => 0,
|
|
UserID => 1,
|
|
);
|
|
|
|
for my $Setting (@SettingList) {
|
|
|
|
# OverriddenFileName is used only in Admin interface.
|
|
delete $Setting->{OverriddenFileName};
|
|
|
|
# If the setting is overriden in the *.pm file, take it as default and update IsModified.
|
|
my $GlobalEffectiveValue = $SysConfigObject->GlobalEffectiveValueGet(
|
|
SettingName => $Setting->{Name},
|
|
);
|
|
|
|
my $IsModified = DataIsDifferent(
|
|
Data1 => \$Setting->{EffectiveValue},
|
|
Data2 => \$GlobalEffectiveValue,
|
|
) || 0;
|
|
|
|
$Setting->{IsModified} = $IsModified;
|
|
|
|
$Setting->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => $Setting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
}
|
|
|
|
$Param{SettingList} = \@SettingList;
|
|
}
|
|
|
|
# get group name
|
|
my @PreferencesGroups = @{ $Kernel::OM->Get('Kernel::Config')->Get('AgentPreferencesGroups') };
|
|
my $GroupSelectedName;
|
|
|
|
PREFERENCESGROUPS:
|
|
for my $Group (@PreferencesGroups) {
|
|
next PREFERENCESGROUPS if $Group->{Key} ne $GroupSelected;
|
|
$GroupSelectedName = $Group->{Name};
|
|
}
|
|
|
|
$LayoutObject->Block(
|
|
Name => 'Body',
|
|
Data => {
|
|
GroupKey => $GroupSelected,
|
|
GroupName => $GroupSelectedName,
|
|
%Param,
|
|
CategoriesStrg => $Self->_GetCategoriesStrg(),
|
|
RootNavigation => $RootNavigation,
|
|
EditingAnotherAgent => $Self->{EditingAnotherAgent},
|
|
CurrentUserFullname =>
|
|
$Kernel::OM->Get('Kernel::System::User')->UserName( UserID => $Self->{CurrentUserID} ),
|
|
CurrentUserID => $Self->{CurrentUserID},
|
|
},
|
|
);
|
|
|
|
my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
|
|
my %Data;
|
|
my %Preferences = %{ $ConfigObject->Get('PreferencesGroups') };
|
|
|
|
GROUP:
|
|
for my $Group ( sort keys %Preferences ) {
|
|
|
|
next GROUP if !$Group;
|
|
next GROUP if !$Preferences{$Group};
|
|
next GROUP if ref $Preferences{$Group} ne 'HASH';
|
|
next GROUP if !$Preferences{$Group}->{PreferenceGroup};
|
|
next GROUP if $Preferences{$Group}->{PreferenceGroup} ne $GroupSelected;
|
|
|
|
# In case of a priority conflict, increase priority until a free slot is found.
|
|
if ( $Data{ $Preferences{$Group}->{Prio} } ) {
|
|
|
|
COUNT:
|
|
for ( 1 .. 151 ) {
|
|
|
|
$Preferences{$Group}->{Prio}++;
|
|
|
|
next COUNT if $Data{ $Preferences{$Group}->{Prio} };
|
|
|
|
$Data{ $Preferences{$Group}->{Prio} } = $Group;
|
|
last COUNT;
|
|
}
|
|
}
|
|
|
|
$Data{ $Preferences{$Group}->{Prio} } = $Group;
|
|
}
|
|
|
|
# sort
|
|
for my $Key ( sort keys %Data ) {
|
|
$Data{ sprintf( "%07d", $Key ) } = $Data{$Key};
|
|
delete $Data{$Key};
|
|
}
|
|
|
|
# show each preferences setting
|
|
PRIO:
|
|
for my $Prio ( sort keys %Data ) {
|
|
my $Group = $Data{$Prio};
|
|
next PRIO if !$ConfigObject->{PreferencesGroups}->{$Group};
|
|
|
|
my %Preference = %{ $ConfigObject->{PreferencesGroups}->{$Group} };
|
|
|
|
if ( !$Self->{EditingAnotherAgent} && !$Preference{Active} ) {
|
|
next PRIO;
|
|
}
|
|
|
|
# load module
|
|
my $Module = $Preference{Module} || 'Kernel::Output::HTML::Preferences::Generic';
|
|
if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
|
|
return $LayoutObject->FatalError();
|
|
}
|
|
|
|
# create a new module object
|
|
my $Object;
|
|
eval {
|
|
$Object = $Module->new(
|
|
%{$Self},
|
|
UserID => $Self->{CurrentUserID},
|
|
UserObject => $Kernel::OM->Get('Kernel::System::User'),
|
|
ConfigItem => \%Preference,
|
|
Debug => $Self->{Debug},
|
|
);
|
|
};
|
|
if ($@) {
|
|
$Kernel::OM->Get('Kernel::System::Log')->Log(
|
|
Priority => 'error',
|
|
Message => "Could not create a new object for $Group Error: $@",
|
|
);
|
|
}
|
|
next PRIO if !$Object;
|
|
|
|
# get params for the new module object
|
|
my @Params;
|
|
eval {
|
|
@Params = $Object->Param( UserData => $Param{UserData} );
|
|
};
|
|
if ($@) {
|
|
$Kernel::OM->Get('Kernel::System::Log')->Log(
|
|
Priority => 'error',
|
|
Message => "Could not get params from $Group Error: $@",
|
|
);
|
|
}
|
|
next PRIO if !@Params;
|
|
|
|
# show item
|
|
$LayoutObject->Block(
|
|
Name => 'Item',
|
|
Data => {
|
|
Group => $Group,
|
|
EditUserID => $Self->{CurrentUserID},
|
|
%Preference,
|
|
},
|
|
);
|
|
|
|
for my $ParamItem (@Params) {
|
|
if ( ref $ParamItem->{Data} eq 'HASH' || ref $Preference{Data} eq 'HASH' ) {
|
|
my %BuildSelectionParams = (
|
|
%Preference,
|
|
%{$ParamItem},
|
|
OptionTitle => 1,
|
|
);
|
|
$BuildSelectionParams{Class} = join( ' ', $BuildSelectionParams{Class} // '', 'Modernize' );
|
|
$ParamItem->{Option} = $LayoutObject->BuildSelection(
|
|
%BuildSelectionParams,
|
|
);
|
|
}
|
|
$LayoutObject->Block(
|
|
Name => 'Block',
|
|
Data => { %Preference, %{$ParamItem}, },
|
|
);
|
|
my $BlockName = $ParamItem->{Block} || $Preference{Block} || 'Option';
|
|
|
|
$LayoutObject->Block(
|
|
Name => $BlockName,
|
|
Data => { %Preference, %{$ParamItem}, },
|
|
);
|
|
|
|
if ( scalar @Params == 1 ) {
|
|
$LayoutObject->Block(
|
|
Name => $BlockName . 'SingleBlock',
|
|
Data => { %Preference, %{$ParamItem}, },
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( scalar @Params > 1 ) {
|
|
$LayoutObject->Block(
|
|
Name => 'MultipleBlocks',
|
|
Data => {%Preference},
|
|
);
|
|
}
|
|
}
|
|
|
|
# create & return output
|
|
return $LayoutObject->Output(
|
|
TemplateFile => 'AgentPreferences',
|
|
Data => {
|
|
%Param,
|
|
},
|
|
);
|
|
}
|
|
|
|
sub _GetCategoriesStrg {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
# get selected category
|
|
my %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
my $Category = $UserPreferences{UserSystemConfigurationCategory};
|
|
|
|
my %Categories = $Kernel::OM->Get('Kernel::System::SysConfig')->ConfigurationCategoriesGet();
|
|
|
|
my %CategoryData = map { $_ => $Categories{$_}->{DisplayName} } keys %Categories;
|
|
|
|
my $CategoriesStrg = $Kernel::OM->Get('Kernel::Output::HTML::Layout')->BuildSelection(
|
|
Data => \%CategoryData,
|
|
Name => 'Category',
|
|
SelectedID => $Category || 'All',
|
|
PossibleNone => 0,
|
|
Translation => 1,
|
|
Sort => 'AlphaNumericKey',
|
|
Class => 'Modernize',
|
|
Title => $Kernel::OM->Get('Kernel::Language')->Translate('Category Search'),
|
|
);
|
|
|
|
return $CategoriesStrg;
|
|
}
|
|
|
|
sub _CheckEditPreferencesPermission {
|
|
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
# check if the current user has the permissions to edit another users preferences
|
|
my $GroupObject = $Kernel::OM->Get('Kernel::System::Group');
|
|
my $EditAnotherUsersPreferencesGroup = $GroupObject->GroupLookup(
|
|
Group => $Kernel::OM->Get('Kernel::Config')->Get('EditAnotherUsersPreferencesGroup'),
|
|
);
|
|
|
|
# get user groups, where the user has the rw privilege
|
|
my %Groups = $GroupObject->PermissionUserGet(
|
|
UserID => $Self->{UserID},
|
|
Type => 'rw',
|
|
);
|
|
|
|
# if the user is a member in this group he can access the feature
|
|
if ( $Groups{$EditAnotherUsersPreferencesGroup} ) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
sub _SettingReset {
|
|
my ( $Self, %Param ) = @_;
|
|
|
|
my $SettingName = $Param{SettingName};
|
|
|
|
my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');
|
|
|
|
my %Setting = $SysConfigObject->SettingGet(
|
|
Name => $SettingName,
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
OverriddenInXML => 1,
|
|
UserID => 1,
|
|
);
|
|
|
|
# OverriddenFileName is used only in Admin interface.
|
|
delete $Setting{OverriddenFileName};
|
|
|
|
my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
|
|
|
|
my %Result;
|
|
|
|
if ( !%Setting ) {
|
|
$Result{Error} = $LayoutObject->{LanguageObject}->Translate("Setting not found!");
|
|
}
|
|
elsif ( !$SysConfigObject->can('UserSettingValueDelete') ) { # OTRS Business Solution™
|
|
$Result{Data}->{Error} = $LayoutObject->{LanguageObject}->Translate(
|
|
"This feature is part of the %s. Please contact us at %s for an upgrade."
|
|
, 'OTRS Business Solution™'
|
|
, 'sales@otrs.com'
|
|
);
|
|
}
|
|
elsif ( $Setting{ModifiedID} ) {
|
|
|
|
# Remove user's value
|
|
my $UserValueDeleted = $SysConfigObject->UserSettingValueDelete(
|
|
Name => $SettingName,
|
|
ModifiedID => $Setting{ModifiedID},
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
if ($UserValueDeleted) {
|
|
|
|
# Get setting value after reset
|
|
%Setting = $SysConfigObject->SettingGet(
|
|
Name => $SettingName,
|
|
TargetUserID => $Self->{CurrentUserID},
|
|
);
|
|
|
|
# If the setting is overriden in the *.pm file, take it as default and update IsModified.
|
|
my $GlobalEffectiveValue = $SysConfigObject->GlobalEffectiveValueGet(
|
|
SettingName => $SettingName,
|
|
);
|
|
|
|
$Setting{EffectiveValue} = $GlobalEffectiveValue;
|
|
|
|
$Result{Data}->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => \%Setting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
$Result{Data}->{SettingData}->{IsModified} = 0;
|
|
$Result{Data}->{SettingData}->{IsLockedByMe} = 1;
|
|
}
|
|
else {
|
|
$Result{Data}->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => \%Setting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
$Result{Data}->{SettingData}->{IsModified} = 1;
|
|
$Result{Data}->{SettingData}->{IsLockedByMe} = 1;
|
|
$Result{Error} = $LayoutObject->{LanguageObject}->Translate(
|
|
"System was unable to reset the setting!",
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
$Result{Data}->{HTMLStrg} = $SysConfigObject->SettingRender(
|
|
Setting => \%Setting,
|
|
RW => 1,
|
|
UserID => $Self->{UserID},
|
|
);
|
|
|
|
$Result{Data}->{SettingData}->{IsLockedByMe} = 1;
|
|
$Result{Error} = $LayoutObject->{LanguageObject}->Translate(
|
|
"System was unable to reset the setting!",
|
|
);
|
|
}
|
|
|
|
# JSON response
|
|
my $JSON = $Kernel::OM->Get('Kernel::System::JSON')->Encode(
|
|
Data => \%Result,
|
|
);
|
|
|
|
return $LayoutObject->Attachment(
|
|
ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
|
|
Content => $JSON,
|
|
Type => 'inline',
|
|
NoCache => 1,
|
|
);
|
|
}
|
|
|
|
1;
|