AppointmentToTicket 11.1.1 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Update to OTOBO 11.1. This package brings the functionality to automatically create a ticket with configurable parameters to a freely chooseable point in time in relation to an appointment. 11.1.x # create the package name my $CodeModule = 'var::packagesetup::AppointmentToTicket'; $Kernel::OM->Get($CodeModule)->CodeUninstall(); b066f040938f8dfde73f75d1657f40b219e54591 2026-07-22 15:34:25 opms.rother-oss.com # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Modules/AgentAppointmentEdit.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::Modules::AgentAppointmentEdit;

use strict;
use warnings;

use Kernel::System::VariableCheck qw(:all);
use Kernel::Language              qw(Translatable);

our $ObjectManagerDisabled = 1;

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

    my $Self = {%Param};
    bless( $Self, $Type );

    $Self->{EmptyString} = '-';

# RotherOSS / AppointmentToTicket
    # frontend specific config
    my $Config = $Kernel::OM->Get('Kernel::Config')->Get("Ticket::Frontend::$Self->{Action}");

    # get the dynamic fields for this screen
    my $DynamicFieldList = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket', 'Article' ],
        FieldFilter => $Config->{DynamicField} || {},
    );

    $Self->{DynamicField}->%* = map { $_->{Name} => $_ } @{ $DynamicFieldList // [] };

    # create form id
    if ( !$Self->{FormID} ) {
        $Self->{FormID} = $Kernel::OM->Get('Kernel::System::Web::UploadCache')->FormIDCreate();
    }

    # methods which are used to determine the possible values of the standard fields
    $Self->{FieldMethods} = [
        {
            FieldID => 'Dest',
            Method  => \&_GetTos
        },
        {
            FieldID => 'NextStateID',
            Method  => \&_GetStates
        },
        {
            FieldID => 'PriorityID',
            Method  => \&_GetPriorities
        },
        {
            FieldID => 'ServiceID',
            Method  => \&_GetServices
        },
        {
            FieldID => 'SLAID',
            Method  => \&_GetSLAs
        },
        {
            FieldID => 'TypeID',
            Method  => \&_GetTypes
        },
    ];

    # dependancies of standard fields which are not defined via ACLs
    $Self->{InternalDependancy} = {
        ServiceID => {
            SLAID     => 1,
            ServiceID => 1,    #CustomerUser updates can be submitted as ElementChanged: ServiceID
        },
        CustomerUser => {
            ServiceID => 1,
        },
    };
# EO AppointmentToTicket

    return $Self;
}

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

    # get param object
    my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');

    # get names of all parameters
    my @ParamNames = $ParamObject->GetParamNames();

    # get params
    my %GetParam;
    PARAMNAME:
    for my $Key (@ParamNames) {

        # skip the Action parameter, it's giving BuildDateSelection problems for some reason
        next PARAMNAME if $Key eq 'Action';

        $GetParam{$Key} = $ParamObject->GetParam( Param => $Key );

        my %SafeGetParam = $Kernel::OM->Get('Kernel::System::HTMLUtils')->Safety(
            String       => $GetParam{$Key},
            NoApplet     => 1,
            NoObject     => 1,
            NoEmbed      => 1,
            NoSVG        => 1,
            NoImg        => 1,
            NoIntSrcLoad => 1,
            NoExtSrcLoad => 1,
            NoJavaScript => 1,
        );

        $GetParam{$Key} = $SafeGetParam{String};
    }

# RotherOSS / AppointmentToTicket
    # hash for check duplicated entries
    my %AddressesList;

    # MultipleCustomer From-field
    my @MultipleCustomer;
    my $CustomersNumber = $GetParam{'CustomerTicketCounterFromCustomer'} || 0;
    # Contains user name
    my $Selected = $GetParam{'CustomerSelected'} || '';

    # get check item object
    my $CheckItemObject = $Kernel::OM->Get('Kernel::System::CheckItem');

    if ($CustomersNumber) {
        my $CustomerCounter = 1;
        for my $Count ( 0 ... $CustomersNumber ) {
            my $CustomerElement  = $GetParam{'CustomerTicketText_' . $Count};
            my $CustomerSelected = $Selected == $Count ? 'checked="checked"' : '';
            my $CustomerKey      = $GetParam{'CustomerKey_' . $Count} || '';

            if ($CustomerElement) {

                my $CountAux         = $CustomerCounter++;
                my $CustomerError    = '';
                my $CustomerErrorMsg = 'CustomerGenericServerErrorMsg';
                my $CustomerDisabled = '';

                if ( $GetParam{From} ) {
                    $GetParam{From} .= ', ' . $CustomerElement;
                }
                else {
                    $GetParam{From} = $CustomerElement;
                }

                # check email address
                for my $Email ( Mail::Address->parse($CustomerElement) ) {
                    if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) )
                    {
                        $CustomerErrorMsg = $CheckItemObject->CheckErrorType()
                            . 'ServerErrorMsg';
                        $CustomerError = 'ServerError';
                    }
                }

                # check for duplicated entries
                if ( defined $AddressesList{$CustomerElement} && $CustomerError eq '' ) {
                    $CustomerErrorMsg = 'IsDuplicatedServerErrorMsg';
                    $CustomerError    = 'ServerError';
                }

                if ( $CustomerError ne '' ) {
                    $CustomerDisabled = 'disabled="disabled"';
                    $CountAux         = $Count . 'Error';
                }
                push @MultipleCustomer, {
                    Count            => $CountAux,
                    CustomerElement  => $CustomerElement,
                    CustomerSelected => $CustomerSelected,
                    CustomerKey      => $CustomerKey,
                    CustomerError    => $CustomerError,
                    CustomerErrorMsg => $CustomerErrorMsg,
                    CustomerDisabled => $CustomerDisabled,
                };
                $AddressesList{$CustomerElement} = 1;
            }
        }
    }

# EO AppointmentToTicket

    my $ConfigObject      = $Kernel::OM->Get('Kernel::Config');
# RotherOSS / AppointmentToTicket
    my $Config = $ConfigObject->Get("Ticket::Frontend::AgentAppointmentEdit");
    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');
    my $FieldRestrictionsObject = $Kernel::OM->Get('Kernel::System::Ticket::FieldRestrictions');
    my $TicketObject = $Kernel::OM->Get('Kernel::System::Ticket');
    my $UploadCacheObject = $Kernel::OM->Get('Kernel::System::Web::UploadCache');
# EO AppointmentToTicket
    my $LayoutObject      = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $CalendarObject    = $Kernel::OM->Get('Kernel::System::Calendar');
    my $AppointmentObject = $Kernel::OM->Get('Kernel::System::Calendar::Appointment');
    my $PluginObject      = $Kernel::OM->Get('Kernel::System::Calendar::Plugin');

    my $JSON = $LayoutObject->JSONEncode( Data => [] );

    my %PermissionLevel = (
        'ro'        => 1,
        'move_into' => 2,
        'create'    => 3,
        'note'      => 4,
        'owner'     => 5,
        'priority'  => 6,
        'rw'        => 7,
    );

    my $Permissions = 'rw';

#RotherOSS / AppointmentToTicket
    # get Dynamic fields for ParamObject
    my %DynamicFieldValues;

    # cycle through the activated Dynamic Fields for this screen
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( values $Self->{DynamicField}->%* ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # extract the dynamic field value from the web request
        $DynamicFieldValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
            DynamicFieldConfig => $DynamicFieldConfig,
            ParamObject        => $ParamObject,
            LayoutObject       => $LayoutObject,
        );
    }

    # convert dynamic field values into a structure for ACLs
    my %DynamicFieldACLParameters;
    DYNAMICFIELD:
    for my $DynamicField ( sort keys %DynamicFieldValues ) {
        next DYNAMICFIELD if !$DynamicField;
        next DYNAMICFIELD if !defined $DynamicFieldValues{$DynamicField};

        $DynamicFieldACLParameters{ 'DynamicField_' . $DynamicField } = $DynamicFieldValues{$DynamicField};
    }
    $GetParam{DynamicField} = \%DynamicFieldACLParameters;
#EO AppointmentToTicket
    # challenge token check
    $LayoutObject->ChallengeTokenCheck();

    # ------------------------------------------------------------ #
    # edit mask
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'EditMask' ) {

        # get all user's valid calendars
        my $ValidID = $Kernel::OM->Get('Kernel::System::Valid')->ValidLookup(
            Valid => 'valid',
        );
        my @Calendars = $CalendarObject->CalendarList(
            UserID  => $Self->{UserID},
            ValidID => $ValidID,
        );

        # transform data for select box
        my @CalendarData = map {
            {
                Key   => $_->{CalendarID},
                Value => $_->{CalendarName},
            }
        } @Calendars;

        # transform data for ID lookup
        my %CalendarLookup = map {
            $_->{CalendarID} => $_->{CalendarName}
        } @Calendars;

        for my $Calendar (@CalendarData) {

            # check permissions
            my $CalendarPermission = $CalendarObject->CalendarPermissionGet(
                CalendarID => $Calendar->{Key},
                UserID     => $Self->{UserID},
            );

            if ( $PermissionLevel{$CalendarPermission} < 3 ) {

                # permissions < create
                $Calendar->{Disabled} = 1;
            }
        }

        # define year boundaries
        my ( %YearPeriodPast, %YearPeriodFuture );
        for my $Field (qw (Start End RecurrenceUntil)) {
            $YearPeriodPast{$Field} = $YearPeriodFuture{$Field} = 5;
        }

        # do not use date selection time zone calculation by default
        my $OverrideTimeZone = 1;

        my %Appointment;
        if ( $GetParam{AppointmentID} ) {
            %Appointment = $AppointmentObject->AppointmentGet(
                AppointmentID => $GetParam{AppointmentID},
            );

            # non-existent appointment
            if ( !$Appointment{AppointmentID} ) {
                my $Output = $LayoutObject->Error(
                    Message => Translatable('Appointment not found!'),
                );

                return $LayoutObject->Attachment(
                    NoCache     => 1,
                    ContentType => 'text/html',
                    Charset     => $LayoutObject->{UserCharset},
                    Content     => $Output,
                    Type        => 'inline',
                );
            }

            # use time zone calculation if editing existing appointments
            # but only if not dealing with an all day appointment
            else {
                $OverrideTimeZone = $Appointment{AllDay} || 0;
            }

            # check permissions
            $Permissions = $CalendarObject->CalendarPermissionGet(
                CalendarID => $Appointment{CalendarID},
                UserID     => $Self->{UserID},
            );

            # Get start time components.
            my $StartTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{StartTime},
                },
            );
            my $StartTimeSettings = $StartTimeObject->Get();
            my $StartTimeComponents;
            for my $Key ( sort keys %{$StartTimeSettings} ) {
                $StartTimeComponents->{"Start$Key"} = $StartTimeSettings->{$Key};
            }

            # Get end time components.
            my $EndTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{EndTime},
                },
            );

            # End times for all day appointments are inclusive, subtract whole day.
            if ( $Appointment{AllDay} ) {
                $EndTimeObject->Subtract(
                    Days => 1,
                );
                if ( $EndTimeObject < $StartTimeObject ) {
                    $EndTimeObject = $StartTimeObject->Clone();
                }
            }

            my $EndTimeSettings = $EndTimeObject->Get();
            my $EndTimeComponents;
            for my $Key ( sort keys %{$EndTimeSettings} ) {
                $EndTimeComponents->{"End$Key"} = $EndTimeSettings->{$Key};
            }

            %Appointment = ( %Appointment, %{$StartTimeComponents}, %{$EndTimeComponents} );

            # Get recurrence until components.
            if ( $Appointment{RecurrenceUntil} ) {
                my $RecurrenceUntilTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Appointment{RecurrenceUntil},
                    },
                );
                my $RecurrenceUntilSettings = $RecurrenceUntilTimeObject->Get();
                my $RecurrenceUntilComponents;
                for my $Key ( sort keys %{$EndTimeSettings} ) {
                    $RecurrenceUntilComponents->{"RecurrenceUntil$Key"} = $RecurrenceUntilSettings->{$Key};
                }

                %Appointment = ( %Appointment, %{$RecurrenceUntilComponents} );
            }

            # Recalculate year boundaries for build selection method.
            my $DateTimeObject   = $Kernel::OM->Create('Kernel::System::DateTime');
            my $DateTimeSettings = $DateTimeObject->Get();

            for my $Field (qw(Start End RecurrenceUntil)) {
                if ( $Appointment{"${Field}Year"} ) {
                    my $Diff = $Appointment{"${Field}Year"} - $DateTimeSettings->{Year};
                    if ( $Diff > 0 && abs $Diff > $YearPeriodFuture{$Field} ) {
                        $YearPeriodFuture{$Field} = abs $Diff;
                    }
                    elsif ( $Diff < 0 && abs $Diff > $YearPeriodPast{$Field} ) {
                        $YearPeriodPast{$Field} = abs $Diff;
                    }
                }
            }

            if ( $Appointment{Recurring} ) {
                my $RecurrenceType = $GetParam{RecurrenceType} || $Appointment{RecurrenceType};

                if ( $RecurrenceType eq 'CustomWeekly' ) {

                    my $DayOffset = $Self->_DayOffsetGet(
                        Time => $Appointment{StartTime},
                    );

                    if ( defined $GetParam{Days} ) {

                        # check parameters
                        $Appointment{Days} = $GetParam{Days};
                    }
                    else {
                        my @Days = @{ $Appointment{RecurrenceFrequency} };

                        # display selected days according to user timezone
                        if ($DayOffset) {
                            for my $Day (@Days) {
                                $Day += $DayOffset;

                                if ( $Day == 8 ) {
                                    $Day = 1;
                                }
                            }
                        }

                        $Appointment{Days} = join( ",", @Days );
                    }
                }
                elsif ( $RecurrenceType eq 'CustomMonthly' ) {

                    my $DayOffset = $Self->_DayOffsetGet(
                        Time => $Appointment{StartTime},
                    );

                    if ( defined $GetParam{MonthDays} ) {

                        # check parameters
                        $Appointment{MonthDays} = $GetParam{MonthDays};
                    }
                    else {
                        my @MonthDays = @{ $Appointment{RecurrenceFrequency} };

                        # display selected days according to user timezone
                        if ($DayOffset) {
                            for my $MonthDay (@MonthDays) {
                                $MonthDay += $DayOffset;
                                if ( $DateTimeSettings->{Day} == 32 ) {
                                    $MonthDay = 1;
                                }
                            }
                        }
                        $Appointment{MonthDays} = join( ",", @MonthDays );
                    }
                }
                elsif ( $RecurrenceType eq 'CustomYearly' ) {

                    my $DayOffset = $Self->_DayOffsetGet(
                        Time => $Appointment{StartTime},
                    );

                    if ( defined $GetParam{Months} ) {

                        # check parameters
                        $Appointment{Months} = $GetParam{Months};
                    }
                    else {
                        my @Months = @{ $Appointment{RecurrenceFrequency} };
                        $Appointment{Months} = join( ",", @Months );
                    }
                }
            }

            # Check if dealing with ticket appointment.
            if ( $Appointment{TicketAppointmentRuleID} ) {
                $GetParam{TicketID} = $CalendarObject->TicketAppointmentTicketID(
                    AppointmentID => $Appointment{AppointmentID},
                );

                my $Rule = $CalendarObject->TicketAppointmentRuleGet(
                    CalendarID => $Appointment{CalendarID},
                    RuleID     => $Appointment{TicketAppointmentRuleID},
                );

                # Get date types from the ticket appointment rule.
                if ( IsHashRefWithData($Rule) ) {
                    for my $Type (qw(StartDate EndDate)) {
                        if (
                            $Rule->{$Type} eq 'FirstResponseTime'
                            || $Rule->{$Type} eq 'UpdateTime'
                            || $Rule->{$Type} eq 'SolutionTime'
                            || $Rule->{$Type} eq 'PendingTime'
                            )
                        {
                            $GetParam{ReadOnlyStart}    = 1 if $Type eq 'StartDate';
                            $GetParam{ReadOnlyDuration} = 1 if $Type eq 'EndDate';
                        }
                        elsif ( $Rule->{$Type} =~ /^Plus_[0-9]+$/ ) {
                            $GetParam{ReadOnlyDuration} = 1;
                        }
                    }
                }
            }
        }

        # get selected timestamp
        my $SelectedTimestamp = sprintf(
            "%04d-%02d-%02d 00:00:00",
            $Appointment{StartYear}  // $GetParam{StartYear},
            $Appointment{StartMonth} // $GetParam{StartMonth},
            $Appointment{StartDay}   // $GetParam{StartDay}
        );

        # Get current date components.
        my $SelectedSystemTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $SelectedTimestamp,
            },
        );
        my $SelectedSystemTimeSettings = $SelectedSystemTimeObject->Get();

        # Set current date components if not defined.
        $Appointment{Days}      //= $SelectedSystemTimeSettings->{DayOfWeek};
        $Appointment{MonthDays} //= $SelectedSystemTimeSettings->{Day};
        $Appointment{Months}    //= $SelectedSystemTimeSettings->{Month};

        # calendar ID selection
        my $CalendarID = $Appointment{CalendarID} // $GetParam{CalendarID};

        # calendar name
        if ($CalendarID) {
            $Param{CalendarName} = $CalendarLookup{$CalendarID};
        }

        # calendar selection
        $Param{CalendarIDStrg} = $LayoutObject->BuildSelection(
            Data         => \@CalendarData,
            SelectedID   => $CalendarID,
            Name         => 'CalendarID',
            Multiple     => 0,
            Class        => 'Modernize Validate_Required',
            PossibleNone => 1,
        );

        # all day
        if (
            $GetParam{AllDay} ||
            ( $GetParam{AppointmentID} && $Appointment{AllDay} )
            )
        {
            $Param{AllDayString}  = Translatable('Yes');
            $Param{AllDayChecked} = 'checked ';

            # start date
            $Param{StartDate} = sprintf(
                "%04d-%02d-%02d",
                $Appointment{StartYear}  // $GetParam{StartYear},
                $Appointment{StartMonth} // $GetParam{StartMonth},
                $Appointment{StartDay}   // $GetParam{StartDay},
            );

            # end date
            $Param{EndDate} = sprintf(
                "%04d-%02d-%02d",
                $Appointment{EndYear}  // $GetParam{EndYear},
                $Appointment{EndMonth} // $GetParam{EndMonth},
                $Appointment{EndDay}   // $GetParam{EndDay},
            );
        }
        else {
            $Param{AllDayString}  = Translatable('No');
            $Param{AllDayChecked} = '';

            # start date
            $Param{StartDate} = sprintf(
                "%04d-%02d-%02d %02d:%02d:00",
                $Appointment{StartYear}   // $GetParam{StartYear},
                $Appointment{StartMonth}  // $GetParam{StartMonth},
                $Appointment{StartDay}    // $GetParam{StartDay},
                $Appointment{StartHour}   // $GetParam{StartHour},
                $Appointment{StartMinute} // $GetParam{StartMinute},
            );

            # end date
            $Param{EndDate} = sprintf(
                "%04d-%02d-%02d %02d:%02d:00",
                $Appointment{EndYear}   // $GetParam{EndYear},
                $Appointment{EndMonth}  // $GetParam{EndMonth},
                $Appointment{EndDay}    // $GetParam{EndDay},
                $Appointment{EndHour}   // $GetParam{EndHour},
                $Appointment{EndMinute} // $GetParam{EndMinute},
            );
        }

        # start date string
        $Param{StartDateString} = $LayoutObject->BuildDateSelection(
            %GetParam,
            %Appointment,
            Prefix                   => 'Start',
            StartHour                => $Appointment{StartHour}   // $GetParam{StartHour},
            StartMinute              => $Appointment{StartMinute} // $GetParam{StartMinute},
            Format                   => 'DateInputFormatLong',
            ValidateDateBeforePrefix => 'End',
            Validate                 => $Appointment{TicketAppointmentRuleID} && $GetParam{ReadOnlyStart} ? 0 : 1,
            YearPeriodPast           => $YearPeriodPast{Start},
            YearPeriodFuture         => $YearPeriodFuture{Start},
            OverrideTimeZone         => $OverrideTimeZone,
        );

        # end date string
        $Param{EndDateString} = $LayoutObject->BuildDateSelection(
            %GetParam,
            %Appointment,
            Prefix                  => 'End',
            EndHour                 => $Appointment{EndHour}   // $GetParam{EndHour},
            EndMinute               => $Appointment{EndMinute} // $GetParam{EndMinute},
            Format                  => 'DateInputFormatLong',
            ValidateDateAfterPrefix => 'Start',
            Validate                => $Appointment{TicketAppointmentRuleID} && $GetParam{ReadOnlyDuration} ? 0 : 1,
            YearPeriodPast          => $YearPeriodPast{End},
            YearPeriodFuture        => $YearPeriodFuture{End},
            OverrideTimeZone        => $OverrideTimeZone,
        );

        # get main object
        my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

        # check if team object is registered
        if ( $MainObject->Require( 'Kernel::System::Calendar::Team', Silent => 1 ) ) {

            my $TeamIDs = $Appointment{TeamID};
            if ( !$TeamIDs ) {
                my @TeamIDs = $ParamObject->GetArray( Param => 'TeamID[]' );
                $TeamIDs = \@TeamIDs;
            }

            my $ResourceIDs = $Appointment{ResourceID};
            if ( !$ResourceIDs ) {
                my @ResourceIDs = $ParamObject->GetArray( Param => 'ResourceID[]' );
                $ResourceIDs = \@ResourceIDs;
            }

            # get needed objects
            my $TeamObject = $Kernel::OM->Get('Kernel::System::Calendar::Team');
            my $UserObject = $Kernel::OM->Get('Kernel::System::User');

            # get allowed team list for current user
            my %TeamList = $TeamObject->AllowedTeamList(
                PreventEmpty => 1,
                UserID       => $Self->{UserID},
            );

            # team names
            my @TeamNames;
            for my $TeamID ( @{$TeamIDs} ) {
                push @TeamNames, $TeamList{$TeamID} if $TeamList{$TeamID};
            }
            if ( scalar @TeamNames ) {
                $Param{TeamNames} = join( '<br>', @TeamNames );
            }
            else {
                $Param{TeamNames} = $Self->{EmptyString};
            }

            # team list string
            $Param{TeamIDStrg} = $LayoutObject->BuildSelection(
                Data         => \%TeamList,
                SelectedID   => $TeamIDs,
                Name         => 'TeamID',
                Multiple     => 1,
                Class        => 'Modernize',
                PossibleNone => 1,
            );

            # iterate through selected teams
            my %TeamUserListAll;
            TEAMID:
            for my $TeamID ( @{$TeamIDs} ) {
                next TEAMID if !$TeamID;

                # get list of team members
                my %TeamUserList = $TeamObject->TeamUserList(
                    TeamID => $TeamID,
                    UserID => $Self->{UserID},
                );

                # get user data
                for my $UserID ( sort keys %TeamUserList ) {
                    my %User = $UserObject->GetUserData(
                        UserID => $UserID,
                    );
                    $TeamUserList{$UserID} = $User{UserFullname};
                }

                %TeamUserListAll = ( %TeamUserListAll, %TeamUserList );
            }

            # resource names
            my @ResourceNames;
            for my $ResourceID ( @{$ResourceIDs} ) {
                push @ResourceNames, $TeamUserListAll{$ResourceID} if $TeamUserListAll{$ResourceID};
            }
            if ( scalar @ResourceNames ) {
                $Param{ResourceNames} = join( '<br>', @ResourceNames );
            }
            else {
                $Param{ResourceNames} = $Self->{EmptyString};
            }

            # team user list string
            $Param{ResourceIDStrg} = $LayoutObject->BuildSelection(
                Data         => \%TeamUserListAll,
                SelectedID   => $ResourceIDs,
                Name         => 'ResourceID',
                Multiple     => 1,
                Class        => 'Modernize',
                PossibleNone => 1,
            );
        }

        my $SelectedRecurrenceType       = 0;
        my $SelectedRecurrenceCustomType = 'CustomDaily';    # default

        if ( $Appointment{Recurring} ) {

            # from appointment
            $SelectedRecurrenceType = $GetParam{RecurrenceType} || $Appointment{RecurrenceType};
            if ( $SelectedRecurrenceType =~ /Custom/ ) {
                $SelectedRecurrenceCustomType = $SelectedRecurrenceType;
                $SelectedRecurrenceType       = 'Custom';
            }
        }

        # recurrence type
        my @RecurrenceTypes = (
            {
                Key   => '0',
                Value => Translatable('Never'),
            },
            {
                Key   => 'Daily',
                Value => Translatable('Every Day'),
            },
            {
                Key   => 'Weekly',
                Value => Translatable('Every Week'),
            },
            {
                Key   => 'Monthly',
                Value => Translatable('Every Month'),
            },
            {
                Key   => 'Yearly',
                Value => Translatable('Every Year'),
            },
            {
                Key   => 'Custom',
                Value => Translatable('Custom'),
            },
        );
        my %RecurrenceTypeLookup = map {
            $_->{Key} => $_->{Value}
        } @RecurrenceTypes;
        $Param{RecurrenceValue} = $LayoutObject->{LanguageObject}->Translate(
            $RecurrenceTypeLookup{$SelectedRecurrenceType},
        );

        # recurrence type selection
        $Param{RecurrenceTypeString} = $LayoutObject->BuildSelection(
            Data         => \@RecurrenceTypes,
            SelectedID   => $SelectedRecurrenceType,
            Name         => 'RecurrenceType',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # recurrence custom type
        my @RecurrenceCustomTypes = (
            {
                Key   => 'CustomDaily',
                Value => Translatable('Daily'),
            },
            {
                Key   => 'CustomWeekly',
                Value => Translatable('Weekly'),
            },
            {
                Key   => 'CustomMonthly',
                Value => Translatable('Monthly'),
            },
            {
                Key   => 'CustomYearly',
                Value => Translatable('Yearly'),
            },
        );
        my %RecurrenceCustomTypeLookup = map {
            $_->{Key} => $_->{Value}
        } @RecurrenceCustomTypes;
        my $RecurrenceCustomType = $RecurrenceCustomTypeLookup{$SelectedRecurrenceCustomType};
        $Param{RecurrenceValue} .= ', ' . $LayoutObject->{LanguageObject}->Translate(
            lc $RecurrenceCustomType,
        ) if $RecurrenceCustomType && $SelectedRecurrenceType eq 'Custom';

        # recurrence custom type selection
        $Param{RecurrenceCustomTypeString} = $LayoutObject->BuildSelection(
            Data       => \@RecurrenceCustomTypes,
            SelectedID => $SelectedRecurrenceCustomType,
            Name       => 'RecurrenceCustomType',
            Class      => 'Modernize',
        );

        # recurrence interval
        my $SelectedInterval = $GetParam{RecurrenceInterval} || $Appointment{RecurrenceInterval} || 1;
        if ( $Appointment{RecurrenceInterval} ) {
            my %RecurrenceIntervalLookup = (
                'CustomDaily' => $LayoutObject->{LanguageObject}->Translate(
                    'day(s)',
                ),
                'CustomWeekly' => $LayoutObject->{LanguageObject}->Translate(
                    'week(s)',
                ),
                'CustomMonthly' => $LayoutObject->{LanguageObject}->Translate(
                    'month(s)',
                ),
                'CustomYearly' => $LayoutObject->{LanguageObject}->Translate(
                    'year(s)',
                ),
            );

            if ( $RecurrenceCustomType && $SelectedRecurrenceType eq 'Custom' ) {
                $Param{RecurrenceValue} .= ', '
                    . $LayoutObject->{LanguageObject}->Translate('every')
                    . ' ' . $Appointment{RecurrenceInterval} . ' '
                    . $RecurrenceIntervalLookup{$SelectedRecurrenceCustomType};
            }
        }

        # add interval selection (1-31)
        my @RecurrenceCustomInterval;
        for ( my $DayNumber = 1; $DayNumber < 32; $DayNumber++ ) {
            push @RecurrenceCustomInterval, {
                Key   => $DayNumber,
                Value => $DayNumber,
            };
        }
        $Param{RecurrenceIntervalString} = $LayoutObject->BuildSelection(
            Data       => \@RecurrenceCustomInterval,
            SelectedID => $SelectedInterval,
            Name       => 'RecurrenceInterval',
        );

        # recurrence limit
        my $RecurrenceLimit = 1;
        if ( $Appointment{RecurrenceCount} ) {
            $RecurrenceLimit = 2;

            if ($SelectedRecurrenceType) {
                $Param{RecurrenceValue} .= ', ' . $LayoutObject->{LanguageObject}->Translate(
                    'for %s time(s)', $Appointment{RecurrenceCount},
                );
            }
        }

        # recurrence limit string
        $Param{RecurrenceLimitString} = $LayoutObject->BuildSelection(
            Data => [
                {
                    Key   => 1,
                    Value => Translatable('until ...'),
                },
                {
                    Key   => 2,
                    Value => Translatable('for ... time(s)'),
                },
            ],
            SelectedID   => $RecurrenceLimit,
            Name         => 'RecurrenceLimit',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        my $RecurrenceUntilDiffTime = 0;
        if ( !$Appointment{RecurrenceUntil} ) {

            # Get current and start time for difference.
            my $SystemTime      = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();
            my $StartTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    Year   => $Appointment{StartYear}   // $GetParam{StartYear},
                    Month  => $Appointment{StartMonth}  // $GetParam{StartMonth},
                    Day    => $Appointment{StartDay}    // $GetParam{StartDay},
                    Hour   => $Appointment{StartHour}   // $GetParam{StartHour},
                    Minute => $Appointment{StartMinute} // $GetParam{StartMinute},
                    Second => 0,
                },
            );
            my $StartTime = $StartTimeObject->ToEpoch();

            $RecurrenceUntilDiffTime = $StartTime - $SystemTime + 60 * 60 * 24 * 3;    # start +3 days
        }
        else {
            $Param{RecurrenceUntil} = sprintf(
                "%04d-%02d-%02d",
                $Appointment{RecurrenceUntilYear},
                $Appointment{RecurrenceUntilMonth},
                $Appointment{RecurrenceUntilDay},
            );

            if ($SelectedRecurrenceType) {
                $Param{RecurrenceValue} .= ', ' . $LayoutObject->{LanguageObject}->Translate(
                    'until %s', $Param{RecurrenceUntil},
                );
            }
        }

        # recurrence until date string
        $Param{RecurrenceUntilString} = $LayoutObject->BuildDateSelection(
            %Appointment,
            %GetParam,
            Prefix                  => 'RecurrenceUntil',
            Format                  => 'DateInputFormat',
            DiffTime                => $RecurrenceUntilDiffTime,
            ValidateDateAfterPrefix => 'Start',
            Validate                => 1,
            YearPeriodPast          => $YearPeriodPast{RecurrenceUntil},
            YearPeriodFuture        => $YearPeriodFuture{RecurrenceUntil},
            OverrideTimeZone        => $OverrideTimeZone,
        );

        # notification template
        my @NotificationTemplates = (
            {
                Key   => '0',
                Value => $LayoutObject->{LanguageObject}->Translate('No notification'),
            },
            {
                Key   => 'Start',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 0 ),
            },
            {
                Key   => '300',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 5 ),
            },
            {
                Key   => '900',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 15 ),
            },
            {
                Key   => '1800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 30 ),
            },
            {
                Key   => '3600',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 1 ),
            },
            {
                Key   => '7200',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 2 ),
            },
            {
                Key   => '43200',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 12 ),
            },
            {
                Key   => '86400',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s day(s) before', 1 ),
            },
            {
                Key   => '172800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s day(s) before', 2 ),
            },
            {
                Key   => '604800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s week before', 1 ),
            },
            {
                Key   => 'Custom',
                Value => $LayoutObject->{LanguageObject}->Translate('Custom'),
            },
        );
        my %NotificationTemplateLookup = map {
            $_->{Key} => $_->{Value}
        } @NotificationTemplates;
        my $SelectedNotificationTemplate = $Appointment{NotificationTemplate} || '0';
        $Param{NotificationValue} = $NotificationTemplateLookup{$SelectedNotificationTemplate};

        # notification selection
        $Param{NotificationStrg} = $LayoutObject->BuildSelection(
            Data         => \@NotificationTemplates,
            SelectedID   => $SelectedNotificationTemplate,
            Name         => 'NotificationTemplate',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # notification custom units
        my @NotificationCustomUnits = (
            {
                Key   => 'minutes',
                Value => $LayoutObject->{LanguageObject}->Translate('minute(s)'),
            },
            {
                Key   => 'hours',
                Value => $LayoutObject->{LanguageObject}->Translate('hour(s)'),
            },
            {
                Key   => 'days',
                Value => $LayoutObject->{LanguageObject}->Translate('day(s)'),
            },
        );
        my %NotificationCustomUnitLookup = map {
            $_->{Key} => $_->{Value}
        } @NotificationCustomUnits;
        my $SelectedNotificationCustomUnit = $Appointment{NotificationCustomRelativeUnit} || 'minutes';

        # notification custom units selection
        $Param{NotificationCustomUnitsStrg} = $LayoutObject->BuildSelection(
            Data         => \@NotificationCustomUnits,
            SelectedID   => $SelectedNotificationCustomUnit,
            Name         => 'NotificationCustomRelativeUnit',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # notification custom units point of time
        my @NotificationCustomUnitsPointOfTime = (
            {
                Key   => 'beforestart',
                Value => $LayoutObject->{LanguageObject}->Translate('before the appointment starts'),
            },
            {
                Key   => 'afterstart',
                Value => $LayoutObject->{LanguageObject}->Translate('after the appointment has been started'),
            },
            {
                Key   => 'beforeend',
                Value => $LayoutObject->{LanguageObject}->Translate('before the appointment ends'),
            },
            {
                Key   => 'afterend',
                Value => $LayoutObject->{LanguageObject}->Translate('after the appointment has been ended'),
            },
        );
        my %NotificationCustomUnitPointOfTimeLookup = map {
            $_->{Key} => $_->{Value}
        } @NotificationCustomUnitsPointOfTime;
        my $SelectedNotificationCustomUnitPointOfTime = $Appointment{NotificationCustomRelativePointOfTime}
            || 'beforestart';

        # notification custom units point of time selection
        $Param{NotificationCustomUnitsPointOfTimeStrg} = $LayoutObject->BuildSelection(
            Data         => \@NotificationCustomUnitsPointOfTime,
            SelectedID   => $SelectedNotificationCustomUnitPointOfTime,
            Name         => 'NotificationCustomRelativePointOfTime',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # Extract the date units for the custom date selection.
        my $NotificationCustomDateTimeSettings = {};
        if ( $Appointment{NotificationCustomDateTime} ) {
            my $NotificationCustomDateTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{NotificationCustomDateTime},
                },
            );
            $NotificationCustomDateTimeSettings = $NotificationCustomDateTimeObject->Get();
        }

        # notification custom date selection
        $Param{NotificationCustomDateTimeStrg} = $LayoutObject->BuildDateSelection(
            Prefix                           => 'NotificationCustomDateTime',
            NotificationCustomDateTimeYear   => $NotificationCustomDateTimeSettings->{Year},
            NotificationCustomDateTimeMonth  => $NotificationCustomDateTimeSettings->{Month},
            NotificationCustomDateTimeDay    => $NotificationCustomDateTimeSettings->{Day},
            NotificationCustomDateTimeHour   => $NotificationCustomDateTimeSettings->{Hour},
            NotificationCustomDateTimeMinute => $NotificationCustomDateTimeSettings->{Minute},
            Format                           => 'DateInputFormatLong',
            YearPeriodPast                   => $YearPeriodPast{Start},
            YearPeriodFuture                 => $YearPeriodFuture{Start},
        );

        # prepare radio button for custom date time and relative input
        $Appointment{NotificationCustom} ||= '';

        if ( $Appointment{NotificationCustom} eq 'datetime' ) {
            $Param{NotificationCustomDateTimeInputRadio} = 'checked ';
        }
        elsif ( $Appointment{NotificationCustom} eq 'relative' ) {
            $Param{NotificationCustomRelativeInputRadio} = 'checked ';
        }
        else {
            $Param{NotificationCustomRelativeInputRadio} = 'checked ';
        }

        # notification custom string value
        if ( $Appointment{NotificationCustom} eq 'datetime' ) {
            $Param{NotificationValue} .= ', ' . $LayoutObject->{LanguageObject}->FormatTimeString(
                $Appointment{NotificationCustomDateTime},
                'DateFormat'
            );
        }
        elsif ( $Appointment{NotificationCustom} eq 'relative' ) {
            if (
                $Appointment{NotificationCustomRelativeUnit}
                && $Appointment{NotificationCustomRelativePointOfTime}
                )
            {
                $Appointment{NotificationCustomRelativeUnitCount} ||= 0;
                $Param{NotificationValue} .= ', '
                    . $Appointment{NotificationCustomRelativeUnitCount}
                    . ' '
                    . $NotificationCustomUnitLookup{$SelectedNotificationCustomUnit}
                    . ' '
                    . $NotificationCustomUnitPointOfTimeLookup{$SelectedNotificationCustomUnitPointOfTime};
            }
        }

# RotherOSS / AppointmentToTicket
        my %FutureTask;
        if ( %Appointment ) {
            my $TaskID;
            if ( $Appointment{FutureTaskID} ) {
                $TaskID = $Appointment{FutureTaskID};
            }
            # Only for parent appointments
            elsif ( $Appointment{Recurring} ) {
                # Check all appointments of series for future task id
                my @AppointmentList = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentList(
                    CalendarID => $Appointment{CalendarID},
                    ParentID => $Appointment{AppointmentID},
                );
                my %ParentAppointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet( AppointmentID => $Appointment{AppointmentID} );
                unshift @AppointmentList, \%ParentAppointment;

                APPOINTMENTLIST:
                for my $RecurringAppointment (@AppointmentList) {
                    if ( $RecurringAppointment->{FutureTaskID} ) {
                        $TaskID = $RecurringAppointment->{FutureTaskID};
                        last APPOINTMENTLIST;
                    }
                }
            }
            if ( $TaskID ) {
                %FutureTask = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskGet(
                    TaskID => $TaskID,
                );
            }
        }
        # ticket template
        my @TicketTemplates = (
            {
                Key   => '0',
                Value => $LayoutObject->{LanguageObject}->Translate('No ticket creation'),
            },
            {
                Key   => 'Start',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 0 ),
            },
            {
                Key   => '300',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 5 ),
            },
            {
                Key   => '900',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 15 ),
            },
            {
                Key   => '1800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s minute(s) before', 30 ),
            },
            {
                Key   => '3600',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 1 ),
            },
            {
                Key   => '7200',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 2 ),
            },
            {
                Key   => '43200',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s hour(s) before', 12 ),
            },
            {
                Key   => '86400',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s day(s) before', 1 ),
            },
            {
                Key   => '172800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s day(s) before', 2 ),
            },
            {
                Key   => '604800',
                Value => $LayoutObject->{LanguageObject}->Translate( '%s week before', 1 ),
            },
            {
                Key   => 'Custom',
                Value => $LayoutObject->{LanguageObject}->Translate('Custom'),
            },
        );
        my %TicketTemplateLookup = map {
            $_->{Key} => $_->{Value}
        } @TicketTemplates;

        my $SelectedTicketTemplate = defined $FutureTask{Data} ? $FutureTask{Data}->{AppointmentTicket}->{Template} : '0';
        $Param{TicketValue} = $TicketTemplateLookup{$SelectedTicketTemplate};

        # ticket selection
        $Param{TicketStrg} = $LayoutObject->BuildSelection(
            Data         => \@TicketTemplates,
            SelectedID   => $SelectedTicketTemplate,
            Name         => 'TicketTemplate',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # ticket custom units
        my @TicketCustomUnits = (
            {
                Key   => 'minutes',
                Value => $LayoutObject->{LanguageObject}->Translate('minute(s)'),
            },
            {
                Key   => 'hours',
                Value => $LayoutObject->{LanguageObject}->Translate('hour(s)'),
            },
            {
                Key   => 'days',
                Value => $LayoutObject->{LanguageObject}->Translate('day(s)'),
            },
        );
        my %TicketCustomUnitLookup = map {
            $_->{Key} => $_->{Value}
        } @TicketCustomUnits;
        my $SelectedTicketCustomUnit = ( $FutureTask{Data} ? $FutureTask{Data}->{AppointmentTicket}->{CustomRelativeUnit} : '' ) || 'minutes';

        # ticket custom units selection
        $Param{TicketCustomUnitsStrg} = $LayoutObject->BuildSelection(
            Data         => \@TicketCustomUnits,
            SelectedID   => $SelectedTicketCustomUnit,
            Name         => 'TicketCustomRelativeUnit',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # ticket custom units point of time
        my @TicketCustomUnitsPointOfTime = (
            {
                Key   => 'beforestart',
                Value => $LayoutObject->{LanguageObject}->Translate('before the appointment starts'),
            },
            {
                Key   => 'afterstart',
                Value => $LayoutObject->{LanguageObject}->Translate('after the appointment has been started'),
            },
            {
                Key   => 'beforeend',
                Value => $LayoutObject->{LanguageObject}->Translate('before the appointment ends'),
            },
            {
                Key   => 'afterend',
                Value => $LayoutObject->{LanguageObject}->Translate('after the appointment has been ended'),
            },
        );
        my %TicketCustomUnitPointOfTimeLookup = map {
            $_->{Key} => $_->{Value}
        } @TicketCustomUnitsPointOfTime;
        my $SelectedTicketCustomUnitPointOfTime = ( $FutureTask{Data} ? $FutureTask{Data}->{AppointmentTicket}->{CustomRelativePointOfTime} : '' )
            || 'beforestart';

        # ticket custom units point of time selection
        $Param{TicketCustomUnitsPointOfTimeStrg} = $LayoutObject->BuildSelection(
            Data         => \@TicketCustomUnitsPointOfTime,
            SelectedID   => $SelectedTicketCustomUnitPointOfTime,
            Name         => 'TicketCustomRelativePointOfTime',
            Multiple     => 0,
            Class        => 'Modernize',
            PossibleNone => 0,
        );

        # Extract the date units for the custom date selection.
        my $TicketCustomDateTimeSettings = {};
        if ( $FutureTask{Data} && $FutureTask{Data}->{AppointmentTicket}->{CustomDateTime} ) {
            my $TicketCustomDateTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $FutureTask{Data}->{AppointmentTicket}->{CustomDateTime},
                },
            );
            $TicketCustomDateTimeSettings = $TicketCustomDateTimeObject->Get();
        }

        # ticket custom date selection
        $Param{TicketCustomDateTimeStrg} = $LayoutObject->BuildDateSelection(
            Prefix                           => 'TicketCustomDateTime',
            TicketCustomDateTimeYear   => $TicketCustomDateTimeSettings->{Year},
            TicketCustomDateTimeMonth  => $TicketCustomDateTimeSettings->{Month},
            TicketCustomDateTimeDay    => $TicketCustomDateTimeSettings->{Day},
            TicketCustomDateTimeHour   => $TicketCustomDateTimeSettings->{Hour},
            TicketCustomDateTimeMinute => $TicketCustomDateTimeSettings->{Minute},
            Format                           => 'DateInputFormatLong',
            YearPeriodPast                   => $YearPeriodPast{Start},
            YearPeriodFuture                 => $YearPeriodFuture{Start},
        );

        # prepare radio button for custom date time and relative input
        if ( $FutureTask{Data} ) {
            $FutureTask{Data}->{AppointmentTicket}->{Custom} ||= '';
        }

        if ( $FutureTask{Data} && $FutureTask{Data}->{AppointmentTicket}->{Custom} eq 'datetime' ) {
            $Param{TicketCustomDateTimeInputRadio} = 'checked="checked"';
        }
        elsif ( $FutureTask{Data} && $FutureTask{Data}->{AppointmentTicket}->{Custom} eq 'relative' ) {
            $Param{TicketCustomRelativeInputRadio} = 'checked="checked"';
        }
        else {
            $Param{TicketCustomRelativeInputRadio} = 'checked="checked"';
        }

        # ticket custom string value
        if ( $FutureTask{Data} && $FutureTask{Data}->{AppointmentTicket}->{Custom} eq 'datetime' ) {
            $Param{TicketValue} .= ', ' . $LayoutObject->{LanguageObject}->FormatTimeString(
                $FutureTask{Data}->{AppointmentTicket}->{CustomDateTime},
                'DateFormat'
            );
        }
        elsif ( $FutureTask{Data} && $FutureTask{Data}->{AppointmentTicket}->{Custom} eq 'relative' ) {
            if (
                $FutureTask{Data}->{AppointmentTicket}->{CustomRelativeUnit}
                && $FutureTask{Data}->{AppointmentTicket}->{CustomRelativePointOfTime}
                )
            {
                $FutureTask{Data}->{AppointmentTicket}->{CustomRelativeUnitCount} ||= 0;
                $Param{TicketValue} .= ', '
                    . $FutureTask{Data}->{AppointmentTicket}->{CustomRelativeUnitCount}
                    . ' '
                    . $TicketCustomUnitLookup{$SelectedTicketCustomUnit}
                    . ' '
                    . $TicketCustomUnitPointOfTimeLookup{$SelectedTicketCustomUnitPointOfTime};
            }
        }
# EO AppointmentToTicket

        # get plugin list
        $Param{PluginList} = $PluginObject->PluginList();

        # new appointment plugin search
        if ( $GetParam{PluginKey} && ( $GetParam{Search} || $GetParam{ObjectID} ) ) {

            if ( grep { $_ eq $GetParam{PluginKey} } keys %{ $Param{PluginList} } ) {

                # search using plugin
                my $ResultList = $PluginObject->PluginSearch(
                    %GetParam,
                    UserID => $Self->{UserID},
                );

                $Param{PluginData}->{ $GetParam{PluginKey} } = [];
                my @LinkArray = sort keys %{$ResultList};

                # add possible links
                for my $LinkID (@LinkArray) {
                    push @{ $Param{PluginData}->{ $GetParam{PluginKey} } }, {
                        LinkID   => $LinkID,
                        LinkName => $ResultList->{$LinkID},
                        LinkURL  => sprintf(
                            $Param{PluginList}->{ $GetParam{PluginKey} }->{PluginURL},
                            $LinkID
                        ),
                    };
                }

                $Param{PluginList}->{ $GetParam{PluginKey} }->{LinkList} = $LayoutObject->JSONEncode(
                    Data => \@LinkArray,
                );
            }
        }

        # edit appointment plugin links
        elsif ( $GetParam{AppointmentID} ) {

            for my $PluginKey ( sort keys %{ $Param{PluginList} } ) {
                my $LinkList = $PluginObject->PluginLinkList(
                    AppointmentID => $GetParam{AppointmentID},
                    PluginKey     => $PluginKey,
                    UserID        => $Self->{UserID},
                );
                my @LinkArray;

                $Param{PluginData}->{$PluginKey} = [];
                for my $LinkID ( sort keys %{$LinkList} ) {
                    push @{ $Param{PluginData}->{$PluginKey} }, $LinkList->{$LinkID};
                    push @LinkArray,                            $LinkList->{$LinkID}->{LinkID};
                }

                $Param{PluginList}->{$PluginKey}->{LinkList} = $LayoutObject->JSONEncode(
                    Data => \@LinkArray,
                );
            }
        }

# RotherOSS / AppointmentToTicket
#         # html mask output
#         $LayoutObject->Block(
#             Name => 'EditMask',
#             Data => {
#                 %Param,
#                 %GetParam,
#                 %Appointment,
#                 PermissionLevel => $PermissionLevel{$Permissions},
#             },
#         );

        # Build ticket fields
        # frontend specific config
        my %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetUserData(
            UserID => $Self->{UserID},
        );

        # Fetch dynamic field configs
        my @DynamicFieldConfigs;
        if ( defined $Config->{DynamicField} ) {
            my $DynamicFieldConfigsRef = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
                Valid       => 1,
                ObjectType  => [ 'Ticket', 'Article' ],
                FieldFilter => $Config->{DynamicField} || {},
            );
            @DynamicFieldConfigs = defined $DynamicFieldConfigsRef ? @{ $DynamicFieldConfigsRef } : ();
        }

        if ( $GetParam{Dest} ) {
            $GetParam{Queue} = $Kernel::OM->Get('Kernel::System::Queue')->QueueLookup( QueueID => $GetParam{Dest} );
            $GetParam{QueueID} = $GetParam{Dest};
        }
        elsif ( %FutureTask ) {
            $GetParam{QueueID} = $FutureTask{Data}->{AppointmentTicket}->{QueueID};
            $GetParam{Queue} = $Kernel::OM->Get('Kernel::System::Queue')->QueueLookup( QueueID => $GetParam{QueueID} );
            $GetParam{NextStateID} = $FutureTask{Data}->{AppointmentTicket}->{StateID};
            $GetParam{TypeID} = $FutureTask{Data}->{AppointmentTicket}->{TypeID};
            $GetParam{ServiceID} = $FutureTask{Data}->{AppointmentTicket}->{ServiceID};
            $GetParam{SLAID} = $FutureTask{Data}->{AppointmentTicket}->{SLAID};
        }
        else {
            my $UserDefaultQueue = $ConfigObject->Get('Ticket::Frontend::UserDefaultQueue') || '';

            if ($UserDefaultQueue) {
                $GetParam{QueueID} = $Kernel::OM->Get('Kernel::System::Queue')->QueueLookup( Queue => $UserDefaultQueue );
                if ( $GetParam{QueueID} ) {
                    $GetParam{Queue} = "$GetParam{TicketQueueID}||$UserDefaultQueue";
                }
            }
        }

        my %DynamicFieldValues;
        # cycle through the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @DynamicFieldConfigs ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

            # extract the dynamic field value from the web request
            $DynamicFieldValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
                DynamicFieldConfig => $DynamicFieldConfig,
                ParamObject        => $ParamObject,
                LayoutObject       => $LayoutObject,
            );

            if ( !$DynamicFieldValues{ $DynamicFieldConfig->{Name} } ) {
                # extract the dynamic field value from the web request with approach for array
                $DynamicFieldValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
                    DynamicFieldConfig => { $DynamicFieldConfig->%*, Name => $DynamicFieldConfig->{Name} . '[]' },
                    ParamObject        => $ParamObject,
                    LayoutObject       => $LayoutObject,
                );
            }
        }

        # cycle trough the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @DynamicFieldConfigs ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);
            next DYNAMICFIELD if !IsHashRefWithData( $DynamicFieldConfig->{Config} );
            next DYNAMICFIELD if !$DynamicFieldConfig->{Name};

            # to store dynamic field value from database (or undefined)
            my $Value;

            # Check if the user has a user specific default value for
            # the dynamic field, otherwise will use Dynamic Field default value
            # get default value from dynamic field config (if any)
            $Value = $DynamicFieldConfig->{Config}->{DefaultValue} || '';

            # override the value from user preferences if is set
            if ( $UserPreferences{ 'UserDynamicField_' . $DynamicFieldConfig->{Name} } ) {
                $Value = $UserPreferences{ 'UserDynamicField_' . $DynamicFieldConfig->{Name} };
            }

            if ( $DynamicFieldValues{$DynamicFieldConfig->{Name}} ) {
                $Value = $DynamicFieldValues{$DynamicFieldConfig->{Name}};
            }

            if ( %FutureTask && $FutureTask{Data}->{AppointmentTicket}->{DynamicFields}->{$DynamicFieldConfig->{Name}} ) {
                $Value = $FutureTask{Data}->{AppointmentTicket}->{DynamicFields}->{$DynamicFieldConfig->{Name}};
            }

            $GetParam{DynamicField}{ 'DynamicField_' . $DynamicFieldConfig->{Name} } = $Value;
        }

        # create html strings for all dynamic fields
        my %DynamicFieldHTMLData;
        DYNAMICFIELD:
        for my $i ( 0 .. $#DynamicFieldConfigs ) {
            next DYNAMICFIELD if !IsHashRefWithData( $DynamicFieldConfigs[$i] );

            my $DynamicFieldConfig = $DynamicFieldConfigs[$i];

            # get field html
            $DynamicFieldHTMLData{ $DynamicFieldConfig->{FieldOrder} } = $DynamicFieldBackendObject->EditFieldRender(
                DynamicFieldConfig   => $DynamicFieldConfig,
                Value           => $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"},
                LayoutObject    => $LayoutObject,
                ParamObject     => $ParamObject,
                AJAXUpdate      => 1,
                Mandatory       => $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
            );
        }
        my @DynamicFieldHTML;
        for my $Key (sort { $a <=> $b } keys %DynamicFieldHTMLData) {
            push @DynamicFieldHTML, $DynamicFieldHTMLData{$Key};
        }

        # get list type
        my $TreeView = 0;
        if ( $ConfigObject->Get('Ticket::Frontend::ListType') eq 'tree' ) {
            $TreeView = 1;
        }

        # if future task exists, transform existing data into neede structure
        if (%FutureTask) {
            my @CustomerUserStrings = split /,/, $FutureTask{Data}->{AppointmentTicket}->{CustomerUser};
            if ( @CustomerUserStrings ) {
                my $Count = 1;
                for my $CustomerUserString ( @CustomerUserStrings ) {
                    my %CustomerUser = $CustomerUserObject->CustomerUserDataGet(
                        User => $CustomerUserString,
                    );
                    if ( %CustomerUser ) {
                        push @MultipleCustomer, {
                            Count => $Count++,
                            CustomerElement => '"' . $CustomerUser{UserFirstname} . ' ' . $CustomerUser{UserLastname} . '" <' . $CustomerUser{UserEmail} . '>',
                            CustomerSelected => ( $FutureTask{Data}->{AppointmentTicket}->{SelectedCustomerUser} eq $CustomerUserString ? 'checked="checked"' : '' ),
                            CustomerKey => $CustomerUser{UserLogin},
                            CustomerError => '',
                            CustomerErrorMsg => 'CustomerGenericServerErrorMsg',
                            CustomerDisabled => '',
                        }
                    }
                    else {
                        push @MultipleCustomer, {
                            Count => $Count++,
                            CustomerElement => $CustomerUserString,
                            CustomerSelected => ( $FutureTask{Data}->{AppointmentTicket}->{SelectedCustomerUser} eq $CustomerUserString ? 'checked="checked"' : '' ),
                            CustomerError => '',
                            CustomerErrrorMsg => 'CustomerGenericServerErrorMsg',
                            CustomerDisabled => '',
                        }
                    }
                }
            }
            $GetParam{SelectedCustomerUser} = $FutureTask{Data}->{AppointmentTicket}->{SelectedCustomerUser};
        }


        # for each standard field which has to be checked, run the defined method
        my $QueueValues = $Self->_GetTos(
            %GetParam,
        );

        my $PriorityValues = $Self->_GetPriorities(
            %GetParam,
        );

        my $StateValues = $Self->_GetStates(
            %GetParam,
        );

        my $TypeValues = $Self->_GetTypes(
            %GetParam,
        );

        my $ServiceValues = $Self->_GetServices(
            %GetParam,
        );

        my $SLAValues = $Self->_GetSLAs(
            %GetParam,
        );

        # Build queue html string
        my $QueueHTMLString;
        if ( $ConfigObject->Get('Ticket::Frontend::NewQueueSelectionType') eq 'Queue' ) {
            $QueueHTMLString = $LayoutObject->AgentQueueListOption(
                Class          => 'Mandatory Validate_Required Modernize',
                Data           => $QueueValues,
                Multiple       => 0,
                Size           => 0,
                Name           => 'Dest',
                TreeView       => $TreeView,
                SelectedID     => $GetParam{QueueID},
                Translation    => 0,
                OnChangeSubmit => 0,
                Mandatory      => 1,
            );
        }
        else {
            $QueueHTMLString = $LayoutObject->BuildSelection(
                Class          => 'Mandatory Validate_Required Modernize',
                Data           => $QueueValues,
                Multiple       => 0,
                Size           => 0,
                Name           => 'Dest',
                TreeView       => $TreeView,
                SelectedID     => $GetParam{QueueID},
                Translation    => 0,
                OnChangeSubmit => 0,
                Mandatory      => 1,
            );
        }

        # build type string
        my $TypeHTMLString;
        if ( $ConfigObject->Get('Ticket::Type') ) {
            $TypeHTMLString = $LayoutObject->BuildSelection(
                Class        => 'Modernize Validate_Required' . ( $Param{Errors}->{TypeIDInvalid} || ' ' ),
                Data         => $TypeValues,
                Name         => 'TypeID',
                SelectedID   => $GetParam{TypeID},
                PossibleNone => 1,
                Sort         => 'AlphanumericValue',
                Translation  => 1,
                Mandatory    => 1,
            );
        }

        # build state string
        my $StateHTMLString = $LayoutObject->BuildSelection(
            Class        => 'Modernize Validate_Required',
            Data         => $StateValues,
            Name         => 'NextStateID',
            SelectedID   => $GetParam{NextStateID} || $Config->{StateDefault},
            SelectedValue => $GetParam{NextStateID} || $Config->{StateDefault},
            PossibleNone => 1,
            Sort         => 'AlphanumericValue',
            Translation  => 1,
            Mandatory    => 1,
        );

        # build service and SLA string
        my $ServiceHTMLString;
        my $SLAHTMLString;
        if ( $ConfigObject->Get('Ticket::Service') ) {
            $ServiceHTMLString = $LayoutObject->BuildSelection(
                Class => 'Modernize '
                    . ( $Config->{ServiceMandatory} ? 'Validate_Required ' : '' )
                    . ( $Param{Errors}->{ServiceIDInvalid} || '' ),
                Data         => $ServiceValues,
                Name         => 'ServiceID',
                SelectedID   => $GetParam{ServiceID},
                PossibleNone => 1,
                TreeView     => $TreeView,
                Sort         => 'TreeView',
                Translation  => 1,
            );
            $SLAHTMLString = $LayoutObject->BuildSelection(
                Class      => 'Modernize '
                    . ( $Config->{SLAMandatory} ? 'Validate_Required ' : '' )
                    . ( $Param{Errors}->{SLAInvalid} || '' ),
                Data         => $SLAValues,
                Name         => 'SLAID',
                SelectedID   => $GetParam{SLAID},
                PossibleNone => 1,
                Sort         => 'AlphanumericValue',
                Translation  => 1,
            );
        }



        # get priority data
        if ( !$GetParam{Priority} ) {
            $GetParam{Priority} = $Config->{Priority};
        }
        if ( %FutureTask ) {
            $GetParam{PriorityID} = $FutureTask{Data}->{AppointmentTicket}->{PriorityID};
        }

        # build priority html string
        my $PriorityHTMLString;
        if ( $Config->{Priority} ) {
            $PriorityHTMLString = $LayoutObject->BuildSelection(
                Class         => 'Validate_Required Modernize',
                Data          => $PriorityValues,
                Name          => 'PriorityID',
                SelectedID    => $GetParam{PriorityID},
                SelectedValue => $GetParam{Priority},
                Translation   => 1,
                Mandatory     => 1,
            );
        }

        $Param{CustomerHiddenContainer} = $#MultipleCustomer != -1 ? '' : 'Hidden';
        $Param{ArticleVisibleForCustomer} = ($Param{TicketArticleVisibleForCustomer} || ( %FutureTask && $FutureTask{Data}->{AppointmentTicket}->{ArticleVisibleForCustomer})) ? 'checked=checked' : '';

        if ( %FutureTask ) {
            # html mask output
            $LayoutObject->Block(
                Name => 'EditMask',
                Data => {
                    %{$FutureTask{Data} || \{}},
                    %Param,
                    %GetParam,
                    %Appointment,
                    PermissionLevel => $PermissionLevel{$Permissions},
                    QueueHTMLString => $QueueHTMLString,
                    PriorityHTMLString => $PriorityHTMLString,
                    TypeHTMLString => $TypeHTMLString,
                    StateHTMLString => $StateHTMLString,
                    ServiceHTMLString => $ServiceHTMLString,
                    ServiceMandatory => $Config->{ServiceMandatory} || 0,
                    SLAHTMLString => $SLAHTMLString,
                    SLAMandatory => $Config->{SLAMandatory} || 0,
                    DynamicFieldHTML => \@DynamicFieldHTML,
                },
            );
        }
        else {
            # html mask output
            $LayoutObject->Block(
                Name => 'EditMask',
                Data => {
                    %Param,
                    %GetParam,
                    %Appointment,
                    PermissionLevel => $PermissionLevel{$Permissions},
                    QueueHTMLString => $QueueHTMLString,
                    PriorityHTMLString => $PriorityHTMLString,
                    TypeHTMLString => $TypeHTMLString,
                    StateHTMLString => $StateHTMLString,
                    ServiceHTMLString => $ServiceHTMLString,
                    ServiceMandatory => $Config->{ServiceMandatory} || 0,
                    SLAHTMLString => $SLAHTMLString,
                    SLAMandatory => $Config->{SLAMandatory} || 0,
                    DynamicFieldHTML => \@DynamicFieldHTML,
               },
            );
        }

        my $CustomerCounter = 0;
        if ( @MultipleCustomer ) {
            for my $Item ( @MultipleCustomer ) {
                # set empty values for errors
                $Item->{CustomerError}    = '';
                $Item->{CustomerDisabled} = '';
                $Item->{CustomerErrorMsg} = 'CustomerGenericServerErrorMsg';

                $LayoutObject->Block(
                    Name => 'MultipleCustomer',
                    Data => $Item,
                );
                $LayoutObject->Block(
                    Name => $Item->{CustomerErrorMsg},
                    Data => $Item,
                );
                if ( $Item->{CustomerError} ) {
                    $LayoutObject->Block(
                        Name => 'CustomerErrorExplantion',
                    );
                }
                $CustomerCounter++;
            }
        }

        if ( !$CustomerCounter ) {
            $Param{CustomerHiddenContainer} = 'Hidden';
        }

        $LayoutObject->Block(
            Name => 'MultipleCustomerCounter',
            Data => {
                CustomerCounter => $CustomerCounter++,
            },
        );
# EO AppointmentToTicket

        $LayoutObject->AddJSData(
            Key   => 'CalendarPermissionLevel',
            Value => $PermissionLevel{$Permissions},
        );
        $LayoutObject->AddJSData(
            Key   => 'EditAppointmentID',
            Value => $Appointment{AppointmentID} // '',
        );
        $LayoutObject->AddJSData(
            Key   => 'EditParentID',
            Value => $Appointment{ParentID} // '',
        );

        # get registered location links
        my $LocationLinkConfig = $ConfigObject->Get('AgentAppointmentEdit::Location::Link') // {};
        for my $ConfigKey ( sort keys %{$LocationLinkConfig} ) {

            # show link icon
            $LayoutObject->Block(
                Name => 'LocationLink',
                Data => {
                    Location => $Appointment{Location} // '',
                    %{ $LocationLinkConfig->{$ConfigKey} },
                },
            );
        }

        my $Output = $LayoutObject->Output(
            TemplateFile => 'AgentAppointmentEdit',
            Data         => {
                %Param,
                %GetParam,
                %Appointment,
            },
            AJAX => 1,
        );
        return $LayoutObject->Attachment(
            NoCache     => 1,
            ContentType => 'text/html',
            Charset     => $LayoutObject->{UserCharset},
            Content     => $Output,
            Type        => 'inline',
        );
    }

    # ------------------------------------------------------------ #
    # add/edit appointment
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'EditAppointment' ) {

# RotherOSS / AppointmentToTicket
        if ($GetParam{TicketTemplate}) {
            # Validate incoming values
            my $QueueValues = $Self->_GetTos(
                %GetParam,
            );
            if ( !$QueueValues->{$GetParam{Dest}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field dest!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );
            }

            my $StateValues = $Self->_GetStates(
                %GetParam,
            );
            if ( !$StateValues->{$GetParam{NextStateID}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field next state!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );

            }

            my $ServiceValues = $Self->_GetServices(
                %GetParam,
            );
            if ( $ConfigObject->Get('Ticket::Service') && ($GetParam{ServiceID} || $Config->{ServiceMandatory}) && !$ServiceValues->{$GetParam{ServiceID}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field service!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );

            }

            my $SLAValues = $Self->_GetSLAs(
                %GetParam,
            );
            if ( $ConfigObject->Get('Ticket::Service') && ($GetParam{SLAID} || $Config->{SLAMandatory}) && !$SLAValues->{$GetParam{SLAID}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field SLA!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );

            }

            my $TypeValues = $Self->_GetTypes(
                %GetParam,
            );
            if ( $ConfigObject->Get('Ticket::Type') &&  !$TypeValues->{$GetParam{TypeID}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field type!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );

            }

            my $PriorityValues = $Self->_GetPriorities(
                %GetParam,
            );
            if ( !$PriorityValues->{$GetParam{PriorityID}} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field priority!' ),
                    Comment => Translatable('Please contact the administrator.'),
                );

            }
        }
# EO AppointmentTicket

        my %Appointment;

        if ( $GetParam{AppointmentID} ) {
            %Appointment = $AppointmentObject->AppointmentGet(
                AppointmentID => $GetParam{AppointmentID},
            );

            # check permissions
            $Permissions = $CalendarObject->CalendarPermissionGet(
                CalendarID => $Appointment{CalendarID},
                UserID     => $Self->{UserID},
            );

            my $RequiredPermission = 2;
            if ( $GetParam{CalendarID} && $GetParam{CalendarID} != $Appointment{CalendarID} ) {

                # in order to move appointment to another calendar, user needs "create" permission
                $RequiredPermission = 3;
            }

            if ( $PermissionLevel{$Permissions} < $RequiredPermission ) {

                # no permission

                # build JSON output
                $JSON = $LayoutObject->JSONEncode(
                    Data => {
                        Success => 0,
                        Error   => Translatable('No permission!'),
                    },
                );

                # send JSON response
                return $LayoutObject->Attachment(
                    ContentType => 'application/json',
                    Content     => $JSON,
                    Type        => 'inline',
                    NoCache     => 1,
                );
            }
        }

        if ( $GetParam{AllDay} ) {
            $GetParam{StartTime} = sprintf(
                "%04d-%02d-%02d 00:00:00",
                $GetParam{StartYear}, $GetParam{StartMonth}, $GetParam{StartDay}
            );
            $GetParam{EndTime} = sprintf(
                "%04d-%02d-%02d 00:00:00",
                $GetParam{EndYear}, $GetParam{EndMonth}, $GetParam{EndDay}
            );

            my $StartTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $GetParam{StartTime},
                },
            );
            my $EndTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $GetParam{EndTime},
                },
            );

            # Prevent storing end time before start time.
            if ( $EndTimeObject < $StartTimeObject ) {
                $EndTimeObject = $StartTimeObject->Clone();
            }

            # Make end time inclusive, add whole day.
            $EndTimeObject->Add(
                Days => 1,
            );
            $GetParam{EndTime} = $EndTimeObject->ToString();
        }
        elsif ( $GetParam{Recurring} && $GetParam{UpdateType} && $GetParam{UpdateDelta} ) {

            my $StartTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{StartTime},
                },
            );
            my $EndTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{EndTime},
                },
            );

            # Calculate new start/end times.
            if ( $GetParam{UpdateType} eq 'StartTime' ) {
                $StartTimeObject->Add(
                    Seconds => $GetParam{UpdateDelta},
                );
                $GetParam{StartTime} = $StartTimeObject->ToString();
            }
            elsif ( $GetParam{UpdateType} eq 'EndTime' ) {
                $EndTimeObject->Add(
                    Seconds => $GetParam{UpdateDelta},
                );
                $GetParam{EndTime} = $EndTimeObject->ToString();
            }
            else {
                $StartTimeObject->Add(
                    Seconds => $GetParam{UpdateDelta},
                );
                $EndTimeObject->Add(
                    Seconds => $GetParam{UpdateDelta},
                );
                $GetParam{StartTime} = $StartTimeObject->ToString();
                $GetParam{EndTime}   = $EndTimeObject->ToString();
            }
        }
        else {
            if (
                defined $GetParam{StartYear}
                && defined $GetParam{StartMonth}
                && defined $GetParam{StartDay}
                && defined $GetParam{StartHour}
                && defined $GetParam{StartMinute}
                )
            {
                $GetParam{StartTime} = sprintf(
                    "%04d-%02d-%02d %02d:%02d:00",
                    $GetParam{StartYear}, $GetParam{StartMonth}, $GetParam{StartDay},
                    $GetParam{StartHour}, $GetParam{StartMinute}
                );

                # Convert start time to local time.
                my $StartTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String   => $GetParam{StartTime},
                        TimeZone => $Self->{UserTimeZone},
                    },
                );
                if ( $Self->{UserTimeZone} ) {
                    $StartTimeObject->ToOTOBOTimeZone();
                }
                $GetParam{StartTime} = $StartTimeObject->ToString();
            }
            else {
                $GetParam{StartTime} = $Appointment{StartTime};
            }

            if (
                defined $GetParam{EndYear}
                && defined $GetParam{EndMonth}
                && defined $GetParam{EndDay}
                && defined $GetParam{EndHour}
                && defined $GetParam{EndMinute}
                )
            {
                $GetParam{EndTime} = sprintf(
                    "%04d-%02d-%02d %02d:%02d:00",
                    $GetParam{EndYear}, $GetParam{EndMonth}, $GetParam{EndDay},
                    $GetParam{EndHour}, $GetParam{EndMinute}
                );

                # Convert end time to local time.
                my $EndTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String   => $GetParam{EndTime},
                        TimeZone => $Self->{UserTimeZone},
                    },
                );
                if ( $Self->{UserTimeZone} ) {
                    $EndTimeObject->ToOTOBOTimeZone();
                }

                # Get already calculated local start time.
                my $StartTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $GetParam{StartTime},
                    },
                );

                # Prevent storing end time before start time.
                if ( $EndTimeObject < $StartTimeObject ) {
                    $EndTimeObject = $StartTimeObject->Clone();
                }

                $GetParam{EndTime} = $EndTimeObject->ToString();
            }
            else {
                $GetParam{EndTime} = $Appointment{EndTime};
            }
        }

        # Prevent recurrence until dates before start time.
        if ( $Appointment{Recurring} && $Appointment{RecurrenceUntil} ) {
            my $StartTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $GetParam{StartTime},
                },
            );
            my $RecurrenceUntilObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Appointment{RecurrenceUntil},
                },
            );
            if ( $RecurrenceUntilObject < $StartTimeObject ) {
                $Appointment{RecurrenceUntil} = $GetParam{StartTime};
            }
        }

        # recurring appointment
        if ( $GetParam{Recurring} && $GetParam{RecurrenceType} ) {

            if (
                $GetParam{RecurrenceType} eq 'Daily'
                || $GetParam{RecurrenceType} eq 'Weekly'
                || $GetParam{RecurrenceType} eq 'Monthly'
                || $GetParam{RecurrenceType} eq 'Yearly'
                )
            {
                $GetParam{RecurrenceInterval} = 1;
            }
            elsif ( $GetParam{RecurrenceType} eq 'Custom' ) {

                if ( $GetParam{RecurrenceCustomType} eq 'CustomWeekly' ) {
                    if ( $GetParam{Days} ) {
                        my @Days = split /,/, $GetParam{Days};
                        $GetParam{RecurrenceFrequency} = \@Days;
                    }
                    else {
                        my $StartTimeObject = $Kernel::OM->Create(
                            'Kernel::System::DateTime',
                            ObjectParams => {
                                String => $GetParam{StartTime},
                            },
                        );
                        my $StartTimeSettings = $StartTimeObject->Get();
                        $GetParam{RecurrenceFrequency} = [ $StartTimeSettings->{DayOfWeek} ];
                    }
                }
                elsif ( $GetParam{RecurrenceCustomType} eq 'CustomMonthly' ) {
                    if ( $GetParam{MonthDays} ) {
                        my @MonthDays = split /,/, $GetParam{MonthDays};
                        $GetParam{RecurrenceFrequency} = \@MonthDays;
                    }
                    else {
                        my $StartTimeObject = $Kernel::OM->Create(
                            'Kernel::System::DateTime',
                            ObjectParams => {
                                String => $GetParam{StartTime},
                            },
                        );
                        my $StartTimeSettings = $StartTimeObject->Get();
                        $GetParam{RecurrenceFrequency} = [ $StartTimeSettings->{Day} ];
                    }
                }
                elsif ( $GetParam{RecurrenceCustomType} eq 'CustomYearly' ) {
                    if ( $GetParam{Months} ) {
                        my @Months = split /,/, $GetParam{Months};
                        $GetParam{RecurrenceFrequency} = \@Months;
                    }
                    else {
                        my $StartTimeObject = $Kernel::OM->Create(
                            'Kernel::System::DateTime',
                            ObjectParams => {
                                String => $GetParam{StartTime},
                            },
                        );
                        my $StartTimeSettings = $StartTimeObject->Get();
                        $GetParam{RecurrenceFrequency} = [ $StartTimeSettings->{Month} ];
                    }
                }

                $GetParam{RecurrenceType} = $GetParam{RecurrenceCustomType};
            }

            # until ...
            if (
                $GetParam{RecurrenceLimit} eq '1'
                && $GetParam{RecurrenceUntilYear}
                && $GetParam{RecurrenceUntilMonth}
                && $GetParam{RecurrenceUntilDay}
                )
            {
                $GetParam{RecurrenceUntil} = sprintf(
                    "%04d-%02d-%02d 00:00:00",
                    $GetParam{RecurrenceUntilYear}, $GetParam{RecurrenceUntilMonth},
                    $GetParam{RecurrenceUntilDay}
                );

                # Prevent recurrence until dates before start time.
                my $StartTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $GetParam{StartTime},
                    },
                );
                my $RecurrenceUntilObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $GetParam{RecurrenceUntil},
                    },
                );
                if ( $RecurrenceUntilObject < $StartTimeObject ) {
                    $GetParam{RecurrenceUntil} = $GetParam{StartTime};
                }

                $GetParam{RecurrenceCount} = undef;
            }

            # for ... time(s)
            elsif ( $GetParam{RecurrenceLimit} eq '2' ) {
                $GetParam{RecurrenceUntil} = undef;
            }
        }

        # Determine notification custom type, if supplied.
        if ( defined $GetParam{NotificationTemplate} ) {
            if ( $GetParam{NotificationTemplate} ne 'Custom' ) {
                $GetParam{NotificationCustom} = '';
            }
            elsif ( $GetParam{NotificationCustomRelativeInput} ) {
                $GetParam{NotificationCustom} = 'relative';
            }
            elsif ( $GetParam{NotificationCustomDateTimeInput} ) {
                $GetParam{NotificationCustom} = 'datetime';

                $GetParam{NotificationCustomDateTime} = sprintf(
                    "%04d-%02d-%02d %02d:%02d:00",
                    $GetParam{NotificationCustomDateTimeYear},
                    $GetParam{NotificationCustomDateTimeMonth},
                    $GetParam{NotificationCustomDateTimeDay},
                    $GetParam{NotificationCustomDateTimeHour},
                    $GetParam{NotificationCustomDateTimeMinute}
                );

                my $NotificationCustomDateTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String   => $GetParam{NotificationCustomDateTime},
                        TimeZone => $Self->{UserTimeZone},
                    },
                );

                if ( $Self->{UserTimeZone} ) {
                    $NotificationCustomDateTimeObject->ToOTOBOTimeZone();
                }

                $GetParam{NotificationCustomDateTime} = $NotificationCustomDateTimeObject->ToString();
            }
        }

# RotherOSS / AppointmentToTicket
        my %FutureTask;
        if ( %Appointment ) {
            my $TaskID;
            if ( $Appointment{FutureTaskID} ) {
                $TaskID = $Appointment{FutureTaskID};
            }
            # Only for parent appointments
            elsif ( $Appointment{Recurring} ) {
                # Check all appointments of series for future task id
                my @AppointmentList = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentList(
                    CalendarID => $Appointment{CalendarID},
                    ParentID => $Appointment{ParentID} || $Appointment{AppointmentID},
                );
                my %ParentAppointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet( AppointmentID => $Appointment{ParentID} || $Appointment{AppointmentID} );
                push @AppointmentList, \%ParentAppointment;

                APPOINTMENTLIST:
                for my $RecurringAppointment (@AppointmentList) {
                    if ( $RecurringAppointment->{FutureTaskID} ) {
                        $TaskID = $RecurringAppointment->{FutureTaskID};
                        last APPOINTMENTLIST;
                    }
                }
            }
            if ( $TaskID ) {
                %FutureTask = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskGet(
                    TaskID => $TaskID,
                );
            }
        }

        my @DynamicFieldConfigs;
        if ( $GetParam{TicketTemplate} && defined $Config->{DynamicField} ) {
            my $DynamicFieldConfigsRef= $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
                Valid       => 1,
                ObjectType  => [ 'Ticket', 'Article' ],
                FieldFilter => $Config->{DynamicField} || {},
            );
            @DynamicFieldConfigs = defined $DynamicFieldConfigsRef ? @{ $DynamicFieldConfigsRef } : ();
        }

        my %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetUserData(
            UserID => $Self->{UserID},
        );

        my %DynamicFieldValues;
        # cycle through the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @DynamicFieldConfigs ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

            my $PossibleValues = $DynamicFieldBackendObject->PossibleValuesGet(
                DynamicFieldConfig => $DynamicFieldConfig,
            );

            # Validate dynamic field value
            my $ValidationResult = $DynamicFieldBackendObject->EditFieldValueValidate(
                DynamicFieldConfig => $DynamicFieldConfig,
                PossibleValuesFilter => IsHashRefWithData($PossibleValues) ? $PossibleValues : undef,
                ParamObject => $ParamObject,
                Mandatory => $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
            );

            if ( !IsHashRefWithData($ValidationResult) ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field %s!', $DynamicFieldConfig->{Label} ),
                    Comment => Translatable('Please contact the administrator.'),
                );
            }
            elsif ( $ValidationResult->{ServerError} ) {
                return $LayoutObject->ErrorScreen(
                    Message => $LayoutObject->{LanguageObject}->Translate( $ValidationResult->{ErrorMessage} ),
                    Comment => Translatable('Please contact the administrator.'),
                );
            }

            # extract the dynamic field value from the web request
            $DynamicFieldValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
                DynamicFieldConfig => $DynamicFieldConfig,
                ParamObject        => $ParamObject,
                LayoutObject       => $LayoutObject,
            );

            if ( !$DynamicFieldValues{ $DynamicFieldConfig->{Name} }
                || (ref($DynamicFieldValues{ $DynamicFieldConfig->{Name} }) eq 'ARRAY'
                    && !IsArrayRefWithData($DynamicFieldValues{ $DynamicFieldConfig->{Name} }))
            ) {
                # extract the dynamic field value from the web request with approach for array
                $DynamicFieldValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
                    DynamicFieldConfig => { $DynamicFieldConfig->%*, Name => $DynamicFieldConfig->{Name} . '[]' },
                    ParamObject        => $ParamObject,
                    LayoutObject       => $LayoutObject,
                );
            }
        }

        # cycle trough the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @DynamicFieldConfigs ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);
            next DYNAMICFIELD if !IsHashRefWithData( $DynamicFieldConfig->{Config} );
            next DYNAMICFIELD if !$DynamicFieldConfig->{Name};

            # to store dynamic field value from database (or undefined)
            my $Value;

            # Check if the user has a user specific default value for
            # the dynamic field, otherwise will use Dynamic Field default value
            # get default value from dynamic field config (if any)
            $Value = $DynamicFieldConfig->{Config}->{DefaultValue} || '';

            # override the value from user preferences if is set
            if ( $UserPreferences{ 'UserDynamicField_' . $DynamicFieldConfig->{Name} } ) {
                $Value = $UserPreferences{ 'UserDynamicField_' . $DynamicFieldConfig->{Name} };
            }

            if ( $DynamicFieldValues{$DynamicFieldConfig->{Name}} ) {
                $Value= $DynamicFieldValues{$DynamicFieldConfig->{Name}};
            }

            $GetParam{DynamicFields}->{ $DynamicFieldConfig->{Name} } = $Value;
        }

        # Parse possibly multiple customer users
        if ( @MultipleCustomer ) {
            for my $CustomerUser (@MultipleCustomer) {
                my $CustomerUserIdentifier = $CustomerUser->{CustomerKey} ? $CustomerUser->{CustomerKey} : $CustomerUser->{CustomerElement};
                if ( $CustomerUser->{CustomerSelected} ) {
                    $GetParam{SelectedCustomerUser} = $CustomerUserIdentifier;
                }
                if ( $GetParam{CustomerUser} ) {
                    $GetParam{CustomerUser} .= ",$CustomerUserIdentifier";
                }
                else {
                    $GetParam{CustomerUser} = $CustomerUserIdentifier;
                }
            }
        }

        # fetch customer id for selected customer user
        my %SelectedCustomerUserData = $CustomerUserObject->CustomerUserDataGet(
            User => $GetParam{SelectedCustomerUser},
        );
        $GetParam{CustomerID} = %SelectedCustomerUserData ? $SelectedCustomerUserData{CustomerID} : '';
# EO AppointmentToTicket

        # team
        if ( $GetParam{'TeamID[]'} ) {
            my @TeamIDs = $ParamObject->GetArray( Param => 'TeamID[]' );
            $GetParam{TeamID} = \@TeamIDs;
        }
        else {
            $GetParam{TeamID} = undef;
        }

        # resources
        if ( $GetParam{'ResourceID[]'} ) {
            my @ResourceID = $ParamObject->GetArray( Param => 'ResourceID[]' );
            $GetParam{ResourceID} = \@ResourceID;
        }
        else {
            $GetParam{ResourceID} = undef;
        }

        # Check if dealing with ticket appointment.
        if ( $Appointment{TicketAppointmentRuleID} ) {

            # Make sure readonly values stay unchanged.
            $GetParam{Title}      = $Appointment{Title};
            $GetParam{CalendarID} = $Appointment{CalendarID};
            $GetParam{AllDay}     = undef;
            $GetParam{Recurring}  = undef;

            my $Rule = $CalendarObject->TicketAppointmentRuleGet(
                CalendarID => $Appointment{CalendarID},
                RuleID     => $Appointment{TicketAppointmentRuleID},
            );

            # Recalculate end time based on time preset.
            if ( IsHashRefWithData($Rule) ) {
                if ( $Rule->{EndDate} =~ /^Plus_([0-9]+)$/ && $GetParam{StartTime} ) {
                    my $Preset = int $1;

                    my $EndTimeObject = $Kernel::OM->Create(
                        'Kernel::System::DateTime',
                        ObjectParams => {
                            String => $GetParam{StartTime},    # base on start time
                        },
                    );

                    # Calculate end time using preset value.
                    $EndTimeObject->Add(
                        Minutes => $Preset,
                    );
                    $GetParam{EndTime} = $EndTimeObject->ToString();
                }
            }
        }

        my $Success;

        # reset empty parameters
        for my $Param ( sort keys %GetParam ) {
            if ( !$GetParam{$Param} ) {
                $GetParam{$Param} = undef;
            }
        }

        # pass current user ID
        $GetParam{UserID} = $Self->{UserID};

        # Get passed plugin parameters.
        my @PluginParams = grep { $_ =~ /^Plugin_/ } keys %GetParam;

# RotherOSS / AppointmentToTicket
        if ( !@PluginParams ) {
            # Coming from either drag and drop or resize, filling params with existing data if present
            if ( $GetParam{AppointmentID} ) {
                my %Appointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet(
                    AppointmentID => $GetParam{AppointmentID},
                );

                my $FutureTaskID;
                if ( $Appointment{FutureTaskID} ) {
                    $FutureTaskID = $Appointment{FutureTaskID};
                }
                elsif ( $Appointment{Recurring} || $Appointment{ParentID} ) {
                    my @AppointmentList = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentList(
                        CalendarID => $Appointment{CalendarID},
                        ParentID => $Appointment{ParentID} || $Appointment{AppointmentID},
                    );
                    my %ParentAppointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet(
                        AppointmentID => $Appointment{ParentID} || $Appointment{AppointmentID},
                    );
                    push @AppointmentList, \%ParentAppointment;
                    APPOINTMENTRECURRING:
                    for my $RecurringAppointment (@AppointmentList) {
                        if ( $RecurringAppointment->{FutureTaskID} ) {
                            $FutureTaskID = $RecurringAppointment->{FutureTaskID};
                            last APPOINTMENTRECURRING;
                        }
                    }
                }

                if ( $FutureTaskID ) {
                    my %FutureTask = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskGet(
                        TaskID => $FutureTaskID,
                    );
                    $GetParam{AppointmentTicket} = {
                        $FutureTask{Data}->{AppointmentTicket}->%*,
                    };
                }
            }
        }

        # Determine ticket custom type, if supplied.
        if ( defined $GetParam{TicketTemplate} ) {
            if ( $GetParam{TicketTemplate} ne 'Custom' ) {
                $GetParam{TicketCustom} = '';
            }
            elsif ( $GetParam{TicketCustomRelativeInput} ) {
                $GetParam{TicketCustom} = 'relative';
            }
            elsif ( $GetParam{TicketCustomDateTimeInput} ) {
                $GetParam{TicketCustom} = 'datetime';

                $GetParam{TicketCustomDateTime} = sprintf(
                    "%04d-%02d-%02d %02d:%02d:00",
                    $GetParam{TicketCustomDateTimeYear},
                    $GetParam{TicketCustomDateTimeMonth},
                    $GetParam{TicketCustomDateTimeDay},
                    $GetParam{TicketCustomDateTimeHour},
                    $GetParam{TicketCustomDateTimeMinute}
                );

                my $TicketCustomDateTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String   => $GetParam{TicketCustomDateTime},
                        TimeZone => $Self->{UserTimeZone},
                    },
                );

                if ( $Self->{UserTimeZone} ) {
                    $TicketCustomDateTimeObject->ToOTOBOTimeZone();
                }

                $GetParam{TicketCustomDateTime} = $TicketCustomDateTimeObject->ToString();
            }
        }

        # Handle Ticket Creation on Appointment
        if ($GetParam{AppointmentTicket}) {
            $GetParam{AppointmentTicket} = {
                Subject                   => $GetParam{Title},
                Title                     => $GetParam{Title},
                Content                   => $GetParam{Description},
                UserID                    => $Self->{UserID},
                Lock                      => 'unlock',
                OwnerID                   => 1,
                Template                  => $GetParam{TicketTemplate},
                Time                      => $GetParam{TicketTime},
                Custom                    => $GetParam{TicketCustom},
                CustomRelativeUnit        => $GetParam{TicketCustomRelativeUnit},
                CustomRelativeUnitCount   => $GetParam{TicketCustomRelativeUnitCount},
                CustomRelativePointOfTime => $GetParam{TicketCustomRelativePointOfTime},
                CustomDateTime            => $GetParam{TicketCustomDateTime},
                QueueID                   => $GetParam{Dest},
                CustomerID                => $GetParam{CustomerID},
                CustomerUser              => $GetParam{CustomerUser},
                SelectedCustomerUser      => $GetParam{SelectedCustomerUser},
                PriorityID                => $GetParam{PriorityID},
                StateID                   => $GetParam{NextStateID},
                ServiceID                 => $GetParam{ServiceID},
                SLAID                     => $GetParam{SLAID},
                TypeID                    => $GetParam{TypeID},
                ArticleVisibleForCustomer => $GetParam{TicketArticleVisibleForCustomer},
                DynamicFields             => $GetParam{DynamicFields},
                $GetParam{AppointmentTicket}->%*,
            };
        }
        else {
            $GetParam{AppointmentTicket} = {
                Subject                   => $GetParam{Title},
                Title                     => $GetParam{Title},
                Content                   => $GetParam{Description},
                UserID                    => $Self->{UserID},
                Lock                      => 'unlock',
                OwnerID                   => 1,
                Template                  => $GetParam{TicketTemplate},
                Time                      => $GetParam{TicketTime},
                Custom                    => $GetParam{TicketCustom},
                CustomRelativeUnit        => $GetParam{TicketCustomRelativeUnit},
                CustomRelativeUnitCount   => $GetParam{TicketCustomRelativeUnitCount},
                CustomRelativePointOfTime => $GetParam{TicketCustomRelativePointOfTime},
                CustomDateTime            => $GetParam{TicketCustomDateTime},
                QueueID                   => $GetParam{Dest},
                CustomerID                => $GetParam{CustomerID},
                CustomerUser              => $GetParam{CustomerUser},
                SelectedCustomerUser      => $GetParam{SelectedCustomerUser},
                PriorityID                => $GetParam{PriorityID},
                StateID                   => $GetParam{NextStateID},
                ServiceID                 => $GetParam{ServiceID},
                SLAID                     => $GetParam{SLAID},
                TypeID                    => $GetParam{TypeID},
                ArticleVisibleForCustomer => $GetParam{TicketArticleVisibleForCustomer},
                DynamicFields             => $GetParam{DynamicFields},
            };
        }
# EO AppointmentToTicket

        if (%Appointment) {

            # Continue only if coming from edit screen
            #   (there is at least one passed plugin parameter).
            if (@PluginParams) {

                # Get all related appointments before the update.
                my @RelatedAppointments  = ( $Appointment{AppointmentID} );
                my @CalendarAppointments = $AppointmentObject->AppointmentList(
                    CalendarID => $Appointment{CalendarID},
                );

                # If we are dealing with a parent, include any child appointments.
                push @RelatedAppointments,
                    map {
                        $_->{AppointmentID}
                    }
                    grep {
                        defined $_->{ParentID}
                        && $_->{ParentID} eq $Appointment{AppointmentID}
                    } @CalendarAppointments;

                # Remove all existing links.
                for my $CurrentAppointmentID (@RelatedAppointments) {
                    my $Success = $PluginObject->PluginLinkDelete(
                        AppointmentID => $CurrentAppointmentID,
                        UserID        => $Self->{UserID},
                    );

                    if ( !$Success ) {
                        $Kernel::OM->Get('Kernel::System::Log')->Log(
                            Priority => 'error',
                            Message  => "Links could not be deleted for appointment $CurrentAppointmentID!",
                        );
                    }
                }
            }

            $Success = $AppointmentObject->AppointmentUpdate(
                %Appointment,
                %GetParam,
            );
        }
        else {
            $Success = $AppointmentObject->AppointmentCreate(
                %GetParam,
            );
        }

        my $AppointmentID = $GetParam{AppointmentID} ? $GetParam{AppointmentID} : $Success;

        if ($AppointmentID) {

            # Continue only if coming from edit screen
            #   (there is at least one passed plugin parameter).
            if (@PluginParams) {

                # Get fresh appointment data.
                %Appointment = $AppointmentObject->AppointmentGet(
                    AppointmentID => $AppointmentID,
                );

                # Process all related appointments.
                my @RelatedAppointments  = ($AppointmentID);
                my @CalendarAppointments = $AppointmentObject->AppointmentList(
                    CalendarID => $Appointment{CalendarID},
                );

                # If we are dealing with a parent, include any child appointments as well.
                push @RelatedAppointments,
                    map {
                        $_->{AppointmentID}
                    }
                    grep {
                        defined $_->{ParentID}
                        && $_->{ParentID} eq $AppointmentID
                    } @CalendarAppointments;

                # Process passed plugin parameters.
                for my $PluginParam (@PluginParams) {
                    my $PluginData = $Kernel::OM->Get('Kernel::System::JSON')->Decode(
                        Data => $GetParam{$PluginParam},
                    );
                    my $PluginKey = $PluginParam;
                    $PluginKey =~ s/^Plugin_//;

                    # Execute link add method of the plugin.
                    if ( IsArrayRefWithData($PluginData) ) {
                        for my $LinkID ( @{$PluginData} ) {
                            for my $CurrentAppointmentID (@RelatedAppointments) {
                                my $Link = $PluginObject->PluginLinkAdd(
                                    AppointmentID => $CurrentAppointmentID,
                                    PluginKey     => $PluginKey,
                                    PluginData    => $LinkID,
                                    UserID        => $Self->{UserID},
                                );

                                if ( !$Link ) {
                                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                                        Priority => 'error',
                                        Message  => "Link could not be created for appointment $CurrentAppointmentID!",
                                    );
                                }
                            }
                        }
                    }
                }
            }
        }

        # build JSON output
        $JSON = $LayoutObject->JSONEncode(
            Data => {
                Success       => $Success ? 1 : 0,
                AppointmentID => $AppointmentID,
            },
        );
    }

# RotherOSS / AppointmentToTicket
    # ------------------------------------------------------------ #
    # AJAX update
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'AJAXUpdate' ) {

        my $Dest        = $ParamObject->GetParam( Param => 'Dest' ) || '';
        # TODO Check how this is used later on since in case of external customer user, selected is not in SelectedCustomer but in CustomerSelected
        my $CustomerUser   = $ParamObject->GetParam( Param => 'SelectedCustomerUser' );
        my $ElementChanged = $ParamObject->GetParam( Param => 'ElementChanged' ) || '';
        my $QueueID        = '';

        $QueueID = $Dest;
        $GetParam{QueueID} = $QueueID;

        # get list type
        my $TreeView = 0;
        if ( $ConfigObject->Get('Ticket::Frontend::ListType') eq 'tree' ) {
            $TreeView = 1;
        }

        my $Autoselect = $ConfigObject->Get('TicketACL::Autoselect') || undef;
        my $ACLPreselection;
        if ( $ConfigObject->Get('TicketACL::ACLPreselection') ) {

            # get cached preselection rules
            my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');
            $ACLPreselection = $CacheObject->Get(
                Type => 'TicketACL',
                Key  => 'Preselection',
            );
            if ( !$ACLPreselection ) {
                $ACLPreselection = $FieldRestrictionsObject->SetACLPreselectionCache();
            }
        }

        my %Convergence = (
            StdFields => 0,
            Fields    => 0,
        );
        my %ChangedElements        = $ElementChanged                                        ? ( $ElementChanged => 1 ) : ();
        my %ChangedElementsDFStart = $ElementChanged                                        ? ( $ElementChanged => 1 ) : ();
        my %ChangedStdFields       = $ElementChanged && $ElementChanged !~ /^DynamicField_/ ? ( $ElementChanged => 1 ) : ();

        my $LoopProtection = 100;
        my %StdFieldValues;
        my %DynFieldStates = (
            Visibility => {},
            Fields     => {},
        );

        until ( $Convergence{Fields} ) {

            # determine standard field input
            until ( $Convergence{StdFields} ) {

                my %NewChangedElements;

                # which standard fields to check - FieldID => GetParamValue (neccessary for Dest)
                my %Check = (
                    Dest        => 'QueueID',
                    NextStateID => 'NextStateID',
                    PriorityID  => 'PriorityID',
                    ServiceID   => 'ServiceID',
                    SLAID       => 'SLAID',
                    TypeID      => 'TypeID',
                );
                if ($ACLPreselection) {
                    FIELD:
                    for my $FieldID ( sort keys %Check ) {
                        if ( !$ACLPreselection->{Fields}{$FieldID} ) {
                            $Kernel::OM->Get('Kernel::System::Log')->Log(
                                Priority => 'debug',
                                Message  => "$FieldID not defined in TicketACL preselection rules!"
                            );
                            next FIELD;
                        }
                        if ( $Autoselect && $Autoselect->{$FieldID} && $ChangedElements{$FieldID} ) {
                            next FIELD;
                        }
                        for my $Element ( sort keys %ChangedElements ) {
                            if (
                                $ACLPreselection->{Rules}{Ticket}{$Element}{$FieldID}
                                || $Self->{InternalDependancy}{$Element}{$FieldID}
                                )
                            {
                                next FIELD;
                            }
                            if ( !$ACLPreselection->{Fields}{$Element} ) {
                                $Kernel::OM->Get('Kernel::System::Log')->Log(
                                    Priority => 'debug',
                                    Message  => "$Element not defined in TicketACL preselection rules!"
                                );
                                next FIELD;
                            }
                        }

                        # delete unaffected fields
                        delete $Check{$FieldID};
                    }
                }

                # for each standard field which has to be checked, run the defined method
                METHOD:
                for my $Field ( @{ $Self->{FieldMethods} } ) {
                    next METHOD if !$Check{ $Field->{FieldID} };

                    # use $Check{ $Field->{FieldID} } for Dest=>QueueID
                    $StdFieldValues{ $Check{ $Field->{FieldID} } } = $Field->{Method}->(
                        $Self,
                        %GetParam,
                        CustomerUserID => $CustomerUser || '',
                        QueueID        => $GetParam{TicketQueueID},
                        Services       => $StdFieldValues{TicketServiceID} || undef,    # needed for SLAID
                    );

                    # special stuff for QueueID/Dest: Dest is "QueueID||QueueName" => "QueueName";
                    if ( $Field->{FieldID} eq 'Dest' ) {
                        TOs:
                        for my $QueueID ( sort keys %{ $StdFieldValues{QueueID} } ) {
                            next TOs if ( $StdFieldValues{QueueID}{$QueueID} eq '-' );
                            $StdFieldValues{Dest}{$QueueID} = $StdFieldValues{QueueID}{$QueueID};
                        }

                        # check current selection of QueueID (Dest will be done together with the other fields)
                        if ( $GetParam{QueueID} && !$StdFieldValues{Dest}{ $GetParam{Dest} } ) {
                            $GetParam{QueueID} = '';
                        }

                        # autoselect
                        elsif ( !$GetParam{QueueID} && $Autoselect && $Autoselect->{Dest} ) {
                            $GetParam{QueueID} = $FieldRestrictionsObject->Autoselect(
                                PossibleValues => $StdFieldValues{QueueID},
                            ) || '';
                        }
                    }

                    # check whether current selected value is still valid for the field
                    if (
                        $GetParam{ $Field->{FieldID} }
                        && !$StdFieldValues{ $Field->{FieldID} }{ $GetParam{ $Field->{FieldID} } }
                        )
                    {
                        # if not empty the field
                        $GetParam{ $Field->{FieldID} }           = '';
                        $NewChangedElements{ $Field->{FieldID} } = 1;
                        $ChangedStdFields{ $Field->{FieldID} }   = 1;
                    }

                    # autoselect
                    elsif ( !$GetParam{ $Field->{FieldID} } && $Autoselect && $Autoselect->{ $Field->{FieldID} } ) {
                        $GetParam{ $Field->{FieldID} } = $FieldRestrictionsObject->Autoselect(
                            PossibleValues => $StdFieldValues{ $Field->{FieldID} },
                        ) || '';
                        if ( $GetParam{ $Field->{FieldID} } ) {
                            $NewChangedElements{ $Field->{FieldID} } = 1;
                            $ChangedStdFields{ $Field->{FieldID} }   = 1;
                        }
                    }
                }

                if ( !%NewChangedElements ) {
                    $Convergence{StdFields} = 1;
                }
                else {
                    %ChangedElements = %NewChangedElements;
                }

                %ChangedElementsDFStart = (
                    %ChangedElementsDFStart,
                    %NewChangedElements,
                );

                if ( $LoopProtection-- < 1 ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Ran into unresolvable loop!",
                    );
                    return;
                }

            }

            %ChangedElements        = %ChangedElementsDFStart;
            %ChangedElementsDFStart = ();

            # check dynamic fields
            my %CurFieldStates;
            if (%ChangedElements) {

                # get values and visibility of dynamic fields
                %CurFieldStates = $FieldRestrictionsObject->GetFieldStates(
                    TicketObject              => $TicketObject,
                    DynamicFields             => $Self->{DynamicField},
                    DynamicFieldBackendObject => $DynamicFieldBackendObject,
                    ChangedElements           => \%ChangedElements,            # optional to reduce ACL evaluation
                    Action                    => $Self->{Action},
                    UserID                    => $Self->{UserID},
                    TicketID                  => $Self->{TicketID},
                    FormID                    => $Self->{FormID},
                    CustomerUser              => $CustomerUser || '',
                    GetParam                  => {
                        %GetParam,
                        OwnerID => $GetParam{NewUserID},
                    },
                    Autoselect      => $Autoselect,
                    ACLPreselection => $ACLPreselection,
                    LoopProtection  => \$LoopProtection,
                );

                # combine FieldStates
                $DynFieldStates{Fields} = {
                    %{ $DynFieldStates{Fields} },
                    %{ $CurFieldStates{Fields} },
                };
                $DynFieldStates{Visibility} = {
                    %{ $DynFieldStates{Visibility} },
                    %{ $CurFieldStates{Visibility} },
                };

                # store new values
                $GetParam{DynamicField} = {
                    %{ $GetParam{DynamicField} },
                    %{ $CurFieldStates{NewValues} },
                };
            }
            # if dynamic fields changed, check standard fields again
            if ( %CurFieldStates && IsHashRefWithData( $CurFieldStates{NewValues} ) ) {
                $Convergence{StdFields} = 0;
                %ChangedElements = map { $_ => 1 } keys %{ $CurFieldStates{NewValues} };
            }
            else {
                $Convergence{Fields} = 1;
            }

        }

        # update Dynamic Fields Possible Values via AJAX
        my @DynamicFieldAJAX;

        # cycle through the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $Index ( sort keys %{ $DynFieldStates{Fields} } ) {
            my $DynamicFieldConfig = $Self->{DynamicField}->[$Index];

            my $DataValues = $DynFieldStates{Fields}{$Index}{NotACLReducible}
                ? $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"}
                :
                (
                    $DynamicFieldBackendObject->BuildSelectionDataGet(
                        DynamicFieldConfig => $DynamicFieldConfig,
                        PossibleValues     => $DynFieldStates{Fields}{$Index}{PossibleValues},
                        Value              => $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"},
                    )
                    || $DynFieldStates{Fields}{$Index}{PossibleValues}
                );

            # add dynamic field to the list of fields to update
            push @DynamicFieldAJAX, {
                Name        => 'DynamicField_' . $DynamicFieldConfig->{Name},
                Data        => $DataValues,
                SelectedID  => $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"},
                Translation => $DynamicFieldConfig->{Config}->{TranslatableValues} || 0,
                Max         => 100,
            };
        }

        # define dynamic field visibility
        if ( IsHashRefWithData( $DynFieldStates{Visibility} ) ) {
            push @DynamicFieldAJAX, {
                Name => 'Restrictions_Visibility',
                Data => $DynFieldStates{Visibility},
            };
        }

        # build AJAX return for the standard fields
        my @StdFieldAJAX;
        my %Attributes = (
            Dest => {
                Translation  => 0,
                PossibleNone => 1,
                TreeView     => $TreeView,
                Max          => 100,
            },
            NextStateID => {
                Translation => 1,
                Max         => 100,
            },
            PriorityID => {
                Translation => 1,
                Max         => 100,
            },
            ServiceID => {
                PossibleNone => 1,
                Translation  => 0,
                TreeView     => $TreeView,
                Max          => 100,
            },
            SLAID => {
                PossibleNone => 1,
                Translation  => 0,
                Max          => 100,
            },
            TypeID => {
                PossibleNone => 1,
                Translation  => 0,
                Max          => 100,
            }
        );
        delete $StdFieldValues{QueueID};
        for my $Field ( sort keys %StdFieldValues ) {
            push @StdFieldAJAX, {
                Name       => $Field,
                Data       => $StdFieldValues{$Field},
                SelectedID => $GetParam{$Field},
                %{ $Attributes{$Field} },
            };
        }

        my $JSON = $LayoutObject->BuildSelectionJSON(
            [
                @StdFieldAJAX,
                @DynamicFieldAJAX,
            ],
        );
        return $LayoutObject->Attachment(
            ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
            Content     => $JSON,
            Type        => 'inline',
            NoCache     => 1,
        );

    }
# EO AppointmentToTicket
    # ------------------------------------------------------------ #
    # delete mask
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'DeleteAppointment' ) {

        if ( $GetParam{AppointmentID} ) {
            my %Appointment = $AppointmentObject->AppointmentGet(
                AppointmentID => $GetParam{AppointmentID},
            );

            my $Success = 0;
            my $Error   = '';

            # Prevent deleting ticket appointment.
            if ( $Appointment{TicketAppointmentRuleID} ) {
                $Error = Translatable('Cannot delete ticket appointment!');
            }
            else {

                # Get all related appointments before the deletion.
                my @RelatedAppointments  = ( $Appointment{AppointmentID} );
                my @CalendarAppointments = $AppointmentObject->AppointmentList(
                    CalendarID => $Appointment{CalendarID},
                );

                # If we are dealing with a parent, include any child appointments.
                push @RelatedAppointments,
                    map {
                        $_->{AppointmentID}
                    }
                    grep {
                        defined $_->{ParentID}
                        && $_->{ParentID} eq $Appointment{AppointmentID}
                    } @CalendarAppointments;

                # Remove all existing links.
                for my $CurrentAppointmentID (@RelatedAppointments) {
                    my $Success = $PluginObject->PluginLinkDelete(
                        AppointmentID => $CurrentAppointmentID,
                        UserID        => $Self->{UserID},
                    );

                    if ( !$Success ) {
                        $Kernel::OM->Get('Kernel::System::Log')->Log(
                            Priority => 'error',
                            Message  => "Links could not be deleted for appointment $CurrentAppointmentID!",
                        );
                    }
                }

                $Success = $AppointmentObject->AppointmentDelete(
                    %GetParam,
                    UserID => $Self->{UserID},
                );

                if ( !$Success ) {
                    $Error = Translatable('No permissions!');
                }
            }

            # build JSON output
            $JSON = $LayoutObject->JSONEncode(
                Data => {
                    Success       => $Success,
                    Error         => $Error,
                    AppointmentID => $GetParam{AppointmentID},
                },
            );
        }
    }

    # ------------------------------------------------------------ #
    # update preferences
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'UpdatePreferences' ) {

        my $Success = 0;

        if (
            $GetParam{OverviewScreen} && (
                $GetParam{DefaultView} || $GetParam{CalendarSelection}
                || ( $GetParam{ShownResources} && $GetParam{TeamID} )
                || $GetParam{ShownAppointments}
            )
            )
        {
            my $PreferenceKey;
            my $PreferenceKeySuffix = '';

            if ( $GetParam{DefaultView} ) {
                $PreferenceKey = 'DefaultView';
            }
            elsif ( $GetParam{CalendarSelection} ) {
                $PreferenceKey = 'CalendarSelection';
            }
            elsif ( $GetParam{ShownResources} && $GetParam{TeamID} ) {
                $PreferenceKey       = 'ShownResources';
                $PreferenceKeySuffix = "-$GetParam{TeamID}";
            }
            elsif ( $GetParam{ShownAppointments} ) {
                $PreferenceKey = 'ShownAppointments';
            }

            # set user preferences
            $Success = $Kernel::OM->Get('Kernel::System::User')->SetPreferences(
                Key    => 'User' . $GetParam{OverviewScreen} . $PreferenceKey . $PreferenceKeySuffix,
                Value  => $GetParam{$PreferenceKey},
                UserID => $Self->{UserID},
            );
        }

        elsif ( $GetParam{OverviewScreen} && $GetParam{RestoreDefaultSettings} ) {
            my $PreferenceKey;
            my $PreferenceKeySuffix = '';

            if ( $GetParam{RestoreDefaultSettings} eq 'ShownResources' && $GetParam{TeamID} ) {
                $PreferenceKey       = 'ShownResources';
                $PreferenceKeySuffix = "-$GetParam{TeamID}";
            }

            # blank user preferences
            $Success = $Kernel::OM->Get('Kernel::System::User')->SetPreferences(
                Key    => 'User' . $GetParam{OverviewScreen} . $PreferenceKey . $PreferenceKeySuffix,
                Value  => '',
                UserID => $Self->{UserID},
            );
        }

        # build JSON output
        $JSON = $LayoutObject->JSONEncode(
            Data => {
                Success => $Success,
            },
        );
    }

    # ------------------------------------------------------------ #
    # team list selection update
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'TeamUserList' ) {
        my @TeamIDs = $ParamObject->GetArray( Param => 'TeamID[]' );
        my %TeamUserListAll;

        # Check if team object is registered.
        if ( $Kernel::OM->Get('Kernel::System::Main')->Require( 'Kernel::System::Calendar::Team', Silent => 1 ) ) {
            my $TeamObject = $Kernel::OM->Get('Kernel::System::Calendar::Team');
            my $UserObject = $Kernel::OM->Get('Kernel::System::User');

            TEAMID:
            for my $TeamID (@TeamIDs) {
                next TEAMID if !$TeamID;

                # get list of team members
                my %TeamUserList = $TeamObject->TeamUserList(
                    TeamID => $TeamID,
                    UserID => $Self->{UserID},
                );

                # get user data
                for my $UserID ( sort keys %TeamUserList ) {
                    my %User = $UserObject->GetUserData(
                        UserID => $UserID,
                    );
                    $TeamUserList{$UserID} = $User{UserFullname};
                }

                %TeamUserListAll = ( %TeamUserListAll, %TeamUserList );
            }
        }

        # build JSON output
        $JSON = $LayoutObject->JSONEncode(
            Data => {
                TeamUserList => \%TeamUserListAll,
            },
        );

    }

    # send JSON response
    return $LayoutObject->Attachment(
        ContentType => 'application/json',
        Content     => $JSON,
        Type        => 'inline',
        NoCache     => 1,
    );
}

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

    # check needed stuff
    for my $Needed (qw(Time)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # Get original date components.
    my $OriginalTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{Time},
        },
    );
    my $OriginalTimeSettings = $OriginalTimeObject->Get();

    # Get destination time according to user timezone.
    my $DestinationTimeObject = $OriginalTimeObject->Clone();
    $DestinationTimeObject->ToTimeZone( TimeZone => $Self->{UserTimeZone} );
    my $DestinationTimeSettings = $DestinationTimeObject->Get();

    # Compare days of two times.
    if ( $OriginalTimeSettings->{Day} == $DestinationTimeSettings->{Day} ) {
        return 0;    # same day
    }
    elsif ( $OriginalTimeObject > $DestinationTimeObject ) {
        return -1;
    }

    return 1;
}

# RotherOSS / AppointmentToTicket
sub _GetPriorities {
    my ( $Self, %Param ) = @_;

    # use default Queue if none is provided
    $Param{QueueID} = $Param{QueueID} || 1;

    # get priority
    my %Priorities;
    if ( $Param{QueueID} ) {
        %Priorities = $Kernel::OM->Get('Kernel::System::Ticket')->TicketPriorityList(
            %Param,
            Action => $Self->{Action},
            UserID => $Self->{UserID},
        );
    }
    return \%Priorities;
}

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

    # get config object
    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

    # check own selection
    my %NewTos;
    if ( $ConfigObject->Get('Ticket::Frontend::NewQueueOwnSelection') ) {
        %NewTos = %{ $ConfigObject->Get('Ticket::Frontend::NewQueueOwnSelection') };
    }
    else {

        # SelectionType Queue or SystemAddress?
        my %Tos;
        if ( $ConfigObject->Get('Ticket::Frontend::NewQueueSelectionType') eq 'Queue' ) {
            %Tos = $Kernel::OM->Get('Kernel::System::Ticket')->MoveList(
                %Param,
                Type    => 'create',
                Action  => $Self->{Action},
                QueueID => $Self->{QueueID},
                UserID  => $Self->{UserID},
            );
        }
        else {
            %Tos = $Kernel::OM->Get('Kernel::System::SystemAddress')->SystemAddressQueueList();
        }

        # get create permission queues
        my %UserGroups = $Kernel::OM->Get('Kernel::System::Group')->PermissionUserGet(
            UserID => $Self->{UserID},
            Type   => 'create',
        );
        my $SystemAddressObject = $Kernel::OM->Get('Kernel::System::SystemAddress');
        my $QueueObject         = $Kernel::OM->Get('Kernel::System::Queue');

        # build selection string
        QUEUEID:
        for my $QueueID ( sort keys %Tos ) {

            my %QueueData = $QueueObject->QueueGet( ID => $QueueID );

            # permission check, can we create new tickets in queue
            next QUEUEID if !$UserGroups{ $QueueData{GroupID} };

            my $String = $ConfigObject->Get('Ticket::Frontend::NewQueueSelectionString')
                || '<Realname> <<Email>> - Queue: <Queue>';
            $String =~ s/<Queue>/$QueueData{Name}/g;
            $String =~ s/<QueueComment>/$QueueData{Comment}/g;

            # remove trailing spaces
            if ( !$QueueData{Comment} ) {
                $String =~ s{\s+\z}{};
            }

            if ( $ConfigObject->Get('Ticket::Frontend::NewQueueSelectionType') ne 'Queue' ) {
                my %SystemAddressData = $SystemAddressObject->SystemAddressGet(
                    ID => $Tos{$QueueID},
                );
                $String =~ s/<Realname>/$SystemAddressData{Realname}/g;
                $String =~ s/<Email>/$SystemAddressData{Name}/g;
            }
            $NewTos{$QueueID} = $String;
        }
    }

    # add empty selection
    $NewTos{''} = '-';

    return \%NewTos;
}

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

    # use default Queue if none is provided
    $Param{QueueID} = $Param{QueueID} || 1;

    # get type
    my %Type;
    if ( $Param{QueueID} || $Param{TicketID} ) {
        %Type = $Kernel::OM->Get('Kernel::System::Ticket')->TicketTypeList(
            %Param,
            Action => $Self->{Action},
            UserID => $Self->{UserID},
        );
    }
    return \%Type;
}

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

    # use default Queue if none is provided
    $Param{QueueID} = $Param{QueueID} || 1;

    my %NextStates;
    if ( $Param{QueueID} || $Param{TicketID} ) {
        %NextStates = $Kernel::OM->Get('Kernel::System::Ticket')->TicketStateList(
            %Param,
            Action => $Self->{Action},
            UserID => $Self->{UserID},
        );
    }
    return \%NextStates;
}

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

    # get service
    my %Service;

    # use default Queue if none is provided
    $Param{QueueID} = $Param{QueueID} || 1;

    # setting customer user id
    $Param{CustomerUserID} = $Param{SelectedCustomerUser};

    # get options for default services for unknown customers
    my $DefaultServiceUnknownCustomer = $Kernel::OM->Get('Kernel::Config')->Get('Ticket::Service::Default::UnknownCustomer');

    # check if no CustomerUserID is selected
    # if $DefaultServiceUnknownCustomer = 0 leave CustomerUserID empty, it will not get any services
    # if $DefaultServiceUnknownCustomer = 1 set CustomerUserID to get default services
    if ( !$Param{CustomerUserID} && $DefaultServiceUnknownCustomer ) {
        $Param{CustomerUserID} = '<DEFAULT>';
    }

    # get service list
    if ( $Param{CustomerUserID} ) {
        %Service = $Kernel::OM->Get('Kernel::System::Ticket')->TicketServiceList(
            %Param,
            Action => $Self->{Action},
            UserID => $Self->{UserID},
        );
    }
    return \%Service;
}

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

    # use default Queue if none is provided
    $Param{QueueID} = $Param{QueueID} || 1;

    # get services if they were not determined in an AJAX call
    if ( !defined $Param{Services} ) {
        $Param{Services} = $Self->_GetServices(%Param);
    }

    # get sla
    my %SLA;
    if ( $Param{ServiceID} && $Param{Services} && %{ $Param{Services} } ) {
        if ( $Param{Services}->{ $Param{ServiceID} } ) {
            %SLA = $Kernel::OM->Get('Kernel::System::Ticket')->TicketSLAList(
                %Param,
                Action => $Self->{Action},
                UserID => $Self->{UserID},
            );
        }
    }
    return \%SLA;
}
# EO AppointmentToTicket

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - ff9e297baf287e16071d3ac6ad7f6c13f11ac7fa - Kernel/Output/HTML/Templates/Standard/AgentAppointmentEdit.tt
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

[% RenderBlockStart("EditMask") %]
<div class="InnerContent">
    <form id="EditAppointmentForm" class="Validate PreventMultipleSubmits">
        <input type="hidden" id="ChallengeToken" name="ChallengeToken" value="[% Env("UserChallengeToken") | html %]"/>
        <input type="hidden" id="Action" name="Action" value="[% Env("Action") | html %]"/>
        <input type="hidden" id="Subaction" name="Subaction" value="EditAppointment"/>
        <input type="hidden" id="AppointmentID" name="AppointmentID" value="[% Data.AppointmentID | html %]"/>
        <input type="hidden" id="Recurring" name="Recurring" value="[% Data.Recurring | html %]"/>
        <input type="hidden" id="RecurrenceDays" name="RecurrenceDays" value="[% Data.RecurrenceDays | html %]"/>
        <input type="hidden" id="RecurrenceMonths" name="RecurrenceMonths" value="[% Data.RecurrenceMonths | html %]"/>
        <input type="hidden" id="RecurrenceMonthDays" name="RecurrenceMonthDays" value="[% Data.RecurrenceMonthDays | html %]"/>
# RotherOSS / AppointmentToTicket
        <input type="hidden" id="AJAXAction" name="AJAXAction" value="[% Env("Action") %]" />
# EO AppointmentToTicket
        <fieldset class="TableLike">
            <legend><span>[% Translate("Basic information") | html %]</span></legend>
            <label for="Title"[% IF Data.PermissionLevel >= 2 %] class="Mandatory"[% END %]>[% IF Data.PermissionLevel >= 2 %]<span class="Marker">*</span> [% END %][% Translate("Title") | html %]:</label>
            <div class="Field">
[% IF Data.TicketAppointmentRuleID %]
                <p id="Title" class="ReadOnlyValue">
                    <a href="[% Env("Baselink") %]Action=AgentTicketZoom;TicketID=[% Data.TicketID %]">[% Data.Title | html %]</a>
                </p>
[% ELSE %]
[% IF Data.PermissionLevel < 2 %]
                <p id="Title" class="ReadOnlyValue">[% Data.Title | html %]</p>
[% ELSE %]
                <input type="text" id="Title" name="Title" value="[% Data.Title | html %]" class="W75pc Validate_Required" />
                <div id="TitleError" class="TooltipErrorMessage">
                    <p>[% Translate("This field is required.") | html %]</p>
                </div>
                <div id="TitleServerError" class="TooltipErrorMessage">
                    <p>[% Translate("This field is required.") | html %]</p>
                </div>
[% END %]
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="Description">[% Translate("Description") | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel < 2 %]
                <p id="Description" class="ReadOnlyValue">[% Data.Description || "-" | html %]</p>
[% ELSE %]
                <textarea id="Description" name="Description" class="W75pc" rows="4">[% Data.Description | html %]</textarea>
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="Location">[% Translate("Location") | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel < 2 %]
                <p id="Location" class="ReadOnlyValue">[% Data.Location || "-" | html %]</p>
[% ELSE %]
                <input type="text" id="Location" name="Location" value="[% Data.Location | html %]" class="W50pc" />
[% END %]
[% RenderBlockStart("LocationLink") %]
                <a class="LocationLink Hidden [% Data.CSSClass | html %]" href="[% Data.URL | html %][% Data.Location | uri %]" data-base-url="[% Data.URL | html %]" title="[% Translate(Data.Text) | html %]" target="[% Data.Target | html %]">
                    <i class="fa [% Data.IconName | html %]"></i>
                </a>
[% RenderBlockEnd("LocationLink") %]
            </div>
            <div class="Clear"></div>
            <label for="CalendarID"[% IF !Data.TicketAppointmentRuleID && Data.PermissionLevel >= 3 %] class="Mandatory"[% END %]>
[% IF !Data.TicketAppointmentRuleID && Data.PermissionLevel >= 3 %]
                <span class="Marker">*</span>
[% END %]
                [% Translate("Calendar") | html %]:
            </label>
            <div class="Field">
[% IF Data.TicketAppointmentRuleID || Data.PermissionLevel < 3 %]
                <p id="CalendarID" class="ReadOnlyValue">[% Data.CalendarName | html %]</p>
[% ELSE %]
                [% Data.CalendarIDStrg %]
                <div id="CalendarIDError" class="TooltipErrorMessage">
                    <p>[% Translate("This field is required.") | html %]</p>
                </div>
                <div id="CalendarIDServerError" class="TooltipErrorMessage">
                    <p>[% Translate("This field is required.") | html %]</p>
                </div>
[% END %]
            </div>
        </fieldset>
[% IF Data.TeamIDStrg %]
        <fieldset class="TableLike">
            <legend><span>[% Translate("Resource") | html %]</span></legend>
            <label for="TeamID">[% Translate("Team") | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel < 2 %]
                <p id="TeamID" class="ReadOnlyValue">[% Data.TeamNames %]</p>
[% ELSE %]
                [% Data.TeamIDStrg %]
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="ResourceID">[% Translate("Agent") | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel < 2 %]
                <p id="ResourceID" class="ReadOnlyValue">[% Data.ResourceNames %]</p>
[% ELSE %]
                [% Data.ResourceIDStrg %]
[% END %]
            </div>
        </fieldset>
[% END %]
        <fieldset class="TableLike">
            <legend><span>[% Translate("Date/Time") | html %]</span></legend>
            <label for="StartDay">[% Translate("Start date") | html %]:</label>
            <div class="Field">
[% IF ( Data.TicketAppointmentRuleID && Data.ReadOnlyStart ) || Data.PermissionLevel < 2 %]
                <p id="StartDay" class="ReadOnlyValue">[% Data.StartDate | Localize("TimeLong") %]</p>
[% ELSE %]
                <div id="StartDayError" class="TooltipErrorMessage">
                    <p>[% Translate("Invalid date!") | html %]</p>
                    <p>[% Translate("Please set this to value before End date.") | html %]</p>
                </div>
                [% Data.StartDateString %]
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="EndDay">[% Translate("End date") | html %]:</label>
            <div class="Field">
[% IF ( Data.TicketAppointmentRuleID && Data.ReadOnlyDuration ) || Data.PermissionLevel < 2 %]
                <p id="EndDay" class="ReadOnlyValue">[% Data.EndDate | Localize("TimeLong") %]</p>
[% ELSE %]
                <div id="EndDayError" class="TooltipErrorMessage">
                    <p>[% Translate("Invalid date!") | html %]</p>
                    <p>[% Translate("Please set this to value after Start date.") | html %]</p>
                </div>
                [% Data.EndDateString %]
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="AllDay">[% Translate("All-day") | html %]:</label>
            <div class="Field">
[% IF Data.TicketAppointmentRuleID || Data.PermissionLevel < 2 %]
                <p id="AllDay" class="ReadOnlyValue">[% Translate(Data.AllDayString) | html %]</p>
[% ELSE %]
                <input type="checkbox" id="AllDay" name="AllDay" [% Data.AllDayChecked %] />
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="RecurrenceType">[% Translate("Repeat") | html %]:</label>
[% IF Data.TicketAppointmentRuleID || Data.PermissionLevel < 2 %]
            <div class="Field">
[% IF Data.ParentID %]
                [% Translate("This an occurrence of a repeating appointment.") | html %]<br>
                <a href="#" id="EditParent">[% Translate("Click here to see the parent appointment.") | html %]</a>
[% ELSE %]
                <p id="RecurrenceType" class="ReadOnlyValue">[% Data.RecurrenceValue | html %]</p>
[% END %]
            </div>
[% ELSE %]
[% IF Data.ParentID %]
            <div class="Field">
                [% Translate("This an occurrence of a repeating appointment.") | html %]<br>
                <a href="#" id="EditParent">[% Translate("Click here to edit the parent appointment.") | html %]</a>
            </div>
[% ELSE %]
            <div class="Field">
                [% Data.RecurrenceTypeString %]
            </div>

            <div class="Field" id="RecurrenceCustomTypeStringDiv">
                <div class="FieldExplanation">
                    [% Translate("Frequency") | html %]:
                    <div class="FieldInline">
                        [% Data.RecurrenceCustomTypeString %]
                    </div>
                </div>
                <div class="FieldExplanation">
                    [% Translate("Every") | html %]:
                    <div class="FieldInline">
                        [% Data.RecurrenceIntervalString %]
                    </div>
                    <span id="RecurrenceIntervalText">
                        <span class="TextDay Hidden">[% Translate("day(s)") | html %]</span>
                        <span class="TextWeek Hidden">[% Translate("week(s)") | html %]</span>
                        <span class="TextMonth Hidden">[% Translate("month(s)") | html %]</span>
                        <span class="TextYear Hidden">[% Translate("year(s)") | html %]</span>
                    </span>
                </div>
            </div>

            <div class="Field" id="RecurrenceCustomWeeklyDiv">
                <div class="FieldExplanation">
                    [% Translate("On") | html %]:
                    <input type="hidden" id="Days" name="Days" value="[% Data.Days %]" />

# Weekly table start
                    <table class="ButtonTable">
                        <tbody>
                            <tr>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="1" title="[% Translate("Monday") | html %]">
                                        [% Translate("Mon") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="2" title="[% Translate("Tuesday") | html %]">
                                        [% Translate("Tue") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="3" title="[% Translate("Wednesday") | html %]">
                                        [% Translate("Wed") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="4" title="[% Translate("Thursday") | html %]">
                                        [% Translate("Thu") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="5" title="[% Translate("Friday") | html %]">
                                        [% Translate("Fri") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="6" title="[% Translate("Saturday") | html %]">
                                        [% Translate("Sat") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="7" title="[% Translate("Sunday") | html %]">
                                        [% Translate("Sun") | html %]
                                    </button>
                                </td>
                            </tr>
                        </tbody>
                    </table>
# Weekly table end

                </div>
            </div>

            <div class="Field" id="RecurrenceCustomMonthlyDiv">
                <div class="FieldExplanation">
                    [% Translate("On") | html %]:
                    <input type="hidden" id="MonthDays" name="MonthDays" value="[% Data.MonthDays %]" />

# Monthly table start
                    <table class="ButtonTable">
                        <tbody>
[% Count = 1 %]
[% WHILE Count < 32 %]
[% IF Count % 7 == 1 %]
                            <tr>
[% END %]

# join strings (Monthly1, Monthly2,...)
[% MonthlyCount = "Monthly" _ Count %]
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" value="[% Count %]" title="[% Count %]">
                                        [% Count %]
                                    </button>
                                </td>
[% IF Count % 7 == 0 %]
                            </tr>
[% END %]

[% Count = Count + 1 %]
[% END %]
                        </tbody>
                    </table>
# Monthly table end

                </div>
            </div>

            <div class="Field" id="RecurrenceCustomYearlyDiv">
                <div class="FieldExplanation">
                    [% Translate("On") | html %]:
                    <input type="hidden" id="Months" name="Months" value="[% Data.Months %]" />

# Yearly table start
                    <table class="ButtonTable">
                        <tbody>
                            <tr>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("January") | html %]" value="1" >
                                        [% Translate("Jan") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("February") | html %]" value="2" >
                                        [% Translate("Feb") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("March") | html %]" value="3" >
                                        [% Translate("Mar") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("April") | html %]" value="4" >
                                        [% Translate("Apr") | html %]
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("May_long") | html %]" value="5" >
                                        [% Translate("May") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("June") | html %]" value="6" >
                                        [% Translate("Jun") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("July") | html %]" value="7" >
                                        [% Translate("Jul") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("August") | html %]" value="8" >
                                        [% Translate("Aug") | html %]
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("September") | html %]" value="9" >
                                        [% Translate("Sep") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("October") | html %]" value="10" >
                                        [% Translate("Oct") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("November") | html %]" value="11" >
                                        [% Translate("Nov") | html %]
                                    </button>
                                </td>
                                <td class="fc">
                                    <button class="fc-button fc-state-default" type="button" title="[% Translate("December") | html %]" value="12" >
                                        [% Translate("Dec") | html %]
                                    </button>
                                </td>
                            </tr>
                        </tbody>
                    </table>
# Yearly table end

                </div>
            </div>

            <div id="RecurrenceLimitDiv" class="Field Hidden">
                [% Data.RecurrenceLimitString %]
            </div>
            <div id="RecurrenceUntilDiv" class="Field Hidden">
                <div id="RecurrenceUntilDayError" class="TooltipErrorMessage">
                    <p>[% Translate("Invalid date!") | html %]</p>
                    <p>[% Translate("Please set this to value after Start date.") | html %]</p>
                </div>
                [% Data.RecurrenceUntilString %]
            </div>
            <div id="RecurrenceCountDiv" class="Field Hidden">
                <input type="text" id="RecurrenceCount" name="RecurrenceCount" value="[% Data.RecurrenceCount | html %]" size="1" maxlength="2" />
            </div>
[% END %]
[% END %]
        </fieldset>

        <fieldset class="TableLike">

            <legend><span>[% Translate("Notification") | html %]</span></legend>

            <label for="NotificationTemplate">[% Translate("Notification") | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel < 2 %]
                <p id="NotificationTemplate" class="ReadOnlyValue">[% Data.NotificationValue | html %]</p>
[% ELSE %]
                [% Data.NotificationStrg %]
[% END %]
            </div>
            <div class="Clear"></div>

            <div class="Field" id="NotificationCustomStringDiv">

                <label for="NotificationCustomRelativeInput">[% Translate("Relative point of time") | html %]:</label>

                <div class="FieldExplanation">

                    <input type="radio" name="NotificationCustomRelativeInput" value="" id="NotificationCustomRelativeInput" [% Data.NotificationCustomRelativeInputRadio %]>
                    <div class="FieldInline">
                        <div>
                            <input type="text" id="NotificationCustomRelativeUnitCount" name="NotificationCustomRelativeUnitCount" value="[% Data.NotificationCustomRelativeUnitCount | html %]" size="1" maxlength="2" />
                        </div>
                        <div class="SpacingTopSmall">
                            [% Data.NotificationCustomUnitsStrg %]
                        </div>
                        <div class="SpacingTopSmall">
                            [% Data.NotificationCustomUnitsPointOfTimeStrg %]
                        </div>
                    </div>

                </div>

                <label for="NotificationCustomDateTimeInput">[% Translate("Date/Time") | html %]:</label>

                <div class="FieldExplanation">
                    <input type="radio" name="NotificationCustomDateTimeInput" value="" id="NotificationCustomDateTimeInput" [% Data.NotificationCustomDateTimeInputRadio %]>
                    [% Data.NotificationCustomDateTimeStrg %]
                </div>
            </div>
            <div class="Clear"></div>

        </fieldset>

[% IF Data.PluginList %]
        <fieldset class="TableLike">
            <legend><span>[% Translate("Link") | html %]</span></legend>
[% FOREACH Key IN Data.PluginList.keys %]
            <label>[% Translate(Data.PluginList.$Key.PluginName) | html %]:</label>
            <div class="Field">
[% IF Data.PermissionLevel >= 2 %]
                <input id="[% Key | html %]" type="text" data-plugin-key="[% Key | html %]" data-plugin-url="[% Data.PluginList.$Key.PluginURL | html %]" class="PluginField W90pc" />
                <input type="hidden" id="Plugin_[% Key | html %]" name="Plugin_[% Key | html %]" value='[% Data.PluginList.$Key.LinkList || "[]" %]' />
[% ELSE %]
[% IF Data.PluginData.$Key.size == 0 %]
                <p class="ReadOnlyValue">-</p>
[% END %]
[% END %]
# keep following block on a single line, so :empty CSS selector would work!
                <div id="PluginContainer_[% Key | html %]"[% IF Data.PermissionLevel >= 2 %] class="PluginContainer"[% END %]>[% FOREACH Link IN Data.PluginData.$Key %]<div class="Link_[% Link.LinkID | html %]">
                    <a href="[% Link.LinkURL %]">[% Link.LinkName | html %]</a>[% IF Data.PermissionLevel >= 2 %]<a class="RemoveButton" href="#" data-plugin-key="[% Key | html %]" data-link-id="[% Link.LinkID | html %]" title="[% Translate("Remove entry") | html %]"><i class="fa fa-minus-square-o"></i><span class="InvisibleText">[% Translate("Remove") | html %]</span></a>[% END %]
                </div>[% END %]</div>
            </div>
            <div class="Clear"></div>
[% END %]
        </fieldset>
[% END %]
# RotherOSS / AppointmentToTicket
        <fieldset class="TableLike">
            <legend><span>[% Translate("Ticket Creation") | html %]</span></legend>
            <label for="TicketTemplate">[% Translate("Ticket") | html %]:</label>
            <div class="Field TicketTemplateSelection">
[% IF Data.PermissionLevel < 2 %]
                <p id="TicketTemplate" class="ReadOnlyValue">[% Data.TicketValue | html %]</p>
[% ELSE %]
                [% Data.TicketStrg %]
[% END %]
            </div>
            <div class="Clear"></div>
            <label for="TicketCustomRelativeInput" class="AppointmentTicketCustomTime">[% Translate("Relative point of time") | html %]:</label>
            <div class="FieldExplanation AppointmentTicketCustomTime">
                <input type="radio" name="TicketCustomRelativeInput" value="" id="TicketCustomRelativeInput" [% Data.TicketCustomRelativeInputRadio %]>
                <div class="FieldInline">
                    <div>
                        <input type="text" id="TicketCustomRelativeUnitCount" name="TicketCustomRelativeUnitCount" value="[% Data.TicketCustomRelativeUnitCount | html %]" size="1" maxlength="2" />
                    </div>
                    <div class="SpacingTopSmall">
                        [% Data.TicketCustomUnitsStrg %]
                    </div>
                    <div class="SpacingTopSmall">
                        [% Data.TicketCustomUnitsPointOfTimeStrg %]
                    </div>
                </div>
            </div>
            <label for="TicketCustomDateTimeInput" class="AppointmentTicketCustomTime">[% Translate("Date/Time") | html %]:</label>
            <div class="FieldExplanation AppointmentTicketCustomTime">
                <input type="radio" name="TicketCustomDateTimeInput" value="" id="TicketCustomDateTimeInput" [% Data.TicketCustomDateTimeInputRadio %]>
                [% Data.TicketCustomDateTimeStrg %]
            </div>
            <input type="hidden" name="PreSelectedCustomerUser" id="PreSelectedCustomerUser" value=""/>
            <input type="hidden" name="SelectedCustomerUser" id="SelectedCustomerUser" value="[% Data.TicketSelectedCustomerUser | html %]"/>
            <div class="Clear"></div>
            <label for="FromCustomer" class="Mandatory"><span class="Marker">*</span>[% Translate("Customer user") | html %]:</label>
            <div class="Field">
                <input id="FromCustomer" type="text" name="FromCustomer" value="" class="CustomerAutoComplete W75pc [% Data.FromInvalid | html %]" autocomplete="off" />
                <div id="FromCustomerServerError" class="TooltipErrorMessage">
[% RenderBlockStart("FromServerErrorMsg") %]
                    <p>[% Translate("Please include at least one customer for the ticket.") | html %]</p>
[% RenderBlockEnd("FromServerErrorMsg") %]
                </div>
            </div>
            <div class="Clear"></div>

            <div class="Field [% Data.CustomerHiddenContainer | html %]">
                <div class="CustomerTicketTemplateFromCustomer SpacingTopSmall Hidden">
                    <input name="CustomerSelected" title="[% Translate("Select this customer as the main customer.") | html %]" id="CustomerSelected" class="CustomerTicketRadio" type="radio" value=""/>
                    <input name="CustomerKey" id="CustomerKey" class="CustomerKey" type="hidden" value=""/>
                    <input class="CustomerTicketText Radio" title="[% Translate("Customer user") | html %]" name="CustomerTicketText" id="CustomerTicketText" type="text" value="" readonly="readonly" />
                    <a href="#" id="RemoveCustomerTicket" class="RemoveButton CustomerTicketRemove">
                        <i class="fa fa-minus-square-o"></i>
                        <span class="InvisibleText">[% Translate("Remove Ticket Customer User") | html %]</span>
                    </a>
                </div>

                <div id="TicketCustomerContentFromCustomer" class="CustomerContainer">
[% RenderBlockStart("MultipleCustomer") %]
                    <div class="SpacingTopSmall ">
                        <input name="CustomerSelected" title="[% Translate("Select this customer as the main customer.") | html %]" id="CustomerSelected_[% Data.Count %]" class="CustomerTicketRadio" type="radio" value="[% Data.Count | html %]" [% Data.CustomerSelected | html %]  [% Data.CustomerDisabled | html %] />
                        <input name="CustomerKey_[% Data.Count | html %]" id="CustomerKey_[% Data.Count | html %]" class="CustomerKey" type="hidden" value="[% Data.CustomerKey | html %]"/>
                        <input class="CustomerTicketText Radio [% Data.CustomerError | html %]" title="[% Translate("Customer user") | html %]" name="CustomerTicketText_[% Data.Count %]" id="CustomerTicketText_[% Data.Count %]" type="text" value="[% Data.CustomerElement | html %]" readonly="readonly" />
                        <a href="#" id="RemoveCustomerTicket_[% Data.Count %]" class="RemoveButton CustomerTicketRemove" name="RemoveCustomerTicket_[% Data.Count %]">
                            <i class="fa fa-minus-square-o"></i>
                            <span class="InvisibleText">[% Translate("Remove Ticket Customer User") | html %]</span>
                        </a>

[% RenderBlockStart("CustomerErrorExplantion") %]
                        <p class="Explanation Error">[% Translate("Please remove this entry and enter a new one with the correct value.") | html %]</p>
[% RenderBlockEnd("CustomerErrorExplantion") %]

                        <div id="CustomerTicketText_[% Data.Count %]ServerError" class="TooltipErrorMessage">
[% RenderBlockStart("CustomerGenericServerErrorMsg") %]
                            <p>[% Translate("This field is required.") | html %]</p>
[% RenderBlockEnd("CustomerGenericServerErrorMsg") %]
[% RenderBlockStart("InvalidConfigServerErrorMsg") %]
                            <p>[% Translate("This email address is not allowed due to the system configuration.") | html %]</p>
[% RenderBlockEnd("InvalidConfigServerErrorMsg") %]
[% RenderBlockStart("InvalidMXServerErrorMsg") %]
                            <p>[% Translate("This email address failed MX check.") | html %]</p>
[% RenderBlockEnd("InvalidMXServerErrorMsg") %]
[% RenderBlockStart("InvalidDNSServerErrorMsg") %]
                            <p>[% Translate("DNS problem, please check your configuration and the error log.") | html %]</p>
[% RenderBlockEnd("InvalidDNSServerErrorMsg") %]
[% RenderBlockStart("InvalidSyntaxServerErrorMsg") %]
                            <p>[% Translate("The syntax of this email address is incorrect.") | html %]</p>
[% RenderBlockEnd("InvalidSyntaxServerErrorMsg") %]
[% RenderBlockStart("IsDuplicatedServerErrorMsg") %]
                            <p>[% Translate("This address already exists on the address list.") | html %]</p>
[% RenderBlockEnd("IsDuplicatedServerErrorMsg") %]
                        </div>
                    </div>
[% RenderBlockEnd("MultipleCustomer") %]

                </div>
[% RenderBlockStart("MultipleCustomerCounter") %]
                <input name="CustomerTicketCounterFromCustomer" id="CustomerTicketCounterFromCustomer" type="hidden" value="[% Data.CustomerCounter | html %]"/>
[% RenderBlockEnd("MultipleCustomerCounter") %]
            </div>
            <div class="Clear"></div>
            <input type="hidden" name="CustomerID" id="CustomerID" value="[% Data.CustomerID | html %]" readonly="readonly"/>
[% IF Data.TypeHTMLString %]
            <div class="Clear"></div>
            <label class="Mandatory" for="TicketTypeID"><span class="Marker">*</span>[% Translate('Type') | html %]</label>
            <div class="Field">
                [% Data.TypeHTMLString %]
                <div id="TicketTypeIDError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                <div id="TicketTypeIDServerError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
            </div>
[% END %]
            <div class="Clear"></div>
            <label class="Mandatory" for="Dest"><span class="Marker">*</span>[% Translate('Queue') | html %]</label>
            <div class="Field">
                [% Data.QueueHTMLString %]
                <div id="DestError" class="TooltipErrorMessage" ><p>[% Translate("This field is required.") | html %]</p></div>
                <div id="DestServerError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
            </div>
[% IF Data.ServiceHTMLString %]
            <div class="Clear"></div>
            [% IF Data.ServiceMandatory %]
                <label class="Mandatory" for="ServiceID"><span class="Marker">*</span> [% Translate("Service") | html %]:</label>
            [% ELSE %]
                <label for="ServiceID">[% Translate("Service") | html %]:</label>
            [% END %]
            <div class="Field">
                [% Data.ServiceHTMLString %]
                [% IF Data.ServiceMandatory %]
                    <div id="ServiceIDError" class="TooltipErrorMessage" ><p>[% Translate("This field is required.") | html %]</p></div>
                [% END %]
                <div id="ServiceIDServerError" class="TooltipErrorMessage"><p>[% Translate("Service invalid.") | html %]</p></div>
            </div>
            <div class="Clear"></div>
            [% IF Data.SLAMandatory %]
                <label class="Mandatory" for="SLAID"><span class="Marker">*</span> [% Translate("Service Level Agreement") | html %]:</label>
            [% ELSE %]
                <label for="SLAID">[% Translate("Service Level Agreement") | html %]:</label>
            [% END %]
            <div class="Field">
                [% Data.SLAHTMLString %]
                [% IF Data.SLAMandatory %]
                    <div id="SLAIDError" class="TooltipErrorMessage" ><p>[% Translate("This field is required.") | html %]</p></div>
                    <div id="SLAIDServerError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                [% END %]
            </div>
[% END %]
            <div class="Clear"></div>
            <label class="Mandatory" for="Priority"><span class="Marker">*</span>[% Translate('Priority') | html %]</label>
            <div class="Field">
                [% Data.PriorityHTMLString %]
            </div>
            <div class="Clear"></div>
            <label class="Mandatory" for="NextStateID"><span class="Marker">*</span>[% Translate('State') | html %]</label>
            <div class="Field">
                [% Data.StateHTMLString %]
            </div>
            <div class="Clear"></div>
            <label for="TicketArticleVisibleForCustomer">[% Translate('Article is visible for customer') | html %]</label>
            <div class="Field">
                <input name="TicketArticleVisibleForCustomer" id="TicketArticleVisibleForCustomer" value="" [% Data.ArticleVisibleForCustomer | html %] type="checkbox" />
            </div>
[% FOREACH DynamicField IN Data.DynamicFieldHTML %]
            <div class="Clear"></div>
            [% DynamicField.Label %]
            <div class="Field">
                [% DynamicField.Field %]
            </div>
[% END %]
       </fieldset>
# EO AppointmentToTicket
    </form>
</div>

<div class="ContentFooter Center">
[% IF !Data.PermissionLevel || Data.PermissionLevel > 1 %]
    <button id="EditFormSubmit" class="Primary CallForAction" value="[% Translate("Save") | html %]"><span><i class="fa fa-check-square-o"></i> [% Translate("Save") | html %]</span></button>
[% END %]
[% IF Data.AppointmentID && !Data.TicketAppointmentRuleID && Data.PermissionLevel > 2 %]
    <button id="EditFormCopy" class="CallForAction" value="[% Translate("Copy") | html %]"><span><i class="fa fa-files-o"></i> [% Translate("Copy") | html %]</span></button>
[% END %]
[% IF Data.AppointmentID && !Data.TicketAppointmentRuleID && Data.PermissionLevel > 2 %]
    <button id="EditFormDelete" class="CallForAction"><span>[% Translate("Delete") | html %]</span></button>
[% END %]
    <button id="EditFormCancel" class="CallForAction"><span>[% Translate("Cancel") | html %]</span></button>
</div>
[% RenderBlockEnd("EditMask") %]
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - b786ccf7a8baa601886fae729fc372ca8a240087 - Kernel/System/Calendar/Appointment.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::System::Calendar::Appointment;

use strict;
use warnings;

use parent qw(Kernel::System::EventHandler);

# core modules
use Digest::MD5 ();

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(:all);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::Cache',
    'Kernel::System::Calendar',
    'Kernel::System::DB',
    'Kernel::System::Daemon::SchedulerDB',
    'Kernel::System::DateTime',
    'Kernel::System::Group',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Scheduler',
);

=head1 NAME

Kernel::System::Calendar::Appointment - calendar appointment lib

=head1 DESCRIPTION

All appointment functions.

=head1 PUBLIC INTERFACE

=head2 new()

create an object. Do not use it directly, instead use:

    use Kernel::System::ObjectManager;
    local $Kernel::OM = Kernel::System::ObjectManager->new();
    my $AppointmentObject = $Kernel::OM->Get('Kernel::System::Calendar::Appointment');

=cut

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

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

    # init of event handler
    $Self->EventHandlerInit(
        Config => 'AppointmentCalendar::EventModulePost',
    );

    $Self->{CacheType} = 'Appointment';
    $Self->{CacheTTL}  = 60 * 60 * 24 * 20;

    return $Self;
}

=head2 AppointmentCreate()

creates a new appointment.

    my $AppointmentID = $AppointmentObject->AppointmentCreate(
        ParentID              => 1,                                       # (optional) valid ParentID for recurring appointments
        CalendarID            => 1,                                       # (required) valid CalendarID
        UniqueID              => 'jwioji-fwjio',                          # (optional) provide desired UniqueID; if there is already existing Appointment
                                                                          #            with same UniqueID, system will delete it
        Title                 => 'Webinar',                               # (required) Title
        Description           => 'How to use Process tickets...',         # (optional) Description
        Location              => 'Straubing',                             # (optional) Location
        StartTime             => '2016-01-01 16:00:00',                   # (required)
        EndTime               => '2016-01-01 17:00:00',                   # (required)
        AllDay                => 0,                                       # (optional) default 0
        TeamID                => [ 1 ],                                   # (optional) must be an array reference if supplied
        ResourceID            => [ 1, 3 ],                                # (optional) must be an array reference if supplied
        Recurring             => 1,                                       # (optional) flag the appointment as recurring (parent only!)
        RecurringRaw          => 1,                                       # (optional) skip loop for recurring appointments (do not create occurrences!)
        RecurrenceType        => 'Daily',                                 # (required if Recurring) Possible "Daily", "Weekly", "Monthly", "Yearly",
                                                                          #           "CustomWeekly", "CustomMonthly", "CustomYearly"

        RecurrenceFrequency   => [1, 3, 5],                               # (required if Custom Recurring) Recurrence pattern
                                                                          #           for CustomWeekly: 1-Mon, 2-Tue,..., 7-Sun
                                                                          #           for CustomMonthly: 1-1st, 2-2nd,.., 31th
                                                                          #           for CustomYearly: 1-Jan, 2-Feb,..., 12-Dec
                                                                          # ...
        RecurrenceCount       => 1,                                       # (optional) How many Appointments to create
        RecurrenceInterval    => 2,                                       # (optional) Repeating interval (default 1)
        RecurrenceUntil       => '2016-01-10 00:00:00',                   # (optional) Until date
        RecurrenceID          => '2016-01-10 00:00:00',                   # (optional) Expected start time for this occurrence
        RecurrenceExclude     => [                                        # (optional) Which specific occurrences to exclude
            '2016-01-10 00:00:00',
            '2016-01-11 00:00:00',
        ],
        NotificationTime      => '2016-01-01 17:00:00',                   # (optional) Point of time to execute the notification event
        NotificationTemplate  => 'Custom',                                # (optional) Template to be used for notification point of time
        NotificationCustom    => 'relative',                              # (optional) Type of the custom template notification point of time
                                                                          #            Possible "relative", "datetime"
        NotificationCustomRelativeUnitCount   => '12',                    # (optional) minutes, hours or days count for custom template
        NotificationCustomRelativeUnit        => 'minutes',               # (optional) minutes, hours or days unit for custom template
        NotificationCustomRelativePointOfTime => 'beforestart',           # (optional) Point of execute for custom templates
                                                                          #            Possible "beforestart", "afterstart", "beforeend", "afterend"
        NotificationCustomDateTime => '2016-01-01 17:00:00',              # (optional) Notification date time for custom template
        TicketAppointmentRuleID    => '9bb20ea035e7a9930652a9d82d00c725', # (optional) Ticket appointment rule ID (for ticket appointments only!)
        UserID                     => 1,                                  # (required) UserID
# RotherOSS / AppointmentToTicket
        AppointmentTicket => {                                            # (optional) Data for ticket creation
            Time => '2016-01-10 00:00:00',                                # (optional) Point of time to execute the ticket creat event
            Template => 'Custom',                                         # (optional) Template to be used for ticket point of time
            Custom => 'relative',                                         # (optional) Type of the custom template ticket point of time
                                                                          #            Possible "relative", "datetime"
            CustomRelativeUnitCount => '12',                              # (optional) minutes, hours or days count for custom template
            CustomRelativeUnit => 'minutes',                              # (optional) minutes, hours or days unit for custom template
            CustomRelativePointOfTime => 'beforestart'  ,                 # (optional) Point of execute for custom templates
                                                                          #            Possible "beforestart", "afterstart", "beforeend", "afterend"
            CustomDateTime => '2016-01-01 17:00:00',                      # (optional) Ticket date time for custom template
            QueueID => 1,                                                 # (optional) Ticket queue
            CustomerID => 1,                                              # (optional) Ticket customer id
            CustomerUser => 'test@test.com',                              # (optional) Ticket customer user
            SelectedCustomerUser => 'test',                               # (optional) Selected customer user
            UserID => 1,                                                  # (optional) Ticket user id
            OwnerID => 1,                                                 # (optional) Ticket owner id
            Lock => 'unlock',                                             # (optional) Ticket lock state
            PriorityID => 3,                                              # (optional) Ticket priority
            StateID => 1,                                                 # (optional) Ticket state
            ServiceID => 1,                                               # (optional) Ticket service
            SLAID => 1,                                                   # (optional) Ticker service level agreement
            TypeID => 1,                                                  # (optional) Ticket type id
            DynamicFields => {                                            # (optional) Name value combinations for dynamic fields
                DynamicFieldName1 => Value1,
                DynamicFieldName2 => Value2,
            },
            ArticleVisibleForCustomer => 1,                               # (optional) If the first Ticket Article is visible for the Customer
        },
# EO AppointmentToTicket
    );

returns parent AppointmentID if successful

Events:
    AppointmentCreate

=cut

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

    # check needed stuff
    for my $Needed (qw(CalendarID Title StartTime EndTime UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # prepare possible notification params
    $Self->_AppointmentNotificationPrepare(
        Data => \%Param,
    );

    # if Recurring is provided, additional parameters must be present
    if ( $Param{Recurring} ) {

        my @RecurrenceTypes = (
            "Daily",       "Weekly",       "Monthly",       "Yearly",
            "CustomDaily", "CustomWeekly", "CustomMonthly", "CustomYearly"
        );

        if (
            !$Param{RecurrenceType}
            || !grep { $_ eq $Param{RecurrenceType} } @RecurrenceTypes
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "RecurrenceType invalid!",
            );
            return;
        }

        if (
            (
                $Param{RecurrenceType} eq 'CustomWeekly'
                || $Param{RecurrenceType} eq 'CustomMonthly'
                || $Param{RecurrenceType} eq 'CustomYearly'
            )
            && !$Param{RecurrenceFrequency}
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "RecurrenceFrequency needed!",
            );
            return;
        }
    }

    $Param{RecurrenceInterval} ||= 1;

    if ( $Param{UniqueID} && !$Param{ParentID} ) {
        my %Appointment = $Self->AppointmentGet(
            UniqueID   => $Param{UniqueID},
            CalendarID => $Param{CalendarID},
        );

        # delete existing appointment with same UniqueID
        if ( %Appointment && $Appointment{AppointmentID} ) {
            $Self->AppointmentDelete(
                AppointmentID => $Appointment{AppointmentID},
                UserID        => $Param{UserID},
            );
        }
    }

    # check ParentID
    if ( $Param{ParentID} && !IsInteger( $Param{ParentID} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "ParentID must be a number!",
        );
        return;
    }

    # Check StartTime.
    my $StartTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{StartTime},
        },
    );
    if ( !$StartTimeObject ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Invalid StartTime!",
        );
        return;
    }

    # check UniqueID
    if ( !$Param{UniqueID} ) {
        $Param{UniqueID} = $Self->GetUniqueID(
            CalendarID => $Param{CalendarID},
            StartTime  => $Param{StartTime},
            UserID     => $Param{UserID},
        );
    }

    # Check EndTime.
    my $EndTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{EndTime},
        },
    );
    if ( !$EndTimeObject ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Invalid EndTime!",
        );
        return;
    }

    # check if array refs
    my %Arrays;
    for my $Parameter (
        qw(TeamID ResourceID RecurrenceFrequency RecurrenceExclude)
        )
    {
        if ( $Param{$Parameter} && @{ $Param{$Parameter} // [] } ) {
            if ( !IsArrayRefWithData( $Param{$Parameter} ) ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "$Parameter not ARRAYREF!",
                );
                return;
            }

            my @Array = @{ $Param{$Parameter} };

            # remove undefined values
            @Array = grep { defined $_ } @Array;

            $Arrays{$Parameter} = join( ',', @Array ) if @Array;
        }
    }

    # check if numbers
    for my $Parameter (
        qw(Recurring RecurrenceCount RecurrenceInterval)
        )
    {
        if ( $Param{$Parameter} && !IsInteger( $Param{$Parameter} ) ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "$Parameter must be a number!",
            );
            return;
        }
    }

    # check RecurrenceUntil
    if ( $Param{RecurrenceUntil} ) {

        # Usually hour, minute and second = 0. In this case, take time from StartTime.
        $Param{RecurrenceUntil} = $Self->_TimeCheck(
            OriginalTime => $Param{StartTime},
            Time         => $Param{RecurrenceUntil},
        );

        my $RecurrenceUntilObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{RecurrenceUntil},
            },
        );

        if (
            !$RecurrenceUntilObject
            || $StartTimeObject > $RecurrenceUntilObject
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Invalid RecurrenceUntil!",
            );
            return;
        }
    }

    # get db object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');
    my @Bind;

    # the parent_id is only supplied for recurring events
    my ( $ParentIDCol, $ParentIDVal ) = ( '', '' );
    if ( $Param{ParentID} ) {
        $ParentIDCol = 'parent_id,';
        $ParentIDVal = '?,';
        push @Bind, \$Param{ParentID};

        # turn off all recurring fields
        delete $Param{Recurring};
        delete $Param{RecurrenceType};
        delete $Param{RecurrenceFrequency};
        delete $Param{RecurrenceCount};
        delete $Param{RecurrenceInterval};
        delete $Param{RecurrenceUntil};
    }

    push @Bind, \$Param{CalendarID}, \$Param{UniqueID}, \$Param{Title}, \$Param{Description},
        \$Param{Location},                              \$Param{StartTime},            \$Param{EndTime},   \$Param{AllDay},
        \$Arrays{TeamID},                               \$Arrays{ResourceID},          \$Param{Recurring}, \$Param{RecurrenceType},
        \$Arrays{RecurrenceFrequency},                  \$Param{RecurrenceCount},      \$Param{RecurrenceInterval},
        \$Param{RecurrenceUntil},                       \$Param{RecurrenceID},         \$Arrays{RecurrenceExclude},
        \$Param{NotificationDate},                      \$Param{NotificationTemplate}, \$Param{NotificationCustom},
        \$Param{NotificationCustomRelativeUnitCount},   \$Param{NotificationCustomRelativeUnit},
        \$Param{NotificationCustomRelativePointOfTime}, \$Param{NotificationCustomDateTime},
        \$Param{TicketAppointmentRuleID},               \$Param{UserID}, \$Param{UserID};

    my $SQL = "
        INSERT INTO calendar_appointment
            ($ParentIDCol calendar_id, unique_id, title, description, location, start_time,
            end_time, all_day, team_id, resource_id, recurring, recur_type, recur_freq, recur_count,
            recur_interval, recur_until, recur_id, recur_exclude, notify_time, notify_template,
            notify_custom, notify_custom_unit_count, notify_custom_unit, notify_custom_unit_point,
            notify_custom_date, ticket_appointment_rule_id, create_time, create_by, change_time,
            change_by)
        VALUES ($ParentIDVal ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
            ?, ?, current_timestamp, ?, current_timestamp, ?)
    ";

    # create db record
    return if !$DBObject->Do(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    my $AppointmentID;

    # return parent id for appointment occurrences
    if ( $Param{ParentID} ) {
        $AppointmentID = $Param{ParentID};
    }

    # get appointment id for the appointment that was just added
    else {
        ($AppointmentID) = $DBObject->SelectRowArray(
            SQL => <<'END_SQL',
SELECT id
  FROM calendar_appointment
  WHERE calendar_id = ?
    AND unique_id   = ?
    AND title       = ?
    AND parent_id   IS NULL
  ORDER BY id DESC
END_SQL
            Bind => [
                \$Param{CalendarID},
                \$Param{UniqueID},
                \$Param{Title},
            ],
        );

        # return if there is not appointment created
        if ( !$AppointmentID ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Can\'t get AppointmentID from INSERT!',
            );
            return;
        }
    }

    # Add recurring appointments. The AppointmentCreate event
    # will be triggered for each added appointment.
    if ( $Param{Recurring} && !$Param{RecurringRaw} ) {
        return if !$Self->_AppointmentRecurringCreate(
            ParentID    => $AppointmentID,
            Appointment => \%Param,
        );
    }

# RotherOSS / AppointmentToTicket
    if ( $Param{TicketTemplate} && !$Param{ParentID} ) {
        my $FutureTaskAppointmentID = 0;
        my $ExecutionTime;
        my $CurrentDateTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
        );
        if ( $Param{Recurring} ) {

            # Get nearest upcoming event
            # If all events are in the past, no future task is created
            my @AppointmentList = $Self->AppointmentList(
                CalendarID => $Param{CalendarID},
                ParentID   => $AppointmentID,
            );
            my %ParentAppointment = $Self->AppointmentGet( AppointmentID => $AppointmentID );
            unshift @AppointmentList, \%ParentAppointment;

            APPOINTMENT:
            for my $Appointment (@AppointmentList) {

                # Take smallest positive distance from current time
                # Take execution time of future task as reference
                my $AppointmentExecutionTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Self->AppointmentToTicketExecutionTime(
                            Data => {
                                TicketTime                      => $Param{TicketTime},
                                TicketTemplate                  => $Param{TicketTemplate},
                                TicketCustom                    => $Param{TicketCustom},
                                TicketCustomRelativeUnitCount   => $Param{TicketCustomRelativeUnitCount},
                                TicketCustomRelativeUnit        => $Param{TicketCustomRelativeUnit},
                                TicketCustomRelativePointOfTime => $Param{TicketCustomRelativePointOfTime},
                                TicketCustomDateTime            => $Param{TicketCustomDateTime},
                            },
                            StartTime => $Appointment->{StartTime},
                            EndTime   => $Appointment->{EndTime},
                        ),
                    },
                );
                if ( $AppointmentExecutionTimeObject->Compare( DateTimeObject => $CurrentDateTimeObject ) > 0 ) {
                    $FutureTaskAppointmentID = $Appointment->{AppointmentID};
                    $ExecutionTime           = $AppointmentExecutionTimeObject->ToString();
                    last APPOINTMENT;
                }
            }

        }
        else {
            my $AppointmentExecutionTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Self->AppointmentToTicketExecutionTime(
                        Data => {
                            TicketTime                      => $Param{TicketTime},
                            TicketTemplate                  => $Param{TicketTemplate},
                            TicketCustom                    => $Param{TicketCustom},
                            TicketCustomRelativeUnitCount   => $Param{TicketCustomRelativeUnitCount},
                            TicketCustomRelativeUnit        => $Param{TicketCustomRelativeUnit},
                            TicketCustomRelativePointOfTime => $Param{TicketCustomRelativePointOfTime},
                            TicketCustomDateTime            => $Param{TicketCustomDateTime},
                        },
                        StartTime => $Param{StartTime},
                        EndTime   => $Param{EndTime},
                    ),
                },
            );

            if ( $AppointmentExecutionTimeObject->Compare( DateTimeObject => $CurrentDateTimeObject ) > 0 ) {
                $FutureTaskAppointmentID = $AppointmentID;
                $ExecutionTime           = $AppointmentExecutionTimeObject->ToString();
            }
        }

        if ($FutureTaskAppointmentID) {
            my $TaskID = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskAdd(
                ExecutionTime => $ExecutionTime,
                Type          => 'AppointmentTicket',
                Data          => {
                    AppointmentTicket => {
                        $Param{AppointmentTicket}->%*,
                    },
                    AppointmentID                   => $FutureTaskAppointmentID,
                },
            );
            if ($TaskID) {
                $Param{FutureTaskID} = $TaskID;
            }
            else {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Ticket task for appointment $AppointmentID could not be created!",
                );
            }

            $SQL = "
                UPDATE calendar_appointment
                SET future_task_id = ?
                WHERE id = ?
            ";
            @Bind = ( \$TaskID, \$FutureTaskAppointmentID );

            # update db record
            return if !$DBObject->Do(
                SQL  => $SQL,
                Bind => \@Bind,
            );
        }
    }
# EO AppointmentToTicket

    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # clean up list methods cache
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'List' . $Param{CalendarID},
    );
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'Days' . $Param{UserID},
    );

    # fire event
    $Self->EventHandler(
        Event => 'AppointmentCreate',
        Data  => {
            AppointmentID => $AppointmentID,
            CalendarID    => $Param{CalendarID},
        },
        UserID => $Param{UserID},
    );

    return $AppointmentID;
}

=head2 AppointmentList()

get a hash of Appointments.

    my @Appointments = $AppointmentObject->AppointmentList(
        CalendarID          => 1,                                       # (required) Valid CalendarID
        Title               => '*',                                     # (optional) Filter by title, wildcard supported
        Description         => '*',                                     # (optional) Filter by description, wildcard supported
        Location            => '*',                                     # (optional) Filter by location, wildcard supported
        StartTime           => '2016-01-01 00:00:00',                   # (optional) Filter by start date
        EndTime             => '2016-02-01 00:00:00',                   # (optional) Filter by end date
        TeamID              => 1,                                       # (optional) Filter by team
        ResourceID          => 2,                                       # (optional) Filter by resource
# RotherOSS / AppointmentToTicket
        ParentID            => 1,                                       # (optional) Filter by parent id, returns only children
# EO AppointmentToTicket
        Result              => 'HASH',                                  # (optional), HASH|ARRAY
    );

returns an array of hashes with select Appointment data or simple array of AppointmentIDs:

Result => 'HASH':

    @Appointments = (
        {
            AppointmentID => 1,
            CalendarID    => 1,
            UniqueID      => '20160101T160000-71E386@localhost',
            Title         => 'Webinar',
            Description   => 'How to use Process tickets...',
            Location      => 'Straubing',
            StartTime     => '2016-01-01 16:00:00',
            EndTime       => '2016-01-01 17:00:00',
            AllDay        => 0,
            Recurring     => 1,                                           # for recurring (parent) appointments only
        },
        {
            AppointmentID => 2,
            ParentID      => 1,                                           # for recurred (child) appointments only
            CalendarID    => 1,
            UniqueID      => '20160101T180000-A78B57@localhost',
            Title         => 'Webinar',
            Description   => 'How to use Process tickets...',
            Location      => 'Straubing',
            StartTime     => '2016-01-02 16:00:00',
            EndTime       => '2016-01-02 17:00:00',
            TeamID        => [ 1 ],
            ResourceID    => [ 1, 3 ],
            AllDay        => 0,
        },
        {
            AppointmentID                         => 3,
            CalendarID                            => 1,
            UniqueID                              => '20160101T180000-A78B57@localhost',
            Title                                 => 'Webinar',
            Description                           => 'How to use Process tickets...',
            Location                              => 'Straubing',
            StartTime                             => '2016-01-02 16:00:00',
            EndTime                               => '2016-01-02 17:00:00',
            TimezoneID                            => 1,
            TeamID                                => [ 1 ],
            ResourceID                            => [ 1, 3 ],
            NotificationDate                      => '2016-01-02 16:10:00',
            NotificationTemplate                  => 'Custom',
            NotificationCustom                    => 'relative',
            NotificationCustomRelativeUnitCount   => '10',
            NotificationCustomRelativeUnit        => 'minutes',
            NotificationCustomRelativePointOfTime => 'afterstart',
            NotificationCustomDateTime            => '2016-01-02 16:00:00',
            TicketAppointmentRuleID               => '9bb20ea035e7a9930652a9d82d00c725',    # for ticket appointments only!
        },
        ...
    );

Result => 'ARRAY':

    @Appointments = ( 1, 2, ... )

=cut

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

    # check needed stuff
    for my $Needed (qw(CalendarID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # output array of hashes by default
    $Param{Result} = $Param{Result} || 'HASH';

    # cache keys
    my $CacheType        = $Self->{CacheType} . 'List' . $Param{CalendarID};
    my $CacheKeyTitle    = $Param{Title}       || 'any';
    my $CacheKeyDesc     = $Param{Description} || 'any';
    my $CacheKeyLocation = $Param{Location}    || 'any';
    my $CacheKeyStart    = $Param{StartTime}   || 'any';
    my $CacheKeyEnd      = $Param{EndTime}     || 'any';
    my $CacheKeyTeam     = $Param{TeamID}      || 'any';
    my $CacheKeyResource = $Param{ResourceID}  || 'any';

# RotherOSS / AppointmentToTicket
    my $CacheKeyParent = $Param{ParentID} || 'any';

# EO AppointmentToTicket

    if ( defined $Param{Title} && $Param{Title} =~ /^[\*]+$/ ) {
        $CacheKeyTitle = 'any';
    }
    if ( defined $Param{Description} && $Param{Description} =~ /^[\*]+$/ ) {
        $CacheKeyDesc = 'any';
    }
    if ( defined $Param{Location} && $Param{Location} =~ /^[\*]+$/ ) {
        $CacheKeyLocation = 'any';
    }

# RotherOSS / AppointmentToTicket
#    my $CacheKey = "$CacheKeyTitle-$CacheKeyDesc-$CacheKeyLocation-$CacheKeyStart-$CacheKeyEnd-$CacheKeyTeam-$CacheKeyResource-$Param{Result}";
    my $CacheKey = "$CacheKeyTitle-$CacheKeyDesc-$CacheKeyLocation-$CacheKeyStart-$CacheKeyEnd-$CacheKeyTeam-$CacheKeyResource-$CacheKeyParent-$Param{Result}";
# EO AppointmentToTicket

    # check cache
    my $Data = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $CacheType,
        Key  => $CacheKey,
    );

    if ( ref $Data eq 'ARRAY' ) {
        return @{$Data};
    }

    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # check time
    if ( $Param{StartTime} ) {
        my $StartTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{StartTime},
            },
        );
        if ( !$StartTimeObject ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "StartTime invalid!",
            );
            return;
        }
    }
    if ( $Param{EndTime} ) {
        my $EndTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{EndTime},
            },
        );
        if ( !$EndTimeObject ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "EndTime invalid!",
            );
            return;
        }
    }

# RotherOSS / AppointmentToTicket
#     my $SQL = '
#         SELECT id, parent_id, calendar_id, unique_id, title, description, location, start_time,
#             end_time, team_id, resource_id, all_day, recurring, notify_time, notify_template,
#             notify_custom, notify_custom_unit_count, notify_custom_unit, notify_custom_unit_point,
#             notify_custom_date, ticket_appointment_rule_id
#         FROM calendar_appointment
#         WHERE calendar_id=?
#     ';
    my $SQL = '
        SELECT id, parent_id, calendar_id, unique_id, title, description, location, start_time,
            end_time, team_id, resource_id, all_day, recurring, notify_time, notify_template,
            notify_custom, notify_custom_unit_count, notify_custom_unit, notify_custom_unit_point,
            notify_custom_date, ticket_appointment_rule_id, future_task_id
        FROM calendar_appointment
        WHERE calendar_id = ?
    ';
# EO AppointmentToTicket

    my @Bind;

    push @Bind, \$Param{CalendarID};

    # Filter title, description and location fields by using QueryCondition method, which will
    #   return backend specific SQL statements in order to provide case insensitive match and
    #   wildcard support.
    FILTER:
    for my $Filter (qw(Title Description Location)) {
        next FILTER if !$Param{$Filter};
        $SQL .= ' AND ' . $DBObject->QueryCondition(
            Key          => lc $Filter,
            Value        => $Param{$Filter},
            SearchPrefix => '*',
            SearchSuffix => '*',
        );
    }

    if ( $Param{StartTime} && $Param{EndTime} ) {

        $SQL .= ' AND (
            (start_time >= ? AND start_time < ?) OR
            (end_time > ? AND end_time <= ?) OR
            (start_time <= ? AND end_time >= ?)
        ) ';
        push @Bind, \$Param{StartTime}, \$Param{EndTime}, \$Param{StartTime}, \$Param{EndTime}, \$Param{StartTime},
            \$Param{EndTime};
    }
    elsif ( $Param{StartTime} && !$Param{EndTime} ) {

        $SQL .= ' AND end_time >= ? ';
        push @Bind, \$Param{StartTime};
    }
    elsif ( !$Param{StartTime} && $Param{EndTime} ) {

        $SQL .= ' AND start_time <= ? ';
        push @Bind, \$Param{EndTime};
    }

    $SQL .= ' ORDER BY id ASC';

    # db query
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    my @Result;

    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # team id
        my @TeamID = split( /,/, $Row[9] // '' );
        if ( $Param{TeamID} ) {
            next ROW if !grep { $_ == $Param{TeamID} } @TeamID;
        }

        # resource id
        $Row[10] = $Row[10] ? $Row[10] : 0;
        my @ResourceID = $Row[10] =~ /,/ ? split( /,/, $Row[10] ) : ( $Row[10] );
        if ( $Param{ResourceID} ) {
            next ROW if !grep { $_ == $Param{ResourceID} } @ResourceID;
        }

# RotherOSS / AppointmentToTicket
        # parent id
        $Row[1] = $Row[1] ? $Row[1] : 0;
        my $ParentID = $Row[1];
        if ( $Param{ParentID} ) {
            next ROW if ( $Param{ParentID} != $ParentID );
        }
# EO AppointmentToTicket

        my %Appointment = (
            AppointmentID                         => $Row[0],
            ParentID                              => $Row[1],
            CalendarID                            => $Row[2],
            UniqueID                              => $Row[3],
            Title                                 => $Row[4],
            Description                           => $Row[5],
            Location                              => $Row[6],
            StartTime                             => $Row[7],
            EndTime                               => $Row[8],
            TeamID                                => \@TeamID,
            ResourceID                            => \@ResourceID,
            AllDay                                => $Row[11],
            Recurring                             => $Row[12],
            NotificationDate                      => $Row[13] || '',
            NotificationTemplate                  => $Row[14],
            NotificationCustom                    => $Row[15],
            NotificationCustomRelativeUnitCount   => $Row[16],
            NotificationCustomRelativeUnit        => $Row[17],
            NotificationCustomRelativePointOfTime => $Row[18],
            NotificationCustomDateTime            => $Row[19] || '',
            TicketAppointmentRuleID               => $Row[20],
# RotherOSS / AppointmentToTicket
            FutureTaskID                          => $Row[21],
# EO AppointmentToTicket
        );
        push @Result, \%Appointment;
    }

    # if Result was ARRAY, output only IDs
    if ( $Param{Result} eq 'ARRAY' ) {
        my @ResultList;
        for my $Appointment (@Result) {
            push @ResultList, $Appointment->{AppointmentID};
        }
        @Result = @ResultList;
    }

    # cache
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $CacheType,
        Key   => $CacheKey,
        Value => \@Result,
        TTL   => $Self->{CacheTTL},
    );

    return @Result;
}

=head2 AppointmentDays()

get a hash of days with Appointments in all user calendars.

    my %AppointmentDays = $AppointmentObject->AppointmentDays(
        StartTime           => '2016-01-01 00:00:00',                   # (optional) Filter by start date
        EndTime             => '2016-02-01 00:00:00',                   # (optional) Filter by end date
        UserID              => 1,                                       # (required) Valid UserID
    );

returns a hash with days as keys and number of Appointments as values:

    %AppointmentDays = {
        '2016-01-01' => 1,
        '2016-01-13' => 2,
        '2016-01-30' => 1,
    };

=cut

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

    # check needed stuff
    for my $Needed (qw(UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # cache keys
    my $CacheType     = $Self->{CacheType} . 'Days' . $Param{UserID};
    my $CacheKeyStart = $Param{StartTime} || 'any';
    my $CacheKeyEnd   = $Param{EndTime}   || 'any';

    # check time
    if ( $Param{StartTime} ) {
        my $StartTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{StartTime},
            },
        );
        if ( !$StartTimeObject ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "StartTime invalid!",
            );
            return;
        }
    }
    if ( $Param{EndTime} ) {
        my $EndTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{EndTime},
            },
        );
        if ( !$EndTimeObject ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "EndTime invalid!",
            );
            return;
        }
    }

    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # check cache
    my $Data = $CacheObject->Get(
        Type => $CacheType,
        Key  => "$CacheKeyStart-$CacheKeyEnd",
    );

    if ( ref $Data eq 'HASH' ) {
        return %{$Data};
    }

    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get user groups
    my %GroupList = $Kernel::OM->Get('Kernel::System::Group')->PermissionUserGet(
        UserID => $Param{UserID},
        Type   => 'ro',
    );
    my @GroupIDs = sort keys %GroupList;

    my $SQL = "
        SELECT ca.start_time, ca.end_time
        FROM calendar_appointment ca
        JOIN calendar c ON ca.calendar_id = c.id
        WHERE c.group_id IN ( ${\(join ', ', @GroupIDs)} )
    ";

    my @Bind;

    if ( $Param{StartTime} && $Param{EndTime} ) {

        $SQL .= 'AND (
            (ca.start_time >= ? AND ca.start_time < ?) OR
            (ca.end_time > ? AND ca.end_time <= ?) OR
            (ca.start_time <= ? AND ca.end_time >= ?)
        ) ';
        push @Bind, \$Param{StartTime}, \$Param{EndTime}, \$Param{StartTime}, \$Param{EndTime}, \$Param{StartTime},
            \$Param{EndTime};
    }
    elsif ( $Param{StartTime} && !$Param{EndTime} ) {

        $SQL .= 'AND ca.end_time >= ? ';
        push @Bind, \$Param{StartTime};
    }
    elsif ( !$Param{StartTime} && $Param{EndTime} ) {

        $SQL .= 'AND ca.start_time <= ? ';
        push @Bind, \$Param{EndTime};
    }

    $SQL .= 'ORDER BY ca.id ASC';

    # db query
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    my %Result;

    while ( my @Row = $DBObject->FetchrowArray() ) {

        my ( $StartTime, $EndTime );

        # StartTime
        if ( $Param{StartTime} ) {
            $StartTime = $Row[0] lt $Param{StartTime} ? $Param{StartTime} : $Row[0];
        }
        else {
            $StartTime = $Row[0];
        }

        # EndTime
        if ( $Param{EndTime} ) {
            $EndTime = $Row[1] gt $Param{EndTime} ? $Param{EndTime} : $Row[1];
        }
        else {
            $EndTime = $Row[1];
        }

        # Get system times.
        my $StartTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $StartTime,
            },
        );
        my $EndTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $EndTime,
            },
        );

        for (
            my $LoopTimeObject = $StartTimeObject->Clone();
            $LoopTimeObject < $EndTimeObject;
            $LoopTimeObject->Add( Days => 1 )
            )
        {
            my $LoopTime = $LoopTimeObject->ToString();

            $LoopTime =~ s/\s.*?$//gsm;

            if ( $Result{$LoopTime} ) {
                $Result{$LoopTime}++;
            }
            else {
                $Result{$LoopTime} = 1;
            }
        }
    }

    # cache
    $CacheObject->Set(
        Type  => $CacheType,
        Key   => "$CacheKeyStart-$CacheKeyEnd",
        Value => \%Result,
        TTL   => $Self->{CacheTTL},
    );

    return %Result;
}

=head2 AppointmentGet()

Get appointment data.

    my %Appointment = $AppointmentObject->AppointmentGet(
        AppointmentID => 1,                                  # (required)
                                                             # or
        UniqueID      => '20160101T160000-71E386@localhost', # (required) will return only parent for recurring appointments
        CalendarID    => 1,                                  # (required)
    );

Returns a hash:

    %Appointment = (
        AppointmentID       => 2,
        ParentID            => 1,                                  # only for recurred (child) appointments
        CalendarID          => 1,
        UniqueID            => '20160101T160000-71E386@localhost',
        Title               => 'Webinar',
        Description         => 'How to use Process tickets...',
        Location            => 'Straubing',
        StartTime           => '2016-01-01 16:00:00',
        EndTime             => '2016-01-01 17:00:00',
        AllDay              => 0,
        TeamID              => [ 1 ],
        ResourceID          => [ 1, 3 ],
        Recurring           => 1,
        RecurrenceType      => 'Daily',
        RecurrenceFrequency => 1,
        RecurrenceCount     => 1,
        RecurrenceInterval  => 2,
        RecurrenceUntil     => '2016-01-10 00:00:00',
        RecurrenceID        => '2016-01-10 00:00:00',
        RecurrenceExclude   => [
            '2016-01-10 00:00:00',
            '2016-01-11 00:00:00',
        ],
        NotificationTime                  => '2016-01-01 17:0:00',
        NotificationTemplate              => 'Custom',
        NotificationCustomUnitCount       => '12',
        NotificationCustomUnit            => 'minutes',
        NotificationCustomUnitPointOfTime => 'beforestart',

        TicketAppointmentRuleID => '9bb20ea035e7a9930652a9d82d00c725',  # for ticket appointments only!
        CreateTime              => '2016-01-01 00:00:00',
        CreateBy                => 2,
        ChangeTime              => '2016-01-01 00:00:00',
        ChangeBy                => 2,
# RotherOSS / AppointmentToTicket
        FutureTaskID => 1,
# EO AppointmentToTicket
    );

=cut

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

    # check needed stuff
    if (
        !$Param{AppointmentID}
        && !( $Param{UniqueID} && $Param{CalendarID} )
        )
    {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need AppointmentID or UniqueID and CalendarID!",
        );
        return;
    }

    my $Data;

    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    if ( $Param{AppointmentID} ) {

        # check cache
        $Data = $CacheObject->Get(
            Type => $Self->{CacheType},
            Key  => $Param{AppointmentID},
        );
    }

    if ( ref $Data eq 'HASH' ) {
        return %{$Data};
    }

    # needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my @Bind;

# RotherOSS / AppointmentToTicket
#     my $SQL = '
#         SELECT id, parent_id, calendar_id, unique_id, title, description, location, start_time,
#             end_time, all_day, team_id, resource_id, recurring, recur_type, recur_freq, recur_count,
#             recur_interval, recur_until, recur_id, recur_exclude, notify_time, notify_template,
#             notify_custom, notify_custom_unit_count, notify_custom_unit, notify_custom_unit_point,
#             notify_custom_date, ticket_appointment_rule_id, create_time, create_by, change_time,
#             change_by
#         FROM calendar_appointment
#        WHERE
#     ';
    my $SQL = '
        SELECT id, parent_id, calendar_id, unique_id, title, description, location, start_time,
            end_time, all_day, team_id, resource_id, recurring, recur_type, recur_freq, recur_count,
            recur_interval, recur_until, recur_id, recur_exclude, notify_time, notify_template,
            notify_custom, notify_custom_unit_count, notify_custom_unit, notify_custom_unit_point,
            notify_custom_date, ticket_appointment_rule_id, create_time, create_by, change_time,
            change_by, future_task_id
        FROM calendar_appointment
        WHERE
    ';
# EO AppointmentToTicket

    if ( $Param{AppointmentID} ) {
        $SQL .= 'id = ? ';
        push @Bind, \$Param{AppointmentID};
    }
    else {
        $SQL .= 'unique_id = ? AND calendar_id = ? AND parent_id IS NULL ';
        push @Bind, \$Param{UniqueID}, \$Param{CalendarID};
    }

    # db query
    return if !$DBObject->Prepare(
        SQL   => $SQL,
        Bind  => \@Bind,
        Limit => 1,
    );

    my %Result;

    while ( my @Row = $DBObject->FetchrowArray() ) {

        # team id
        my @TeamID = split( /,/, $Row[10] // '' );

        # resource id
        my @ResourceID = split( /,/, $Row[11] // '0' );

        # recurrence frequency
        my @RecurrenceFrequency = $Row[14] ? split( /,/, $Row[14] ) : undef;

        # recurrence exclude
        my @RecurrenceExclude = $Row[19] ? split( /,/, $Row[19] ) : undef;

        $Result{AppointmentID}                         = $Row[0];
        $Result{ParentID}                              = $Row[1];
        $Result{CalendarID}                            = $Row[2];
        $Result{UniqueID}                              = $Row[3];
        $Result{Title}                                 = $Row[4];
        $Result{Description}                           = $Row[5];
        $Result{Location}                              = $Row[6];
        $Result{StartTime}                             = $Row[7];
        $Result{EndTime}                               = $Row[8];
        $Result{AllDay}                                = $Row[9];
        $Result{TeamID}                                = \@TeamID;
        $Result{ResourceID}                            = \@ResourceID;
        $Result{Recurring}                             = $Row[12];
        $Result{RecurrenceType}                        = $Row[13];
        $Result{RecurrenceFrequency}                   = \@RecurrenceFrequency;
        $Result{RecurrenceCount}                       = $Row[15];
        $Result{RecurrenceInterval}                    = $Row[16];
        $Result{RecurrenceUntil}                       = $Row[17];
        $Result{RecurrenceID}                          = $Row[18];
        $Result{RecurrenceExclude}                     = \@RecurrenceExclude;
        $Result{NotificationDate}                      = $Row[20] || '';
        $Result{NotificationTemplate}                  = $Row[21] || '';
        $Result{NotificationCustom}                    = $Row[22] || '';
        $Result{NotificationCustomRelativeUnitCount}   = $Row[23] || 0;
        $Result{NotificationCustomRelativeUnit}        = $Row[24] || '';
        $Result{NotificationCustomRelativePointOfTime} = $Row[25] || '';
        $Result{NotificationCustomDateTime}            = $Row[26] || '';
        $Result{TicketAppointmentRuleID}               = $Row[27];
        $Result{CreateTime}                            = $Row[28];
        $Result{CreateBy}                              = $Row[29];
        $Result{ChangeTime}                            = $Row[30];
        $Result{ChangeBy}                              = $Row[31];
# RotherOSS / AppointmentToTicket
        $Result{FutureTaskID}                          = $Row[32];
# EO AppointmentToTicket
    }

    if ( $Param{AppointmentID} ) {

        # cache
        $CacheObject->Set(
            Type  => $Self->{CacheType},
            Key   => $Param{AppointmentID},
            Value => \%Result,
            TTL   => $Self->{CacheTTL},
        );
    }

    return %Result;
}

=head2 AppointmentUpdate()

updates an existing appointment.

    my $Success = $AppointmentObject->AppointmentUpdate(
        AppointmentID         => 2,                                       # (required)
        CalendarID            => 1,                                       # (required) Valid CalendarID
        Title                 => 'Webinar',                               # (required) Title
        Description           => 'How to use Process tickets...',         # (optional) Description
        Location              => 'Straubing',                             # (optional) Location
        StartTime             => '2016-01-01 16:00:00',                   # (required)
        EndTime               => '2016-01-01 17:00:00',                   # (required)
        AllDay                => 0,                                       # (optional) Default 0
        Team                  => 1,                                       # (optional)
        ResourceID            => [ 1, 3 ],                                # (optional) must be an array reference if supplied
        Recurring             => 1,                                       # (optional) flag the appointment as recurring (parent only!)

        RecurrenceType        => 'Daily',                                 # (required if Recurring) Possible "Daily", "Weekly", "Monthly", "Yearly",
                                                                          #           "CustomWeekly", "CustomMonthly", "CustomYearly"

        RecurrenceFrequency   => 1,                                       # (required if Custom Recurring) Recurrence pattern
                                                                          #           for CustomWeekly: 1-Mon, 2-Tue,..., 7-Sun
                                                                          #           for CustomMonthly: 1-Jan, 2-Feb,..., 12-Dec
                                                                          # ...
        RecurrenceCount       => 1,                                       # (optional) How many Appointments to create
        RecurrenceInterval    => 2,                                       # (optional) Repeating interval (default 1)
        RecurrenceUntil       => '2016-01-10 00:00:00',                   # (optional) Until date
        NotificationTime      => '2016-01-01 17:00:00',                   # (optional) Point of time to execute the notification event
        NotificationTemplate  => 'Custom',                                # (optional) Template to be used for notification point of time
        NotificationCustom    => 'relative',                              # (optional) Type of the custom template notification point of time
                                                                          #            Possible "relative", "datetime"
        NotificationCustomRelativeUnitCount   => '12',                    # (optional) minutes, hours or days count for custom template
        NotificationCustomRelativeUnit        => 'minutes',               # (optional) minutes, hours or days unit for custom template
        NotificationCustomRelativePointOfTime => 'beforestart',           # (optional) Point of execute for custom templates
                                                                          #            Possible "beforestart", "afterstart", "beforeend", "afterend"
        NotificationCustomDateTime => '2016-01-01 17:00:00',              # (optional) Notification date time for custom template
        TicketAppointmentRuleID    => '9bb20ea035e7a9930652a9d82d00c725', # (optional) Ticket appointment rule ID (for ticket appointments only!)
        UserID                     => 1,                                  # (required) UserID
# RotherOSS / AppointmentToTicket
        FutureTaskID => 1,                                                # (optional) ID of future task
        AppointmentTicket => {                                            # (optional) Data for ticket creation
            Time => '2016-01-10 00:00:00',                                # (optional) Point of time to execute the ticket creat event
            Template => 'Custom',                                         # (optional) Template to be used for ticket point of time
            Custom => 'relative',                                         # (optional) Type of the custom template ticket point of time
                                                                          #            Possible "relative", "datetime"
            CustomRelativeUnitCount => '12',                              # (optional) minutes, hours or days count for custom template
            CustomRelativeUnit => 'minutes',                              # (optional) minutes, hours or days unit for custom template
            CustomRelativePointOfTime => 'beforestart'  ,                 # (optional) Point of execute for custom templates
                                                                          #            Possible "beforestart", "afterstart", "beforeend", "afterend"
            CustomDateTime => '2016-01-01 17:00:00',                      # (optional) Ticket date time for custom template
            QueueID => 1,                                                 # (optional) Ticket queue
            CustomerID => 1,                                              # (optional) Ticket customer id
            CustomerUser => 'test@test.com',                              # (optional) Ticket customer user
            SelectedCustomerUser => 'test',                               # (optional) Selected customer user
            UserID => 1,                                                  # (optional) Ticket user id
            OwnerID => 1,                                                 # (optional) Ticket owner id
            Lock => 'unlock',                                             # (optional) Ticket lock state
            PriorityID => 3,                                              # (optional) Ticket priority
            StateID => 1,                                                 # (optional) Ticket state
            ServiceID => 1,                                               # (optional) Ticket service
            SLAID => 1,                                                   # (optional) Ticket service level agreement
            TypeID => 1,                                                  # (optional) Ticket type id
            DynamicFields => {                                            # (optional) Name value combinations for dynamic fields
                DynamicFieldName1 => Value1,
                DynamicFieldName2 => Value2,
            },
        },
# EO AppointmentToTicket
    );

returns 1 if successful:
    $Success = 1;

Events:
    AppointmentUpdate

=cut

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

    # check needed stuff
    for my $Needed (qw(AppointmentID CalendarID Title StartTime EndTime UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # prepare possible notification params
    my $Success = $Self->_AppointmentNotificationPrepare(
        Data => \%Param,
    );

    # if Recurring is provided, additional parameters must be present
    if ( $Param{Recurring} ) {

        my @RecurrenceTypes = (
            "Daily",       "Weekly",       "Monthly",       "Yearly",
            "CustomDaily", "CustomWeekly", "CustomMonthly", "CustomYearly"
        );

        if (
            !$Param{RecurrenceType}
            || !grep { $_ eq $Param{RecurrenceType} } @RecurrenceTypes
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "RecurrenceType invalid!",
            );
            return;
        }

        if (
            (
                $Param{RecurrenceType} eq 'CustomWeekly'
                || $Param{RecurrenceType} eq 'CustomMonthly'
                || $Param{RecurrenceType} eq 'CustomYearly'
            )
            && !$Param{RecurrenceFrequency}
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "RecurrenceFrequency needed!",
            );
            return;
        }
    }

    $Param{RecurrenceInterval} ||= 1;

    # Check StartTime.
    my $StartTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{StartTime},
        },
    );
    if ( !$StartTimeObject ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "StartTime invalid!",
        );
        return;
    }

    # Check EndTime.
    my $EndTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{EndTime},
        },
    );
    if ( !$EndTimeObject ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "EndTime invalid!",
        );
        return;
    }

    # needed objects
    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # check if array refs
    my %Arrays;
    for my $Parameter (
        qw(TeamID ResourceID RecurrenceFrequency)
        )
    {
        if ( $Param{$Parameter} && @{ $Param{$Parameter} // [] } ) {
            if ( !IsArrayRefWithData( $Param{$Parameter} ) ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "$Parameter not ARRAYREF!",
                );
                return;
            }

            my @Array = @{ $Param{$Parameter} };

            # remove undefined values
            @Array = grep { defined $_ } @Array;

            $Arrays{$Parameter} = join( ',', @Array ) if @Array;
        }
    }

    # check if numbers
    for my $Parameter (
        qw(Recurring RecurrenceCount RecurrenceInterval)
        )
    {
        if ( $Param{$Parameter} && !IsInteger( $Param{$Parameter} ) ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "$Parameter must be a number!",
            );
            return;
        }
    }

    # check RecurrenceUntil
    if ( $Param{RecurrenceUntil} ) {

        # Usually hour, minute and second = 0. In this case, take time from StartTime.
        $Param{RecurrenceUntil} = $Self->_TimeCheck(
            OriginalTime => $Param{StartTime},
            Time         => $Param{RecurrenceUntil},
        );

        my $RecurrenceUntilObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{RecurrenceUntil},
            },
        );

        if (
            !$RecurrenceUntilObject
            || $StartTimeObject > $RecurrenceUntilObject
            )
        {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "RecurrenceUntil invalid!",
            );
            return;
        }
    }

    # get previous CalendarID
    my $PreviousCalendarID = $Self->_AppointmentGetCalendarID(
        AppointmentID => $Param{AppointmentID},
    );

    # set recurrence exclude list
    my @RecurrenceExclude = @{ $Param{RecurrenceExclude} // [] };

    # get RecurrenceID
    my $RecurrenceID = $Self->_AppointmentGetRecurrenceID(
        AppointmentID => $Param{AppointmentID},
    );

    # use exclude list to flag the recurring occurrence as updated
    if ($RecurrenceID) {
        @RecurrenceExclude = ($RecurrenceID);
    }

    # reset exclude list if recurrence is turned off
    elsif ( !$Param{Recurring} ) {
        @RecurrenceExclude = ();
    }

    # remove undefined values
    @RecurrenceExclude = grep { defined $_ } @RecurrenceExclude;

    # serialize data
    my $RecurrenceExclude = join( ',', @RecurrenceExclude ) || undef;

    # delete existing recurred appointments
    my $DeleteSuccess = $Self->_AppointmentRecurringDelete(
        ParentID => $Param{AppointmentID},
    );

    if ( !$DeleteSuccess ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Unable to delete recurring Appointment!",
        );
        return;
    }

# RotherOSS / AppointmentToTicket
#     # update appointment
#     my $SQL = '
#         UPDATE calendar_appointment
#         SET
#             calendar_id=?, title=?, description=?, location=?, start_time=?, end_time=?, all_day=?,
#             team_id=?, resource_id=?, recurring=?, recur_type=?, recur_freq=?, recur_count=?,
#             recur_interval=?, recur_until=?, recur_exclude=?, notify_time=?, notify_template=?,
#             notify_custom=?, notify_custom_unit_count=?, notify_custom_unit=?,
#             notify_custom_unit_point=?, notify_custom_date=?, ticket_appointment_rule_id=?,
#             change_time=current_timestamp, change_by=?
#         WHERE id=?
#     ';

#     # update db record
#     return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
#         SQL  => $SQL,
#         Bind => [
#             \$Param{CalendarID},                            \$Param{Title},           \$Param{Description}, \$Param{Location},
#             \$Param{StartTime},                             \$Param{EndTime},         \$Param{AllDay},      \$Arrays{TeamID},
#             \$Arrays{ResourceID},                           \$Param{Recurring},       \$Param{RecurrenceType},
#             \$Arrays{RecurrenceFrequency},                  \$Param{RecurrenceCount}, \$Param{RecurrenceInterval},
#             \$Param{RecurrenceUntil},                       \$RecurrenceExclude,      \$Param{NotificationDate},
#             \$Param{NotificationTemplate},                  \$Param{NotificationCustom},
#             \$Param{NotificationCustomRelativeUnitCount},   \$Param{NotificationCustomRelativeUnit},
#             \$Param{NotificationCustomRelativePointOfTime}, \$Param{NotificationCustomDateTime},
#             \$Param{TicketAppointmentRuleID},               \$Param{UserID}, \$Param{AppointmentID},
#         ],
#     );
    my $SQL = '
        UPDATE calendar_appointment
        SET
            calendar_id = ?, title = ?, description = ?, location = ?, start_time = ?, end_time = ?, all_day = ?,
            team_id = ?, resource_id = ?, recurring = ?, recur_type = ?, recur_freq = ?, recur_count = ?,
            recur_interval = ?, recur_until = ?, recur_exclude = ?, notify_time = ?, notify_template = ?,
            notify_custom = ?, notify_custom_unit_count = ?, notify_custom_unit = ?,
            notify_custom_unit_point = ?, notify_custom_date = ?, ticket_appointment_rule_id = ?,
            change_time = current_timestamp, change_by = ?, future_task_id = ?
        WHERE id = ?
    ';

    # update db record
    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => $SQL,
        Bind => [
            \$Param{CalendarID},                            \$Param{Title},           \$Param{Description}, \$Param{Location},
            \$Param{StartTime},                             \$Param{EndTime},         \$Param{AllDay},      \$Arrays{TeamID},
            \$Arrays{ResourceID},                           \$Param{Recurring},       \$Param{RecurrenceType},
            \$Arrays{RecurrenceFrequency},                  \$Param{RecurrenceCount}, \$Param{RecurrenceInterval},
            \$Param{RecurrenceUntil},                       \$RecurrenceExclude,      \$Param{NotificationDate},
            \$Param{NotificationTemplate},                  \$Param{NotificationCustom},
            \$Param{NotificationCustomRelativeUnitCount},   \$Param{NotificationCustomRelativeUnit},
            \$Param{NotificationCustomRelativePointOfTime}, \$Param{NotificationCustomDateTime},
            \$Param{TicketAppointmentRuleID},               \$Param{UserID}, \$Param{FutureTaskID}, \$Param{AppointmentID},
        ],
    );
# EO AppointmentToTicket

    # add recurred appointments again
    if ( $Param{Recurring} ) {
        return if !$Self->_AppointmentRecurringCreate(
            ParentID    => $Param{AppointmentID},
            Appointment => \%Param,
        );
    }

# RotherOSS / AppointmentToTicket
    my $DBObject              = $Kernel::OM->Get('Kernel::System::DB');
    my $CurrentDateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');
    my $FutureTaskAppointmentID;

    # Set future task id to NULL and delete future task if no id provided, else update existing future task
    if ( !$Param{AppointmentTicket}->{Template} ) {

        for my $PossibleParam (
            qw(
                Date Template Custom CustomRelativeUnitCount
                CustomRelativeUnit CustomRelativePointOfTime CustomDateTime
            )
            )
        {
            $Param{AppointmentTicket}->{$PossibleParam} = undef;
        }
    }
    if ( $Param{FutureTaskID} && !$Param{AppointmentTicket}->{Template} ) {
        $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskDelete(
            TaskID => $Param{FutureTaskID}
        );
        $Param{FutureTaskID} = undef;
    }

    # FutureTask is to be (re)created
    elsif ( $Param{AppointmentTicket}->{Template} ) {

        # Collect data for creating or updating future task
        my %FutureTaskData = (
            Type => 'AppointmentTicket',
            Data => {
                AppointmentTicket => {
                    $Param{AppointmentTicket}->%*,
                },
            },
        );

        # Check for recurring and if execution time is in future
        if ( $Param{Recurring} ) {
            my @AppointmentList = $Self->AppointmentList(
                CalendarID => $PreviousCalendarID,
                ParentID   => $Param{AppointmentID}
            );
            my %ParentAppointment = $Self->AppointmentGet( AppointmentID => $Param{AppointmentID} );
            unshift @AppointmentList, \%ParentAppointment;

            APPOINTMENT:
            for my $Appointment (@AppointmentList) {
                my $AppointmentExecutionTime = $Self->AppointmentToTicketExecutionTime(
                    Data => {
                        TicketTime                      => $Param{AppointmentTicket}->{Time},
                        TicketTemplate                  => $Param{AppointmentTicket}->{Template},
                        TicketCustom                    => $Param{AppointmentTicket}->{Custom},
                        TicketCustomRelativeUnitCount   => $Param{AppointmentTicket}->{CustomRelativeUnitCount},
                        TicketCustomRelativeUnit        => $Param{AppointmentTicket}->{CustomRelativeUnit},
                        TicketCustomRelativePointOfTime => $Param{AppointmentTicket}->{CustomRelativePointOfTime},
                        TicketCustomDateTime            => $Param{AppointmentTicket}->{CustomDateTime},
                    },

                    # when the appointment was just updated in database, maybe the data is still incorrect here
                    StartTime => $Appointment->{AppointmentID} == $Param{AppointmentID} ? $Param{StartTime} : $Appointment->{StartTime},
                    EndTime   => $Appointment->{AppointmentID} == $Param{AppointmentID} ? $Param{EndTime}   : $Appointment->{EndTime},
                );
                my $AppointmentExecutionTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $AppointmentExecutionTime,
                    }
                );

                if ( $AppointmentExecutionTimeObject->Compare( DateTimeObject => $CurrentDateTimeObject ) > 0 ) {
                    $FutureTaskData{Data}->{AppointmentID} = $Appointment->{AppointmentID};
                    $FutureTaskData{ExecutionTime}         = $AppointmentExecutionTime;
                    last APPOINTMENT;
                }
            }
            $FutureTaskAppointmentID = $FutureTaskData{Data}->{AppointmentID};

        }
        else {
            # Single appointment, checking if its execution time is in the future
            my $AppointmentExecutionTime = $Self->AppointmentToTicketExecutionTime(
                Data => {
                    TicketTime                      => $Param{AppointmentTicket}->{Time},
                    TicketTemplate                  => $Param{AppointmentTicket}->{Template},
                    TicketCustom                    => $Param{AppointmentTicket}->{Custom},
                    TicketCustomRelativeUnitCount   => $Param{AppointmentTicket}->{CustomRelativeUnitCount},
                    TicketCustomRelativeUnit        => $Param{AppointmentTicket}->{CustomRelativeUnit},
                    TicketCustomRelativePointOfTime => $Param{AppointmentTicket}->{CustomRelativePointOfTime},
                    TicketCustomDateTime            => $Param{AppointmentTicket}->{CustomDateTime},
                },
                StartTime => $Param{StartTime},
                EndTime   => $Param{EndTime},
            );
            my $AppointmentExecutionTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $AppointmentExecutionTime,
                },
            );
            if ( $AppointmentExecutionTimeObject->Compare( DateTimeObject => $CurrentDateTimeObject ) ) {
                $FutureTaskData{Data}->{AppointmentID} = $Param{AppointmentID};
                $FutureTaskAppointmentID               = $FutureTaskData{Data}->{AppointmentID};
                $FutureTaskData{ExecutionTime}         = $AppointmentExecutionTimeObject->ToString();
            }
        }
        if ( $Param{FutureTaskID} ) {
            $FutureTaskData{TaskID} = $Param{FutureTaskID};

            # If there is an appointment with execution time in the future, update future task
            if ( $FutureTaskData{Data}->{AppointmentID} ) {
                my $Success = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskUpdate(%FutureTaskData);
                if ( !$Success ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Future task $FutureTaskData{TaskID} of type appointment ticket for appointment $FutureTaskData{Data}->{AppointmentID} could not be updated!",
                    );
                }
            }
            else {
                # Delete existing future task since updated execution time is not in the future
                $Param{FutureTaskID} = undef;
                $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskDelete(
                    TaskID => $FutureTaskData{TaskID},
                );
            }
        }

        # No future task id present, create future task if execution time is in the future
        else {
            if ( $FutureTaskData{Data}->{AppointmentID} ) {
                $Param{FutureTaskID} = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskAdd(%FutureTaskData);
            }
        }
    }

    # delete future task ids from all related appointments and update it where it belongs afterwards
    my $DeleteFutureTaskIDSQL = "
        UPDATE calendar_appointment
        SET future_task_id = NULL
        WHERE id = ?
        OR parent_id = ?
    ";
    my @Bind = ( \$Param{AppointmentID}, \$Param{AppointmentID} );

    # update db record
    return if !$DBObject->Do(
        SQL  => $DeleteFutureTaskIDSQL,
        Bind => \@Bind,
    );

    if ($FutureTaskAppointmentID) {
        my $UpdateFutureTaskIDSQL = "
            UPDATE calendar_appointment
            SET future_task_id = ?
            WHERE id = ?
        ";
        my @Bind = ( \$Param{FutureTaskID}, \$FutureTaskAppointmentID );

        # update db record
        return if !$DBObject->Do(
            SQL  => $UpdateFutureTaskIDSQL,
            Bind => \@Bind,
        );
    }

# EO AppointmentToTicket

    # delete cache
    $CacheObject->Delete(
        Type => $Self->{CacheType},
        Key  => $Param{AppointmentID},
    );

    # clean up list methods cache
    my @CalendarIDs = ( $Param{CalendarID} );
    push @CalendarIDs, $PreviousCalendarID if $PreviousCalendarID ne $Param{CalendarID};
    for my $CalendarID (@CalendarIDs) {
        $CacheObject->CleanUp(
            Type => $Self->{CacheType} . 'List' . $CalendarID,
        );
    }
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'Days' . $Param{UserID},
    );

    # fire event
    $Self->EventHandler(
        Event => 'AppointmentUpdate',
        Data  => {
            AppointmentID => $Param{AppointmentID},
            CalendarID    => $Param{CalendarID},
        },
        UserID => $Param{UserID},
    );

    return 1;
}

=head2 AppointmentDelete()

deletes an existing appointment.

    my $Success = $AppointmentObject->AppointmentDelete(
        AppointmentID   => 1,                              # (required)
        UserID          => 1,                              # (required)
    );

returns 1 if successful:
    $Success = 1;

Events:
    AppointmentDelete

=cut

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

    # check needed stuff
    for my $Needed (qw(AppointmentID UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # needed objects
    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # get CalendarID
    my $CalendarID = $Self->_AppointmentGetCalendarID(
        AppointmentID => $Param{AppointmentID},
    );

    # check user's permissions for this calendar
    my $Permission = $Kernel::OM->Get('Kernel::System::Calendar')->CalendarPermissionGet(
        CalendarID => $CalendarID,
        UserID     => $Param{UserID},
    );

    my @RequiredPermissions = ( 'create', 'rw' );

    if ( !grep { $Permission eq $_ } @RequiredPermissions ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "User($Param{UserID}) has no permission to delete Appointment($Param{AppointmentID})!",
        );
        return;
    }

    my %Appointment = $Self->AppointmentGet(
        AppointmentID => $Param{AppointmentID},
    );

    # save exclusion info to parent appointment
    if ( $Appointment{ParentID} && $Appointment{RecurrenceID} ) {
        $Self->_AppointmentRecurringExclude(
            ParentID     => $Appointment{ParentID},
            RecurrenceID => $Appointment{RecurrenceID},
        );
    }

    # delete recurring appointments
    my $DeleteRecurringSuccess = $Self->_AppointmentRecurringDelete(
        ParentID => $Param{AppointmentID},
    );

    if ( !$DeleteRecurringSuccess ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Recurring appointments couldn\'t be deleted!',
        );
        return;
    }

# RotherOSS / AppointmentToTicket
    # delete future task if present
    # TODO Handle deletion of a recurring child event and shift future task
    if ( $Appointment{FutureTaskID} ) {
        my $Success = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskDelete(
            TaskID => $Appointment{FutureTaskID},
        );
        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Future task AppointmentTicket couln\'t be deleted!',
            );
        }
    }

# EO AppointmentToTicket

    # delete appointment
    my $SQL = '
        DELETE FROM calendar_appointment
        WHERE id = ?
    ';

    # delete db record
    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => $SQL,
        Bind => [
            \$Param{AppointmentID},
        ],
    );

    # Fire event.
    $Self->EventHandler(
        Event => 'AppointmentDelete',
        Data  => {
            AppointmentID => $Param{AppointmentID},
            CalendarID    => $CalendarID,
        },
        UserID => $Param{UserID},
    );

    # delete cache
    $CacheObject->Delete(
        Type => $Self->{CacheType},
        Key  => $Param{AppointmentID},
    );

    # clean up list methods cache
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'List' . $CalendarID,
    );
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'Days' . $Param{UserID},
    );

    return 1;
}

=head2 AppointmentDeleteOccurrence()

deletes a single recurring appointment occurrence.

    my $Success = $AppointmentObject->AppointmentDeleteOccurrence(
        UniqueID     => '20160101T160000-71E386@localhost',    # (required)
        RecurrenceID => '2016-01-10 00:00:00',                 # (required)
        UserID       => 1,                                     # (required)
    );

returns 1 if successful:
    $Success = 1;

=cut

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

    # check needed stuff
    for my $Needed (qw(UniqueID CalendarID RecurrenceID UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # get db object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # db query
    return if !$DBObject->Prepare(
        SQL => '
            SELECT id FROM calendar_appointment
            WHERE unique_id = ? AND calendar_id = ? AND recur_id = ?',
        Bind  => [ \$Param{UniqueID}, \$Param{CalendarID}, \$Param{RecurrenceID} ],
        Limit => 1,
    );

    my %Appointment;

    # get additional info
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Appointment{AppointmentID} = $Row[0];
    }
    return if !%Appointment;

    # delete db record
    return if !$DBObject->Do(
        SQL   => 'DELETE FROM calendar_appointment WHERE id = ?',
        Bind  => [ \$Appointment{AppointmentID} ],
        Limit => 1,
    );

    # get cache object
    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # delete cache
    $CacheObject->Delete(
        Type => $Self->{CacheType},
        Key  => $Appointment{AppointmentID},
    );

    # clean up list methods cache
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'List' . $Param{CalendarID},
    );
    $CacheObject->CleanUp(
        Type => $Self->{CacheType} . 'Days' . $Param{UserID},
    );

    return 1;
}

=head2 GetUniqueID()

Returns UniqueID containing appointment start time, random hash and system C<FQDN>.

    my $UniqueID = $AppointmentObject->GetUniqueID(
        CalendarID => 1,                        # (required)
        StartTime  => '2016-01-01 00:00:00',    # (required)
        UserID     => 1,                        # (required)
    );

    $UniqueID = '20160101T000000-B9909D@localhost';

=cut

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

    # check needed stuff
    for my $Needed (qw(CalendarID StartTime UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # calculate a hash
    my $RandomString = $Kernel::OM->Get('Kernel::System::Main')->GenerateRandomString( Length => 32 );
    my $String       = "$Param{CalendarID}-$RandomString-$Param{UserID}";
    my $Digest       = unpack( 'N', Digest::MD5->new()->add($String)->digest() );
    my $DigestHex    = sprintf( '%x', $Digest );
    my $Hash         = uc( sprintf( "%.6s", $DigestHex ) );

    # Prepare start timestamp for UniqueID.
    my $StartTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{StartTime},
        },
    );
    return if !$StartTimeObject;
    my $StartTimeStrg = $StartTimeObject->ToString();
    $StartTimeStrg =~ s/[-:]//g;
    $StartTimeStrg =~ s/\s/T/;

    # get system FQDN
    my $FQDN = $Kernel::OM->Get('Kernel::Config')->Get('FQDN');

    # return UniqueID
    return "$StartTimeStrg-$Hash\@$FQDN";
}

=head2 AppointmentUpcomingGet()

Get appointment data for upcoming appointment start or end.

    my @UpcomingAppointments = $AppointmentObject->AppointmentUpcomingGet(
        Timestamp => '2016-08-02 03:59:00', # get appointments for the related notification timestamp
    );

Returns appointment data of AppointmentGet().

=cut

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

    # get current timestamp
    my $CurrentTimestamp;

    # create needed sql query based on the current or a given timestamp
    my $SQL = 'SELECT id, parent_id, calendar_id, unique_id FROM calendar_appointment ';

    if ( $Param{Timestamp} ) {
        $CurrentTimestamp = $Param{Timestamp};
        $SQL .= "WHERE notify_time = ? ";
    }
    else {
        $CurrentTimestamp = $Kernel::OM->Create('Kernel::System::DateTime')->ToString();
        $SQL .= "WHERE notify_time >= ? ";
    }

    $SQL .= 'ORDER BY notify_time ASC';

    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # db query
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => [ \$CurrentTimestamp ],
    );

    my @ResultRaw;

    while ( my @Row = $DBObject->FetchrowArray() ) {

        my %UpcomingAppointment;

        $UpcomingAppointment{AppointmentID} = $Row[0];
        $UpcomingAppointment{ParentID}      = $Row[1];
        $UpcomingAppointment{CalendarID}    = $Row[2];
        $UpcomingAppointment{UniqueID}      = $Row[3];

        push @ResultRaw, \%UpcomingAppointment;
    }

    my @Results;

    APPOINTMENTDATA:
    for my $AppointmentData (@ResultRaw) {

        next APPOINTMENTDATA if !IsHashRefWithData($AppointmentData);
        next APPOINTMENTDATA if !$AppointmentData->{CalendarID};
        next APPOINTMENTDATA if !$AppointmentData->{AppointmentID};

        my %Appointment = $Self->AppointmentGet( %{$AppointmentData} );

        push @Results, \%Appointment;
    }

    return @Results;
}

=head2 AppointmentFutureTasksDelete()

Delete all calendar appointment future tasks.

    my $Success = $AppointmentObject->AppointmentFutureTasksDelete();

returns:

    True if future task deletion was successful, otherwise false.

=cut

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

    # get a local scheduler db object
    my $SchedulerObject = $Kernel::OM->Get('Kernel::System::Scheduler');

    # get a list of already stored future tasks
    my @FutureTaskList = $SchedulerObject->FutureTaskList(
        Type => 'CalendarAppointment',
    );

    # flush obsolete future tasks
    if ( IsArrayRefWithData( \@FutureTaskList ) ) {

        FUTURETASK:
        for my $FutureTask (@FutureTaskList) {

            next FUTURETASK if !$FutureTask;
            next FUTURETASK if !IsHashRefWithData($FutureTask);

            my $Success = $SchedulerObject->FutureTaskDelete(
                TaskID => $FutureTask->{TaskID},
            );

            if ( !$Success ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Could not delete future task with id $FutureTask->{TaskID}!",
                );
                return;
            }
        }
    }

    return 1;
}

=head2 AppointmentFutureTasksUpdate()

Update OTOBO daemon future task list for upcoming appointments.

    my $Success = $AppointmentObject->AppointmentFutureTasksUpdate();

returns:

    True if future task update was successful, otherwise false.

=cut

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

    # get appointment data for upcoming appointments
    my @UpcomingAppointments = $Self->AppointmentUpcomingGet();

    # check for no upcoming appointments
    if ( !IsArrayRefWithData( \@UpcomingAppointments ) ) {

        # flush obsolete future tasks
        my $Success = $Self->AppointmentFutureTasksDelete();

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Could not delete appointment future tasks!',
            );
            return;
        }

        return 1;
    }

    # get a local scheduler db object
    my $SchedulerObject = $Kernel::OM->Get('Kernel::System::Scheduler');

    # get a list of already stored future tasks
    my @FutureTaskList = $SchedulerObject->FutureTaskList(
        Type => 'CalendarAppointment',
    );

    # check for invalid task count (just one task max allowed)
    if ( scalar @FutureTaskList > 1 ) {

        # flush obsolete future tasks
        my $Success = $Self->AppointmentFutureTasksDelete();

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Could not delete appointment future tasks!',
            );
            return;
        }
    }

    # check if it is needed to update the future task list
    if ( IsArrayRefWithData( \@FutureTaskList ) ) {
        my $UpdateNeeded = 0;

        FUTURETASK:
        for my $FutureTask (@FutureTaskList) {

            if (
                !IsHashRefWithData($FutureTask)
                || !$FutureTask->{TaskID}
                || !$FutureTask->{ExecutionTime}
                )
            {
                $UpdateNeeded = 1;
                last FUTURETASK;
            }

            # get the stored future task
            my %FutureTaskData = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskGet(
                TaskID => $FutureTask->{TaskID},
            );

            if ( !IsHashRefWithData( \%FutureTaskData ) ) {
                $UpdateNeeded = 1;
                last FUTURETASK;
            }

            # Get date time objects of stored and upcoming times to compare.
            my $FutureTaskTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $FutureTaskData{Data}->{NotifyTime},
                },
            );
            my $UpcomingAppointmentTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $UpcomingAppointments[0]->{NotificationDate},
                },
            );

            # Do nothing if the upcoming notification time equals the stored value.
            if ( $UpcomingAppointmentTimeObject != $FutureTaskTimeObject ) {
                $UpdateNeeded = 1;
                last FUTURETASK;
            }
        }

        if ($UpdateNeeded) {

            # flush obsolete future tasks
            my $Success = $Self->AppointmentFutureTasksDelete();

            if ( !$Success ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => 'Could not delete appointment future tasks!',
                );
                return;
            }
        }
        else {
            return 1;
        }
    }

    # schedule new future tasks for notification actions
    my $TaskID = $SchedulerObject->TaskAdd(
        ExecutionTime => $UpcomingAppointments[0]->{NotificationDate},
        Name          => 'AppointmentNotification',
        Type          => 'CalendarAppointment',
        Data          => {
            NotifyTime => $UpcomingAppointments[0]->{NotificationDate},
        },
    );

    if ( !$TaskID ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  =>
                "Could not schedule future task for AppointmentID $UpcomingAppointments[0]->{AppointmentID}!",
        );
        return;
    }

    return 1;
}

=head2 _AppointmentNotificationPrepare()

Prepare appointment notification data.

    my $Success = $AppointmentObject->_AppointmentNotificationPrepare();

returns:

    True if preparation was successful, otherwise false.

=cut

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

    # check needed stuff
    for my $Needed (qw(Data)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # reset notification data if needed
    if ( !$Param{Data}->{NotificationTemplate} ) {

        for my $PossibleParam (
            qw(
                NotificationDate NotificationTemplate NotificationCustom NotificationCustomRelativeUnitCount
                NotificationCustomRelativeUnit NotificationCustomRelativePointOfTime NotificationCustomDateTime
            )
            )
        {
            $Param{Data}->{$PossibleParam} = undef;
        }
    }

    # prepare possible notification params
    for my $PossibleParam (
        qw(
            NotificationTemplate NotificationCustom NotificationCustomRelativeUnit
            NotificationCustomRelativePointOfTime
        )
        )
    {
        $Param{Data}->{$PossibleParam} ||= '';
    }

    # special check for relative unit count as it can be zero
    # (empty and negative values will be treated as zero to avoid errors)
    if (
        !IsNumber( $Param{Data}->{NotificationCustomRelativeUnitCount} )
        || $Param{Data}->{NotificationCustomRelativeUnitCount} <= 0
        )
    {
        $Param{Data}->{NotificationCustomRelativeUnitCount} = 0;
    }

    # set empty datetime strings to undef
    for my $PossibleParam (qw(NotificationDate NotificationCustomDateTime)) {
        $Param{Data}->{$PossibleParam} ||= undef;
    }

    return if !$Param{Data}->{NotificationTemplate};

    #
    # template Start
    #
    if ( $Param{Data}->{NotificationTemplate} eq 'Start' ) {

        # setup the appointment start date as notification date
        $Param{Data}->{NotificationDate} = $Param{Data}->{StartTime};
    }

    #
    # template time before start
    #
    elsif (
        $Param{Data}->{NotificationTemplate} ne 'Custom'
        && IsNumber( $Param{Data}->{NotificationTemplate} )
        && $Param{Data}->{NotificationTemplate} > 0
        )
    {

        return if !IsNumber( $Param{Data}->{NotificationTemplate} );

        # offset template (before start datetime) used
        my $Offset = $Param{Data}->{NotificationTemplate};

        # Get date time object of appointment start time.
        my $StartTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{Data}->{StartTime},
            },
        );

        # Subtract offset in seconds for new notification date time.
        $StartTimeObject->Subtract(
            Seconds => $Offset,
        );

        $Param{Data}->{NotificationDate} = $StartTimeObject->ToString();
    }

    #
    # template Custom
    #
    else {

        # Compute date of custom relative input.
        if ( $Param{Data}->{NotificationCustom} eq 'relative' ) {

            my $CustomUnitCount = $Param{Data}->{NotificationCustomRelativeUnitCount};
            my $CustomUnit      = $Param{Data}->{NotificationCustomRelativeUnit};
            my $CustomUnitPoint = $Param{Data}->{NotificationCustomRelativePointOfTime};

            # setup the count to compute for the offset
            my %UnitOffsetCompute = (
                minutes => 60,
                hours   => 3600,
                days    => 86400,
            );

            my $NotificationLocalTimeObject;

            # Compute from start time.
            if ( $CustomUnitPoint eq 'beforestart' || $CustomUnitPoint eq 'afterstart' ) {
                $NotificationLocalTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Param{Data}->{StartTime},
                    },
                );
            }

            # Compute from end time.
            elsif ( $CustomUnitPoint eq 'beforeend' || $CustomUnitPoint eq 'afterend' ) {
                $NotificationLocalTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Param{Data}->{EndTime},
                    },
                );
            }

            # Not supported point of time.
            else {
                return;
            }

            # compute the offset to be used
            my $Offset = ( $CustomUnitCount * $UnitOffsetCompute{$CustomUnit} );

            # save the newly computed notification datetime string
            if ( $CustomUnitPoint eq 'beforestart' || $CustomUnitPoint eq 'beforeend' ) {
                $NotificationLocalTimeObject->Subtract(
                    Seconds => $Offset,
                );
                $Param{Data}->{NotificationDate} = $NotificationLocalTimeObject->ToString();
            }
            else {
                $NotificationLocalTimeObject->Add(
                    Seconds => $Offset,
                );
                $Param{Data}->{NotificationDate} = $NotificationLocalTimeObject->ToString();
            }
        }

        # Compute date of custom date/time input.
        elsif ( $Param{Data}->{NotificationCustom} eq 'datetime' ) {

            $Param{Data}->{NotificationCustom} = 'datetime';

            # validation
            if ( !IsStringWithData( $Param{Data}->{NotificationCustomDateTime} ) ) {
                return;
            }

            # save the given date time values as notification datetime string (i.e. 2016-06-28 02:00:00)
            $Param{Data}->{NotificationDate} = $Param{Data}->{NotificationCustomDateTime};
        }
    }

    if ( !IsStringWithData( $Param{Data}->{NotificationDate} ) ) {
        $Param{Data}->{NotificationDate} = undef;
    }

    if ( !IsStringWithData( $Param{Data}->{NotificationCustomDateTime} ) ) {
        $Param{Data}->{NotificationCustomDateTime} = undef;
    }

    return 1;
}

# RotherOSS / AppointmentToTicket
=head2 AppointmentToTicketExecutionTime()

computes execution time for future tasks of type AppointmentToTicket based on start time and offset params

=cut

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

    # check needed stuff
    for my $Needed (qw(Data StartTime EndTime)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # reset ticket data if needed
    if ( !$Param{Data}->{TicketTemplate} ) {

        for my $PossibleParam (
            qw(
                TicketDate TicketTemplate TicketCustom TicketCustomRelativeUnitCount
                TicketCustomRelativeUnit TicketCustomRelativePointOfTime TicketCustomDateTime
            )
            )
        {
            $Param{Data}->{$PossibleParam} = undef;
        }
    }

    # compute execution time for task
    # prepare possible ticket params
    for my $PossibleParam (
        qw(
            TicketTemplate TicketCustom TicketCustomRelativeUnit
            TicketCustomRelativePointOfTime
        )
        )
    {
        $Param{Data}->{$PossibleParam} ||= '';
    }

    # special check for relative unit count as it can be zero
    # (empty and negative values will be treated as zero to avoid errors)
    if (
        !IsNumber( $Param{Data}->{TicketCustomRelativeUnitCount} )
        || $Param{Data}->{TicketCustomRelativeUnitCount} <= 0
        )
    {
        $Param{Data}->{TicketCustomRelativeUnitCount} = 0;
    }

    # set empty datetime strings to undef
    for my $PossibleParam (qw(TicketDate TicketCustomDateTime)) {
        $Param{Data}->{$PossibleParam} ||= undef;
    }

    return if !$Param{Data}->{TicketTemplate};

    #
    # template Start
    #
    if ( $Param{Data}->{TicketTemplate} eq 'Start' ) {

        # setup the appointment start date as ticket date
        $Param{Data}->{TicketDate} = $Param{StartTime};
    }

    #
    # template time before start
    #
    elsif (
        $Param{Data}->{TicketTemplate} ne 'Custom'
        && IsNumber( $Param{Data}->{TicketTemplate} )
        && $Param{Data}->{TicketTemplate} > 0
        )
    {

        return if !IsNumber( $Param{Data}->{TicketTemplate} );

        # offset template (before start datetime) used
        my $Offset = $Param{Data}->{TicketTemplate};

        # Get date time object of appointment start time.
        my $StartTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{StartTime},
            },
        );

        # Subtract offset in seconds for new notification date time.
        $StartTimeObject->Subtract(
            Seconds => $Offset,
        );

        $Param{Data}->{TicketDate} = $StartTimeObject->ToString();
    }

    #
    # template Custom
    #
    else {

        # Compute date of custom relative input.
        if ( $Param{Data}->{TicketCustom} eq 'relative' ) {

            my $CustomUnitCount = $Param{Data}->{TicketCustomRelativeUnitCount};
            my $CustomUnit      = $Param{Data}->{TicketCustomRelativeUnit};
            my $CustomUnitPoint = $Param{Data}->{TicketCustomRelativePointOfTime};

            # setup the count to compute for the offset
            my %UnitOffsetCompute = (
                minutes => 60,
                hours   => 3600,
                days    => 86400,
            );

            my $TicketLocalTimeObject;

            # Compute from start time.
            if ( $CustomUnitPoint eq 'beforestart' || $CustomUnitPoint eq 'afterstart' ) {
                $TicketLocalTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Param{StartTime},
                    },
                );
            }

            # Compute from end time.
            elsif ( $CustomUnitPoint eq 'beforeend' || $CustomUnitPoint eq 'afterend' ) {
                $TicketLocalTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Param{EndTime},
                    },
                );
            }

            # Not supported point of time.
            else {
                return;
            }

            # compute the offset to be used
            my $Offset = ( $CustomUnitCount * $UnitOffsetCompute{$CustomUnit} );

            # save the newly computed ticket datetime string
            if ( $CustomUnitPoint eq 'beforestart' || $CustomUnitPoint eq 'beforeend' ) {
                $TicketLocalTimeObject->Subtract(
                    Seconds => $Offset,
                );
                $Param{Data}->{TicketDate} = $TicketLocalTimeObject->ToString();
            }
            else {
                $TicketLocalTimeObject->Add(
                    Seconds => $Offset,
                );
                $Param{Data}->{TicketDate} = $TicketLocalTimeObject->ToString();
            }
        }

        # Compute date of custom date/time input.
        elsif ( $Param{Data}->{TicketCustom} eq 'datetime' ) {

            $Param{Data}->{TicketCustom} = 'datetime';

            # validation
            if ( !IsStringWithData( $Param{Data}->{TicketCustomDateTime} ) ) {
                return;
            }

            # save the given date time values as ticket datetime string (i.e. 2016-06-28 02:00:00)
            $Param{Data}->{TicketDate} = $Param{Data}->{TicketCustomDateTime};
        }
    }

    if ( !IsStringWithData( $Param{Data}->{TicketDate} ) ) {
        $Param{Data}->{TicketDate} = undef;
    }

    if ( !IsStringWithData( $Param{Data}->{TicketCustomDateTime} ) ) {
        $Param{Data}->{TicketCustomDateTime} = undef;
    }
    return $Param{Data}->{TicketDate};

}

# EO AppointmentToTicket

=head2 AppointmentNotification()

Will be triggered by the OTOBO daemon to fire events for appointments,
that reaches it's reminder (notification) time.

    my $Success = $AppointmentObject->AppointmentNotification();

returns:

    True if notify action was successful, otherwise false.

=cut

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

    # check needed stuff
    for my $Needed (qw(NotifyTime)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # get appointments for the related notification timestamp
    my @UpcomingAppointments = $Self->AppointmentUpcomingGet(
        Timestamp => $Param{NotifyTime},
    );

    return if !IsArrayRefWithData( \@UpcomingAppointments );

    # sleep at least 1 second to make sure the timestamp doesn't
    # equals the last one for update upcoming future tasks
    sleep 1;

    UPCOMINGAPPOINTMENT:
    for my $UpcomingAppointment (@UpcomingAppointments) {

        next UPCOMINGAPPOINTMENT if !$UpcomingAppointment;
        next UPCOMINGAPPOINTMENT if !IsHashRefWithData($UpcomingAppointment);
        next UPCOMINGAPPOINTMENT if !$UpcomingAppointment->{AppointmentID};

        # fire event
        $Self->EventHandler(
            Event => 'AppointmentNotification',
            Data  => {
                AppointmentID => $UpcomingAppointment->{AppointmentID},
                CalendarID    => $UpcomingAppointment->{CaledarID},
            },
            UserID => 1,
        );
    }

    return 1;
}

=begin Internal:

=cut

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

    # check needed stuff
    for my $Needed (qw(ParentID Appointment)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    my $StartTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{Appointment}->{StartTime},
        },
    );
    my $EndTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{Appointment}->{EndTime},
        },
    );

    my @RecurrenceExclude = @{ $Param{Appointment}->{RecurrenceExclude} // [] };

    # remove undefined values
    @RecurrenceExclude = grep { defined $_ } @RecurrenceExclude;

    # reset the parameter for occurrences
    $Param{Appointment}->{RecurrenceExclude} = undef;

    my $OriginalStartTimeObject = $StartTimeObject->Clone();
    my $OriginalEndTimeObject   = $EndTimeObject->Clone();
    my $Step                    = 0;

    # until ...
    if ( $Param{Appointment}->{RecurrenceUntil} ) {
        my $RecurrenceUntilObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Param{Appointment}->{RecurrenceUntil},
            },
        );

        UNTIL_TIME:
        while ( $StartTimeObject <= $RecurrenceUntilObject ) {
            $Step += $Param{Appointment}->{RecurrenceInterval};

            # calculate recurring times
            $StartTimeObject = $Self->_CalculateRecurrenceTime(
                Appointment  => $Param{Appointment},
                Step         => $Step,
                OriginalTime => $OriginalStartTimeObject,
                CurrentTime  => $StartTimeObject,
            );

            last UNTIL_TIME if !$StartTimeObject;
            last UNTIL_TIME if $StartTimeObject > $RecurrenceUntilObject;

            $EndTimeObject = $StartTimeObject->Clone();
            $EndTimeObject->Add(
                Seconds =>
                    $OriginalEndTimeObject->Delta( DateTimeObject => $OriginalStartTimeObject )->{AbsoluteSeconds},
            );

            my $StartTime = $StartTimeObject->ToString();
            my $EndTime   = $EndTimeObject->ToString();

            # Bugfix: on some systems with older perl version system might calculate timezone difference.
            $StartTime = $Self->_TimeCheck(
                OriginalTime => $Param{Appointment}->{StartTime},
                Time         => $StartTime,
            );
            $EndTime = $Self->_TimeCheck(
                OriginalTime => $Param{Appointment}->{EndTime},
                Time         => $EndTime,
            );

            # skip excluded appointments
            next UNTIL_TIME if grep { $StartTime eq $_ } @RecurrenceExclude;

            # the AppointmentCreate event will be triggered
            $Self->AppointmentCreate(
                %{ $Param{Appointment} },
                ParentID     => $Param{ParentID},
                StartTime    => $StartTime,
                EndTime      => $EndTime,
                RecurrenceID => $StartTime,
            );
        }
    }

    # for ... time(s)
    elsif ( $Param{Appointment}->{RecurrenceCount} ) {

        COUNT:
        for ( 1 .. $Param{Appointment}->{RecurrenceCount} - 1 ) {
            $Step += $Param{Appointment}->{RecurrenceInterval};

            # calculate recurring times
            $StartTimeObject = $Self->_CalculateRecurrenceTime(
                Appointment  => $Param{Appointment},
                Step         => $Step,
                OriginalTime => $OriginalStartTimeObject,
                CurrentTime  => $StartTimeObject,
            );

            last COUNT if !$StartTimeObject;

            $EndTimeObject = $StartTimeObject->Clone();
            $EndTimeObject->Add(
                Seconds =>
                    $OriginalEndTimeObject->Delta( DateTimeObject => $OriginalStartTimeObject )->{AbsoluteSeconds},
            );

            my $StartTime = $StartTimeObject->ToString();
            my $EndTime   = $EndTimeObject->ToString();

            # Bugfix: on some systems with older perl version system might calculate timezone difference.
            $StartTime = $Self->_TimeCheck(
                OriginalTime => $Param{Appointment}->{StartTime},
                Time         => $StartTime,
            );
            $EndTime = $Self->_TimeCheck(
                OriginalTime => $Param{Appointment}->{EndTime},
                Time         => $EndTime,
            );

            # skip excluded appointments
            next COUNT if grep { $StartTime eq $_ } @RecurrenceExclude;

            $Self->AppointmentCreate(
                %{ $Param{Appointment} },
                ParentID     => $Param{ParentID},
                StartTime    => $StartTime,
                EndTime      => $EndTime,
                RecurrenceID => $StartTime,
            );
        }
    }

    return 1;
}

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

    # check needed stuff
    for my $Needed (qw(ParentID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

# RotherOSS / AppointmentToTicket
    my %ParentAppointment = $Self->AppointmentGet( AppointmentID => $Param{ParentID} );
    my @AppointmentList   = $Self->AppointmentList(
        CalendarID => $ParentAppointment{CalendarID},
        ParentID   => $Param{ParentID},
    );

    # delete future task if present
    for my $Appointment (@AppointmentList) {
        if ( $Appointment->{FutureTaskID} ) {
            my $Success = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB')->FutureTaskDelete(
                TaskID => $Appointment->{FutureTaskID},
            );
            if ( !$Success ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => 'Future task AppointmentTicket couln\'t be deleted!',
                );
            }
        }
    }

# EO AppointmentToTicket

    # delete recurring appointments
    my $SQL = '
        DELETE FROM calendar_appointment
        WHERE parent_id = ?
    ';

    # delete db record
    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => $SQL,
        Bind => [
            \$Param{ParentID},
        ],
    );

    return 1;
}

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

    # check needed stuff
    for my $Needed (qw(ParentID RecurrenceID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');
    my $DBObject    = $Kernel::OM->Get('Kernel::System::DB');

    # db query
    return if !$DBObject->Prepare(
        SQL  => 'SELECT recur_exclude FROM calendar_appointment WHERE id = ?',
        Bind => [ \$Param{ParentID} ],
    );

    # get existing exclusions
    my @RecurrenceExclude;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        @RecurrenceExclude = split( /,/, $Row[0] ) if $Row[0];
    }
    push @RecurrenceExclude, $Param{RecurrenceID};
    @RecurrenceExclude = sort @RecurrenceExclude;

    # join into string
    my $RecurrenceExclude;
    if (@RecurrenceExclude) {
        $RecurrenceExclude = join( ',', @RecurrenceExclude );
    }

    # update db record
    return if !$DBObject->Do(
        SQL  => 'UPDATE calendar_appointment SET recur_exclude = ? WHERE id = ?',
        Bind => [ \$RecurrenceExclude, \$Param{ParentID} ],
    );

    # delete cache
    $CacheObject->Delete(
        Type => $Self->{CacheType},
        Key  => $Param{ParentID},
    );

    return 1;
}

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

    # check needed stuff
    for my $Needed (qw(AppointmentID)) {
        if ( !defined $Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # sql query
    my $SQL  = 'SELECT calendar_id FROM calendar_appointment WHERE id = ?';
    my @Bind = ( \$Param{AppointmentID} );

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # start query
    return if !$DBObject->Prepare(
        SQL   => $SQL,
        Bind  => \@Bind,
        Limit => 1,
    );

    my $CalendarID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $CalendarID = $Row[0];
    }

    return $CalendarID;
}

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

    # check needed stuff
    for my $Needed (qw(AppointmentID)) {
        if ( !defined $Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    # sql query
    my $SQL  = 'SELECT recur_id FROM calendar_appointment WHERE id = ?';
    my @Bind = ( \$Param{AppointmentID} );

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # start query
    return if !$DBObject->Prepare(
        SQL   => $SQL,
        Bind  => \@Bind,
        Limit => 1,
    );

    my $RecurrenceID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $RecurrenceID = $Row[0];
    }

    return $RecurrenceID;
}

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

    # check needed stuff
    for my $Needed (qw(Appointment Step OriginalTime CurrentTime)) {
        if ( !defined $Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    my $OriginalTimeObject = $Param{OriginalTime};

    # We will modify this object throughout the function.
    my $CurrentTimeObject = $Param{CurrentTime};

    if ( $Param{Appointment}->{RecurrenceType} eq 'Daily' ) {

        # Add one day.
        $CurrentTimeObject->Add(
            Days => 1,
        );
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'Weekly' ) {

        # Add 7 days.
        $CurrentTimeObject->Add(
            Days => 7,
        );
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'Monthly' ) {
        my $TempTimeObject = $OriginalTimeObject->Clone();

        # Remember start day.
        my $StartDay = $TempTimeObject->Get()->{Day};

        # Add months based on current step.
        $TempTimeObject->Add(
            Months => $Param{Step},
        );

        # Get end day.
        my $EndDay = $TempTimeObject->Get()->{Day};

        # Check if month doesn't have enough days (for example: January 31 + 1 month = March 1).
        if ( $StartDay != $EndDay ) {
            $TempTimeObject->Subtract(
                Days => $EndDay,
            );
        }

        $CurrentTimeObject = $TempTimeObject->Clone();
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'Yearly' ) {
        my $TempTimeObject = $OriginalTimeObject->Clone();

        # Remember start day.
        my $StartDay = $TempTimeObject->Get()->{Day};

        # Add years based on current step.
        $TempTimeObject->Add(
            Years => $Param{Step},
        );

        # Get end day.
        my $EndDay = $TempTimeObject->Get()->{Day};

        # Check if month doesn't have enough days (for example: January 31 + 1 month = March 1).
        if ( $StartDay != $EndDay ) {
            $TempTimeObject->Subtract(
                Days => $EndDay,
            );
        }

        $CurrentTimeObject = $TempTimeObject->Clone();
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'CustomDaily' ) {

        # Add number of days.
        $CurrentTimeObject->Add(
            Days => $Param{Appointment}->{RecurrenceInterval},
        );
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'CustomWeekly' ) {

        # this block covers following use case:
        # each n-th Monday and Friday

        my $Found;

        # loop up to 7*n times (7 days in week * frequency)
        LOOP:
        for ( my $Counter = 0; $Counter < 7 * $Param{Appointment}->{RecurrenceInterval}; $Counter++ ) {

            # Add one day.
            $CurrentTimeObject->Add(
                Days => 1,
            );

            my $CWDiff = $Self->_CWDiff(
                CurrentTime  => $CurrentTimeObject,
                OriginalTime => $OriginalTimeObject,
            );

            next LOOP if $CWDiff % $Param{Appointment}->{RecurrenceInterval};

            my $WeekDay = $CurrentTimeObject->Get()->{DayOfWeek};

            # check if SystemTime match requirements
            if ( grep { $WeekDay == $_ } @{ $Param{Appointment}->{RecurrenceFrequency} } ) {
                $Found = 1;
                last LOOP;
            }
        }

        return if !$Found;
    }

    elsif ( $Param{Appointment}->{RecurrenceType} eq 'CustomMonthly' ) {

        # Occurs every 2nd month on 5th, 10th and 15th day
        my $Found;

        # loop through each day (max one year), and check if day matches.
        DAY:
        for ( my $Counter = 0; $Counter < 31 * 366; $Counter++ ) {

            # Add one day.
            $CurrentTimeObject->Add(
                Days => 1,
            );

            # Skip month if needed
            next DAY
                if ( $CurrentTimeObject->Get()->{Month} - $OriginalTimeObject->Get()->{Month} )
                % $Param{Appointment}->{RecurrenceInterval};

            # next day if this day should be skipped
            next DAY
                if !grep { $CurrentTimeObject->Get()->{Day} == $_ } @{ $Param{Appointment}->{RecurrenceFrequency} };

            $Found = 1;
            last DAY;
        }
        return if !$Found;
    }
    elsif ( $Param{Appointment}->{RecurrenceType} eq 'CustomYearly' ) {

        # this block covers following use case:
        # Occurs each 3th year, January 18th and March 18th
        my $Found;

        my $RecurrenceUntilObject;
        if ( $Param{Appointment}->{RecurrenceUntil} ) {
            $RecurrenceUntilObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Param{Appointment}->{RecurrenceUntil},
                },
            );
        }

        my $NextDayObject = $CurrentTimeObject->Clone();
        $NextDayObject->Add(
            Days => 1,
        );

        MONTH:
        for ( my $Counter = 1;; $Counter++ ) {
            my $TempTimeObject = $OriginalTimeObject->Clone();

            # remember start day
            my $StartDay = $TempTimeObject->Get()->{Day};

            $TempTimeObject->Add(
                Months => $Counter,
            );

            # get end day
            my $EndDay = $TempTimeObject->Get()->{Day};

            # check if month doesn't have enough days (for example: january 31 + 1 month = march 01)
            if ( $StartDay != $EndDay ) {
                $TempTimeObject->Subtract(
                    Days => $EndDay,
                );
            }

            $CurrentTimeObject = $TempTimeObject->Clone();

            # skip this time, since it was already checked
            next MONTH if $CurrentTimeObject < $NextDayObject;

            # check loop conditions (according to Until / )
            if ($RecurrenceUntilObject) {
                last MONTH if $CurrentTimeObject > $RecurrenceUntilObject;
            }
            else {
                last MONTH
                    if $Counter
                    > 12 * $Param{Appointment}->{RecurrenceInterval} * $Param{Appointment}->{RecurrenceCount};
            }

            # check if year is OK
            next MONTH
                if ( $CurrentTimeObject->Get()->{Year} - $OriginalTimeObject->Get()->{Year} )
                % $Param{Appointment}->{RecurrenceInterval};

            # next month if this month should be skipped
            next MONTH
                if !grep { $CurrentTimeObject->Get()->{Month} == $_ } @{ $Param{Appointment}->{RecurrenceFrequency} };

            $Found = 1;
            last MONTH;
        }
        return if !$Found;
    }
    else {
        return;
    }

    return $CurrentTimeObject;
}

=head2 _TimeCheck()

Check if Time and OriginalTime have same hour, minute and second value, and return timestamp with
values (hour, minute and second) as in Time.

    my $Result = $Self->_TimeCheck(
        OriginalTime => '2016-01-01 00:01:00',     # (required)
        Time         => '2016-02-01 00:02:00',     # (required)
    );

Returns:
    $Result = '2016-02-01 00:01:00';

=cut

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

    for my $Needed (qw(OriginalTime Time)) {
        if ( !defined $Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    my ( $OriginalDate, $OriginalTime ) = $Param{OriginalTime} =~ m/(.*?)\s(.*?)$/;
    my ($Date) = $Param{Time} =~ m/(.*?)\s(.*?)$/;

    return "$Date $OriginalTime";
}

=head2 _CWDiff()

Returns how many calendar weeks has passed between two unix times.

    my $CWDiff = $Self->_CWDiff(
        CurrentTime  => $CurrentTimeObject,     (required) Date time object with current time
        OriginalTime => $OriginalTimeObject,    (required) Date time object with original time
    );

returns:
    $CWDiff = 5;

=cut

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

    for my $Needed (qw(CurrentTime OriginalTime)) {
        if ( !defined $Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

    my $OriginalTimeObject = $Param{OriginalTime};
    my $CurrentTimeObject  = $Param{CurrentTime};

    my $StartYear = $OriginalTimeObject->Get()->{Year};
    my $EndYear   = $CurrentTimeObject->Get()->{Year};

    my $Result = $CurrentTimeObject->{CPANDateTimeObject}->week_number()
        - $OriginalTimeObject->{CPANDateTimeObject}->week_number();

    # If date is end of the year and date CW starts with 1, we need to include additional year.
    if ( $Result < 0 && $CurrentTimeObject->Get()->{Day} == 31 && $CurrentTimeObject->Get()->{Month} == 12 ) {
        $EndYear++;
    }

    for my $Year ( $StartYear .. $EndYear - 1 ) {
        my $CW  = 0;
        my $Day = 31;

        while ( $CW < 50 ) {

            # To get how many CW's are in this year, we set temporary date to 31-dec.
            my $DateTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => "$Year-12-$Day 23:59:00",
                },
            );

            $CW = $DateTimeObject->{CPANDateTimeObject}->week_number();
            $Day--;
        }

        $Result += $CW;
    }

    return $Result;
}

=end Internal:

=cut

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/System/Daemon/SchedulerDB.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::System::Daemon::SchedulerDB;

use strict;
use warnings;

# core modules
use MIME::Base64 qw(decode_base64 encode_base64);
use Time::HiRes  ();

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(:all);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::Cache',
    'Kernel::System::CronEvent',
    'Kernel::System::DateTime',
    'Kernel::System::DB',
    'Kernel::System::Encode',
    'Kernel::System::GenericAgent',
    'Kernel::System::Main',
    'Kernel::System::Log',
    'Kernel::System::Storable',
);

=head1 NAME

Kernel::System::Daemon::SchedulerDB - Scheduler database lib

=head1 DESCRIPTION

Includes all scheduler related database functions.

=head1 PUBLIC INTERFACE

=head2 new()

create a scheduler database object. Do not use it directly, instead use:

    my $SchedulerDBObject = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB');

=cut

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

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

    return $Self;
}

=head2 TaskAdd()

add a new task to scheduler task list

    my $TaskID = $SchedulerDBObject->TaskAdd(
        Type                     => 'GenericInterface',     # e. g. GenericInterface, Test
        Name                     => 'any name',             # optional
        Attempts                 => 5,                      # optional (default 1)
        MaximumParallelInstances => 2,                      # optional (default 0), number of tasks
                                                            #   with the same type (and name if
                                                            #   provided) that can exists at the same
                                                            #   time, value of 0 means unlimited
        Data => {                                           # data payload
            ...
        },
    );

Returns:

    my $TaskID = 123;  # false in case of an error or -1 in case of reach MaximumParallelInstances

=cut

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

    # check needed stuff
    for my $Key (qw(Type Data)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    if ( $Param{MaximumParallelInstances} && $Param{MaximumParallelInstances} =~ m{\A \d+ \z}msx ) {

        # get the list of all worker tasks for the specified task type
        my @List = $Self->TaskList(
            Type => $Param{Type},
        );

        my @FilteredList = @List;

        if ( $Param{Name} ) {

            # remove all tasks that does not match specified task name
            @FilteredList = grep { $_->{Name} eq $Param{Name} } @List;
        }

        # compare the number of task with the maximum parallel limit
        return -1 if scalar @FilteredList >= $Param{MaximumParallelInstances};
    }

    # set default of attempts parameter
    $Param{Attempts} ||= 1;

    # serialize data as string
    my $Data = $Kernel::OM->Get('Kernel::System::Storable')->Serialize(
        Data => $Param{Data},
    );

    # encode task data
    $Kernel::OM->Get('Kernel::System::Encode')->EncodeOutput($Data);
    $Data = encode_base64($Data);

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my $Identifier;
    TRY:
    for my $Try ( 1 .. 10 ) {

        # calculate a task identifier
        $Identifier = $Self->_GetIdentifier();

        # insert the task (initially locked with lock_key = 1 so it will not be taken by any worker
        #   at this moment)
        last TRY if $DBObject->Do(
            SQL => '
                INSERT INTO scheduler_task
                    (ident, name, task_type, task_data, attempts, lock_key, create_time)
                VALUES
                    (?, ?, ?, ?, ?, 1, current_timestamp)',
            Bind => [
                \$Identifier,
                \$Param{Name},
                \$Param{Type},
                \$Data,
                \$Param{Attempts},
            ],
        );
    }

    # get task id
    $DBObject->Prepare(
        SQL  => 'SELECT id FROM scheduler_task WHERE ident = ?',
        Bind => [ \$Identifier ],
    );

    # fetch the task id
    my $TaskID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $TaskID = $Row[0];
    }

    # unlock the task, for now on the task can be taken by any worker
    $DBObject->Do(
        SQL => '
            UPDATE scheduler_task
            SET lock_key = 0
            WHERE lock_key = 1 AND id = ?',
        Bind => [
            \$TaskID,
        ],
    );

    # delete task list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'TaskListUnlocked',
    );

    return $TaskID;
}

=head2 TaskGet()

get scheduler task

    my %Task = $SchedulerDBObject->TaskGet(
        TaskID => 123,
    );

Returns:

    %Task = (
        TaskID         => 123,
        Name           => 'any name',
        Type           => 'GenericInterface',
        Data           => $DataRef,
        Attempts       => 10,
        LockKey        => 'XYZ',
        LockTime       => '2011-02-08 15:08:01',
        LockUpdateTime => '2011-02-08 15:08:01',
        CreateTime     => '2011-02-08 15:08:00',
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get task from database
    return if !$DBObject->Prepare(
        SQL => '
            SELECT name, task_type, task_data, attempts, lock_key, lock_time, lock_update_time,
                create_time
            FROM scheduler_task
            WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # get storable object
    my $StorableObject = $Kernel::OM->Get('Kernel::System::Storable');

    my %Task;
    while ( my @Data = $DBObject->FetchrowArray() ) {

        # decode task data
        my $DecodedData = decode_base64( $Data[2] );

        # deserialize data
        my $DataParam = $StorableObject->Deserialize( Data => $DecodedData );

        if ( !$DataParam ) {

            # error log
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Task data is not in a correct storable format! TaskID: ' . $Param{TaskID},
            );

            # remove damaged task
            $Self->TaskDelete(
                TaskID => $Param{TaskID},
            );

            return;
        }

        %Task = (
            TaskID         => $Param{TaskID},
            Name           => $Data[0],
            Type           => $Data[1],
            Data           => $DataParam || {},
            Attempts       => $Data[3],
            LockKey        => $Data[4] // 0,
            LockTime       => $Data[5] // '',
            LockUpdateTime => $Data[6] // '',
            CreateTime     => $Data[7],
        );
    }

    return %Task;
}

=head2 TaskDelete()

delete a task from scheduler task list

    my $Success = $SchedulerDBObject->TaskDelete(
        TaskID => 123,
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # delete task from the list
    $Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => 'DELETE FROM scheduler_task WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # delete task list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'TaskListUnlocked',
    );

    return 1;
}

=head2 TaskList()

get the list of scheduler tasks

    my @List = $SchedulerDBObject->TaskList(
        Type => 'some type',  # optional
    );

Returns:

    @List = (
        {
            TaskID => 123,
            Name   => 'any name',
            Type   => 'GenericInterface',
        },
        {
            TaskID => 456,
            Name   => 'any other name',
            Type   => 'GenericInterface',
        },
        # ...
    );

=cut

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

    my $SQL = 'SELECT id, name, task_type FROM scheduler_task';
    my @Bind;

    # add type
    if ( $Param{Type} ) {
        $SQL .= ' WHERE task_type = ?';
        @Bind = ( \$Param{Type} );
    }

    $SQL .= ' ORDER BY id ASC';

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    # fetch the result
    my @List;
    while ( my @Row = $DBObject->FetchrowArray() ) {

        push @List, {
            TaskID => $Row[0],
            Name   => $Row[1],
            Type   => $Row[2],
        };
    }

    return @List;
}

=head2 TaskListUnlocked()

get a list of unlocked tasks

    my @TaskList = $SchedulerDBObject->TaskListUnlocked();

Returns:

    @TaskList = ( 456, 789, 395 );

=cut

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

    # get cache object
    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    # read cache
    my $Cache = $CacheObject->Get(
        Type           => 'SchedulerDB',
        Key            => 'TaskListUnlocked',
        CacheInMemory  => 0,
        CacheInBackend => 1,
    );
    return @{$Cache} if $Cache;

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return if !$DBObject->Prepare(
        SQL => 'SELECT id FROM scheduler_task WHERE lock_key = 0 ORDER BY id ASC',
    );

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

    # set cache
    $CacheObject->Set(
        Type           => 'SchedulerDB',
        Key            => 'TaskListUnlocked',
        TTL            => 10,
        Value          => \@List,
        CacheInMemory  => 0,
        CacheInBackend => 1,
    );

    return @List;
}

=head2 TaskLock()

locks task to a specific PID

    my $Success = $SchedulerDBObject->TaskLock(
        TaskID => 123,
        NodeID => 1,    # the id on the node in a cluster environment
        PID    => 456,  # the process ID of the worker that is locking the task
    );

=cut

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

    # check needed stuff
    for my $Key (qw(TaskID NodeID PID)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # create the lock key
    my $LockKeyNodeID = sprintf '%03d', $Param{NodeID};
    my $LockKeyPID    = sprintf '%08d', $Param{PID};
    my $LockKey       = '1' . $LockKeyNodeID . $LockKeyPID;

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get locked task
    return if !$DBObject->Prepare(
        SQL  => 'SELECT lock_key FROM scheduler_task WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # fetch the result
    my $LockKeyFromDBBefore = '';
    while ( my @Data = $DBObject->FetchrowArray() ) {
        $LockKeyFromDBBefore = $Data[0] || '';
    }

    return 1 if $LockKeyFromDBBefore eq $LockKey;

    # lock the task in database
    return if !$DBObject->Do(
        SQL => '
            UPDATE scheduler_task
            SET lock_key = ?, lock_time = current_timestamp, lock_update_time = current_timestamp
            WHERE lock_key = 0 AND id = ?',
        Bind => [
            \$LockKey,
            \$Param{TaskID},
        ],
    );

    # get locked task
    return if !$DBObject->Prepare(
        SQL  => 'SELECT lock_key, attempts FROM scheduler_task WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # fetch the result
    my $LockKeyFromDB = '';
    my $Attempts      = 0;
    while ( my @Data = $DBObject->FetchrowArray() ) {
        $LockKeyFromDB = $Data[0];
        $Attempts      = $Data[1];
    }

    return if $LockKeyFromDB ne $LockKey;

    # remove task if attempts is 0
    if ( !$Attempts ) {
        $Self->TaskDelete(
            TaskID => $Param{TaskID},
        );

        return;
    }
    else {

        $Attempts--;

        # decrement number of attempts
        $DBObject->Do(
            SQL => '
                UPDATE scheduler_task
                SET attempts = ?
                WHERE lock_key = ? AND id = ?',
            Bind => [
                \$Attempts,
                \$LockKey,
                \$Param{TaskID},
            ],
        );
    }

    # delete list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'TaskListUnlocked',
    );

    return 1;
}

=head2 TaskCleanup()

deletes obsolete worker tasks

    my $Success = $SchedulerDBObject->TaskCleanup();

=cut

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

    my @List = $Self->TaskList();

    TASKITEM:
    for my $TaskItem (@List) {

        my %Task = $Self->TaskGet(
            TaskID => $TaskItem->{TaskID},
        );

        # skip if task does not have a lock key
        next TASKITEM if !$Task{LockKey};

        # skip if the lock key is invalid
        next TASKITEM if $Task{LockKey} < 1;

        # get system time
        my $SystemTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

        # get expiration time. 7 days ago system time
        my $ExpiredTime = $SystemTime - ( 60 * 60 * 24 * 7 );

        my $LockTime = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Task{LockTime},
            },
        );

        $LockTime = $LockTime ? $LockTime->ToEpoch() : 0;

        # skip if task is not expired
        next TASKITEM if $LockTime > $ExpiredTime;

        my $Success = $Self->TaskDelete(
            TaskID => $Task{TaskID},
        );

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Could not delete task $Task{Name}-$Task{Type} ($Task{TaskID})\n",
            );
        }
    }

    return 1;
}

=head2 TaskSummary()

get a summary of the tasks from the worker task table divided into handled and unhandled

    my @Summary = $SchedulerDBObject->TaskSummary();

=cut

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

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return () if !$DBObject->Prepare(
        SQL => '
            SELECT id, name, task_type, lock_key, lock_time, create_time
            FROM scheduler_task
            ORDER BY id ASC',
    );

    # fetch the result
    my @List;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        push @List, {
            Name       => $Row[1],
            Type       => $Row[2],
            LockKey    => $Row[3] // 0,
            LockTime   => $Row[4] // '',
            CreateTime => $Row[5],
        };
    }

    my @HandledTasks;
    my @UnhandledTasks;

    my $SystemTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

    TASK:
    for my $Task (@List) {

        # check if the task is unlocked or lock key is not valid (unhandled tasks)
        if ( $Task->{LockKey} < 1 ) {
            push @UnhandledTasks, {
                Name       => $Task->{Name},
                Type       => $Task->{Type},
                CreateTime => $Task->{CreateTime},
            };
        }
        else {

            # extract the NodeID and ProcessID from the lock key
            my ( $NodeID, $ProcessID ) = $Task->{LockKey} =~ m{\A 1 (\d{3}) (\d{8}) \z}msx;

            # calculate duration from lock time
            my $CurrentDuration;
            if ( defined $Task->{LockTime} ) {
                my $LockSystemTime = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Task->{LockTime},
                    },
                );
                $LockSystemTime = $LockSystemTime ? $LockSystemTime->ToEpoch() : 0;

                $CurrentDuration = $Self->_Seconds2String( $SystemTime - $LockSystemTime );
            }

            push @HandledTasks, {
                Name            => $Task->{Name},
                Type            => $Task->{Type},
                NodeID          => $NodeID,
                ProcessID       => $ProcessID,
                LockTime        => $Task->{LockTime},
                CreateTime      => $Task->{CreateTime},
                CurrentDuration => $CurrentDuration
            };
        }
    }

    return (
        {
            Header => 'Unhandled Worker Tasks:',
            Column => [
                {
                    Name        => 'Name',
                    DisplayName => 'Name',
                    Size        => 40,
                },
                {
                    Name        => 'Type',
                    DisplayName => 'Type',
                    Size        => 20,
                },
                {
                    Name        => 'CreateTime',
                    DisplayName => 'Create Time',
                    Size        => 20,
                },
            ],
            Data          => \@UnhandledTasks,
            NoDataMessage => 'There are currently no tasks waiting to be executed.',
        },
        {
            Header => 'Handled Worker Tasks:',
            Column => [
                {
                    Name        => 'Name',
                    DisplayName => 'Name',
                    Size        => 40,
                },
                {
                    Name        => 'Type',
                    DisplayName => 'Type',
                    Size        => 20,
                },
                {
                    Name        => 'NodeID',
                    DisplayName => 'NID',
                    Size        => 4,
                },
                {
                    Name        => 'ProcessID',
                    DisplayName => 'PID',
                    Size        => 9,
                },
                {
                    Name        => 'CurrentDuration',
                    DisplayName => 'Duration',
                    Size        => 20,
                },
            ],
            Data          => \@HandledTasks,
            NoDataMessage => 'There are currently no tasks being executed.',
        },
    );
}

=head2 TaskLockUpdate()

sets the task lock update time as current time for the specified tasks

    my $Success = $SchedulerDBObject->TaskLockUpdate(
        TaskIDs => [123, 456],
    );

=cut

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

    # check needed stuff
    if ( !IsArrayRefWithData( $Param{TaskIDs} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "TaskIDs is missing or invalid!",
        );

        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my $TaskIDs = join ',', map { $DBObject->Quote( $_, 'Integer' ) } @{ $Param{TaskIDs} };

    return 1 if !$TaskIDs;

    # set lock update time in database
    return if !$DBObject->Do(
        SQL => "
            UPDATE scheduler_task
            SET lock_update_time = current_timestamp
            WHERE id IN ( $TaskIDs )",
    );

    return 1;
}

=head2 TaskUnlockExpired()

remove lock status for working tasks that has not been updated its lock update time for more than 5 minutes

    my $Success = $SchedulerDBObject->TaskUnlockExpired();

=cut

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

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database (get all worker tasks with a lock key different than 0)
    return if !$DBObject->Prepare(
        SQL => '
            SELECT id, name, lock_update_time
            FROM scheduler_task
            WHERE lock_key <> 0
                AND lock_key <> 1
            ORDER BY id ASC',
    );

    # fetch the result
    my @List;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # get current system time
        my $SystemTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

        # convert lock update time stamp to a system time
        my $LockUpdateTime = 0;

        if ( $Row[2] ) {
            $LockUpdateTime = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Row[2],
                },
            );
            $LockUpdateTime = $LockUpdateTime ? $LockUpdateTime->ToEpoch() : 0;
        }
        else {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Lock Update Time missing for task $Row[1]! ($Row[0])",
            );
        }

        # skip task if it has been locked update time is in within the last 5 minutes
        next ROW if $SystemTime - $LockUpdateTime < ( 60 * 5 );

        push @List, {
            TaskID   => $Row[0],
            Name     => $Row[1],
            LockTime => $Row[2],
        };
    }

    # stop if there are no tasks to unlock
    return 1 if !@List;

    for my $Task (@List) {

        # unlock all the task that has been locked for more than 1 minute
        return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
            SQL => '
                UPDATE scheduler_task
                SET lock_key = 0, lock_time = NULL, lock_update_time = NULL
                WHERE id = ?',
            Bind => [ \$Task->{TaskID}, ],
        );
    }

    return 1;
}

=head2 FutureTaskAdd()

add a new task to scheduler future task list

    my $TaskID = $SchedulerDBObject->FutureTaskAdd(
        ExecutionTime            => '2015-01-01 00:00:00',
        Type                     => 'GenericInterface',  # e. g. GenericInterface, Test
        Name                     => 'any name',          # optional
        Attempts                 => 5,                   # optional (default 1)
        MaximumParallelInstances => 2,                   # optional (default 0), number of tasks
                                                         #   with the same type (and name if provided)
                                                         #   that can exists at the same time,
                                                         #   value of 0 means unlimited
        Data => {                                        # data payload
            ...
        },
    );

Returns:

    my $TaskID = 123;  # or false in case of an error

=cut

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

    # check needed stuff
    for my $Key (qw(ExecutionTime Type Data)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # check valid ExecutionTime

    my $SystemTime = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{ExecutionTime},
        },
    );

    if ( !$SystemTime ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "ExecutionTime is invalid!",
        );

        return;
    }
    $SystemTime = $SystemTime->ToEpoch();

    if ( $Param{MaximumParallelInstances} && $Param{MaximumParallelInstances} =~ m{\A \d+ \z}msx ) {

        # get the list of all future tasks for the specified task type
        my @List = $Self->FutureTaskList(
            Type => $Param{Type},
        );

        my @FilteredList = @List;
        if ( $Param{Name} && @List ) {

            # remove all tasks that does not match specified task name
            @FilteredList = grep { ( $_->{Name} || '' ) eq $Param{Name} } @List;
        }

        # compare the number of task with the maximum parallel limit
        return -1 if scalar @FilteredList >= $Param{MaximumParallelInstances};
    }

    # set default of attempts parameter
    $Param{Attempts} ||= 1;

    # serialize data as string
    my $Data = $Kernel::OM->Get('Kernel::System::Storable')->Serialize(
        Data => $Param{Data},
    );

    # encode task data
    $Kernel::OM->Get('Kernel::System::Encode')->EncodeOutput($Data);
    $Data = encode_base64($Data);

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my $Identifier;
    TRY:
    for my $Try ( 1 .. 10 ) {

        # calculate a task identifier
        $Identifier = $Self->_GetIdentifier();

        # insert the future task (initially locked with lock_key = 1 so it will not be taken by any
        #    moved into worker task list at this moment)
        last TRY if $DBObject->Do(
            SQL => '
                INSERT INTO scheduler_future_task
                    (ident, execution_time, name, task_type, task_data, attempts, lock_key, create_time)
                VALUES
                    (?, ?, ?, ?, ?, ?, 1, current_timestamp)',
            Bind => [
                \$Identifier,
                \$Param{ExecutionTime},
                \$Param{Name},
                \$Param{Type},
                \$Data,
                \$Param{Attempts},
            ],
        );
    }

    # get task id
    $DBObject->Prepare(
        SQL  => 'SELECT id FROM scheduler_future_task WHERE ident = ?',
        Bind => [ \$Identifier ],
    );

    # fetch the task id
    my $TaskID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $TaskID = $Row[0];
    }

    # unlock the task, for now on the task can be moved to the worker task list
    $DBObject->Do(
        SQL => '
            UPDATE scheduler_future_task
            SET lock_key = 0
            WHERE lock_key = 1 AND id = ?',
        Bind => [
            \$TaskID,
        ],
    );

    # delete future task list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'FutureTaskListUnlocked',    # TODO FIXME
    );

    return $TaskID;
}

# RotherOSS / AppointmentToTicket

=head2 FutureTaskUpdate()

updates an existing task in the scheduler future task list

    my $Success = $SchedulerDBObject->FutureTaskUpdate(
        TaskID => 123,
        ExecutionTime => '2015-01-01 00:00:00',
        Data => {
            ...
        },
    );

=cut

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

    # check needed stuff
    for my $Key (qw(TaskID ExecutionTime Data)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # check valid ExecutionTime

    my $SystemTime = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $Param{ExecutionTime},
        },
    );

    if ( !$SystemTime ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "ExecutionTime is invalid!",
        );

        return;
    }
    $SystemTime = $SystemTime->ToEpoch();

    if ( $Param{MaximumParallelInstances} && $Param{MaximumParallelInstances} =~ m{\A \d+ \z}msx ) {

        # get the list of all future tasks for the specified task type
        my @List = $Self->FutureTaskList(
            Type => $Param{Type},
        );

        my @FilteredList = @List;
        if ( $Param{Name} && @List ) {

            # remove all tasks that does not match specified task name
            @FilteredList = grep { ( $_->{Name} || '' ) eq $Param{Name} } @List;
        }

        # compare the number of task with the maximum parallel limit
        return -1 if scalar @FilteredList >= $Param{MaximumParallelInstances};
    }

    # set default of attempts parameter
    $Param{Attempts} ||= 1;

    # serialize data as string
    my $Data = $Kernel::OM->Get('Kernel::System::Storable')->Serialize(
        Data => $Param{Data},
    );

    # encode task data
    $Kernel::OM->Get('Kernel::System::Encode')->EncodeOutput($Data);
    $Data = encode_base64($Data);

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    TRY:
    for my $Try ( 1 .. 10 ) {

        # insert the future task (initially locked with lock_key = 1 so it will not be taken by any
        #    moved into worker task list at this moment)
        last TRY if $DBObject->Do(
            SQL => '
                UPDATE scheduler_future_task
                SET execution_time = ?, task_data = ?
                WHERE id = ?',
            Bind => [
                \$Param{ExecutionTime},
                \$Data,
                \$Param{TaskID},
            ],
        );
    }

    # delete future task list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'FutureTaskListUnlocked',    # TODO FIXME
    );

    return 1;
}

# EO AppointmentToTicket

=head2 FutureTaskGet()

get scheduler future task

    my %Task = $SchedulerDBObject->FutureTaskGet(
        TaskID => 123,
    );

Returns:

    %Task = (
        TaskID        => 123,
        ExecutionTime => '2015-01-01 00:00:00',
        Name          => 'any name',
        Type          => 'GenericInterface',
        Data          => $DataRef,
        Attempts      => 10,
        LockKey       => 'XYZ',
        LockTime      => '2011-02-08 15:08:01',
        CreateTime    => '2011-02-08 15:08:00',
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get task from database
    return if !$DBObject->Prepare(
        SQL =>
            'SELECT execution_time, name, task_type, task_data, attempts, lock_key, lock_time, create_time
            FROM scheduler_future_task
            WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # get storable object
    my $StorableObject = $Kernel::OM->Get('Kernel::System::Storable');

    my %Task;
    while ( my @Data = $DBObject->FetchrowArray() ) {

        # decode task data
        my $DecodedData = decode_base64( $Data[3] );

        # deserialize data
        my $DataParam = $StorableObject->Deserialize( Data => $DecodedData );

        if ( !$DataParam ) {

            # error log
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Future task data is not in a correct storable format! TaskID: ' . $Param{TaskID},
            );

            # remove damaged future task
            $Self->FutureTaskDelete(
                TaskID => $Param{TaskID},
            );

            return;
        }

        %Task = (
            TaskID        => $Param{TaskID},
            ExecutionTime => $Data[0],
            Name          => $Data[1],
            Type          => $Data[2],
            Data          => $DataParam || {},
            Attempts      => $Data[4],
            LockKey       => $Data[5] // 0,
            LockTime      => $Data[6] // '',
            CreateTime    => $Data[7],
        );
    }

    return %Task;
}

=head2 FutureTaskDelete()

delete a task from scheduler future task list

    my $Success = $SchedulerDBObject->FutureTaskDelete(
        TaskID => 123,
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # delete task from the future list
    $Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => 'DELETE FROM scheduler_future_task WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # delete future task list cache
    $Kernel::OM->Get('Kernel::System::Cache')->Delete(
        Type => 'SchedulerDB',
        Key  => 'FutureTaskListUnlocked',    # TODO FIXME
    );

    return 1;
}

=head2 FutureTaskList()

get the list of scheduler future tasks

    my @List = $SchedulerDBObject->FutureTaskList(
        Type => 'some type',  # optional
    );

Returns:

    @List = (
        {
            TaskID        => 123,
            ExecutionTime => '2015-01-01 00:00:00',
            Name          => 'any name',
            Type          => 'GenericInterface',
        },
        {
            TaskID        => 456,
            ExecutionTime => '2015-01-01 00:00:00',
            Name          => 'any other name',
            Type          => 'GenericInterface',
        },
        # ...
    );

=cut

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

    my $SQL = 'SELECT id, execution_time, name, task_type FROM scheduler_future_task';
    my @Bind;

    # add type
    if ( $Param{Type} ) {
        $SQL .= ' WHERE task_type = ?';
        @Bind = ( \$Param{Type} );
    }

    $SQL .= ' ORDER BY id ASC';

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    # fetch the result
    my @List;
    while ( my @Row = $DBObject->FetchrowArray() ) {

        push @List, {
            TaskID        => $Row[0],
            ExecutionTime => $Row[1],
            Name          => $Row[2],
            Type          => $Row[3],
        };
    }

    return @List;
}

=head2 FutureTaskToExecute()

moves all future tasks with reached execution time to the task table to execute

    my $Success = $SchedulerDBObject->FutureTaskToExecute(
        NodeID => 1,    # the ID of the node in a cluster environment
        PID    => 456,  # the process ID of the daemon that is moving the tasks to execution
    );

=cut

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

    # check needed stuff
    for my $Key (qw(NodeID PID)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # create the lock key
    my $LockKeyNodeID = sprintf '%03d', $Param{NodeID};
    my $LockKeyPID    = sprintf '%08d', $Param{PID};
    my $LockKey       = '1' . $LockKeyNodeID . $LockKeyPID;

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get current time
    my $CurrentTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToString();

    # lock the task in database
    return if !$DBObject->Do(
        SQL => '
            UPDATE scheduler_future_task
            SET lock_key = ?, lock_time = current_timestamp
            WHERE lock_key = 0 AND execution_time <= ?',
        Bind => [
            \$LockKey,
            \$CurrentTime,
        ],
    );

    # get all locked future tasks
    return if !$DBObject->Prepare(
        SQL => '
            SELECT id, name, task_type, task_data, attempts
            FROM scheduler_future_task
            WHERE lock_key = ?
            ORDER BY execution_time ASC',
        Bind => [ \$LockKey ],
    );

    # get storable object
    my $StorableObject = $Kernel::OM->Get('Kernel::System::Storable');

    # fetch the result
    my @FutureTaskList;
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # decode task data
        my $DecodedData = decode_base64( $Row[3] );

        # deserialize data
        my $DataParam = $StorableObject->Deserialize( Data => $DecodedData );

        if ( !$DataParam ) {

            # error log
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Future task data is not in a correct storable format! TaskID: ' . $Param{TaskID},
            );

            # remove damaged future task
            $Self->FutureTaskDelete(
                TaskID => $Param{TaskID},
            );

            return;
        }

        my %Task = (
            TaskID   => $Row[0],
            Name     => $Row[1],
            Type     => $Row[2],
            Data     => $DataParam || {},
            Attempts => $Row[4],
        );

        push @FutureTaskList, \%Task;
    }

    # move tasks to the execution task list
    for my $FutureTask (@FutureTaskList) {

        my %Task = %{$FutureTask};

        delete $Task{TaskID};

        # add task to the list
        $Self->TaskAdd(%Task);

        # remove future task
        $Self->FutureTaskDelete(
            TaskID => $FutureTask->{TaskID},
        );
    }

    return 1;
}

=head2 FutureTaskSummary()

get a summary of the tasks from the future task table

    my @Summary = $SchedulerDBObject->FutureTaskSummary();

=cut

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

    my @List = $Self->FutureTaskList();

    return (
        {
            Header => 'Tasks to be executed in future:',
            Column => [
                {
                    Name        => 'Name',
                    DisplayName => 'Name',
                    Size        => 40,
                },
                {
                    Name        => 'Type',
                    DisplayName => 'Type',
                    Size        => 20,
                },
                {
                    Name        => 'ExecutionTime',
                    DisplayName => 'To Execute At',
                    Size        => 20,
                },
            ],
            Data          => \@List,
            NoDataMessage => 'There are currently no tasks to be executed in future.',
        },
    );
}

=head2 CronTaskToExecute()

creates cron tasks that needs to be run in the current time into the task table to execute

    my $Success = $SchedulerDBObject->CronTaskToExecute(
        NodeID => 1,    # the ID of the node in a cluster environment
        PID    => 456,  # the process ID of the daemon that is creating the tasks to execution
    );

=cut

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

    # check needed stuff
    for my $Key (qw(NodeID PID)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # get cron config
    my $Config = $Kernel::OM->Get('Kernel::Config')->Get('Daemon::SchedulerCronTaskManager::Task') || {};

    # do nothing if there are no cron tasks definitions in SysConfig
    return 1 unless IsHashRefWithData($Config);

    # get needed objects
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    my %UsedTaskNames;

    CRONJOBKEY:
    for my $CronjobKey ( sort keys %{$Config} ) {

        next CRONJOBKEY if !$CronjobKey;

        # extract config
        my $JobConfig = $Config->{$CronjobKey};

        next CRONJOBKEY if !IsHashRefWithData($JobConfig);

        for my $Needed (qw(Module TaskName Function)) {
            if ( !$JobConfig->{$Needed} ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Config option Daemon::SchedulerCronTaskManager::Task###$CronjobKey is invalid."
                        . " Need '$Needed' parameter!",
                );

                next CRONJOBKEY;
            }
        }

        if ( $UsedTaskNames{ $JobConfig->{TaskName} } ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Config option Daemon::SchedulerCronTaskManager::Task###$CronjobKey is invalid."
                    . " TaskName parameter '$JobConfig->{TaskName}' is already used by another task!",
            );

            next CRONJOBKEY;
        }

        # calculate last cron time
        my $PreviousEventTimestamp = $CronEventObject->PreviousEventGet(
            Schedule => $JobConfig->{Schedule},
        );

        next CRONJOBKEY if !$PreviousEventTimestamp;

        # execute recurrent tasks
        $Self->RecurrentTaskExecute(
            NodeID                   => $Param{NodeID},
            PID                      => $Param{PID},
            TaskName                 => $JobConfig->{TaskName},
            TaskType                 => 'Cron',
            PreviousEventTimestamp   => $PreviousEventTimestamp,
            MaximumParallelInstances => $JobConfig->{MaximumParallelInstances},
            Data                     => {
                Module   => $JobConfig->{Module}   || '',
                Function => $JobConfig->{Function} || '',
                Params   => $JobConfig->{Params}   || '',
            },
        );
        $UsedTaskNames{ $JobConfig->{TaskName} } = 1;
    }

    return 1;
}

=head2 CronTaskCleanup()

removes recurrent tasks that do not have a matching cron tasks definition in SysConfig.

    my $Success = $SchedulerDBObject->CronTaskCleanup();

=cut

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

    # get cron config
    my $Config = $Kernel::OM->Get('Kernel::Config')->Get('Daemon::SchedulerCronTaskManager::Task') || {};

    # do nothing if there are no cron tasks definitions in SysConfig
    return 1 unless IsHashRefWithData($Config);

    # get needed objects
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    my %CronJobLookup;

    CRONJOBKEY:
    for my $CronjobKey ( sort keys %{$Config} ) {

        next CRONJOBKEY if !$CronjobKey;

        # extract config
        my $JobConfig = $Config->{$CronjobKey};

        next CRONJOBKEY if !IsHashRefWithData($JobConfig);

        next CRONJOBKEY if ( !$JobConfig->{Module} );

        next CRONJOBKEY if ( $JobConfig->{Module} && !$JobConfig->{Function} );

        # calculate last cron time
        my $PreviousEventTimestamp = $CronEventObject->PreviousEventGet(
            Schedule => $JobConfig->{Schedule},
        );

        next CRONJOBKEY if !$PreviousEventTimestamp;

        $CronJobLookup{ $JobConfig->{TaskName} } = 1;
    }

    # get a list of all generic agent recurrent tasks
    my @TaskList = $Self->RecurrentTaskList(
        Type => 'Cron',
    );

    TASK:
    for my $Task (@TaskList) {

        # skip if task has an active generic agent job in the DB
        next TASK if $CronJobLookup{ $Task->{Name} };

        my $Success = $Self->RecurrentTaskDelete(
            TaskID => $Task->{TaskID},
        );

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Task $Task->{Name}-$Task->{Type} ($Task->{TaskID}) could not be deleted!",
            );
        }
    }

    return 1;
}

=head2 CronTaskSummary()

get a summary of the cron tasks from the recurrent task table

    my @Summary = $SchedulerDBObject->CronTaskSummary();

=cut

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

    # get cron jobs from the SysConfig
    my $Config = $Kernel::OM->Get('Kernel::Config')->Get('Daemon::SchedulerCronTaskManager::Task') || {};

    my %TaskLookup;

    JOBNAME:
    for my $JobName ( sort keys %{$Config} ) {

        my $JobConfig = $Config->{$JobName};

        next JOBNAME if !$JobConfig;
        next JOBNAME if !$JobConfig->{Schedule};

        $TaskLookup{$JobName} = $JobConfig->{Schedule};
    }

    return $Self->RecurrentTaskSummary(
        Type        => 'Cron',
        DisplayType => 'cron',
        TaskLookup  => \%TaskLookup,
    );
}

=head2 GenericAgentTaskToExecute()

creates generic agent tasks that needs to be run in the current time into the task table to execute

    my $Success = $SchedulerDBObject->GenericAgentTaskToExecute(
        NodeID => 1,    # the ID of the node in a cluster environment
        PID    => 456,  # the process ID of the daemon that is creating the tasks to execution
    );

=cut

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

    # check needed stuff
    for my $Key (qw(NodeID PID)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    # get generic agent object
    my $GenericAgentObject = $Kernel::OM->Get('Kernel::System::GenericAgent');

    # get a list of generic agent jobs
    my %JobList = $GenericAgentObject->JobList();

    # do nothing if there are no generic agent jobs
    return 1 if !%JobList;

    # get CRON event objects
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    JOBNAME:
    for my $JobName ( sort keys %JobList ) {

        # get job
        my %Job = $GenericAgentObject->JobGet(
            Name => $JobName,
        );

        # skip if job is invalid
        next JOBNAME if !$Job{Valid};

        # get required params
        my $ScheduleCheck = 1;
        for my $Key (qw( ScheduleDays ScheduleMinutes ScheduleHours )) {
            if ( !$Job{$Key} ) {
                $ScheduleCheck = 0;
            }
        }

        # skip if job is not time based
        next JOBNAME if !$ScheduleCheck;

        # get CRON tab for Generic Agent Schedule
        my $Schedule = $CronEventObject->GenericAgentSchedule2CronTab(%Job);

        next JOBNAME if !$Schedule;

        # get the last time the GenericAgent job should be executed, this returns even THIS minute
        my $PreviousEventTimestamp = $CronEventObject->PreviousEventGet(
            Schedule => $Schedule,
        );

        next JOBNAME if !$PreviousEventTimestamp;

        # execute recurrent tasks
        $Self->RecurrentTaskExecute(
            NodeID                   => $Param{NodeID},
            PID                      => $Param{PID},
            TaskName                 => $JobName,
            TaskType                 => 'GenericAgent',
            PreviousEventTimestamp   => $PreviousEventTimestamp,
            MaximumParallelInstances => 1,
            Data                     => \%Job,
        );
    }

    return 1;
}

=head2 GenericAgentTaskCleanup()

removes recurrent tasks that does not have a matching generic agent job

    my $Success = $SchedulerDBObject->GenericAgentTaskCleanup();

=cut

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

    # get generic agent object
    my $GenericAgentObject = $Kernel::OM->Get('Kernel::System::GenericAgent');

    # get a list of generic agent jobs
    my %JobList = $GenericAgentObject->JobList();

    # do nothing if there are no generic agent jobs
    return 1 if !%JobList;

    my %GenericAgentJobLookup;

    # get CRON event objects
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    JOBNAME:
    for my $JobName ( sort keys %JobList ) {

        # get job
        my %Job = $GenericAgentObject->JobGet(
            Name => $JobName,
        );

        # skip if job is invalid
        next JOBNAME if !$Job{Valid};

        # get required params
        my $ScheduleCheck = 1;
        for my $Key (qw( ScheduleDays ScheduleMinutes ScheduleHours )) {
            if ( !$Job{$Key} ) {
                $ScheduleCheck = 0;
            }
        }

        # skip if job is not time based
        next JOBNAME if !$ScheduleCheck;

        # get CRON tab for Generic Agent Schedule
        my $Schedule = $CronEventObject->GenericAgentSchedule2CronTab(%Job);

        next JOBNAME if !$Schedule;

        $GenericAgentJobLookup{$JobName} = 1;
    }

    # get a list of all generic agent recurrent tasks
    my @TaskList = $Self->RecurrentTaskList(
        Type => 'GenericAgent',
    );

    TASK:
    for my $Task (@TaskList) {

        # skip if task has an active generic agent job in the DB
        next TASK if $GenericAgentJobLookup{ $Task->{Name} };

        my $Success = $Self->RecurrentTaskDelete(
            TaskID => $Task->{TaskID},
        );

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Task $Task->{Name}-$Task->{Type} ($Task->{TaskID}) could not be deleted!",
            );
        }
    }

    return 1;
}

=head2 GenericAgentTaskSummary()

get a summary of the generic agent tasks from the recurrent task table

    my @Summary = $SchedulerDBObject->GenericAgentTaskSummary();

=cut

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

    # get generic agent object
    my $GenericAgentObject = $Kernel::OM->Get('Kernel::System::GenericAgent');

    # get a list of generic agent jobs from the DB
    my %JobList = $GenericAgentObject->JobList();

    # get cron event object
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    my %TaskLookup;

    JOBNAME:
    for my $JobName ( sort keys %JobList ) {

        # get job
        my %JobConfig = $GenericAgentObject->JobGet(
            Name => $JobName,
        );

        next JOBNAME if !%JobConfig;
        next JOBNAME if !$JobConfig{Valid};

        # get required params
        my $ScheduleCheck = 1;
        for my $Key (qw( ScheduleDays ScheduleMinutes ScheduleHours )) {
            if ( !$JobConfig{$Key} ) {
                $ScheduleCheck = 0;
            }
        }

        # skip if job is not time based
        next JOBNAME if !$ScheduleCheck;

        # get CRON tab for Generic Agent Schedule
        my $Schedule = $CronEventObject->GenericAgentSchedule2CronTab(%JobConfig);

        next JOBNAME if !$Schedule;

        $TaskLookup{$JobName} = $Schedule;
    }

    return $Self->RecurrentTaskSummary(
        Type        => 'GenericAgent',
        DisplayType => 'generic agent',
        TaskLookup  => \%TaskLookup,
    );
}

=head2 RecurrentTaskGet()

get scheduler recurrent task

    my %Task = $SchedulerDBObject->RecurrentTaskGet(
        TaskID => 123,
    );

Returns:

    %Task = (
        TaskID            => 123,
        Name              => 'any name',
        Type              => 'GenericInterface',
        LastExecutionTime => '2015-01-01 00:00:00',
        LockKey           => 'XYZ',
        LockTime          => '2015-01-02 00:00:00'
        CreateTime        => '2015-01-01 00:00:00'
        ChangeTime        => '2015-01-02 00:00:00'
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get task from database
    return if !$DBObject->Prepare(
        SQL => 'SELECT name, task_type, last_execution_time, lock_key, lock_time, create_time, change_time
            FROM scheduler_recurrent_task
            WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    my %Task;
    while ( my @Data = $DBObject->FetchrowArray() ) {

        %Task = (
            TaskID            => $Param{TaskID},
            Name              => $Data[0],
            Type              => $Data[1],
            LastExecutionTime => $Data[2],
            LockKey           => $Data[3] // 0,
            LockTime          => $Data[4] // '',
            CreateTime        => $Data[5],
            ChangeTime        => $Data[6]
        );
    }

    return %Task;
}

=head2 RecurrentTaskList()

get the list of scheduler recurrent tasks

    my @List = $SchedulerDBObject->RecurrentTaskList(
        Type => 'some type',  # optional
    );

Returns:

    @List = (
        {
            TaskID            => 123,
            Name              => 'any name',
            Type              => 'GenericInterface',
            LastExecutionTime => '2015-01-01 00:00:00',
            LockKey           => 'XYZ',
            LockTime          => '2015-01-02 00:00:00'
            CreateTime        => '2015-01-01 00:00:00'
            ChangeTime        => '2015-01-02 00:00:00'
        },
        {
            TaskID            => 456,
            Name              => 'any other name',
            Type              => 'GenericInterface',
            LastExecutionTime => '2015-01-01 00:00:00',
            LockKey           => 'XYZ',
            LockTime          => '2015-01-02 00:00:00'
            CreateTime        => '2015-01-01 00:00:00'
            ChangeTime        => '2015-01-02 00:00:00'
        },
        # ...
    );

=cut

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

    my $SQL = '
        SELECT id, name, task_type, last_execution_time, lock_key, lock_time, create_time,
            change_time
        FROM scheduler_recurrent_task';
    my @Bind;

    # add type
    if ( $Param{Type} ) {
        $SQL .= ' WHERE task_type = ?';
        @Bind = ( \$Param{Type} );
    }

    $SQL .= ' ORDER BY id ASC';

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return if !$DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

    # fetch the result
    my @List;
    while ( my @Row = $DBObject->FetchrowArray() ) {

        push @List, {
            TaskID            => $Row[0],
            Name              => $Row[1],
            Type              => $Row[2],
            LastExecutionTime => $Row[3],
            LockKey           => $Row[4] // 0,
            LockTime          => $Row[5] // '',
            CreateTime        => $Row[6],
            ChangeTime        => $Row[7],
        };
    }

    return @List;
}

=head2 RecurrentTaskDelete()

delete a task from scheduler recurrent task list

    my $Success = $SchedulerDBObject->RecurrentTaskDelete(
        TaskID => 123,
    );

=cut

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

    # check needed stuff
    if ( !$Param{TaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TaskID!',
        );
        return;
    }

    # get task to delete cache
    my %Task = $Self->RecurrentTaskGet(
        TaskID => $Param{TaskID},
    );

    # delete task from the recurrent task list
    $Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => 'DELETE FROM scheduler_recurrent_task WHERE id = ?',
        Bind => [ \$Param{TaskID} ],
    );

    # delete cache if task exits before the delete
    if (%Task) {

        my $CacheKey = "$Task{Name}::$Task{Type}";

        $Kernel::OM->Get('Kernel::System::Cache')->Delete(
            Type => 'SchedulerDBRecurrentTaskExecute',
            Key  => '$CacheKey',
        );
    }

    return 1;
}

=head2 RecurrentTaskExecute()

executes recurrent tasks like cron or generic agent tasks

    my $Success = $SchedulerDBObject->RecurrentTaskExecute(
        NodeID                   => 1,                 # the ID of the node in a cluster environment
        PID                      => 456,               # the process ID of the daemon that is creating
                                                       #    the tasks to execution
        TaskName                 => 'UniqueTaskName',
        TaskType                 => 'Cron',
        PreviousEventTimestamp   => 1433212343,
        MaximumParallelInstances => 1,                 # optional (default 0) number of tasks with the
                                                       #    same name and type that can be in execution
                                                       #    table at the same time, value of 0 means
                                                       #    unlimited
        Data                   => {                    # data payload
            ...
        },
    );

=cut

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

    # check needed stuff
    for my $Key (qw(NodeID PID TaskName TaskType PreviousEventTimestamp Data)) {
        if ( !$Param{$Key} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Key!",
            );

            return;
        }
    }

    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    my $CacheKey = "$Param{TaskName}::$Param{TaskType}";

    # read cache
    my $Cache = $CacheObject->Get(
        Type           => 'SchedulerDBRecurrentTaskExecute',
        Key            => $CacheKey,
        CacheInMemory  => 0,
        CacheInBackend => 1,
    );

    return 1 if $Cache && $Cache eq $Param{PreviousEventTimestamp};

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my $LastExecutionTimeStamp;

    # get entry id and last execution time from database
    my $EntryID;
    TRY:
    for my $Try ( 1 .. 10 ) {

        # insert entry if not exists
        if ( $Try ne 1 ) {

            return if !$DBObject->Do(
                SQL => "
                    INSERT INTO scheduler_recurrent_task
                        (name, task_type, last_execution_time, lock_key, create_time, change_time)
                    VALUES
                        (?, ?, ?, 0, current_timestamp, current_timestamp)",
                Bind => [
                    \$Param{TaskName},
                    \$Param{TaskType},
                    \$Param{PreviousEventTimestamp},
                ],
            );
        }

        # get entry id
        next TRY if !$DBObject->Prepare(
            SQL => "
                SELECT id, last_execution_time
                FROM scheduler_recurrent_task
                WHERE task_type = ? AND name = ?",
            Bind => [
                \$Param{TaskType},
                \$Param{TaskName},
            ],
        );

        # fetch the entry id
        while ( my @Row = $DBObject->FetchrowArray() ) {
            $EntryID                = $Row[0];
            $LastExecutionTimeStamp = $Row[1];
        }

        last TRY if $EntryID;
    }

    return if !$EntryID;

    if ( $LastExecutionTimeStamp eq $Param{PreviousEventTimestamp} ) {

        # set cache
        $CacheObject->Set(
            Type           => 'SchedulerDBRecurrentTaskExecute',
            Key            => $CacheKey,
            TTL            => 60 * 5,
            Value          => $Param{PreviousEventTimestamp},
            CacheInMemory  => 0,
            CacheInBackend => 1,
        );

        return 1;
    }

    # create the lock key
    my $LockKeyNodeID = sprintf '%03d', $Param{NodeID};
    my $LockKeyPID    = sprintf '%08d', $Param{PID};
    my $LockKey       = '1' . $LockKeyNodeID . $LockKeyPID;

    # lock the entry in database
    return if !$DBObject->Do(
        SQL => '
            UPDATE scheduler_recurrent_task
            SET lock_key = ?, lock_time = current_timestamp, change_time = current_timestamp
            WHERE lock_key = 0 AND id = ?',
        Bind => [
            \$LockKey,
            \$EntryID,
        ],
    );

    # get locked entry
    $DBObject->Prepare(
        SQL  => 'SELECT lock_key FROM scheduler_recurrent_task WHERE id = ?',
        Bind => [ \$EntryID ],
    );

    # fetch the result
    my $LockKeyFromDB = '';
    while ( my @Data = $DBObject->FetchrowArray() ) {
        $LockKeyFromDB = $Data[0];
    }

    return 1 if $LockKeyFromDB ne $LockKey;

    # set cache
    $CacheObject->Set(
        Type           => 'SchedulerDBRecurrentTaskExecute',
        Key            => $CacheKey,
        TTL            => 60 * 5,
        Value          => $Param{PreviousEventTimestamp},
        CacheInMemory  => 0,
        CacheInBackend => 1,
    );

    # add the task
    my $TaskID = $Self->TaskAdd(
        Type                     => $Param{TaskType},
        Name                     => $Param{TaskName},
        Attempts                 => 1,
        MaximumParallelInstances => $Param{MaximumParallelInstances},
        Data                     => $Param{Data},
    );

    # unlock the task
    if ( IsPositiveInteger($TaskID) ) {
        $DBObject->Do(
            SQL => '
                UPDATE scheduler_recurrent_task
                SET lock_key = 0, lock_time = NULL, last_execution_time = ?, last_worker_task_id = ?,
                    change_time = current_timestamp
                WHERE lock_key = ? AND id = ?',
            Bind => [
                \$Param{PreviousEventTimestamp},
                \$TaskID,
                \$LockKey,
                \$EntryID,
            ],
        );
    }
    else {
        $DBObject->Do(
            SQL => '
                UPDATE scheduler_recurrent_task
                SET lock_key = 0, lock_time = NULL, change_time = current_timestamp
                WHERE lock_key = ? AND id = ?',
            Bind => [
                \$LockKey,
                \$EntryID,
            ],
        );
    }

    return 1 if $TaskID;

    # error handling
    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'error',
        Message  => "Could not create new scheduler recurrent task $Param{TaskName}!",
    );

    return;
}

=head2 RecurrentTaskSummary()

get a summary of the recurring tasks for the specified task type

    my @Summary = $SchedulerDBObject->RecurrentTaskSummary(
        Type         => 'some_type',
        DisplayType  => 'some type',
        TaskLookup   => {                       # only tasks with names in this table will be shown
            TaskName1 => '* * * * *',           #   the value of the items in this table is a crontab
            TaskName3 => '*/1 3,4 * * * 0',     #   format schedule
        }
    );

=cut

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

    # check needed stuff
    for my $Needed (qw(Type DisplayType TaskLookup)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );

            return ();
        }
    }

    if ( ref $Param{TaskLookup} ne 'HASH' ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "TaskLookup is invalid!",
        );

        return ();
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database
    return () if !$DBObject->Prepare(
        SQL => '
            SELECT id, name, task_type, last_execution_time, last_worker_status, last_worker_running_time
            FROM scheduler_recurrent_task
            WHERE task_type = ?
            ORDER BY id ASC',
        Bind => [ \$Param{Type} ],
    );

    # get needed objects
    my $CronEventObject = $Kernel::OM->Get('Kernel::System::CronEvent');

    # fetch the result
    my @List;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # skip tasks that are not registered in the TaskLookup table
        my $Schedule = $Param{TaskLookup}->{ $Row[1] };

        next ROW if !$Schedule;

        # calculate next cron event time
        my $NextExecutionTime = $CronEventObject->NextEventGet(
            Schedule => $Schedule,
        );

        my $LastWorkerStatus;
        if ( defined $Row[4] ) {
            $LastWorkerStatus = $Row[4] ? 'Success' : 'Fail';
        }

        my $LastWorkerRunningTime;
        if ( defined $Row[5] ) {
            $LastWorkerRunningTime = $Self->_Seconds2String( $Row[5] );
        }

        push @List, {
            Name                  => $Row[1],
            Type                  => $Row[2],
            LastExecutionTime     => $Row[3]                // '',
            NextExecutionTime     => $NextExecutionTime     // '',
            LastWorkerStatus      => $LastWorkerStatus      // 'N/A',
            LastWorkerRunningTime => $LastWorkerRunningTime // 'N/A',
        };
    }

    return (
        {
            Header => "Recurrent $Param{DisplayType} tasks:",
            Column => [
                {
                    Name        => 'Name',
                    DisplayName => 'Name',
                    Size        => 40,
                },
                {
                    Name        => 'LastExecutionTime',
                    DisplayName => 'Last Execution',
                    Size        => 20,
                },
                {
                    Name        => 'LastWorkerStatus',
                    DisplayName => 'Last Status',
                    Size        => 12,
                },
                {
                    Name        => 'LastWorkerRunningTime',
                    DisplayName => 'Last Duration',
                    Size        => 18,
                },
                {
                    Name        => 'NextExecutionTime',
                    DisplayName => 'Next Execution',
                    Size        => 20,
                },
            ],
            Data          => \@List,
            NoDataMessage => "There are currently no $Param{DisplayType} recurring tasks configured.",
        },
    );
}

=head2 RecurrentTaskWorkerInfoSet()

sets last worker information (success status and running time) to a recurrent task

    my $Success = $SchedulerDBObject->RecurrentTaskWorkerInfoSet(
        LastWorkerTaskID      => 123,        # the task ID from the worker table that is performing the
                                             #      recurring task
        LastWorkerStatis      => 1,          # optional 1 or 0, defaults to 0, 1 means success
        LastWorkerRunningTime => 123,        # optional, defaults to 0, the number in seconds a worker took
                                             #      to complete the task
    );

=cut

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

    # check needed stuff
    if ( !$Param{LastWorkerTaskID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need LastWorkerTaskID!",
        );

        return;
    }

    my $LastWorkerStatus      = $Param{LastWorkerStatus} ? 1 : 0;
    my $LastWorkerRunningTime = $Param{LastWorkerRunningTime} // 0;

    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL => '
            UPDATE scheduler_recurrent_task
            SET last_worker_status = ?, last_worker_running_time = ?, change_time = current_timestamp
            WHERE last_worker_task_id = ?',
        Bind => [
            \$LastWorkerStatus,
            \$LastWorkerRunningTime,
            \$Param{LastWorkerTaskID},
        ],
    );

    return 1;
}

=head2 RecurrentTaskUnlockExpired()

remove lock status for recurring tasks that has been locked for more than 1 minutes

    my $Success = $SchedulerDBObject->RecurrentTaskUnlockExpired(
        Type => 'some_type',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Type} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need Type",
        );
    }

    # get needed objects
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # ask the database (get all recurrent tasks for the given type with a lock key different than 0)
    return if !$DBObject->Prepare(
        SQL => '
            SELECT id, name, lock_time
            FROM scheduler_recurrent_task
            WHERE task_type = ?
                AND lock_key <> 0
            ORDER BY id ASC',
        Bind => [ \$Param{Type} ],
    );

    # fetch the result
    my @List;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # get current system time
        my $SystemTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

        # convert lock time stamp to a system time
        my $LockTime = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $Row[2],
            },
        );
        $LockTime = $LockTime ? $LockTime->ToEpoch() : 0;

        # skip task if it has been locked within the last minute
        next ROW if $SystemTime - $LockTime < 60;

        push @List, {
            TaskID   => $Row[0],
            Name     => $Row[1],
            LockTime => $Row[2],
        };
    }

    # stop if there are no tasks to unlock
    return 1 if !@List;

    for my $Task (@List) {

        # unlock all the task that has been locked for more than 1 minute
        return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
            SQL => '
                UPDATE scheduler_recurrent_task
                SET lock_key = 0, lock_time = NULL, change_time = current_timestamp
                WHERE id = ?',
            Bind => [ \$Task->{TaskID}, ],
        );
    }

    return 1;
}

=head1 PRIVATE INTERFACE

=head2 _Seconds2String()

convert an amount of seconds to a more human readable format, e.g. < 1 Second, 5 Minutes

    my $String = $SchedulerDBObject->_Seconds2String(.2);

returns

    $String = '< 1 Second';

or

    my $String = $SchedulerDBObject->_Seconds2String(8);

returns

    $String = '8 Second(s)';

or

    my $String = $SchedulerDBObject->_Seconds2String(62);

returns

    $String = '1 Minute(s)';

or

    my $String = $SchedulerDBObject->_Seconds2String(3610);

returns

    $String = '1 Hour(s)';

or

    my $String = $SchedulerDBObject->_Seconds2String(86_640);

returns

    $String = '1 Day(s)';

=cut

sub _Seconds2String {
    my ( $Self, $Seconds ) = @_;

    return '< 1 Second' if $Seconds < 1;

    if ( $Seconds >= 24 * 60 * 60 ) {
        return sprintf '%.1f Day(s)', $Seconds / ( 24 * 60 * 60 );
    }
    elsif ( $Seconds >= 60 * 60 ) {
        return sprintf '%.1f Hour(s)', $Seconds / ( 60 * 60 );
    }
    elsif ( $Seconds >= 60 ) {
        return sprintf '%.1f Minute(s)', $Seconds / (60);
    }
    else {
        return sprintf '%.1f Second(s)', $Seconds;
    }
}

=head2 _GetIdentifier()

calculate a task identifier.

    my $Identifier = $SchedulerDBObject->_GetIdentifier();

returns

    $Identifier = 1234456789;

=cut

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

    my ( $Seconds, $Microseconds ) = Time::HiRes::gettimeofday();
    my $ProcessID = $$;

    my $Identifier = $ProcessID . $Microseconds;

    my $RandomString = $Kernel::OM->Get('Kernel::System::Main')->GenerateRandomString(
        Length     => 18 - length $Identifier,
        Dictionary => [ 0 .. 9 ],                # numeric
    );

    $Identifier .= $RandomString;

    return $Identifier;
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIEtlcm5lbDo6TGFuZ3VhZ2U6OmRlX0FwcG9pbnRtZW50VG9UaWNrZXQ7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7CnVzZSB1dGY4OwoKc3ViIERhdGEgewogICAgbXkgJFNlbGYgPSBzaGlmdDsKCiAgICAjIFRlbXBsYXRlOiBBZ2VudEFwcG9pbnRtZW50RWRpdAogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnVGlja2V0IENyZWF0aW9uJ30gPSAnVGlja2V0LUVyc3RlbGx1bmcnOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnQXJ0aWNsZSBpcyB2aXNpYmxlIGZvciBjdXN0b21lcid9ID0gJ0FydGlrZWwgaXN0IGbDvHIgS3VuZGVuIHNpY2h0YmFyJzsKCiAgICAjIFBlcmwgTW9kdWxlOiBLZXJuZWwvTW9kdWxlcy9BZ2VudEFwcG9pbnRtZW50RWRpdC5wbQogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnTm8gdGlja2V0IGNyZWF0aW9uJ30gPSAnS2VpbmUgVGlja2V0LUVyc3RlbGx1bmcnOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnQ291bGQgbm90IHBlcmZvcm0gdmFsaWRhdGlvbiBvbiBmaWVsZCBkZXN0ISd9ID0gJ0RpZSDDnGJlcnByw7xmdW5nIGRlcyBGZWxkZXMgZGVzdCBrb25udGUgbmljaHQgZHVyY2hnZWbDvGhydCB3ZXJkZW4hJzsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J0NvdWxkIG5vdCBwZXJmb3JtIHZhbGlkYXRpb24gb24gZmllbGQgbmV4dCBzdGF0ZSEnfSA9ICdEaWUgw5xiZXJwcsO8ZnVuZyBkZXMgRmVsZGVzIG5leHQgc3RhdGUga29ubnRlIG5pY2h0IGR1cmNoZ2Vmw7xocnQgd2VyZGVuISc7CiAgICAkU2VsZi0+e1RyYW5zbGF0aW9ufS0+eydDb3VsZCBub3QgcGVyZm9ybSB2YWxpZGF0aW9uIG9uIGZpZWxkIHNlcnZpY2UhJ30gPSAnVmFsaWRpZXJ1bmcgaW0gQXXDn2VuZGllbnN0IGtvbm50ZSBuaWNodCBkdXJjaGdlZsO8aHJ0IHdlcmRlbiEnOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnQ291bGQgbm90IHBlcmZvcm0gdmFsaWRhdGlvbiBvbiBmaWVsZCBTTEEhJ30gPSAnRGllIFZhbGlkaWVydW5nIGRlcyBGZWxkZXMgU0xBIGtvbm50ZSBuaWNodCBkdXJjaGdlZsO8aHJ0IHdlcmRlbiEnOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnQ291bGQgbm90IHBlcmZvcm0gdmFsaWRhdGlvbiBvbiBmaWVsZCB0eXBlISd9ID0gJ0RpZSDDnGJlcnByw7xmdW5nIGRlcyBGZWxkdHlwcyBrb25udGUgbmljaHQgZHVyY2hnZWbDvGhydCB3ZXJkZW4hJzsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J0NvdWxkIG5vdCBwZXJmb3JtIHZhbGlkYXRpb24gb24gZmllbGQgcHJpb3JpdHkhJ30gPSAnRGllIMOcYmVycHLDvGZ1bmcgZGVzIEZlbGRlcyBQcmlvcml0w6R0IGtvbm50ZSBuaWNodCBkdXJjaGdlZsO8aHJ0IHdlcmRlbiEnOwoKICAgICMgU3lzQ29uZmlnCiAgICAkU2VsZi0+e1RyYW5zbGF0aW9ufS0+eydEZXRlcm1pbmVzIHRoZSBuZXh0IHBvc3NpYmxlIHRpY2tldCBzdGF0ZXMsIGFmdGVyIHRoZSBjcmVhdGlvbiBvZiBhIG5ldyB0aWNrZXQgZnJvbSBhIGNhbGVuZGFyIGFwcG9pbnRtZW50IGluIHRoZSBhZ2VudCBpbnRlcmZhY2UuJ30gPQogICAgICAgICdFcm1pdHRlbHQgZGllIG7DpGNoc3Rtw7ZnbGljaGVuIFRpY2tldHN0YXR1cywgbmFjaGRlbSBlaW4gbmV1ZXMgVGlja2V0IGF1cyBlaW5lbSBLYWxlbmRlcnRlcm1pbiBpbiBkZXIgQWdlbnRlbm9iZXJmbMOkY2hlIGVyc3RlbGx0IHd1cmRlLic7CiAgICAkU2VsZi0+e1RyYW5zbGF0aW9ufS0+eydEeW5hbWljIGZpZWxkcyBzaG93biBpbiB0aGUgYXBwb2ludG1lbnQgZWRpdCBzY3JlZW4gb2YgdGhlIGFnZW50IGludGVyZmFjZS4nfSA9CiAgICAgICAgJ0R5bmFtaXNjaGUgRmVsZGVyLCBkaWUgaW4gZGVyIFRlcm1pbmJlYXJiZWl0dW5nc21hc2tlIGRlciBBZ2VudGVuc2Nobml0dHN0ZWxsZSBhbmdlemVpZ3Qgd2VyZGVuJzsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J0xvYWRlcm1vZHVsZSByZWdpc3RyYXRpb24gZm9yIHRoZSBhZ2VudCBpbnRlcmZhY2UuJ30gPSAnTG9hZGVybW9kdWwtUmVnaXN0cmllcnVuZyBmw7xyIGRpZSBBZ2VudGVuc2Nobml0dHN0ZWxsZS4nOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnU2V0cyB0aGUgZGVmYXVsdCBuZXh0IHN0YXRlIGZvciBuZXcgdGlja2V0cyBpbiB0aGUgQWdlbnRBcHBvaW50bWVudEVkaXQgaW50ZXJmYWNlLid9ID0KICAgICAgICAnTGVndCBkZW4gU3RhbmRhcmRuYWNoZm9sZ2VzdGF0dXMgZsO8ciBuZXVlIFRpY2tldHMgaW4gZGVyIFNjaG5pdHRzdGVsbGUgQWdlbnRBcHBvaW50bWVudEVkaXQgZmVzdC4nOwogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnU2V0cyB0aGUgZGVmYXVsdCBwcmlvcml0eSBmb3IgbmV3IHRpY2tldHMgaW4gdGhlIEFnZW50QXBwb2ludG1lbnRFZGl0IGludGVyZmFjZS4nfSA9CiAgICAgICAgJ0xlZ3QgZGllIFN0YW5kYXJkcHJpb3JpdMOkdCBmw7xyIG5ldWUgVGlja2V0cyBpbiBkZXIgU2Nobml0dHN0ZWxsZSBBZ2VudEFwcG9pbnRtZW50RWRpdCBmZXN0Lic7CgoKICAgIHB1c2ggQHsgJFNlbGYtPntKYXZhU2NyaXB0U3RyaW5nc30gLy8gW10gfSwgKAogICAgJyslcyBtb3JlJywKICAgICdBbGwgb2NjdXJyZW5jZXMnLAogICAgJ0FsbC1kYXknLAogICAgJ0FwcG9pbnRtZW50JywKICAgICdBcHInLAogICAgJ0FwcmlsJywKICAgICdBcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gZGVsZXRlIHRoaXMgYXBwb2ludG1lbnQ/IFRoaXMgb3BlcmF0aW9uIGNhbm5vdCBiZSB1bmRvbmUuJywKICAgICdBdWcnLAogICAgJ0F1Z3VzdCcsCiAgICAnQ2xvc2UgdGhpcyBkaWFsb2cnLAogICAgJ0RheScsCiAgICAnRGVjJywKICAgICdEZWNlbWJlcicsCiAgICAnRHVwbGljYXRlZCBlbnRyeScsCiAgICAnRmViJywKICAgICdGZWJydWFyeScsCiAgICAnRmlyc3Qgc2VsZWN0IGEgY3VzdG9tZXIgdXNlciwgdGhlbiBzZWxlY3QgYSBjdXN0b21lciBJRCB0byBhc3NpZ24gdG8gdGhpcyB0aWNrZXQuJywKICAgICdGcicsCiAgICAnRnJpJywKICAgICdGcmlkYXknLAogICAgJ0l0IGlzIGdvaW5nIHRvIGJlIGRlbGV0ZWQgZnJvbSB0aGUgZmllbGQsIHBsZWFzZSB0cnkgYWdhaW4uJywKICAgICdKYW4nLAogICAgJ0phbnVhcnknLAogICAgJ0p1bCcsCiAgICAnSnVseScsCiAgICAnSnVtcCcsCiAgICAnSnVuJywKICAgICdKdW5lJywKICAgICdKdXN0IHRoaXMgb2NjdXJyZW5jZScsCiAgICAnTG9hZGluZy4uLicsCiAgICAnTWFyJywKICAgICdNYXJjaCcsCiAgICAnTWF5JywKICAgICdNYXlfbG9uZycsCiAgICAnTW8nLAogICAgJ01vbicsCiAgICAnTW9uZGF5JywKICAgICdNb250aCcsCiAgICAnTmFtZScsCiAgICAnTmV4dCcsCiAgICAnTm92JywKICAgICdOb3ZlbWJlcicsCiAgICAnT2N0JywKICAgICdPY3RvYmVyJywKICAgICdQbGVhc2UgZWl0aGVyIHR1cm4gc29tZSBvZmYgZmlyc3Qgb3IgaW5jcmVhc2UgdGhlIGxpbWl0IGluIGNvbmZpZ3VyYXRpb24uJywKICAgICdQcmVzcyBDdHJsK0MgKENtZCtDKSB0byBjb3B5IHRvIGNsaXBib2FyZCcsCiAgICAnUHJldmlvdXMnLAogICAgJ1Jlc291cmNlcycsCiAgICAnUmVzdG9yZSBkZWZhdWx0IHNldHRpbmdzJywKICAgICdTYScsCiAgICAnU2F0JywKICAgICdTYXR1cmRheScsCiAgICAnU2F2ZScsCiAgICAnU2VsZWN0IGEgY3VzdG9tZXIgSUQgdG8gYXNzaWduIHRvIHRoaXMgdGlja2V0LicsCiAgICAnU2VwJywKICAgICdTZXB0ZW1iZXInLAogICAgJ1NldHRpbmdzJywKICAgICdTdScsCiAgICAnU3VuJywKICAgICdTdW5kYXknLAogICAgJ1RoJywKICAgICdUaGlzIGFkZHJlc3MgYWxyZWFkeSBleGlzdHMgb24gdGhlIGFkZHJlc3MgbGlzdC4nLAogICAgJ1RoaXMgaXMgYSByZXBlYXRpbmcgYXBwb2ludG1lbnQnLAogICAgJ1RodScsCiAgICAnVGh1cnNkYXknLAogICAgJ1RpbWVsaW5lIERheScsCiAgICAnVGltZWxpbmUgTW9udGgnLAogICAgJ1RpbWVsaW5lIFdlZWsnLAogICAgJ1RvZGF5JywKICAgICdUb28gbWFueSBhY3RpdmUgY2FsZW5kYXJzJywKICAgICdUdScsCiAgICAnVHVlJywKICAgICdUdWVzZGF5JywKICAgICdXZScsCiAgICAnV2VkJywKICAgICdXZWRuZXNkYXknLAogICAgJ1dlZWsnLAogICAgJ1dvdWxkIHlvdSBsaWtlIHRvIGVkaXQganVzdCB0aGlzIG9jY3VycmVuY2Ugb3IgYWxsIG9jY3VycmVuY2VzPycsCiAgICAnbW9yZScsCiAgICAnbm9uZScsCiAgICApOwoKfQoKMTsK # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::System::Daemon::DaemonModules::SchedulerTaskWorker::AppointmentTicket;

use strict;
use warnings;

use parent                        qw(Kernel::System::Daemon::DaemonModules::BaseTaskWorker);
use Kernel::System::VariableCheck qw(:all);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::CustomerUser',
    'Kernel::System::DB',
    'Kernel::System::Daemon::SchedulerDB',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::HTMLUtils',
    'Kernel::System::LinkObject',
    'Kernel::System::Log',
    'Kernel::System::Calendar::Appointment',
    'Kernel::System::Ticket',
    'Kernel::System::Ticket::Article',
);

=head1 NAME

Kernel::System::Daemon::DaemonModules::SchedulerTaskWorker::AppointmentTicket - Scheduler daemon task handler module for AppointmentTicket

=head1 DESCRIPTION

This task handler executes appointment ticket jobs.

=head1 PUBLIC INTERFACE

=head2 new()

    use Kernel::System::ObjectManager;
    local $Kernel::OM = Kernel::System::ObjectManager->new();
    my $TaskHandlerObject = $Kernel::OM-Get('Kernel::System::Daemon::DaemonModules::SchedulerTaskWorker::AppointmentTicket');

=cut

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

    my $Self = {};
    bless( $Self, $Type );

    $Self->{Debug}      = $Param{Debug};
    $Self->{WorkerName} = 'Worker: AppointmentTicket';

    return $Self;
}

=head2 Run()

performs the selected task.

    my $Result = $TaskHandlerObject->Run(
        TaskID   => 123,
        TaskName => 'some name',    # optional
        Data     => {               # appointment id as got from Kernel::System::Calendar::Appointment::AppointmentGet()
            NotifyTime => '2016-08-02 03:59:00',
        },
    );

Returns:

    $Result = 1; # or fail in case of an error

=cut

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

    # check task params
    my $CheckResult = $Self->_CheckTaskParams(
        %Param,
        NeededDataAttributes =>
            [
                'AppointmentTicket', 'AppointmentID'
            ],
    );

    # stop execution if an error in params is detected
    return if !$CheckResult;

    my $DBObject                  = $Kernel::OM->Get('Kernel::System::DB');
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');
    my $ConfigObject              = $Kernel::OM->Get('Kernel::Config');

    my $Config = $ConfigObject->Get('Ticket::Frontend::AgentAppointmentEdit');

    if ( $Self->{Debug} ) {
        print "    $Self->{WorkerName} executes task: $Param{TaskName}\n";
    }

    # fetching customer user from selectedcustomeruser
    my %CustomerUser = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
        User => $Param{Data}->{AppointmentTicket}->{SelectedCustomerUser},
    );

    # create the appointment ticket
    my $TicketID = $Kernel::OM->Get('Kernel::System::Ticket')->TicketCreate(
        $Param{Data}->{AppointmentTicket}->%*,
        CustomerUser => %CustomerUser ? $CustomerUser{UserLogin} : $Param{Data}->{AppointmentTicket}->{SelectedCustomerUser},
    );

    if ( !$TicketID ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not trigger ticket appointment for AppointmentID $Param{Data}->{AppointmentID}!",
        );
    }

    # set dynamic fields for ticket
    my @DynamicFieldConfigs;
    my %DynamicFields;
    if ( $Param{Data}->{AppointmentTicket}->{DynamicFields} ) {

        # Fetch dynamic field configs
        if ( defined $Config->{DynamicField} ) {
            my $DynamicFieldConfigsRef = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
                Valid       => 1,
                ObjectType  => [ 'Ticket', 'Article' ],
                FieldFilter => $Config->{DynamicField} || {},
            );
            @DynamicFieldConfigs = defined $DynamicFieldConfigsRef ? @{$DynamicFieldConfigsRef} : ();
        }

        # set ticket dynamic fields
        %DynamicFields = %{ $Param{Data}->{AppointmentTicket}->{DynamicFields} };
        DYNAMICFIELDTICKET:
        for my $DynamicFieldConfig (@DynamicFieldConfigs) {
            next DYNAMICFIELDTICKET if !IsHashRefWithData($DynamicFieldConfig);
            next DYNAMICFIELDTICKET if $DynamicFieldConfig->{ObjectType} ne 'Ticket';
            if ( $DynamicFields{ $DynamicFieldConfig->{Name} } ) {

                # set the value
                my $Success = $DynamicFieldBackendObject->ValueSet(
                    DynamicFieldConfig => $DynamicFieldConfig,
                    ObjectID           => $TicketID,
                    Value              => $Param{Data}->{AppointmentTicket}->{DynamicFields}->{ $DynamicFieldConfig->{Name} },
                    UserID             => $Param{Data}->{AppointmentTicket}->{UserID},
                );
            }
        }
    }

    # preparing from data
    my $ArticleFrom;
    my @CustomerUsers = split /,/, $Param{Data}->{AppointmentTicket}->{CustomerUser};
    for my $CustomerUser (@CustomerUsers) {
        my %CustomerUserData = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
            User => $CustomerUser,
        );
        my $CustomerUserString
            = %CustomerUserData ? "\"$CustomerUserData{UserFirstname} $CustomerUserData{UserLastname}\" <$CustomerUserData{UserEmail}>" : $CustomerUser;
        if ($ArticleFrom) {
            $ArticleFrom .= ", $CustomerUserString";
        }
        else {
            $ArticleFrom = "$CustomerUserString";
        }
    }

    my $ArticleObject        = $Kernel::OM->Get('Kernel::System::Ticket::Article');
    my $ArticleBackendObject = $ArticleObject->BackendForChannel( ChannelName => 'Internal' );
    my $ArticleID            = $ArticleBackendObject->ArticleCreate(
        TicketID             => $TicketID,
        SenderType           => 'system',
        IsVisibleForCustomer => $Param{Data}->{AppointmentTicket}->{ArticleVisibleForCustomer} || 0,
        From                 => $ArticleFrom,
        To                   => $Param{Data}->{AppointmentTicket}->{UserID},
        Subject              => $Param{Data}->{AppointmentTicket}->{Subject},
        Body                 => $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML( String => $Param{Data}->{AppointmentTicket}->{Content} ),
        MimeType             => 'text/html',
        Charset              => 'utf-8',
        UserID               => $Param{Data}->{AppointmentTicket}->{UserID},
        HistoryType          => 'Misc',
        HistoryComment       => 'Automatically created ticket from appointment',
        AutoResponseType     => ( $ConfigObject->Get('AutoResponseForWebTickets') )
        ? 'auto reply'
        : '',
        OrigHeader => {
            From    => $ArticleFrom,
            To      => $Param{Data}->{AppointmentTicket}->{UserID},
            Subject => $Param{Data}->{AppointmentTicket}->{Subject},
            Body    => $Param{Data}->{AppointmentTicket}->{Content},
        },
        Queue => $Param{Data}->{AppointmentTicket}->{QueueID},
    );

    if ( !$ArticleID ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not create article for ticket $TicketID from appointment $Param{Data}->{AppointmentID}!",
        );
    }

    # set article dynamic fields
    if ( $Param{Data}->{AppointmentTicket}->{DynamicFields} ) {
        DYNAMICFIELDARTICLE:
        for my $DynamicFieldConfig (@DynamicFieldConfigs) {
            next DYNAMICFIELDARTICLE if !IsHashRefWithData($DynamicFieldConfig);
            next DYNAMICFIELDARTICLE if $DynamicFieldConfig->{ObjectType} ne 'Article';
            if ( $DynamicFields{ $DynamicFieldConfig->{Name} } ) {

                # set the value
                my $Success = $DynamicFieldBackendObject->ValueSet(
                    DynamicFieldConfig => $DynamicFieldConfig,
                    ObjectID           => $ArticleID,
                    Value              => $Param{Data}->{AppointmentTicket}->{DynamicFields}->{ $DynamicFieldConfig->{Name} },
                    UserID             => $Param{Data}->{AppointmetTicket}->{UserID},
                );
            }
        }
    }

    my %Appointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet(
        AppointmentID => $Param{Data}->{AppointmentID},
    );

    # link the tickets
    $Kernel::OM->Get('Kernel::System::LinkObject')->LinkAdd(
        SourceObject => 'Appointment',
        SourceKey    => $Appointment{AppointmentID},
        TargetObject => 'Ticket',
        TargetKey    => $TicketID,
        Type         => 'Normal',
        State        => 'Valid',
        UserID       => $Param{Data}->{AppointmentTicket}->{UserID},
    );

    # delete future task id from appointment
    my $Success = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentUpdate(
        %Appointment,
        UserID       => $Param{Data}->{AppointmentTicket}->{UserID},
        FutureTaskID => undef,
    );

    # Check if appointment is recurring and if so, create next future task for appointment which is in the future and closest to now
    if ( $Appointment{Recurring} || $Appointment{ParentID} ) {

        # Get all related appointments
        my @Appointments = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentList(
            CalendarID => $Appointment{CalendarID},
            ParentID   => $Appointment{ParentID} || $Appointment{AppointmentID},
        );

        # Push parent into list since AppointmentList with filter ParentID does not include the parent itself
        my %ParentAppointment = $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentGet(
            AppointmentID => ( $Appointment{ParentID} ? $Appointment{ParentID} : $Appointment{AppointmentID} )
        );
        push @Appointments, \%ParentAppointment;

        my $CurrentTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime'
        );

        my $NextAppointment;
        my $TimeDiff;
        my $ExecutionTime;
        for my $AppointmentRef (@Appointments) {

            my $AppointmentExecutionTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentToTicketExecutionTime(
                        Data => {
                            TicketTime                      => $Param{Data}->{AppointmentTicket}->{Time},
                            TicketTemplate                  => $Param{Data}->{AppointmentTicket}->{Template},
                            TicketCustom                    => $Param{Data}->{AppointmentTicket}->{Custom},
                            TicketCustomRelativeUnitCount   => $Param{Data}->{AppointmentTicket}->{CustomRelativeUnitCount},
                            TicketCustomRelativeUnit        => $Param{Data}->{AppointmentTicket}->{CustomRelativeUnit},
                            TicketCustomRelativePointOfTime => $Param{Data}->{AppointmentTicket}->{CustomRelativePointOfTime},
                            TicketCustomDateTime            => $Param{Data}->{AppointmentTicket}->{CustomDateTime},
                        },
                        StartTime => $AppointmentRef->{StartTime},
                        EndTime   => $AppointmentRef->{EndTime},
                    ),
                },
            );
            if ( $AppointmentExecutionTimeObject->Compare( DateTimeObject => $CurrentTimeObject ) > 0 ) {
                my $DeltaResult = $AppointmentExecutionTimeObject->Delta( DateTimeObject => $CurrentTimeObject );
                if ( !defined $TimeDiff ) {
                    $NextAppointment = $AppointmentRef;
                    $TimeDiff        = $DeltaResult->{AbsoluteSeconds};
                    $ExecutionTime   = $AppointmentExecutionTimeObject->ToString();
                }
                elsif ( $DeltaResult->{AbsoluteSeconds} < $TimeDiff ) {
                    $NextAppointment = $AppointmentRef;
                    $TimeDiff        = $DeltaResult->{AbsoluteSeconds};
                    $ExecutionTime   = $AppointmentExecutionTimeObject->ToString();
                }
            }
        }

        if ($NextAppointment) {

            # update appointment in db
            $Kernel::OM->Get('Kernel::System::Calendar::Appointment')->AppointmentUpdate(
                $NextAppointment->%*,
                UserID            => $Param{Data}->{AppointmentTicket}->{UserID},
                AppointmentTicket => {
                    $Param{Data}->{AppointmentTicket}->%*,
                },
            );
        }

    }

    return $TicketID;
}

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

use strict;
use warnings;
use utf8;

# Set up the test driver $Self when we are running as a standalone script.
use Kernel::System::UnitTest::RegisterDriver;

our $Self;

$Kernel::OM->ObjectParamAdd(
    'Kernel::System::UnitTest::Helper' => {
        RestoreDatabase => 1,
    },
);
my $HelperObject = $Kernel::OM->Get('Kernel::System::UnitTest::Helper');
my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

# Do not check emails.
$ConfigObject->Set(
    Key   => 'CheckEmailAddresses',
    Value => 0,
);

# Get necessary objects.
my $CalendarObject    = $Kernel::OM->Get('Kernel::System::Calendar');
my $AppointmentObject = $Kernel::OM->Get('Kernel::System::Calendar::Appointment');
my $ArticleObject     = $Kernel::OM->Get('Kernel::System::Ticket::Article');
my $LinkObject        = $Kernel::OM->Get('Kernel::System::LinkObject');
my $SchedulerDBObject = $Kernel::OM->Get('Kernel::System::Daemon::SchedulerDB');
my $TaskHandlerObject = $Kernel::OM->Get('Kernel::System::Daemon::DaemonModules::SchedulerTaskWorker::AppointmentTicket');
my $TicketObject      = $Kernel::OM->Get('Kernel::System::Ticket');
$Self->Is(
    ref $SchedulerDBObject,
    'Kernel::System::Daemon::SchedulerDB',
    "Kernel::System::Daemon::SchedulerDB->new()",
);

# Create calendar
my $CalendarName = 'Test_' . $HelperObject->GetRandomID();
my %Calendar     = $CalendarObject->CalendarCreate(
    CalendarName => $CalendarName,
    GroupID      => 1,
    Color        => '#FF7700',
    UserID       => 1,
);

my $StartTimeObj = $Kernel::OM->Create(
    'Kernel::System::DateTime'
);
$StartTimeObj->Add(
    Days => 1,
);
my $EndTimeObj = $Kernel::OM->Create(
    'Kernel::System::DateTime'
);
$EndTimeObj->Add(
    Days  => 1,
    Hours => 1,
);

# Create Test Customer User
my $TestCustomerUserLogin = $HelperObject->TestCustomerUserCreate();

# Create Appointment with FutureTask
my $RandomID          = $HelperObject->GetRandomID();
my %AppointmentTicket = (
    Time                      => undef,
    Template                  => 'Start',
    Custom                    => "",
    CustomRelativeUnitCount   => undef,
    CustomRelativeUnit        => 'minutes',
    CustomRelativePointOfTime => 'beforestart',
    CustomDateTime            => undef,
    QueueID                   => 1,
    CustomerID                => $TestCustomerUserLogin,
    CustomerUser              => $TestCustomerUserLogin,
    SelectedCustomerUser      => $TestCustomerUserLogin,
    UserID                    => 1,
    OwnerID                   => 1,
    Lock                      => 'unlock',
    PriorityID                => 3,
    StateID                   => 4,
    ServiceID                 => undef,
    SLAID                     => undef,
    TypeID                    => undef,
    Title                     => 'SomeTitle_' . $RandomID,
    Subject                   => 'SomeTitle_' . $RandomID,
    Content                   => 'SomeDescription_' . $RandomID,
    DynamicFields             => undef,
    ArticleVisibleForCustomer => undef,
);
my $SingleAppointmentID = $AppointmentObject->AppointmentCreate(
    CalendarID                      => $Calendar{CalendarID},
    Title                           => 'SomeTitle_' . $RandomID,
    Description                     => 'SomeDescription_' . $RandomID,
    StartTime                       => $StartTimeObj->ToString(),
    EndTime                         => $EndTimeObj->ToString(),
    UserID                          => 1,
    AppointmentTicket               => \%AppointmentTicket,
    TicketTemplate                  => $AppointmentTicket{Template},
    TicketCustom                    => $AppointmentTicket{Custom},
    TicketCustomRelativeUnit        => $AppointmentTicket{CustomRelativeUnit},
    TicketCustomRelativePointOfTime => $AppointmentTicket{CustomRelativePointOfTime},
);

my %SingleAppointment = $AppointmentObject->AppointmentGet(
    AppointmentID => $SingleAppointmentID,
);

my %FutureTask = $SchedulerDBObject->FutureTaskGet(
    TaskID => $SingleAppointment{FutureTaskID},
);

# Trigger Future Task Execution
$TaskHandlerObject->Run(
    TaskID   => $FutureTask{TaskID},
    TaskName => $FutureTask{Name},
    Data     => $FutureTask{Data},
);

# Check if ticket was created -> via link object
my $LinkList = $LinkObject->LinkList(
    Object => 'Appointment',
    Key    => $SingleAppointmentID,
    State  => 'Valid',
    UserID => 1,
);

$Self->Is(
    scalar keys %{$LinkList},
    1,
    "The number of created links for the appointment is not correct",
);

# Fetch Ticket
my %Ticket = $TicketObject->TicketGet(
    TicketID => ( keys $LinkList->{Ticket}->{Normal}->{Source}->%* )[0],
    UserID   => 1,
);

$Self->IsNot(
    scalar keys %Ticket,
    0,
    "Ticket was not created",
);

# Fetch Article
my @ArticleList = $ArticleObject->ArticleList(
    TicketID => $Ticket{TicketID},
);

$Self->Is(
    scalar @ArticleList,
    1,
    "The number of created articles for the ticket is not correct",
);

my %Article = $ArticleObject->BackendForArticle( %{ $ArticleList[0] } )->ArticleGet( %{ $ArticleList[0] } );
$Self->IsNot(
    scalar keys %Article,
    0,
    "Article was not created",
);

# Create Recurring Appointment with Future Task on Parent Appointment
my $RandomIDRecurring          = $HelperObject->GetRandomID();
my %AppointmentTicketRecurring = (
    Time                      => undef,
    Template                  => 'Start',
    Custom                    => "",
    CustomRelativeUnitCount   => undef,
    CustomRelativeUnit        => 'minutes',
    CustomRelativePointOfTime => 'beforestart',
    CustomDateTime            => undef,
    QueueID                   => 1,
    CustomerID                => $TestCustomerUserLogin,
    CustomerUser              => $TestCustomerUserLogin,
    SelectedCustomerUser      => $TestCustomerUserLogin,
    UserID                    => 1,
    OwnerID                   => 1,
    Lock                      => 'unlock',
    PriorityID                => 3,
    StateID                   => 4,
    ServiceID                 => undef,
    SLAID                     => undef,
    TypeID                    => undef,
    Title                     => 'SomeTitle_' . $RandomIDRecurring,
    Subject                   => 'SomeTitle_' . $RandomIDRecurring,
    Content                   => 'SomeDescription_' . $RandomIDRecurring,
    DynamicFields             => undef,
    ArticleVisibleForCustomer => undef,
);
my $RecurringAppointmentID = $AppointmentObject->AppointmentCreate(
    CalendarID                      => $Calendar{CalendarID},
    Recurring                       => 1,
    RecurrenceDays                  => "",
    RecurrenceMonths                => "",
    RecurrenceMonthDays             => "",
    RecurrenceType                  => "Weekly",
    RecurrenceCustomType            => "CustomDaily",
    RecurrenceInterval              => 1,
    Days                            => 4,
    MonthDays                       => 30,
    Months                          => 6,
    RecurrenceLimit                 => 2,
    RecurrenceUntilDay              => 3,
    RecurrenceUntilMonth            => 7,
    RecurrenceUntilYear             => 2022,
    RecurrenceCount                 => 4,
    Title                           => 'SomeTitle_' . $RandomIDRecurring,
    Description                     => 'SomeDescription_' . $RandomIDRecurring,
    StartTime                       => $StartTimeObj->ToString(),
    EndTime                         => $EndTimeObj->ToString(),
    UserID                          => 1,
    AppointmentTicket               => \%AppointmentTicketRecurring,
    TicketTemplate                  => $AppointmentTicketRecurring{Template},
    TicketCustom                    => $AppointmentTicketRecurring{Custom},
    TicketCustomRelativeUnit        => $AppointmentTicketRecurring{CustomRelativeUnit},
    TicketCustomRelativePointOfTime => $AppointmentTicketRecurring{CustomRelativePointOfTime},
);
$Kernel::OM->Get('Kernel::System::Cache')->CleanUp();

my %RecurringAppointment = $AppointmentObject->AppointmentGet(
    AppointmentID => $RecurringAppointmentID,
);

my %FutureTaskRecurring = $SchedulerDBObject->FutureTaskGet(
    TaskID => $RecurringAppointment{FutureTaskID},
);

my $StartTimePastObj = $Kernel::OM->Create(
    'Kernel::System::DateTime',
);
$StartTimePastObj->Subtract(
    Days => 4,
);

my $EndTimePastObj = $Kernel::OM->Create(
    'Kernel::System::DateTime',
    Days  => 3,
    Hours => 23,
);

# Shift Appointment to the past and check if FutureTask was shifted to the correct Child Appointment
my $Success = $AppointmentObject->AppointmentUpdate(
    %RecurringAppointment,
    AppointmentTicket => $FutureTaskRecurring{Data}->{AppointmentTicket},
    StartTime         => $StartTimePastObj->ToString(),
    EndTime           => $EndTimePastObj->ToString(),
    UserID            => 1,
);

# Check if FutureTask was shifted correctly
my @AppointmentList = $AppointmentObject->AppointmentList(
    CalendarID => $Calendar{CalendarID},
    ParentID   => $RecurringAppointmentID,
);

$Self->Is(
    scalar @AppointmentList,
    3,
    "Number of child appointments is not correct",
);

$Self->IsNot(
    $AppointmentList[0]->{FutureTaskID},
    undef,
    "Future task was not shifted correctly",
);

# Create Appointment with FutureTask, shift it and check FutureTask Execution Time
my $SingleAppointmentID2 = $AppointmentObject->AppointmentCreate(
    CalendarID                      => $Calendar{CalendarID},
    Title                           => 'SomeTitle_' . $RandomID,
    Description                     => 'SomeDescription_' . $RandomID,
    StartTime                       => $StartTimeObj->ToString(),
    EndTime                         => $EndTimeObj->ToString(),
    UserID                          => 1,
    AppointmentTicket               => \%AppointmentTicket,
    TicketTemplate                  => $AppointmentTicket{Template},
    TicketCustom                    => $AppointmentTicket{Custom},
    TicketCustomRelativeUnit        => $AppointmentTicket{CustomRelativeUnit},
    TicketCustomRelativePointOfTime => $AppointmentTicket{CustomRelativePointOfTime},
);

my %SingleAppointment2 = $AppointmentObject->AppointmentGet(
    AppointmentID => $SingleAppointmentID2,
);
my %FutureTask2 = $SchedulerDBObject->FutureTaskGet(
    TaskID => $SingleAppointment2{FutureTaskID},
);
$StartTimeObj->Add(
    Days => 1
);
$EndTimeObj->Add(
    Days => 1,
);

# Update Appointment
$Success = $AppointmentObject->AppointmentUpdate(
    %SingleAppointment2,
    AppointmentTicket => $FutureTask2{Data}->{AppointmentTicket},
    StartTime         => $StartTimeObj->ToString(),
    EndTime           => $EndTimeObj->ToString(),
    UserID            => 1,
);

my %SingleAppointment2Updated = $AppointmentObject->AppointmentGet(
    AppointmentID => $SingleAppointmentID2,
);

$Self->Is(
    $Success,
    1,
    "Appointment update was not successful",
);

my %FutureTask2Updated = $SchedulerDBObject->FutureTaskGet(
    TaskID => $SingleAppointment2Updated{FutureTaskID},
);

$Self->Is(
    $FutureTask2Updated{ExecutionTime},
    $StartTimeObj->ToString(),
    "Future task was not updated correctly",
);

# Create Recurring Appointment with Future Task on Parent Appointment
my $RecurringAppointmentID2 = $AppointmentObject->AppointmentCreate(
    CalendarID                      => $Calendar{CalendarID},
    Title                           => 'SomeTitle_' . $RandomIDRecurring,
    Description                     => 'SomeDescription_' . $RandomIDRecurring,
    StartTime                       => $StartTimeObj->ToString(),
    EndTime                         => $EndTimeObj->ToString(),
    UserID                          => 1,
    AppointmentTicket               => \%AppointmentTicketRecurring,
    TicketTemplate                  => $AppointmentTicketRecurring{Template},
    TicketCustom                    => $AppointmentTicketRecurring{Custom},
    TicketCustomRelativeUnit        => $AppointmentTicketRecurring{CustomRelativeUnit},
    TicketCustomRelativePointOfTime => $AppointmentTicketRecurring{CustomRelativePointOfTime},
);
$Kernel::OM->Get('Kernel::System::Cache')->CleanUp();

my %RecurringAppointment2 = $AppointmentObject->AppointmentGet(
    AppointmentID => $RecurringAppointmentID2,
);

my %FutureTaskRecurring2 = $SchedulerDBObject->FutureTaskGet(
    TaskID => $RecurringAppointment2{FutureTaskID},
);

$StartTimeObj->Add(
    Days => 1
);
$EndTimeObj->Add(
    Days => 1,
);

# Update Appointment
$Success = $AppointmentObject->AppointmentUpdate(
    %RecurringAppointment2,
    AppointmentTicket => $FutureTaskRecurring2{Data}->{AppointmentTicket},
    StartTime         => $StartTimeObj->ToString(),
    EndTime           => $EndTimeObj->ToString(),
    UserID            => 1,
);

$Self->Is(
    $Success,
    1,
    "Appointment update was not successful",
);

my %FutureTaskRecurring2Updated = $SchedulerDBObject->FutureTaskGet(
    TaskID => $RecurringAppointment2{FutureTaskID},
);

$Self->Is(
    $FutureTaskRecurring2Updated{ExecutionTime},
    $StartTimeObj->ToString(),
    "Future task was not updated correctly",
);

$Self->DoneTesting();
 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 // --
// OTOBO is a web-based ticketing system for service organisations.
// --
// Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
// Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
// --
// $origin: otobo - deb99d60daf212ae73ec7feb78074f3f7ae563f8 - var/httpd/htdocs/js/Core.Agent.AppointmentCalendar.js
// --
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// --

/*global Clipboard */   // eslint-disable-line no-redeclare

"use strict";

var Core = Core || {};
Core.Agent = Core.Agent || {};

/**
 * @namespace Core.Agent.AppointmentCalendar
 * @memberof Core.Agent
 * @author
 * @description
 *      This namespace contains the appointment calendar functions.
 */
Core.Agent.AppointmentCalendar = (function (TargetNS) {

    // Appointment days cache and ready flag
    var AppointmentDaysCache,
        AppointmentDaysCacheRefreshed = false,
        AJAXCounter = 0,
        CurrentView,
        CalendarSources = {};

    /**
     * @name Init
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      Initializes the appointment calendar control.
     */
    TargetNS.Init = function () {
        var CalendarConfig = Core.Config.Get('CalendarConfig'),
            ResourceConfig,
            $CalendarObj = $('#calendar'),
            $DatepickerObj,
            ClipboardJS,
            CurrentAppointment = [];

        if (Core.Config.Get('Action') == 'AgentAppointmentAgendaOverview') {
            TargetNS.AgentAppointmentAgendaOverview();
            return;
        }

        if (!CalendarConfig) {
            return;
        }

        $DatepickerObj = $('<div />')
            .prop('id', 'Datepicker')
            .addClass('Hidden')
            .insertAfter($CalendarObj),

        ClipboardJS = new Clipboard('.CopyToClipboard');

        if (Core.Config.Get('TeamID')) {
            ResourceConfig = {
                url: Core.Config.Get('CGIHandle'),
                type: 'POST',
                data: {
                    ChallengeToken: $('#ChallengeToken').val(),
                    Action: 'AgentAppointmentTeamList',
                    Subaction: 'ListResources',
                    TeamID: Core.Config.Get('TeamID')
                }
            };
        }

        // Initialize calendar
        $CalendarObj.fullCalendar({
            header: {
                left: 'month,agendaWeek,agendaDay timelineMonth,timelineWeek,timelineDay',
                center: 'title',
                right: 'jump,today prev,next'
            },
            customButtons: {
                jump: {
                    text: Core.Language.Translate('Jump'),
                    click: function() {
                        ShowDatepicker($CalendarObj, $DatepickerObj, $(this));
                    }
                }
            },
            defaultView: Core.Config.Get('DefaultView'),
            allDayText: Core.Language.Translate('All-day'),
            isRTL: Core.Config.Get('IsRTLLanguage'),
            columnFormat: 'ddd, D MMM',
            timeFormat: 'HH:mm',
            slotLabelFormat: 'HH:mm',
            titleFormat: 'D MMM YYYY',
            weekNumbers: true,
            weekNumberTitle: '#',
            weekNumberCalculation: 'ISO',
            eventLimit: true,
            eventLimitText: Core.Language.Translate('more'),
            height: 600,
            editable: true,
            selectable: true,
            firstDay: Core.Config.Get('CalendarWeekDayStart'),
            monthNames: [
                Core.Language.Translate('January'),
                Core.Language.Translate('February'),
                Core.Language.Translate('March'),
                Core.Language.Translate('April'),
                Core.Language.Translate('May_long'),
                Core.Language.Translate('June'),
                Core.Language.Translate('July'),
                Core.Language.Translate('August'),
                Core.Language.Translate('September'),
                Core.Language.Translate('October'),
                Core.Language.Translate('November'),
                Core.Language.Translate('December')
            ],
            monthNamesShort: [
                Core.Language.Translate('Jan'),
                Core.Language.Translate('Feb'),
                Core.Language.Translate('Mar'),
                Core.Language.Translate('Apr'),
                Core.Language.Translate('May'),
                Core.Language.Translate('Jun'),
                Core.Language.Translate('Jul'),
                Core.Language.Translate('Aug'),
                Core.Language.Translate('Sep'),
                Core.Language.Translate('Oct'),
                Core.Language.Translate('Nov'),
                Core.Language.Translate('Dec')
            ],
            dayNames: [
                Core.Language.Translate('Sunday'),
                Core.Language.Translate('Monday'),
                Core.Language.Translate('Tuesday'),
                Core.Language.Translate('Wednesday'),
                Core.Language.Translate('Thursday'),
                Core.Language.Translate('Friday'),
                Core.Language.Translate('Saturday')
            ],
            dayNamesShort: [
                Core.Language.Translate('Sun'),
                Core.Language.Translate('Mon'),
                Core.Language.Translate('Tue'),
                Core.Language.Translate('Wed'),
                Core.Language.Translate('Thu'),
                Core.Language.Translate('Fri'),
                Core.Language.Translate('Sat')
            ],
            buttonText: {
                today: Core.Language.Translate('Today'),
                month: Core.Language.Translate('Month'),
                week: Core.Language.Translate('Week'),
                day: Core.Language.Translate('Day'),
                timelineMonth: Core.Language.Translate('Timeline Month'),
                timelineWeek: Core.Language.Translate('Timeline Week'),
                timelineDay: Core.Language.Translate('Timeline Day'),
                jump: Core.Language.Translate('Jump'),
                prevDatepicker: Core.Language.Translate('Previous'),
                nextDatepicker: Core.Language.Translate('Next')
            },
            schedulerLicenseKey: 'GPL-My-Project-Is-Open-Source',
            slotDuration: '00:30:00',
            forceEventDuration: true,
            nowIndicator: true,
            timezone: 'local',
            resourceAreaWidth: '21%',
            views: {
                month: {
                    titleFormat: 'MMMM YYYY',
                    columnFormat: 'dddd'
                },
                agendaDay: {
                    titleFormat: 'D MMM YYYY',
                    resources: false
                },
                timelineMonth: {
                    slotDuration: '24:00:00',
                    duration: {
                        months: 1
                    },
                    slotLabelFormat: [
                        'D'
                    ]
                },
                timelineWeek: {
                    slotDuration: '02:00:00',
                    duration: {
                        week: 1
                    },
                    slotLabelFormat: [
                        'ddd, D MMM',
                        'HH'
                    ]
                },
                timelineDay: {
                    slotDuration: '00:30:00',
                    duration: {
                        days: 1
                    },
                    slotLabelFormat: [
                        'ddd, D MMM',
                        'HH:mm'
                    ]
                }
            },
            loading: function(IsLoading) {
                if (IsLoading) {
                    $('.CalendarWidget').addClass('Loading');
                } else {
                    $('.CalendarWidget').removeClass('Loading');
                }
            },
            viewRender: function(View) {

                // Check if we are on a timeline view.
                if (View.name === 'timelineWeek' || View.name === 'timelineDay') {

                    // Add calendar week number to timeline view titles.
                    window.setTimeout(function () {
                        $CalendarObj.find('.fc-toolbar > div > h2').append(
                            $('<span />').addClass('fc-week-number')
                                .text(View.start.format(' #W'))
                        );
                    }, 0);

                    // Initialize restore settings button.
                    RestoreDefaultSettingsInit();
                }

                // Remember view selection
                if (CurrentView !== undefined && CurrentView !== View.name) {
                    Core.AJAX.FunctionCall(
                        Core.Config.Get('CGIHandle'),
                        {
                            ChallengeToken: $('#ChallengeToken').val(),
                            Action: 'AgentAppointmentEdit',
                            Subaction: 'UpdatePreferences',
                            OverviewScreen: Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'CalendarOverview',
                            DefaultView: View.name
                        },
                        function (Response) {
                            if (!Response.Success) {
                                Core.Debug.Log('Error updating user preferences!');
                            }
                        }
                    );
                }
                CurrentView = View.name;
            },
            select: function(Start, End, JSEvent, View, Resource) {
                var Data = {
                    Start: Start,
                    End: End,
                    JSEvent: JSEvent,
                    View: View,
                    Resource: Resource
                };
                TargetNS.OpenEditDialog(Data);
                $CalendarObj.fullCalendar('unselect');
            },
            eventClick: function(CalEvent, JSEvent) {
                var Data = {
                    Start: CalEvent.start,
                    End: CalEvent.end,
                    CalEvent: CalEvent
                };
                TargetNS.OpenEditDialog(Data);
                JSEvent.stopPropagation();
                return false;
            },
            eventDrop: function(CalEvent, Delta, RevertFunc) {
                var Data = {
                    CalEvent: CalEvent,
                    PreviousAppointment: CurrentAppointment,
                    Delta: Delta,
                    RevertFunc: RevertFunc
                };
                UpdateAppointment(Data);
            },
            eventResize: function(CalEvent, Delta, RevertFunc) {
                var Data = {
                    CalEvent: CalEvent,
                    PreviousAppointment: CurrentAppointment,
                    Delta: Delta,
                    RevertFunc: RevertFunc
                };
                UpdateAppointment(Data);
            },
            eventRender: function(CalEvent, $Element) {
                var $IconContainer,
                    $Icon;

                if (CalEvent.allDay
                    || CalEvent.recurring
                    || CalEvent.parentId
                    || CalEvent.notification
                    || CalEvent.ticketAppointmentType) {

                    // Create container and icon element
                    $IconContainer = $('<div />').addClass('Icons');
                    $Icon = $('<i />').addClass('fa');

                    // Mark appointment with appropriate icon(s)
                    if (CalEvent.allDay) {
                        $Icon.clone()
                            .addClass('fa-sun-o')
                            .appendTo($IconContainer);
                    }
                    if (CalEvent.recurring) {
                        $Icon.clone()
                            .addClass('fa-repeat')
                            .appendTo($IconContainer);
                    }
                    if (CalEvent.parentId) {
                        $Icon.clone()
                            .addClass('fa-link')
                            .appendTo($IconContainer);
                    }
                    if (CalEvent.notification) {
                        $Icon.clone()
                            .addClass('fa-bell')
                            .appendTo($IconContainer);
                    }
                    if (CalEvent.ticketAppointmentType) {
                        $Icon.clone()
                            .addClass('fa-char-' + Core.Config.Get('TicketAppointmentConfig')[CalEvent.ticketAppointmentType].Mark)
                            .appendTo($IconContainer);
                    }

                    // Prepend container to the appointment
                    $Element.find('.fc-content')
                        .prepend($IconContainer);
                }
            },
            eventResizeStart: function(CalEvent) {
                CurrentAppointment.start = CalEvent.start;
                CurrentAppointment.end = CalEvent.end;
            },
            eventDragStart: function(CalEvent) {
                CurrentAppointment.start = CalEvent.start;
                CurrentAppointment.end = CalEvent.end;
                CurrentAppointment.resourceIds = CalEvent.resourceIds;
            },
            eventMouseover: function(CalEvent, JSEvent) {
                var $TooltipObj,
                    PosX = 0,
                    PosY = 0,
                    TooltipHTML = Core.Template.Render('Agent/AppointmentCalendar/AppointmentTooltip', {
                        'PluginList': Core.Config.Get('PluginList'),
                        'CalEvent': CalEvent,
                        'TooltipTemplateResource': Core.Config.Get('TooltipTemplateResource') || 0,
                        'TicketAppointmentConfig': Core.Config.Get('TicketAppointmentConfig')
                    }),
                    DocumentVisibleLeft = $(document).scrollLeft() + $(window).width(),
                    DocumentVisibleTop = $(document).scrollTop() + $(window).height(),
                    LastXPosition,
                    LastYPosition;

                if (!JSEvent) {
                    JSEvent = window.event;
                }
                if (JSEvent.pageX || JSEvent.pageY) {
                    PosX = JSEvent.pageX;
                    PosY = JSEvent.pageY;
                } else if (JSEvent.clientX || JSEvent.clientY) {
                    PosX = JSEvent.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
                    PosY = JSEvent.clientY + document.body.scrollTop + document.documentElement.scrollTop;
                }

                // Increase positions so the tooltip do not overlap with mouse pointer
                PosX += 10;
                PosY += 10;

                if (TooltipHTML.length > 0) {

                    // Create tooltip object
                    $TooltipObj = $(TooltipHTML)
                        .offset({
                            top: PosY,
                            left: PosX
                        })
                        .appendTo('body');

                    // Re-calculate top position if needed
                    LastYPosition = PosY + $TooltipObj.height();
                    if (LastYPosition > DocumentVisibleTop) {
                        PosY = PosY - $TooltipObj.height();
                        $TooltipObj.css('top', PosY + 'px');
                    }

                    // Re-calculate left position if needed
                    LastXPosition = PosX + $TooltipObj.width();
                    if (LastXPosition > DocumentVisibleLeft) {
                        PosX = PosX - $TooltipObj.width() - 30;
                        $TooltipObj.css('left', PosX + 'px');
                    }

                    // Show the tooltip
                    $TooltipObj.fadeIn('fast');
                }
            },
            eventMouseout: function() {
                $('.AppointmentTooltip').fadeOut("fast").remove();
            },
            eventAfterAllRender: function () {

                // If the first day in timelineMonth view is not Saturday or Sunday, the first div.fc-bgevent should be removed.
                // There is a bug from fullcalendar and it can be solved here. See bug#14764.
                if (!$('.fc-timelineMonth-view .fc-slats td.fc-widget-content:eq(0)').hasClass('fc-sat')
                    && !$('.fc-timelineMonth-view .fc-slats td.fc-widget-content:eq(0)').hasClass('fc-sun')) {
                    $('.fc-timelineMonth-view .fc-bgevent-container .fc-bgevent:eq(0)').remove();
                }
            },
            events: Core.Config.Get('WorkingHoursConfig'),
            resources: ResourceConfig,
            resourceColumns: [
                {
                    labelText: Core.Language.Translate('Name'),
                    field: 'title'
                }
            ],
            resourceLabelText: Core.Language.Translate('Resources')
        });

        // Initialize datepicker
        $DatepickerObj.datepicker({
            showOn: 'button',
            buttonText: Core.Language.Translate('Jump'),
            constrainInput: true,
            prevText: Core.Language.Translate('Previous'),
            nextText: Core.Language.Translate('Next'),
            firstDay: Core.Config.Get('CalendarWeekDayStart'),
            showMonthAfterYear: 0,
            monthNames: [
                Core.Language.Translate('January'),
                Core.Language.Translate('February'),
                Core.Language.Translate('March'),
                Core.Language.Translate('April'),
                Core.Language.Translate('May_long'),
                Core.Language.Translate('June'),
                Core.Language.Translate('July'),
                Core.Language.Translate('August'),
                Core.Language.Translate('September'),
                Core.Language.Translate('October'),
                Core.Language.Translate('November'),
                Core.Language.Translate('December')
            ],
            monthNamesShort: [
                Core.Language.Translate('Jan'),
                Core.Language.Translate('Feb'),
                Core.Language.Translate('Mar'),
                Core.Language.Translate('Apr'),
                Core.Language.Translate('May'),
                Core.Language.Translate('Jun'),
                Core.Language.Translate('Jul'),
                Core.Language.Translate('Aug'),
                Core.Language.Translate('Sep'),
                Core.Language.Translate('Oct'),
                Core.Language.Translate('Nov'),
                Core.Language.Translate('Dec')
            ],
            dayNames: [
                Core.Language.Translate('Sunday'),
                Core.Language.Translate('Monday'),
                Core.Language.Translate('Tuesday'),
                Core.Language.Translate('Wednesday'),
                Core.Language.Translate('Thursday'),
                Core.Language.Translate('Friday'),
                Core.Language.Translate('Saturday')
            ],
            dayNamesShort: [
                Core.Language.Translate('Sun'),
                Core.Language.Translate('Mon'),
                Core.Language.Translate('Tue'),
                Core.Language.Translate('Wed'),
                Core.Language.Translate('Thu'),
                Core.Language.Translate('Fri'),
                Core.Language.Translate('Sat')
            ],
            dayNamesMin: [
                Core.Language.Translate('Su'),
                Core.Language.Translate('Mo'),
                Core.Language.Translate('Tu'),
                Core.Language.Translate('We'),
                Core.Language.Translate('Th'),
                Core.Language.Translate('Fr'),
                Core.Language.Translate('Sa')
            ],
            isRTL: Core.Config.Get('IsRTLLanguage'),
            onSelect: function(DateText) {
                $CalendarObj.fullCalendar('gotoDate', new Date(DateText));
                $('#DatepickerOverlay').remove();
                $DatepickerObj.hide();
            },
            beforeShowDay: function(DateObject) {
                if (AppointmentDaysCacheRefreshed) {
                    return CheckDate(DateObject);
                } else {
                    return [true];
                }
            },
            onChangeMonthYear: function(Year, Month) {
                AppointmentDays($DatepickerObj, Year, Month);
            }
        });

        $.each(CalendarConfig, function (Index, Calendar) {
            var CalendarData = {
                ChallengeToken: $("#ChallengeToken").val(),
                Action: 'AgentAppointmentList',
                Subaction: 'ListAppointments',
                CalendarID: Calendar.CalendarID,
                ResourceID: Core.Config.Get('ResourceID'),
                TeamID: Core.Config.Get('TeamID')
            };
            CalendarSources[Calendar.CalendarID] = {
                id: Calendar.CalendarID,
                url: Core.Config.Get('CGIHandle'),
                type: 'POST',
                data: CalendarData,
                color: Calendar.Color,
                textColor: Calendar.TextColor,
                borderColor: 'rgba(0, 0, 0, 0.2)',
                startParam: 'StartTime',
                endParam: 'EndTime',

                // Workaround for removeEventSource.
                googleCalendarId: Calendar.CalendarID,

                eventDataTransform: function(AppointmentData) {
                    var TicketAppointmentConfig = Core.Config.Get('TicketAppointmentConfig');

                    return {
                        id: AppointmentData.AppointmentID,
                        parentId: AppointmentData.ParentID,
                        start: AppointmentData.StartTime,
                        startDate: AppointmentData.StartDate,
                        end: AppointmentData.EndTime,
                        endDate: AppointmentData.EndDate,
                        title: AppointmentData.Title,
                        description: AppointmentData.Description,
                        location: AppointmentData.Location,
                        calendarId: AppointmentData.CalendarID,
                        allDay: parseInt(AppointmentData.AllDay, 10) ? true : false,
                        recurring: parseInt(AppointmentData.Recurring, 10) ? true : false,
                        teamIds: AppointmentData.TeamID,
                        teamNames: AppointmentData.TeamNames,
                        resourceIds: AppointmentData.ResourceID,
                        resourceNames: AppointmentData.ResourceNames,
                        pluginData: AppointmentData.PluginData,
                        calendarName: Calendar.CalendarName,
                        calendarColor: Calendar.Color,
                        notification: AppointmentData.NotificationDate.length ? true : false,
                        notificationDate: AppointmentData.NotificationDate,
                        ticketAppointmentType: AppointmentData.TicketAppointmentStartDate,
                        startEditable: typeof AppointmentData.TicketAppointmentStartDate === 'undefined' ? true :
                            typeof TicketAppointmentConfig[AppointmentData.TicketAppointmentStartDate].NoDrag !== 'undefined' ? false : true,
                        durationEditable: typeof AppointmentData.TicketAppointmentEndDate === 'undefined' ? true :
                            typeof TicketAppointmentConfig[AppointmentData.TicketAppointmentStartDate].NoDrag !== 'undefined' ? true : false
                    };
                }
            };
        });

        $('.CalendarSwitch input[type="checkbox"]').each(function () {
            CalendarSwitchInit($(this));
        });

        // Auto open appointment create screen.
        if (Core.Config.Get('AppointmentCreate')) {
            TargetNS.OpenEditDialog({
                Start: Core.Config.Get('AppointmentCreate').Start ? $.fullCalendar.moment(Core.Config.Get('AppointmentCreate').Start) : $.fullCalendar.moment().add(1, 'hours').startOf('hour'),
                End: Core.Config.Get('AppointmentCreate').End ? $.fullCalendar.moment(Core.Config.Get('AppointmentCreate').End) : $.fullCalendar.moment().add(2, 'hours').startOf('hour'),
                PluginKey: Core.Config.Get('AppointmentCreate').PluginKey ? Core.Config.Get('AppointmentCreate').PluginKey : null,
                Search: Core.Config.Get('AppointmentCreate').Search ? Core.Config.Get('AppointmentCreate').Search : null,
                ObjectID: Core.Config.Get('AppointmentCreate').ObjectID ? Core.Config.Get('AppointmentCreate').ObjectID : null
            });
        }

        // Auto open appointment edit screen
        else if (Core.Config.Get('AppointmentID')) {
            TargetNS.OpenEditDialog({ CalEvent: { id: Core.Config.Get('AppointmentID') } });
        }

        $('#AppointmentCreateButton')
            .off('click.AppointmentCalendar')
            .on('click.AppointmentCalendar', function () {
                TargetNS.OpenEditDialog({
                    Start: $.fullCalendar.moment().add(1, 'hours').startOf('hour'),
                    End: $.fullCalendar.moment().add(2, 'hours').startOf('hour')
                });

                return false;
            });

        CalendarSettingsInit();

        ResourceSettingsInit();

        $('#Team').on('change', function() {
            $('#ChangeTeamForm').submit();
        });

        Core.UI.Table.InitTableFilter($('#FilterCalendars'), $('#Calendars'));

        ClipboardJS.on('success', function (Event) {
            $(Event.trigger).hide()
                .fadeIn();
            Event.clearSelection();
        });

        ClipboardJS.on('error', function(Event) {
            Core.Form.ErrorTooltips.InitTooltip($(Event.trigger), Core.Language.Translate('Press Ctrl+C (Cmd+C) to copy to clipboard'));
            $(Event.trigger).focus();
        });
    };

    /**
     * @private
     * @name ShowDatepicker
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $CalendarObj - Calendar control object.
     * @param {jQueryObject} $DatepickerObj - Datepicker control object.
     * @param {jQueryObject} $JumpButton - Datepicker button object.
     * @description
     *      Show date picker control.
     */
    function ShowDatepicker($CalendarObj, $DatepickerObj, $JumpButton) {
        var CurrentDate = $CalendarObj.fullCalendar('getDate'),
            Year = CurrentDate.format('YYYY'),
            Month = CurrentDate.format('M');

        $('<div />').prop('id', 'DatepickerOverlay')
            .appendTo($('body'))
            .on('click.AppointmentCalendar', function () {
                $(this).remove();
                $DatepickerObj.hide();
            });

        AppointmentDays($DatepickerObj, Year, Month);

        $DatepickerObj.datepicker('setDate', CurrentDate.toDate())
            .css({
                left: parseInt($JumpButton.offset().left - $DatepickerObj.outerWidth() + $JumpButton.outerWidth(), 10),
                top: parseInt($JumpButton.offset().top - $DatepickerObj.outerHeight() + $JumpButton.outerHeight(), 10)
            }).fadeIn('fast');
    }

    /**
     * @private
     * @name CheckDate
     * @memberof Core.Agent.AppointmentCalendar
     * @function
     * @param {DateObject} DateObject - A JS date object to check.
     * @returns {Array} First element is always true, second element contains the name of a CSS
     *                  class, third element a description for the date.
     * @description
     *      Check if date has an appointment.
     */
    function CheckDate(DateObject) {
        var DateMoment = $.fullCalendar.moment(DateObject),
            DayAppointments = AppointmentDaysCache[DateMoment.format('YYYY-MM-DD')],
            DayClass = DayAppointments ? 'Highlight' : '',
            DayDescription = DayAppointments ? DayAppointments.toString() : '';

        return [true, DayClass, DayDescription];
    }

    /**
     * @private
     * @name AppointmentDays
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $DatepickerObj - Datepicker control object.
     * @param {Integer} Year - Selected year.
     * @param {Integer} Month - Selected month (1-12).
     * @description
     *      Caches the list of appointment days for later use.
     */
    function AppointmentDays($DatepickerObj, Year, Month) {
        var StartTime = $.fullCalendar.moment(Year + '-' + Month, 'YYYY-M').startOf('month'),
            EndTime = $.fullCalendar.moment(Year + '-' + Month, 'YYYY-M').add(1, 'months').startOf('month'),
            Data = {
                ChallengeToken: $('#ChallengeToken').val(),
                Action: 'AgentAppointmentList',
                Subaction: 'AppointmentDays',
                StartTime: StartTime.format('YYYY-MM-DD'),
                EndTime: EndTime.format('YYYY-MM-DD')
            };

        $DatepickerObj.addClass('AJAXLoading');
        AppointmentDaysCacheRefreshed = false;

        Core.AJAX.FunctionCall(
            Core.Config.Get('CGIHandle'),
            Data,
            function (Response) {
                if (Response) {
                    AppointmentDaysCache = Response;
                    AppointmentDaysCacheRefreshed = true;
                    $DatepickerObj.removeClass('AJAXLoading');

                    // Refresh the date picker because this call is asynchronous
                    $DatepickerObj.datepicker('refresh');
                }
            }
        );
    }

    /**
     * @public
     * @name ShowWaitingDialog
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      Shows waiting dialog.
     */
    TargetNS.ShowWaitingDialog = function () {
// RotherOSS / AppointmentToTicket
        $('.Modal.Dialog.Persistent').removeClass('Persistent');
// EO AppointmentToTicket
        Core.UI.Dialog.ShowContentDialog('<div class="Spacing Center"><span class="AJAXLoader" title="' + Core.Language.Translate('Loading...') + '"></span></div>', Core.Language.Translate('Loading...'), '10px', 'Center', true);
    }

    /**
     * @public
     * @name OpenEditDialog
     * @memberof Core.Agent.AppointmentCalendar
     * @param {Object} AppointmentData - Hash with appointment data.
     * @param {Moment} AppointmentData.Start - Moment object with start date/time.
     * @param {Moment} AppointmentData.End - Moment object with end date/time.
     * @param {Object} AppointmentData.CalEvent - Calendar event object (FullCalendar).
     * @param {Object} AppointmentData.Resource - Calendar resource object (FullCalendar).
     * @description
     *      This method opens the appointment dialog after selecting a time period or an appointment.
     */
    TargetNS.OpenEditDialog = function (AppointmentData) {
        var Data = {
            ChallengeToken: $('#ChallengeToken').val(),
            Action: 'AgentAppointmentEdit',
            Subaction: 'EditMask',
            AppointmentID: AppointmentData.CalEvent ? AppointmentData.CalEvent.id : null,
            StartYear: !AppointmentData.CalEvent ? AppointmentData.Start.year() : null,
            StartMonth: !AppointmentData.CalEvent ? AppointmentData.Start.month() + 1 : null,
            StartDay: !AppointmentData.CalEvent ? AppointmentData.Start.date() : null,
            StartHour: !AppointmentData.CalEvent ? AppointmentData.Start.hour() : null,
            StartMinute: !AppointmentData.CalEvent ? AppointmentData.Start.minute() : null,
            EndYear: !AppointmentData.CalEvent ? AppointmentData.End.year() : null,
            EndMonth: !AppointmentData.CalEvent ? AppointmentData.End.month() + 1 : null,
            EndDay: !AppointmentData.CalEvent ? AppointmentData.End.date() : null,
            EndHour: !AppointmentData.CalEvent ? AppointmentData.End.hour() : null,
            EndMinute: !AppointmentData.CalEvent ? AppointmentData.End.minute() : null,
            AllDay: !AppointmentData.CalEvent ? (AppointmentData.End.hasTime() ? '0' : '1') : null,
            TeamID: AppointmentData.Resource ? [ AppointmentData.Resource.TeamID ] : null,
            ResourceID: AppointmentData.Resource ? [ AppointmentData.Resource.id ] : null,
            PluginKey: AppointmentData.PluginKey ? AppointmentData.PluginKey : null,
            Search: AppointmentData.Search ? AppointmentData.Search : null,
            ObjectID: AppointmentData.ObjectID ? AppointmentData.ObjectID : null
        };

        // Make end time for all day appointments inclusive
        if (Data.AllDay && Data.AllDay === '1') {
            AppointmentData.End.subtract(1, 'day');
            Data.EndYear = AppointmentData.End.year();
            Data.EndMonth = AppointmentData.End.month() + 1;
            Data.EndDay = AppointmentData.End.date();
            Data.EndHour = AppointmentData.End.hour();
            Data.EndMinute = AppointmentData.End.minute();
        }

        function EditDialog() {
            TargetNS.ShowWaitingDialog();
            Core.AJAX.FunctionCall(
                Core.Config.Get('CGIHandle'),
                Data,
                function (HTML) {
// RotherOSS / AppointmentToTicket
                    // Core.UI.Dialog.ShowContentDialog(HTML, Core.Language.Translate('Appointment'), '10px', 'Center', true, undefined, true);
                    Core.UI.Dialog.ShowDialog({
                        HTML: HTML,
                        Title: Core.Language.Translate('Appointment'),
                        Modal: true,
                        CloseOnClickOutside: false,
                        CloseOnEscape: true,
                        PositionTop: '10px',
                        PositionLeft: 'Center',
                        Buttons: undefined,
                        AllowAutoGrow: true,
                        Persistent: true
                    });
// EO AppointmentToTicket
                    Core.UI.InputFields.Activate($('.Dialog:visible'));

                    TargetNS.AgentAppointmentEdit();
                },
                'html'
            );
        }

        // Repeating event
        if (AppointmentData.CalEvent && AppointmentData.CalEvent.parentId) {
            Core.UI.Dialog.ShowDialog({
                Title: Core.Language.Translate('This is a repeating appointment'),
                HTML: Core.Language.Translate('Would you like to edit just this occurrence or all occurrences?'),
                Modal: true,
// RotherOSS / AppointmentToTicket
                // CloseOnClickOutside: true,
                CloseOnClickOutside: false,
// EO AppointmentToTicket
                CloseOnEscape: true,
                PositionTop: '20%',
                PositionLeft: 'Center',
                Buttons: [
                    {
                        Label: Core.Language.Translate('All occurrences'),
                        Class: 'Primary CallForAction',
                        Function: function() {
                            Data.AppointmentID = AppointmentData.CalEvent.parentId;
// RotherOSS / AppointmentToTicket
                            // EditDialog();
                            EditDialog(false);
// EO AppointmentToTicket
                        }
                    },
                    {
                        Label: Core.Language.Translate('Just this occurrence'),
                        Class: 'CallForAction',
                        Function: EditDialog
                    },
                    {
                        Type: 'Close',
                        Label: Core.Language.Translate('Close this dialog')
                    }
                ]
            });
        } else {
            EditDialog();
        }
    }

    /**
     * @private
     * @name UpdateAppointment
     * @memberof Core.Agent.AppointmentCalendar
     * @param {Object} AppointmentData - Hash with appointment data.
     * @param {Object} AppointmentData.CalEvent - Calendar event object (FullCalendar).
     * @description
     *      This method updates the appointment with supplied data.
     */
    function UpdateAppointment(AppointmentData) {
        var Data = {
            ChallengeToken: $('#ChallengeToken').val(),
            Action: 'AgentAppointmentEdit',
            Subaction: 'EditAppointment',
            AppointmentID: AppointmentData.CalEvent.id,
            StartYear: AppointmentData.CalEvent.start.year(),
            StartMonth: AppointmentData.CalEvent.start.month() + 1,
            StartDay: AppointmentData.CalEvent.start.date(),
            StartHour: AppointmentData.CalEvent.start.hour(),
            StartMinute: AppointmentData.CalEvent.start.minute(),
            EndYear: AppointmentData.CalEvent.end.year(),
            EndMonth: AppointmentData.CalEvent.end.month() + 1,
            EndDay: AppointmentData.CalEvent.end.date(),
            EndHour: AppointmentData.CalEvent.end.hour(),
            EndMinute: AppointmentData.CalEvent.end.minute(),
            AllDay: AppointmentData.CalEvent.end.hasTime() ? '0' : '1',
            Recurring: AppointmentData.CalEvent.recurring ? '1' : '0',
            TeamID: AppointmentData.CalEvent.teamIds ? AppointmentData.CalEvent.teamIds : undefined,
            ResourceID: AppointmentData.CalEvent.resourceIds ? AppointmentData.CalEvent.resourceIds :
                AppointmentData.CalEvent.resourceId ? [ AppointmentData.CalEvent.resourceId ] : undefined
        };

        // Assigned resource didn't change
        if (
            AppointmentData.CalEvent.resourceId
            && AppointmentData.PreviousAppointment.resourceIds
            && $.inArray(
                AppointmentData.CalEvent.resourceId,
                AppointmentData.PreviousAppointment.resourceIds
            ) !== -1
        ) {
            Data.ResourceID = AppointmentData.PreviousAppointment.resourceIds;
        }

        function Update() {
// RotherOSS / AppointmentToTicket
            $('.Dialog:visible').removeClass('Persistent');
// EO AppointmentToTicket
            Core.UI.Dialog.CloseDialog($('.Dialog:visible'));
            Core.AJAX.FunctionCall(
                Core.Config.Get('CGIHandle'),
                Data,
                function (Response) {
                    if (Response.Success) {
                        $('#calendar').fullCalendar('refetchEvents');
                    } else {
                        AppointmentData.RevertFunc();
                    }

                    // Close the dialog
// RotherOSS / AppointmentToTicket
                    $('.Dialog:visible').removeClass('Persistent');
// EO AppointmentToTicket
                    Core.UI.Dialog.CloseDialog($('.Dialog:visible'));
                }
            );
        }

        // Make end time for all day appointments inclusive
        if (AppointmentData.CalEvent.allDay) {
            AppointmentData.CalEvent.end.subtract(1, 'day');
            Data.EndYear = AppointmentData.CalEvent.end.year();
            Data.EndMonth = AppointmentData.CalEvent.end.month() + 1;
            Data.EndDay = AppointmentData.CalEvent.end.date();
            Data.EndHour = AppointmentData.CalEvent.end.hour();
            Data.EndMinute = AppointmentData.CalEvent.end.minute();
        }

        // Repeating event
        if (AppointmentData.CalEvent.parentId) {
            Core.UI.Dialog.ShowDialog({
                Title: Core.Language.Translate('This is a repeating appointment'),
                HTML: Core.Language.Translate('Would you like to edit just this occurrence or all occurrences?'),
                Modal: true,
                CloseOnClickOutside: true,
                CloseOnEscape: true,
                PositionTop: '20%',
                PositionLeft: 'Center',
                Buttons: [
                    {
                        Label: Core.Language.Translate('All occurrences'),
                        Class: 'Primary CallForAction',
                        Function: function() {
                            Data.AppointmentID = AppointmentData.CalEvent.parentId;
                            Data.Recurring = '1';
                            Data.UpdateDelta = AppointmentData.Delta.asSeconds();
                            if (
                                AppointmentData.CalEvent.start.diff(AppointmentData.PreviousAppointment.start, 'seconds')
                                === Data.UpdateDelta
                                &&
                                AppointmentData.CalEvent.end.diff(AppointmentData.PreviousAppointment.end, 'seconds')
                                === Data.UpdateDelta
                            ) {
                                Data.UpdateType = 'Both';
                            }
                            else if (
                                AppointmentData.PreviousAppointment.start.diff(AppointmentData.CalEvent.start, 'seconds')
                                === Data.UpdateDelta
                            ) {
                                Data.UpdateType = 'StartTime';
                                Data.UpdateDelta = Data.UpdateDelta * -1;
                            }
                            else if (
                                AppointmentData.CalEvent.end.diff(AppointmentData.PreviousAppointment.end, 'seconds')
                                === Data.UpdateDelta
                            ) {
                                Data.UpdateType = 'EndTime';
                            }
                            Update();
                        }
                    },
                    {
                        Label: Core.Language.Translate('Just this occurrence'),
                        Class: 'CallForAction',
                        Function: function() {
                            AppointmentData.CalEvent.parentId = null;
                            Update();
                        }
                    },
                    {
                        Type: 'Close',
                        Label: Core.Language.Translate('Close this dialog'),
                        Function: function() {
// RotherOSS / AppointmentToTicket
                            $('.Dialog:visible').removeClass('Persistent');
// EO AppointmentToTicket
                            Core.UI.Dialog.CloseDialog($('.Dialog:visible'));
                            AppointmentData.RevertFunc();
                        }
                    }
                ]
            });
        } else {
            Update();
        }
    }

    /**
     * @private
     * @name CalendarSwitchInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $CalendarSwitch - calendar checkbox element.
     * @description
     *      This method initializes calendar checkbox behavior and loads multiple calendars to the
     *      FullCalendar control.
     */
    function CalendarSwitchInit($CalendarSwitch) {

        // Initialize enabled sources
        if ($CalendarSwitch.prop('checked')) {
            $('#calendar').fullCalendar('addEventSource', CalendarSources[$CalendarSwitch.data('id')]);
        }

        // Register change event handler
        $CalendarSwitch.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
            if ($('.CalendarSwitch input:checked').length > Core.Config.Get('CalendarLimit')) {
                $CalendarSwitch.prop('checked', false);
                Core.UI.Dialog.ShowAlert(Core.Language.Translate('Too many active calendars'), Core.Language.Translate('Please either turn some off first or increase the limit in configuration.'));
            } else {
                CalendarSwitchSource($CalendarSwitch);
            }
        });
    }

    /**
     * @private
     * @name CalendarSwitchSource
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $CalendarSwitch - calendar checkbox element.
     * @description
     *      This method enables/disables calendar source in FullCalendar control and stores
     *      selection to user preferences.
     */
    function CalendarSwitchSource($CalendarSwitch) {
        var CalendarSelection = [];

        // Show/hide the calendar appointments
        if ($CalendarSwitch.prop('checked')) {
            $('#calendar').fullCalendar('addEventSource', CalendarSources[$CalendarSwitch.data('id')]);
        } else {
            $('#calendar').fullCalendar('removeEventSource', $CalendarSwitch.data('id'));
        }

        // Get all checked calendars
        $.each($('.CalendarSwitch input:checked'), function (Index, Element) {
            CalendarSelection.push($(Element).data('id'));
        });

        // Store selection in user preferences
        Core.AJAX.FunctionCall(
            Core.Config.Get('CGIHandle'),
            {
                ChallengeToken: $('#ChallengeToken').val(),
                Action: 'AgentAppointmentEdit',
                Subaction: 'UpdatePreferences',
                OverviewScreen: Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'CalendarOverview',
                CalendarSelection: JSON.stringify(CalendarSelection)
            },
            function (Response) {
                if (!Response.Success) {
                    Core.Debug.Log('Error updating user preferences!');
                }
            }
        );
    }

    /**
     * @name LocationLinkInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $LocationObj - location field.
     * @param {jQueryObject} $LocationLinks - location links.
     * @description
     *      This method initializes location link behavior.
     */
    TargetNS.LocationLinkInit = function ($LocationObj, $LocationLinks) {
        var LocationValue = $LocationObj.val() || $LocationObj.text();

        $LocationLinks.each(function (Index, Element) {
            var $LinkObj = $(Element),
                BaseURL  = $LinkObj.data('baseUrl');

            // Update link URL and show it if location is set
            if (LocationValue.length > 0 && LocationValue !== '-') {
                $LinkObj.attr('href', BaseURL + encodeURIComponent(LocationValue))
                    .fadeIn('fast');
            }

            // Otherwise, hide the link
            else {
                $LinkObj.fadeOut('fast');
            }
        });

        // Register key up event handler
        $LocationObj.off('keyup.AppointmentCalendar').on('keyup.AppointmentCalendar', function() {
            TargetNS.LocationLinkInit($LocationObj, $LocationLinks);
        });
    }

    /**
     * @name AllDayInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $AllDay - all day checkbox element.
     * @description
     *      This method initializes all day checkbox behavior.
     */
    TargetNS.AllDayInit = function ($AllDay) {
        if ($('#StartMonth:disabled').length > 0) {
            return;
        }

        // Show/hide the start hour/minute and complete end time
        if ($AllDay.prop('checked')) {
            $('#StartHour,#StartMinute,#EndHour,#EndMinute').val('0')
                .prop('disabled', true)
                .prop('readonly', true);
        } else {
            $('#StartHour,#StartMinute,#EndHour,#EndMinute')
                .prop('disabled', false)
                .prop('readonly', false);
        }

        // Register change event handler
        $AllDay.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
            TargetNS.AllDayInit($AllDay);
        });
    }

    /**
     * @name RecurringInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {Object} Fields - Array with references to recurring fields.
     * @param {jQueryObject} Fields.$Recurring - field with recurring flag.
     * @param {jQueryObject} Fields.$RecurrenceType - drop down with recurrence type
     * @param {jQueryObject} Fields.$RecurrenceCustomType - Recurrence pattern
     * @param {jQueryObject} Fields.$RecurrenceCustomTypeStringDiv - Custom type drop-down
     * @param {jQueryObject} Fields.$RecurrenceIntervalText - interval text
     * @param {jQueryObject} Fields.$RecurrenceCustomWeeklyDiv - contains week days table
     * @param {jQueryObject} Fields.$RecurrenceCustomMonthlyDiv - contains month days table
     * @param {jQueryObject} Fields.$RecurrenceCustomYearlyDiv - contains months table
     * @param {jQueryObject} Fields.$RecurrenceLimitDiv - layer with recurrence limit fields.
     * @param {jQueryObject} Fields.$RecurrenceLimit - drop down with recurrence limit field.
     * @param {jQueryObject} Fields.$RecurrenceCountDiv - layer with reccurence count field.
     * @param {jQueryObject} Fields.$RecurrenceUntilDiv - layer with reccurence until fields.
     * @param {jQueryObject} Fields.$RecurrenceUntilDay - select field for reccurence until day.
     * @description
     *      This method initializes recurrence fields behavior.
     */
    TargetNS.RecurringInit = function (Fields) {

        function RecInit(Fields) {
            var Days = [],
                MonthDays = [],
                Months = [],
                Index;

            if ($('input#Days').length) {
                Days = $('input#Days').val().split(',');
            }
            if ($('input#MonthDays').length) {
                MonthDays = $('input#MonthDays').val().split(',');
            }
            if ($('input#MonthDays').length) {
                Months = $('input#Months').val().split(',');
            }

            for (Index = 0; Index < Days.length; Index++) {
                if (Days[Index] != "") {
                    $("#RecurrenceCustomWeeklyDiv button[value=" + Days[Index] + "]")
                        .addClass("fc-state-active");
                }
            }

            for (Index = 0; Index < MonthDays.length; Index++) {
                if (MonthDays[Index] != "") {
                    $("#RecurrenceCustomMonthlyDiv button[value=" + MonthDays[Index] + "]")
                        .addClass("fc-state-active");
                }
            }

            for (Index = 0; Index < Months.length; Index++) {
                if (Months[Index] != "") {
                    $("#RecurrenceCustomYearlyDiv button[value=" + Months[Index] + "]")
                        .addClass("fc-state-active");
                }
            }

            if (Fields.$RecurrenceType.val() == 0) {
                Fields.$Recurring.val(0);
                Fields.$RecurrenceCustomTypeStringDiv.hide();
                Fields.$RecurrenceCustomWeeklyDiv.hide();
                Fields.$RecurrenceCustomMonthlyDiv.hide();
                Fields.$RecurrenceCustomYearlyDiv.hide();

                Fields.$RecurrenceLimitDiv.hide();
                Fields.$RecurrenceCountDiv.hide();
                Fields.$RecurrenceUntilDiv.hide();

                // Skip validation of RecurrenceUntil fields
                Fields.$RecurrenceUntilDay.addClass('ValidationIgnore');
            }
            else if (Fields.$RecurrenceType.val() == 'Custom') {
                Fields.$Recurring.val(1);
                Fields.$RecurrenceCustomTypeStringDiv.show();

                if (Fields.$RecurrenceCustomType.val()=="CustomDaily") {
                    Fields.$RecurrenceCustomWeeklyDiv.hide();
                    Fields.$RecurrenceCustomMonthlyDiv.hide();
                    Fields.$RecurrenceCustomYearlyDiv.hide();
                    Fields.$RecurrenceIntervalText.find('span')
                        .hide()
                        .end()
                        .find('.TextDay')
                        .show();
                }
                else if (Fields.$RecurrenceCustomType.val()=="CustomWeekly") {
                    Fields.$RecurrenceCustomWeeklyDiv.show();

                    Fields.$RecurrenceCustomMonthlyDiv.hide();
                    Fields.$RecurrenceCustomYearlyDiv.hide();
                    Fields.$RecurrenceIntervalText.find('span')
                        .hide()
                        .end()
                        .find('.TextWeek')
                        .show();
                }
                else if (Fields.$RecurrenceCustomType.val()=="CustomMonthly") {
                    Fields.$RecurrenceCustomMonthlyDiv.show();

                    Fields.$RecurrenceCustomWeeklyDiv.hide();
                    Fields.$RecurrenceCustomYearlyDiv.hide();
                    Fields.$RecurrenceIntervalText.find('span')
                        .hide()
                        .end()
                        .find('.TextMonth')
                        .show();
                }
                else if (Fields.$RecurrenceCustomType.val()=="CustomYearly") {
                    Fields.$RecurrenceCustomYearlyDiv.show();

                    Fields.$RecurrenceCustomWeeklyDiv.hide();
                    Fields.$RecurrenceCustomMonthlyDiv.hide();
                    Fields.$RecurrenceIntervalText.find('span')
                        .hide()
                        .end()
                        .find('.TextYear')
                        .show();
                }

                Fields.$RecurrenceLimitDiv.show();
                Fields.$RecurrenceLimit.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
                    if ($(this).val() == 1) {
                        Fields.$RecurrenceCountDiv.hide();
                        Fields.$RecurrenceUntilDiv.show();

                        // Resume validation of RecurrenceUntil fields
                        Fields.$RecurrenceUntilDay.removeClass('ValidationIgnore');
                    } else {
                        Fields.$RecurrenceUntilDiv.hide();
                        Fields.$RecurrenceCountDiv.show();

                        // Skip validation of RecurrenceUntil fields
                        Fields.$RecurrenceUntilDay.addClass('ValidationIgnore');
                    }
                }).trigger('change.AppointmentCalendar');

                Core.UI.InputFields.Activate(Fields.$RecurrenceCustomTypeStringDiv);
                Core.UI.InputFields.Activate(Fields.$RecurrenceLimitDiv);
            }
            else {
                Fields.$Recurring.val(1);
                Fields.$RecurrenceLimitDiv.show();

                Fields.$RecurrenceCustomTypeStringDiv.hide();
                Fields.$RecurrenceCustomWeeklyDiv.hide();
                Fields.$RecurrenceCustomMonthlyDiv.hide();
                Fields.$RecurrenceCustomYearlyDiv.hide();

                Fields.$RecurrenceLimit.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
                    if ($(this).val() == 1) {
                        Fields.$RecurrenceCountDiv.hide();
                        Fields.$RecurrenceUntilDiv.show();

                        // Resume validation of RecurrenceUntil fields
                        Fields.$RecurrenceUntilDay.removeClass('ValidationIgnore');
                    } else {
                        Fields.$RecurrenceUntilDiv.hide();
                        Fields.$RecurrenceCountDiv.show();

                        // Skip validation of RecurrenceUntil fields
                        Fields.$RecurrenceUntilDay.addClass('ValidationIgnore');
                    }
                }).trigger('change.AppointmentCalendar');
                Core.UI.InputFields.Activate(Fields.$RecurrenceLimitDiv);
            }

            Fields.$RecurrenceCustomType.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
                TargetNS.RecurringInit(Fields);
            });
        }

        Fields.$RecurrenceType.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
            RecInit(Fields);
        }).trigger('change.AppointmentCalendar');
    }

    /**
     * @name NotificationInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {Object} Fields - Array with references to reminder fields.
     * @param {jQueryObject} Fields.$Notification - drop down with system notification selection.
     * @param {jQueryObject} Fields.$NotificationCustomStringDiv - custom selection of system notification date
     * @description
     *      This method initializes the reminder section behavior.
     */
    TargetNS.NotificationInit = function (Fields) {
        var NotificationCustomStringDiv = Fields.$NotificationCustomStringDiv.attr('id');

        if (Fields.$NotificationTemplate.val() !== 'Custom') {

            // hide the custom fields
            Fields.$NotificationCustomStringDiv.hide();
        }
        else {

            // custom field is needed
            Fields.$NotificationCustomStringDiv.show();

            // initialize modern fields on custom selection
            Core.UI.InputFields.InitSelect($('select.Modernize'));
        }

        // disable enable the different custom fields
        if (Fields.$NotificationCustomRelativeInput.prop('checked')) {

            // enable relative date fields
            Fields.$NotificationCustomRelativeInput.val(1);
            Fields.$NotificationCustomRelativeUnitCount.prop('disabled', false).prop('readonly', false);
            Fields.$NotificationCustomRelativeUnit.prop('disabled', false);
            Fields.$NotificationCustomRelativePointOfTime.prop('disabled', false);

            // disable the custom date time fields
            Fields.$NotificationCustomDateTimeInput.val('');
            Fields.$NotificationCustomDateTimeDay.prop('disabled', true);
            Fields.$NotificationCustomDateTimeMonth.prop('disabled', true);
            Fields.$NotificationCustomDateTimeYear.prop('disabled', true);
            Fields.$NotificationCustomDateTimeHour.prop('disabled', true);
            Fields.$NotificationCustomDateTimeMinute.prop('disabled', true);
        }
        else {

            // enable the custom date time input
            Fields.$NotificationCustomDateTimeInput.val(1);
            Fields.$NotificationCustomDateTimeInput.prop('checked', true);
            Fields.$NotificationCustomDateTimeDay.prop('disabled', false);
            Fields.$NotificationCustomDateTimeMonth.prop('disabled', false);
            Fields.$NotificationCustomDateTimeYear.prop('disabled', false);
            Fields.$NotificationCustomDateTimeHour.prop('disabled', false);
            Fields.$NotificationCustomDateTimeMinute.prop('disabled', false);

            // disable relative date fields
            Fields.$NotificationCustomRelativeInput.val('');
            Fields.$NotificationCustomRelativeInput.prop('checked', false);
            Fields.$NotificationCustomRelativeUnitCount.prop('disabled', true).prop('readonly', true);
            Fields.$NotificationCustomRelativeUnit.prop('disabled', true);
            Fields.$NotificationCustomRelativePointOfTime.prop('disabled', true);
        }

        // TODO: Workaround for InputFields bug in the framework (disabled attribute not checked after initialization)
        Core.UI.InputFields.Deactivate('#' + Core.App.EscapeSelector(NotificationCustomStringDiv));
        Core.UI.InputFields.Activate('#' + Core.App.EscapeSelector(NotificationCustomStringDiv));

        // Register change event handler
        Fields.$NotificationTemplate.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
            TargetNS.NotificationInit(Fields);
        });

        Fields.$NotificationCustomRelativeInput.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {

            // handle radio buttons
            Fields.$NotificationCustomRelativeInput.prop('checked', true);
            Fields.$NotificationCustomDateTimeInput.prop('checked', false);

            // process changes
            TargetNS.NotificationInit(Fields);
        });

        Fields.$NotificationCustomDateTimeInput.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {

            // handle radio buttons
            Fields.$NotificationCustomDateTimeInput.prop('checked', true);
            Fields.$NotificationCustomRelativeInput.prop('checked', false);

            // process changes
            TargetNS.NotificationInit(Fields);
        });
    }

// RotherOSS / AppointmentToTicket
    /**
     * @name TicketInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {Object} Fields - Array with references to ticket creation fields.
     * @param {jQueryObject} Fields.$Ticket - drop down with system notification selection.
     * @param {jQueryObject} Fields.$TicketCustomStringDiv - custom selection of system ticket date
     * @description
     *      This method initializes the ticket creation section behavior.
     */
    TargetNS.TicketInit = function (Fields) {

        if (Fields.$TicketTemplate.val() === '0') {

            $('.TicketTemplateSelection ~ div:not(.Hidden)').hide();
            $('.TicketTemplateSelection ~ label').hide();

            // Remove mandatory and validate classes
            $('.TicketTemplateSelection ~ div > .Validate_Required').addClass('Validate_If_Active').removeClass('Validate_Required');
        } else {

            $('.TicketTemplateSelection ~ div:not(.Hidden)').show();
            $('.TicketTemplateSelection ~ label').show();

            if (Fields.$TicketTemplate.val() !== 'Custom') {

                // hide the custom fields
                $('.TicketTemplateSelection ~ div.AppointmentTicketCustomTime').hide();
                $('.TicketTemplateSelection ~ label.AppointmentTicketCustomTime').hide();

            }

            // Add mandatory and validate classes
            $('.TicketTemplateSelection ~ div > .Validate_If_Active').addClass('Validate_Required').removeClass('Validate_If_Active');

            // Bind event to customer radio button.
            $('.CustomerTicketRadio').on('change', function () {

                if ($(this).prop('checked')){

                    let CustomerKey = $('#CustomerKey_' +$(this).val()).val();
                    // get customer tickets
                    Core.Agent.CustomerSearch.ReloadCustomerInfo(CustomerKey);
                }
                return false;
            });

           // Bind event to customer remove button.
            $('.CustomerTicketRemove').on('click', function () {
                Core.Agent.CustomerSearch.RemoveCustomerTicket($(this));
                return false;
            });

            // initialize customer user search field
            Core.Agent.CustomerSearchAutoComplete.Init();
            // initialize modern fields on custom selection
            Core.UI.InputFields.InitSelect($('select.Modernize'));

            // init selected customer user
            $('.CustomerTicketRadio').each(function() {
                if ($(this).prop('checked')){

                    let CustomerKey = $('#CustomerKey_' +$(this).val()).val();
                    // get customer tickets
                    Core.Agent.CustomerSearch.ReloadCustomerInfo(CustomerKey);

                }
            });

        }

        // disable enable the different custom fields
        if (Fields.$TicketCustomRelativeInput.prop('checked')) {

            // enable relative date fields
            Fields.$TicketCustomRelativeInput.val(1);
            Fields.$TicketCustomRelativeUnitCount.prop('disabled', false).prop('readonly', false);
            Fields.$TicketCustomRelativeUnit.prop('disabled', false);
            Fields.$TicketCustomRelativePointOfTime.prop('disabled', false);

            // disable the custom date time fields
            Fields.$TicketCustomDateTimeInput.val('');
            Fields.$TicketCustomDateTimeDay.prop('disabled', true);
            Fields.$TicketCustomDateTimeMonth.prop('disabled', true);
            Fields.$TicketCustomDateTimeYear.prop('disabled', true);
            Fields.$TicketCustomDateTimeHour.prop('disabled', true);
            Fields.$TicketCustomDateTimeMinute.prop('disabled', true);
        }
        else {

            // enable the custom date time input
            Fields.$TicketCustomDateTimeInput.val(1);
            Fields.$TicketCustomDateTimeInput.prop('checked', true);
            Fields.$TicketCustomDateTimeDay.prop('disabled', false);
            Fields.$TicketCustomDateTimeMonth.prop('disabled', false);
            Fields.$TicketCustomDateTimeYear.prop('disabled', false);
            Fields.$TicketCustomDateTimeHour.prop('disabled', false);
            Fields.$TicketCustomDateTimeMinute.prop('disabled', false);

            // disable relative date fields
            Fields.$TicketCustomRelativeInput.val('');
            Fields.$TicketCustomRelativeInput.prop('checked', false);
            Fields.$TicketCustomRelativeUnitCount.prop('disabled', true).prop('readonly', true);
            Fields.$TicketCustomRelativeUnit.prop('disabled', true);
            Fields.$TicketCustomRelativePointOfTime.prop('disabled', true);
        }

        // Register change event handler
        Fields.$TicketTemplate.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {
            TargetNS.TicketInit(Fields);
        });

        Fields.$TicketCustomRelativeInput.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {

            // handle radio buttons
            Fields.$TicketCustomRelativeInput.prop('checked', true);
            Fields.$TicketCustomDateTimeInput.prop('checked', false);

            // process changes
            TargetNS.TicketInit(Fields);
        });

        Fields.$TicketCustomDateTimeInput.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function() {

            // handle radio buttons
            Fields.$TicketCustomDateTimeInput.prop('checked', true);
            Fields.$TicketCustomRelativeInput.prop('checked', false);

            // process changes
            TargetNS.TicketInit(Fields);
        });

        // Bind form update event to fields
        var AJAXUpdateFields = ['TypeID', 'Dest', 'NextStateID', 'PriorityID', 'ServiceID', 'SLAID'],
            ModifiedFields;
        $.each(AJAXUpdateFields, function(Index, Value) {
            ModifiedFields = Core.Data.CopyObject(AJAXUpdateFields).concat(Core.Config.Get('DynamicFieldNames'));
            ModifiedFields.splice(Index, 1);

            FieldUpdate(Value, ModifiedFields);
        });
    }

    /**
     * @private
     * @name FieldUpdate
     * @memberof Core.Agent.TicketPhone.Init
     * @function
     * @param {String} Value - FieldID
     * @param {Array} ModifiedFields - Fields
     * @description
     *      Create on change event handler
     */
    function FieldUpdate (Value, ModifiedFields) {
        $('#' + Value).on('change', function () {
            Core.AJAX.FormUpdate($('#EditAppointmentForm'), 'AJAXUpdate', Value, ModifiedFields);
        });

    }
// EO AppointmentToTicket

    /**
     * @name TeamInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $TeamIDObj - field with list of teams.
     * @param {jQueryObject} $ResourceIDObj - field with list of resources.
     * @param {jQueryObject} $TeamValueObj - field with read only values for team.
     * @param {jQueryObject} $ResourceValueObj - field with read only values for resources.
     * @description
     *      This method initializes team fields behavior.
     */
    TargetNS.TeamInit = function ($TeamIDObj, $ResourceIDObj, $TeamValueObj, $ResourceValueObj) {
        $TeamIDObj.off('change.AppointmentCalendar').on('change.AppointmentCalendar', function () {
            var Data = {
                ChallengeToken: $('#ChallengeToken').val(),
                Action: 'AgentAppointmentEdit',
                Subaction: 'TeamUserList',
                TeamID: $TeamIDObj.val()
            };

            ToggleAJAXLoader($ResourceIDObj, true);

            Core.AJAX.FunctionCall(
                Core.Config.Get('CGIHandle'),
                Data,
                function (Response) {
                    var SelectedID = $ResourceIDObj.val();
                    if (Response.TeamUserList) {
                        $ResourceIDObj.empty();
                        $.each(Response.TeamUserList, function (Index, Value) {
                            var NewOption = new Option(Value, Index);

                            // Overwrite option text, because of wrong html quoting of text content.
                            // (This is needed for IE.)
                            NewOption.innerHTML = Core.App.EscapeHTML(Value);

                            // Restore selection
                            if (SelectedID && SelectedID.indexOf(Index) > -1) {
                                NewOption.selected = true;
                            }

                            $ResourceIDObj.append(NewOption);
                        });

                        // Trigger custom redraw event for InputFields
                        $ResourceIDObj.trigger('redraw.InputField');
                    }
                    ToggleAJAXLoader($ResourceIDObj, false);
                }
            );
        });

        function CollapseValues($ValueObj, Values) {
            $ValueObj.html('');
            $.each(Values, function (Index, Value) {
                var Count = Values.length,
                    TooltipIndex = $('.Dialog').css('z-index');

                if (Index < 2) {
                    $ValueObj.html($ValueObj.html() + Value + '<br>');
                } else {
                    Values.splice(-Count, 2);
                    $('<a />').attr('href', '#')
                        .addClass('DialogTooltipLink')
                        .text(Core.Language.Translate('+%s more', Count-2))
                        .off('click.AppointmentCalendar')
                        .on('click.AppointmentCalendar', function (Event) {
                            var $TooltipObj,
                                PosX = 0,
                                PosY = 0,
                                TooltipHTML = '<p>' + Values.join('<br>') + '</p>',
                                DocumentVisibleLeft = $(document).scrollLeft() + $(window).width(),
                                DocumentVisibleTop = $(document).scrollTop() + $(window).height(),
                                LastXPosition,
                                LastYPosition;

                            // Close existing tooltips
                            $('.DialogTooltip').remove();

                            if (Event.pageX || Event.pageY) {
                                PosX = Event.pageX;
                                PosY = Event.pageY;
                            } else if (Event.clientX || Event.clientY) {
                                PosX = Event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
                                PosY = Event.clientY + document.body.scrollTop + document.documentElement.scrollTop;
                            }

                            // Increase positions so the tooltip do not overlap with mouse pointer
                            PosX += 10;
                            PosY += 5;

                            if (typeof TooltipIndex !== 'undefined') {
                                TooltipIndex = parseInt(TooltipIndex, 10) + 500;
                            }
                            else{
                                TooltipIndex = 4000;
                            }

                            // Create tooltip object
                            $TooltipObj = $('<div/>').addClass('AppointmentTooltip DialogTooltip Hidden')
                                .offset({
                                    top: PosY,
                                    left: PosX
                                })
                                .html(TooltipHTML)
                                .css('z-index', TooltipIndex)
                                .css('width', 'auto')
                                .off('click.AppointmentCalendar')
                                .on('click.AppointmentCalendar', function (Event) {
                                    Event.stopPropagation();
                                })
                                .appendTo('body');

                            // Re-calculate top position if needed
                            LastYPosition = PosY + $TooltipObj.height();
                            if (LastYPosition > DocumentVisibleTop) {
                                PosY = PosY - $TooltipObj.height();
                                $TooltipObj.css('top', PosY + 'px');
                            }

                            // Re-calculate left position if needed
                            LastXPosition = PosX + $TooltipObj.width();
                            if (LastXPosition > DocumentVisibleLeft) {
                                PosX = PosX - $TooltipObj.width() - 30;
                                $TooltipObj.css('left', PosX + 'px');
                            }

                            // Show the tooltip
                            $TooltipObj.fadeIn('fast');

                            // Close tooltip on any outside click
                            $(document).off('click.AppointmentCalendar')
                                .on('click.AppointmentCalendar', function (Event) {
                                    $('.Close').on('click', function(){
                                        $('.DialogTooltip').remove();
                                    });
                                    if (!$(Event.target).closest('.DialogTooltipLink').length) {
                                        $('.DialogTooltip').remove();
                                        $(document).off('click.AppointmentCalendar');
                                    }
                                });
                        })
                        .appendTo($ValueObj);
                    return false;
                }
            });
        }

        // Collapse read only values
        if ($TeamValueObj.length) {
            CollapseValues($TeamValueObj, $TeamValueObj.html().split('<br>'));
        }
        if ($ResourceValueObj.length) {
            CollapseValues($ResourceValueObj, $ResourceValueObj.html().split('<br>'));
        }
    }

    /**
     * @private
     * @name CalendarSettingsInit
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      This method initializes calendar settings behavior.
     */
    function CalendarSettingsInit() {
        var $CalendarSettingsObj = $('#CalendarSettingsButton'),
            CalendarSettingsDialogHTML;

        if (!$CalendarSettingsObj.length) {
            return;
        }

        CalendarSettingsDialogHTML = Core.Template.Render('Agent/AppointmentCalendar/CalendarSettingsDialog', {
            'ShownAppointmentsStrg': Core.Config.Get('ShownAppointmentsStrg')
        });

        // Calendar settings button
        $CalendarSettingsObj.off('click.AppointmentCalendar').on('click.AppointmentCalendar', function (Event) {
            Core.UI.Dialog.ShowContentDialog(CalendarSettingsDialogHTML, Core.Language.Translate('Settings'), '10px', 'Center', true,
                [
                    {
                        Label: Core.Language.Translate('Save'),
                        Class: 'Primary',
                        Function: function () {
                            var $ShownAppointments = $('#ShownAppointments'),
                                Data = {
                                    ChallengeToken: $('#ChallengeToken').val(),
                                    Action: 'AgentAppointmentEdit',
                                    Subaction: 'UpdatePreferences',
                                    OverviewScreen: Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'CalendarOverview',
                                    ShownAppointments: $ShownAppointments.val()
                                };

                            Core.Agent.AppointmentCalendar.ShowWaitingDialog();

                            Core.AJAX.FunctionCall(
                                Core.Config.Get('CGIHandle'),
                                Data,
                                function (Response) {
                                    if (!Response.Success) {
                                        Core.Debug.Log('Error updating user preferences!');
                                    }
                                    window.location.href = Core.Config.Get('Baselink') + 'Action=AgentAppointment' + (Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'CalendarOverview');
                                }
                            );
                        }
                    }
                ], true);

            Event.preventDefault();
            Event.stopPropagation();

            return false;
        });

        // Show settings dialog immediately
        if (Core.Config.Get('CalendarSettingsShow')) {
            $CalendarSettingsObj.trigger('click.AppointmentCalendar');
        }
    }

    /**
     * @private
     * @name ResourceSettingsInit
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      This method initializes resource settings behavior.
     */
    function ResourceSettingsInit() {
        var $ResourceSettingsObj = $('#ResourceSettingsButton'),
            ResourceSettingsDialogHTML;

        if (!$ResourceSettingsObj.length) {
            return;
        }

        ResourceSettingsDialogHTML = Core.Template.Render('Agent/AppointmentCalendar/ResourceSettingsDialog', Core.Config.Get('ShownResourceSettings'));

        // Resource settings button
        $ResourceSettingsObj.off('click.AppointmentCalendar').on('click.AppointmentCalendar', function (Event) {
            Core.UI.Dialog.ShowContentDialog(ResourceSettingsDialogHTML, Core.Language.Translate('Settings'), '10px', 'Center', true,
                [
                    {
                        Label: Core.Language.Translate('Save'),
                        Class: 'Primary',
                        Function: function () {
                            var $ListContainer = $('.AllocationListContainer').find('.AssignedFields'),
                                ShownResources = [],
                                Data = {
                                    ChallengeToken: $('#ChallengeToken').val(),
                                    Action: 'AgentAppointmentEdit',
                                    Subaction: 'UpdatePreferences',
                                    OverviewScreen: Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'ResourceOverview',
                                    TeamID: $('#Team').val()
                                };

                            if (isJQueryObject($ListContainer) && $ListContainer.length) {
                                $.each($ListContainer.find('li'), function() {
                                    ShownResources.push($(this).attr('data-fieldname'));
                                });
                            }
                            Data.ShownResources = JSON.stringify(ShownResources);

                            Core.Agent.AppointmentCalendar.ShowWaitingDialog();

                            Core.AJAX.FunctionCall(
                                Core.Config.Get('CGIHandle'),
                                Data,
                                function (Response) {
                                    if (!Response.Success) {
                                        Core.Debug.Log('Error updating user preferences!');
                                    }
                                    location.reload();
                                }
                            );
                        }
                    }
                ], true);

            Event.preventDefault();
            Event.stopPropagation();

            Core.Agent.TableFilters.SetAllocationList();

            return false;
        });

        // Initialize restore settings button.
        RestoreDefaultSettingsInit();
    }

    /**
     * @private
     * @name ResourceSettingsInit
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      Adds restore default settings button (trash can) to view and initializes its behavior.
     */
    function RestoreDefaultSettingsInit() {
        var $RestoreSettingsObj;

        // Skip if button is not needed or we already have one.
        if (
            !Core.Config.Get('RestoreDefaultSettings')
            || $('#RestoreDefaultSettings').length > 0
            )
        {
            return;
        }

        // Create the button.
        $RestoreSettingsObj = $('<a />').attr('id', 'RestoreDefaultSettings')
            .attr('href', '#')
            .attr('title', Core.Language.Translate('Restore default settings'))
            .append($('<i />').addClass('fa fa-trash'));

        // Add it to the column header.
        $('tr.fc-super + tr .fc-cell-content').append($RestoreSettingsObj);

        // Register click handler.
        $RestoreSettingsObj.off('click.AppointmentCalendar').on('click.AppointmentCalendar', function (Event) {
            Core.AJAX.FunctionCall(
                Core.Config.Get('CGIHandle'),
                {
                    ChallengeToken: $('#ChallengeToken').val(),
                    Action: 'AgentAppointmentEdit',
                    Subaction: 'UpdatePreferences',
                    OverviewScreen: Core.Config.Get('OverviewScreen') ? Core.Config.Get('OverviewScreen') : 'ResourceOverview',
                    RestoreDefaultSettings: 'ShownResources',
                    TeamID: $('#Team').val()
                },
                function (Response) {
                    if (!Response.Success) {
                        Core.Debug.Log('Error updating user preferences!');
                    }
                    location.reload();
                }
            );

            Event.preventDefault();
            Event.stopPropagation();

            return false;
        });
    }

    /**
     * @private
     * @name ToggleAJAXLoader
     * @memberof Core.Agent.AppointmentCalendar
     * @function
     * @param {jQueryObject} $Element - Object reference of the field which is updated
     * @param {Boolean} Show - Show or hide the AJAX loader image
     * @description
     *      Shows and hides an ajax loader for every element which is updates via ajax.
     */
    function ToggleAJAXLoader($Element, Show) {
        var $Loader = $('#AJAXLoader' + $Element.attr('id')),
            LoaderHTML = '<span id="AJAXLoader' + $Element.attr('id') + '" class="AJAXLoader"></span>';

        // Element not present
        if (!$Element.length) {
            return;
        }

        // Show or hide the loader
        if (Show) {
            if (!$Loader.length) {
                $Element.after(LoaderHTML);
            } else {
                $Loader.show();
            }
        } else {
            if ($Loader.length) {
                $Loader.hide();
            }
        }
    }

    /**
     * @name PluginInit
     * @memberof Core.Agent.AppointmentCalendar
     * @param {jQueryObject} $PluginFields - fields with different plugin searches.
     * @description
     *      This method initializes plugin fields behavior.
     */
    TargetNS.PluginInit = function ($PluginFields) {

        function InitRemoveButtons() {
            $('.RemoveButton').off('click.AppointmentCalendar').on('click.AppointmentCalendar', function () {
                var $RemoveObj = $(this),
                    PluginKey = $RemoveObj.data('pluginKey'),
                    $PluginDataObj = $('#Plugin_' + Core.App.EscapeSelector(PluginKey)),
                    PluginData = JSON.parse($PluginDataObj.val()),
                    LinkID = $RemoveObj.data('linkId').toString(),
                    $Parent = $RemoveObj.parent();

                PluginData.splice(PluginData.indexOf(LinkID), 1);
                $PluginDataObj.val(JSON.stringify(PluginData));

                $Parent.remove();

                return false;
            });
        }

        function AddLink(PluginKey, PluginURL, LinkID, LinkName) {
            var $PluginContainerObj = $('#PluginContainer_' + Core.App.EscapeSelector(PluginKey)),
                $PluginDataObj = $('#Plugin_' + Core.App.EscapeSelector(PluginKey)),
                PluginData = JSON.parse($PluginDataObj.val()),
                $ExistingLinks = $PluginContainerObj.find('.Link_' + Core.App.EscapeSelector(LinkID)),
                $LinkContainerObj = $('<div />'),
                $URLObj = $('<a />'),
                $RemoveObj = $('<a />'),
                LinkURL = PluginURL.replace('%s', LinkID);

            if ($ExistingLinks.length > 0) {
                return;
            }

            PluginData.push(LinkID);
            $PluginDataObj.val(JSON.stringify(PluginData));

            $LinkContainerObj.addClass('Link_' + Core.App.EscapeSelector(LinkID));

            $URLObj.attr('href', LinkURL)
                .attr('target', '_blank')
                .text(LinkName)
                .appendTo($LinkContainerObj);

            $RemoveObj.attr('href', '#')
                .addClass('RemoveButton')
                .data('pluginKey', PluginKey)
                .data('linkId', LinkID)
                .append(
                    $('<i />').addClass('fa fa-minus-square-o')
                )
                .appendTo($LinkContainerObj);

            $LinkContainerObj.appendTo($PluginContainerObj);
            InitRemoveButtons();
        }

        $PluginFields.each(function () {
            var $Element = $(this),
                PluginKey = $Element.data('pluginKey'),
                PluginURL = $Element.data('pluginUrl');

            // Skip already initialized fields
            if ($Element.hasClass('ui-autocomplete-input')) {
                return true;
            }

            Core.UI.Autocomplete.Init($Element, function (Request, Response) {
                    var URL = Core.Config.Get('CGIHandle'),
                        CurrentAJAXNumber = ++AJAXCounter,
                        Data = {
                            ChallengeToken: $('#ChallengeToken').val(),
                            Action: 'AgentAppointmentPluginSearch',
                            PluginKey: PluginKey,
                            Term: Request.term + '*',
                            MaxResults: 20
                        };

                    $Element.data(
                        'AutoCompleteXHR',
                        Core.AJAX.FunctionCall(
                            URL,
                            Data,
                            function (Result) {
                                var Data = [];

                                // Check if the result is from the latest ajax request
                                if (AJAXCounter !== CurrentAJAXNumber) {
                                    return false;
                                }

                                $.each(Result, function () {
                                    Data.push({
                                        label: this.Value,
                                        key:  this.Key,
                                        value: this.Value
                                    });
                                });
                                Response(Data);
                            }
                        )
                    );
            }, function (Event, UI) {
                Event.stopPropagation();
                $Element.val('').trigger('select.Autocomplete');
                AddLink(PluginKey, PluginURL, UI.item.key, UI.item.label);

                return false;
            }, PluginKey);
        });

        InitRemoveButtons();
    }

    /**
     * @name EditAppointment
     * @param {Object} Data - Hash with call and appointment data.
     * @param {Integer} Data.AppointmentID - Appointment ID.
     * @param {Integer} Data.Action - Edit action.
     * @param {Integer} Data.Subaction - Edit subaction.
     * @param {Integer} Data.Title - Appointment title.
     * @param {Integer} Data.Description - Appointment description.
     * @param {Integer} Data.Location - Appointment location.
     * @param {Integer} Data.StartYear - Appointment start year.
     * @param {Integer} Data.StartMonth - Appointment start month.
     * @param {Integer} Data.StartDay - Appointment start day.
     * @param {Integer} Data.StartHour - Appointment start hour.
     * @param {Integer} Data.StartMinute - Appointment start minute.
     * @param {Integer} Data.EndYear - Appointment end year.
     * @param {Integer} Data.EndMonth - Appointment end month.
     * @param {Integer} Data.EndDay - Appointment end day.
     * @param {Integer} Data.EndHour - Appointment end hour.
     * @param {Integer} Data.EndMinute - Appointment end minute.
     * @param {Integer} Data.AllDay - Is appointment an all-day appointment (0|1)?
     * @description
     *      This method submits an edit appointment call to the backend and refreshes the view.
      */
    TargetNS.EditAppointment = function (Data) {
        if (Core.Config.Get('Action') === 'AgentAppointmentAgendaOverview') {
            $('.OverviewControl').addClass('Loading');
        }

        Core.AJAX.FunctionCall(
            Core.Config.Get('CGIHandle'),
            Data,
            function (Response) {
                if (Response.Success) {
                    $('#calendar').fullCalendar('refetchEvents');

                    // Close the dialog
// RotherOSS / AppointmentToTicket
                    $('.Dialog:visible').removeClass('Persistent');
// EO AppointmentToTicket
                    Core.UI.Dialog.CloseDialog($('.Dialog:visible'));

                    // Reload page if necessary
                    if (Core.Config.Get('Action') === 'AgentAppointmentAgendaOverview') {
                        window.location.reload();
                    }
                }
                else {
                    if (Response.Error) {
                        alert(Response.Error);
                    }
                }
            }
        );
    };

    /**
     * @name AgentAppointmentAgendaOverview
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      This method initializes functionalities for AgentAppointmentAgentOverview screen.
     */
    TargetNS.AgentAppointmentAgendaOverview = function () {
        var Config = Core.Config.Get('AppointmentAgendaOverview');

        $('#AppointmentCreateButton').off('click').on('click', function () {
            Core.Agent.AppointmentCalendar.OpenEditDialog({
                Start: $.fullCalendar.moment(Config.Start).add(1, 'hours').startOf('hour'),
                End: $.fullCalendar.moment(Config.Start).add(2, 'hours').startOf('hour')
            });

            return false;
        });
        $('.MasterAction').bind('click', function () {
            var $MasterActionLink = $(this).find('.MasterActionLink'),
                AppointmentID = $MasterActionLink.data('appointmentId');

            Core.Agent.AppointmentCalendar.OpenEditDialog({
                CalEvent: {
                    id: AppointmentID
                }
            });

            return false;
        });
    }

    /**
     * @name AgentAppointmentAgendaOverview
     * @memberof Core.Agent.AppointmentCalendar
     * @description
     *      This method initializes functionalities for AgentAppointmentEdit screen.
     */
    TargetNS.AgentAppointmentEdit = function () {
        Core.Form.Validate.Init();
        TargetNS.LocationLinkInit($('#Location'), $('.LocationLink'));
        TargetNS.AllDayInit($('#AllDay'));
        TargetNS.RecurringInit({
            $Recurring: $('#Recurring'),
            $RecurrenceType: $('#RecurrenceType'),
            $RecurrenceCustomType: $('#RecurrenceCustomType'),
            $RecurrenceCustomTypeStringDiv: $('#RecurrenceCustomTypeStringDiv'),
            $RecurrenceIntervalText: $('#RecurrenceIntervalText'),
            $RecurrenceCustomWeeklyDiv: $('#RecurrenceCustomWeeklyDiv'),
            $RecurrenceCustomMonthlyDiv: $('#RecurrenceCustomMonthlyDiv'),
            $RecurrenceCustomYearlyDiv: $('#RecurrenceCustomYearlyDiv'),
            $RecurrenceLimitDiv: $('#RecurrenceLimitDiv'),
            $RecurrenceLimit: $('#RecurrenceLimit'),
            $RecurrenceUntilDiv: $('#RecurrenceUntilDiv'),
            $RecurrenceUntilDay: $('#RecurrenceUntilDay'),
            $RecurrenceCountDiv: $('#RecurrenceCountDiv')
        });
        TargetNS.NotificationInit({
            $NotificationTemplate: $('#NotificationTemplate'),
            $NotificationCustomStringDiv: $('#NotificationCustomStringDiv'),
            $NotificationCustomRelativeInput: $('#NotificationCustomRelativeInput'),
            $NotificationCustomRelativeUnitCount: $('#NotificationCustomRelativeUnitCount'),
            $NotificationCustomRelativeUnit: $('#NotificationCustomRelativeUnit'),
            $NotificationCustomRelativePointOfTime: $('#NotificationCustomRelativePointOfTime'),
            $NotificationCustomDateTimeInput: $('#NotificationCustomDateTimeInput'),
            $NotificationCustomDateTimeDay: $('#NotificationCustomDateTimeDay'),
            $NotificationCustomDateTimeMonth: $('#NotificationCustomDateTimeMonth'),
            $NotificationCustomDateTimeYear: $('#NotificationCustomDateTimeYear'),
            $NotificationCustomDateTimeHour: $('#NotificationCustomDateTimeHour'),
            $NotificationCustomDateTimeMinute: $('#NotificationCustomDateTimeMinute')
        });
// RotherOSS / AppointmentToTicket
        TargetNS.TicketInit({
            $TicketTemplate: $('#TicketTemplate'),
            $TicketCustomStringDiv: $('#TicketCustomStringDiv'),
            $TicketCustomCreationDiv: $('#TicketCustomCreationDiv'),
            $TicketCustomRelativeInput: $('#TicketCustomRelativeInput'),
            $TicketCustomRelativeUnitCount: $('#TicketCustomRelativeUnitCount'),
            $TicketCustomRelativeUnit: $('#TicketCustomRelativeUnit'),
            $TicketCustomRelativePointOfTime: $('#TicketCustomRelativePointOfTime'),
            $TicketCustomDateTimeInput: $('#TicketCustomDateTimeInput'),
            $TicketCustomDateTimeDay: $('#TicketCustomDateTimeDay'),
            $TicketCustomDateTimeMonth: $('#TicketCustomDateTimeMonth'),
            $TicketCustomDateTimeYear: $('#TicketCustomDateTimeYear'),
            $TicketCustomDateTimeHour: $('#TicketCustomDateTimeHour'),
            $TicketCustomDateTimeMinute: $('#TicketCustomDateTimeMinute')
        });
// EO AppointmentToTicket
        TargetNS.TeamInit($('#TeamID'), $('#ResourceID'), $('label[for="TeamID"] + div.Field p.ReadOnlyValue'), $('label[for="ResourceID"] + div.Field p.ReadOnlyValue'));

        if (Core.Config.Get('CalendarPermissionLevel') > 1) {
            TargetNS.PluginInit($('.PluginField'), $('#ChallengeToken').val());
        }

        Core.Form.Validate.SetSubmitFunction($('#EditAppointmentForm'), function (Form) {
            var Data = new Object(),
                Days = new Array(),
                MonthDays = new Array(),
                Months = new Array();

            // serialize days
            $("#RecurrenceCustomWeeklyDiv button.fc-state-active").each(function(){
                Days.push($(this).val());
            });
            $("input#Days").val(Days.join());

            // serialize month days
            $("#RecurrenceCustomMonthlyDiv button.fc-state-active").each(function(){
                MonthDays.push($(this).val());
            });
            $("input#MonthDays").val(MonthDays.join());

            // serialize months
            $("#RecurrenceCustomYearlyDiv button.fc-state-active").each(function(){
                Months.push($(this).val());
            });
            $("input#Months").val(Months.join());

            $(Form).find('input,textarea,select').each(function (Index, Element) {
                if (Element.type == 'checkbox') {
                    Data[Element.id] = $(Element).prop('checked') ? '1' : '0';
// RotherOSS / AppointmentToTicket
                } else if (Element.name == 'CustomerSelected') {
                    if (!Data[Element.name] && $(Element).prop('checked')) {
                        Data[Element.name] = $(Element).val();
                    }
// EO AppointmentToTicket
                } else {
                    Data[Element.id] = $(Element).val();
                }
            });

            TargetNS.ShowWaitingDialog();
            TargetNS.EditAppointment(Data);
        });

        $(".ButtonTable button").on("click", function() {
            $(this).toggleClass("fc-state-active");
        });

        // Duplicate appointment
        $('#EditFormCopy').on('click', function() {
            // Reset AppointmentID, remove Copy & Delete buttons
            $("#EditAppointmentForm input#AppointmentID").val("");
            $('#EditAppointmentForm').submit();
        });

        // Save the appointment
        $('#EditFormSubmit').on('click', function() {
            $('#EditAppointmentForm').submit();
        });

        // Delete the appointment
        if (Core.Config.Get('EditAppointmentID')) {
            $('#EditFormDelete').on('click', function() {
                if (window.confirm(Core.Language.Translate('Are you sure you want to delete this appointment? This operation cannot be undone.'))) {
                    Core.Agent.AppointmentCalendar.ShowWaitingDialog();
                    Core.Agent.AppointmentCalendar.EditAppointment({
                        AppointmentID: Core.Config.Get('EditAppointmentID'),
                        Action: 'AgentAppointmentEdit',
                        Subaction: 'DeleteAppointment'
                    });
                }
            });
        }

        // Edit parent appointment
        if (Core.Config.Get('EditParentID')) {
            $('#EditParent').on('click', function() {
                var Data = {
                    ChallengeToken: $("#ChallengeToken").val(),
                    Action: 'AgentAppointmentEdit',
                    Subaction: 'EditMask',
                    AppointmentID: Core.Config.Get('EditParentID')
                };

                Core.Agent.AppointmentCalendar.ShowWaitingDialog();
                Core.AJAX.FunctionCall(
                    Core.Config.Get('CGIHandle'),
                    Data,
                    function (HTML) {
                        Core.UI.Dialog.ShowContentDialog(HTML, Core.Language.Translate('Appointment'), '10px', 'Center', true, undefined, true);
                        Core.UI.InputFields.Activate($('.Dialog:visible'));
                        TargetNS.AgentAppointmentEdit();
                    },
                    'html'
                );
            });
        }

        // Close the dialog
        $('#EditFormCancel').on('click', function() {
// RotherOSS / AppointmentToTicket
            $('.Dialog:visible').removeClass('Persistent');
// EO AppointmentToTicket
            Core.UI.Dialog.CloseDialog($('.Dialog:visible'));
        });

        // Initialize datepicker buttons.
        if (Core.Config.Get('CalendarPermissionLevel') > 2) {
            $.each(['Start', 'End', 'RecurrenceUntil', 'NotificationCustomDateTime'], function (Index, Prefix) {
                Core.UI.Datepicker.Init({
                    Day: $('#' + Core.App.EscapeSelector(Prefix) + 'Day'),
                    Month: $('#' + Core.App.EscapeSelector(Prefix) + 'Month'),
                    Year: $('#' + Core.App.EscapeSelector(Prefix) + 'Year'),
                    Hour: $('#' + Core.App.EscapeSelector(Prefix) + 'Hour'),
                    Minute: $('#' + Core.App.EscapeSelector(Prefix) + 'Minute'),
                    WeekDayStart: Core.Config.Get('CalendarWeekDayStart')
                });
            });
        }
    }

    Core.Init.RegisterNamespace(TargetNS, 'APP_MODULE');

    return TargetNS;
}(Core.Agent.AppointmentCalendar || {}));
 // --
// OTOBO is a web-based ticketing system for service organisations.
// --
// Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
// Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
// --
// $origin: otobo - deb99d60daf212ae73ec7feb78074f3f7ae563f8 - var/httpd/htdocs/js/Core.Agent.CustomerSearch.js
// --
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// --

"use strict";

var Core = Core || {};
Core.Agent = Core.Agent || {};

/**
 * @namespace Core.Agent.CustomerSearch
 * @memberof Core.Agent
 * @author
 * @description
 *      This namespace contains the special module functions for the customer search.
 */
Core.Agent.CustomerSearch = (function (TargetNS) {
    /**
     * @private
     * @name BackupData
     * @memberof Core.Agent.CustomerSearch
     * @member {Object}
     * @description
     *      Saves Customer data for later restore.
     */
    var BackupData = {
            CustomerInfo: '',
            CustomerEmail: '',
            CustomerKey: ''
        },
    /**
     * @private
     * @name CustomerFieldChangeRunCount
     * @memberof Core.Agent.CustomerSearch
     * @member {Object}
     * @description
     *      Needed for the change event of customer fields, if ActiveAutoComplete is false (disabled).
     */
        CustomerFieldChangeRunCount = {};

    /**
     * @private
     * @name DeactivateSelectionCustomerID
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @description
     *      Disable the selection for the customer ID, if needed.
     */
    function DeactivateSelectionCustomerID () {
        if($('#TemplateSelectionCustomerID').length) {
            $('#SelectionCustomerID').prop('disabled', true)
            $('#SelectionCustomerID').prop('title', Core.Language.Translate('First select a customer user, then select a customer ID to assign to this ticket.'));
            $('#SelectionCustomerID').addClass('Disabled');
        }
    }

    /**
     * @private
     * @name ActivateSelectionCustomerID
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} Value - The value attribute of the radio button to be selected.
     * @param {String} Name - The name of the radio button to be selected.
     * @description
     *      Activate the customer ID selection button, if .
     */
    function ActivateSelectionCustomerID () {
        if ($('#TemplateSelectionCustomerID').length && $('#SelectionCustomerID').hasClass('Disabled')) {
            $('#SelectionCustomerID').prop('disabled', false)
            $('#SelectionCustomerID').prop('title', Core.Language.Translate('Select a customer ID to assign to this ticket.'));
            $('#SelectionCustomerID').removeClass('Disabled');
        }
    }

    /**
     * @private
     * @name GetCustomerInfo
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} CustomerUserID
     * @description
     *      This function gets customer data for customer info table.
     */
    function GetCustomerInfo(CustomerUserID) {
        var Data = {
                Action: 'AgentCustomerSearch',
                Subaction: 'CustomerInfo',
                CustomerUserID: CustomerUserID
            },
            SignatureURL;

        Core.AJAX.FunctionCall(Core.Config.Get('Baselink'), Data, function (Response) {

            $('#CustomerID').val(Response.CustomerID);
            $('#ShowCustomerID').html(Response.CustomerID);

            // Publish information for subscribers
            Core.App.Publish('Event.Agent.CustomerSearch.GetCustomerInfo.Callback', [Response.CustomerID]);

            // show customer info
            $('#CustomerInfo .Content').html(Response.CustomerTableHTMLString);

// RotherOSS / AppointmentToTicket
//             // only execute this part, if in AgentTicketEmail or AgentTicketPhone
//             if (Core.Config.Get('Action') === 'AgentTicketEmail' || Core.Config.Get('Action') === 'AgentTicketPhone') {
//                 var $Form = Core.Config.Get('Action') === 'AgentTicketEmail' ? $('#NewEmailTicket') : $('#NewPhoneTicket');
            // only execute this part, if in AgentTicketEmail or AgentTicketPhone or AgentAppointmentEdit
            if (Core.Config.Get('Action') === 'AgentTicketEmail' || Core.Config.Get('Action') === 'AgentTicketPhone' || Core.Config.Get('Action') === 'AgentAppointmentCalendarOverview') {
                var $Form;
                if (Core.Config.Get('Action') === 'AgentTicketEmail') {
                    $Form = $('#NewEmailTicket');
                }
                else if (Core.Config.Get('Action') === 'AgentTicketPhone') {
                    $Form = $('#NewPhoneTicket');
                }
                else if (Core.Config.Get('Action') === 'AgentAppointmentCalendarOverview') {
                    $Form = $('#EditAppointmentForm');
                }
// EO AppointmentToTicket

                // reset service
                $('#ServiceID').attr('selectedIndex', 0);
                // update services (trigger ServiceID change event)
                Core.AJAX.FormUpdate($Form, 'AJAXUpdate', 'ServiceID');

                // Update signature if needed.
                if ($('#Dest').val() !== '') {
                    SignatureURL = Core.Config.Get('Baselink') + 'Action=' + Core.Config.Get('Action') + ';Subaction=Signature;Dest=' + $('#Dest').val() + ';SelectedCustomerUser=' + $('#SelectedCustomerUser').val();
                    $('#Signature').attr('src', SignatureURL);
                }
            }
            if (Core.Config.Get('Action') === 'AgentTicketProcess') {
                // reset service
                $('#ServiceID').attr('selectedIndex', 0);
                // update services (trigger ServiceID change event)
                Core.AJAX.FormUpdate($('#CustomerID').closest('form'), 'AJAXUpdate', 'ServiceID');
            }
        });
    }

    /**
     * @private
     * @name GetCustomerTickets
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} CustomerUserID
     * @param {String} CustomerID
     * @description
     *      This function gets customer tickets.
     */
    function GetCustomerTickets(CustomerUserID, CustomerID) {

        var Data = {
            Action: 'AgentCustomerSearch',
            Subaction: 'CustomerTickets',
            CustomerUserID: CustomerUserID,
            CustomerID: CustomerID
        };

        // check if customer tickets should be shown
        if (typeof Core.Config.Get('CustomerSearch') !== 'undefined' && !parseInt(Core.Config.Get('CustomerSearch').ShowCustomerTickets, 10)) {
            return;
        }

        /**
         * @private
         * @name CustomerHistoryEvents
         * @memberof Core.Agent.CustomerSearch.GetCustomerTickets
         * @function
         * @description
         *      This function creates events for Customer History overview table.
         */
        function CustomerHistoryEvents() {
            $('select[name=ResponseID]').on('change', function () {
                var URL;
                if ($(this).val() > 0) {
                    URL = Core.Config.Get('Baselink') + $(this).parents().serialize();
                    Core.UI.Popup.OpenPopup(URL, 'TicketAction');

                    // Reset the select box so that it can be used again from the same window.
                    $(this).val('0');
                }
            });
            $('select[name=ResponseID]').on('click', function (Event) {
                Event.stopPropagation();
                return false;
            });

            $('#CustomerTickets .MasterAction').on('click', function (Event) {
                var $MasterActionLink = $(this).find('a.MasterActionLink');

                // Prevent MasterAction on Modernize input fields.
                if ($(Event.target).hasClass('InputField_Search')) {
                    return true;
                }

                // Event must be done in the parent window because AgentTicketCustomer is in popup.
                if (Core.Config.Get('Action') === 'AgentTicketCustomer') {
                    Core.UI.Popup.ExecuteInParentWindow(function(WindowObject) {
                        WindowObject.Core.UI.Popup.FirePopupEvent('URL', { URL: $MasterActionLink.attr('href') });
                    });
                    Core.UI.Popup.ClosePopup();
                    return false;
                }
                else {

                    // Only act if the link was not clicked directly.
                    if (Event.target !== $MasterActionLink.get(0)) {
                        window.location = $MasterActionLink.attr('href');
                        return false;
                    }
                }
            });

            $("#SortBy").off('change').on('change', function () {
                var SortedData,
                    Selection = $(this).val().split('|');

                if (Selection.length === 2) {

                    // Show sorted customer tickets.
                    SortedData = {
                        Action: 'AgentCustomerSearch',
                        Subaction: 'CustomerTickets',
                        CustomerUserID: CustomerUserID,
                        CustomerID: CustomerID,
                        SortBy: Selection[0],
                        OrderBy: Selection[1]
                    };
                    Core.AJAX.FunctionCall(Core.Config.Get('Baselink'), SortedData, function (Response) {
                        if ($('#CustomerTickets').length) {
                            $('#CustomerTickets').html(Response.CustomerTicketsHTMLString);
                            ReplaceCustomerTicketLinks();
                        }
                    });
                }
            });

            // Activate Modernize fields.
            Core.UI.InputFields.Activate();
            Core.App.Subscribe('Event.UI.Accordion.OpenElement', function($Element) {
                Core.UI.InputFields.Activate($Element);
            });
        }

        /**
         * @private
         * @name ReplaceCustomerTicketLinks
         * @memberof Core.Agent.CustomerSearch.GetCustomerTickets
         * @function
         * @returns {Boolean} Returns false.
         * @description
         *      This function replaces and shows customer ticket links.
         */
        function ReplaceCustomerTicketLinks() {
            $('#CustomerTickets').find('.AriaRoleMain').removeAttr('role').removeClass('AriaRoleMain');

            // Replace overview mode links (S, M, L view), pagination links with AJAX
            $('#CustomerTickets').find('.OverviewZoom a, .Pagination a, .TableSmall th a').click(function () {
                // Cut out BaseURL and query string from the URL
                var Link = $(this).attr('href'),
                    URLComponents;

                URLComponents = Link.split('?', 2);

                Core.AJAX.FunctionCall(URLComponents[0], URLComponents[1], function (Response) {
                    // show customer tickets
                    if ($('#CustomerTickets').length) {
                        $('#CustomerTickets').html(Response.CustomerTicketsHTMLString);
                        ReplaceCustomerTicketLinks();

                        $('#CustomerTickets a.SplitSelection').off('click').on('click', function() {
                            Core.Agent.TicketSplit.OpenSplitSelection($(this).attr('href'));
                            return false;
                        });
                    }
                });
                return false;
            });

            // Init accordion of overview article preview
            Core.UI.Accordion.Init($('.Preview > ul'), 'li h3 a', '.HiddenBlock');

            // Events for Customer History table - AgentTicketPhone, AgentTicketEmail and AgentTicketCustomer screens.
            if (
                Core.Config.Get('Action') === 'AgentTicketPhone' ||
                Core.Config.Get('Action') === 'AgentTicketEmail' ||
                Core.Config.Get('Action') === 'AgentTicketCustomer' ||
                Core.Config.Get('Action') === 'AgentChatAppend'
                )
            {
                CustomerHistoryEvents();
            }

            return false;
        }

        Core.AJAX.FunctionCall(Core.Config.Get('Baselink'), Data, function (Response) {
            // show customer tickets
            if ($('#CustomerTickets').length) {
                $('#CustomerTickets').html(Response.CustomerTicketsHTMLString);
                ReplaceCustomerTicketLinks();

                // click event for opening popup
                $('#CustomerTickets a.AsPopup').off('click').on('click', function () {
                    Core.UI.Popup.OpenPopup($(this).attr('href'), 'Action');
                    return false;
                });

                $('#CustomerTickets a.SplitSelection').off('click').on('click', function() {
                    Core.Agent.TicketSplit.OpenSplitSelection($(this).attr('href'));
                    return false;
                });
            }
        });
    }

    /**
     * @private
     * @name CheckPhoneCustomerCountLimit
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @description
     *      In AgentTicketPhone, this checks if more than one entry is allowed
     *      in the customer list and blocks/unblocks the autocomplete field as needed.
     */
    function CheckPhoneCustomerCountLimit() {

        // Only operate in AgentTicketPhone
        if (Core.Config.Get('Action') !== 'AgentTicketPhone') {
            return;
        }

        // Check if multiple from entries are allowed
        if (parseInt(Core.Config.Get('CustomerSearch').AllowMultipleFrom, 10)) {
            return;
        }

        if ($('#TicketCustomerContentFromCustomer input.CustomerTicketText').length > 0) {
            $('#FromCustomer').val('').prop('disabled', true).prop('readonly', true);
            $('#Dest').trigger('focus');
        }
        else {
            $('#FromCustomer').val('').prop('disabled', false).prop('readonly', false);
        }
    }

    /**
     * @private
     * @name InitSimple
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {jQueryObject} $Element - The jQuery object of the input field with autocomplete.
     * @description
     *      Initializes the module.
     */
    TargetNS.InitSimple = function ($Element) {
        var CustomerSearchType = $Element.data('customer-search-type');

        if (CustomerSearchType) {
            Core.UI.Autocomplete.Init($Element, function (Request, Response) {
                    var URL = Core.Config.Get('Baselink'), Data = {
                        Action: 'AgentCustomerSearch',
                        Subaction: 'Search' + CustomerSearchType,
                        Term: Request.term,
                        MaxResults: Core.UI.Autocomplete.GetConfig('MaxResultsDisplayed')
                    };

                    $Element.data('AutoCompleteXHR', Core.AJAX.FunctionCall(URL, Data, function (Result) {
                        var ValueData = [];
                        $Element.removeData('AutoCompleteXHR');
                        $.each(Result, function () {
                            ValueData.push({
                                label: this.Label + (CustomerSearchType == 'CustomerUser' ? ' (' + this.Value + ')' : ''),
                                value: this.Value
                            });
                        });
                        Response(ValueData);
                    }));
            }, function (Event, UI) {
                $Element.val(UI.item.value).trigger('select.Autocomplete');

                Event.preventDefault();
                Event.stopPropagation();

                return false;
            }, 'CustomerSearch');
        }
    }

    /**
     * @private
     * @name Init
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {jQueryObject} $Element - The jQuery object of the input field with autocomplete.
     * @description
     *      Initializes the module.
     */
    TargetNS.Init = function ($Element) {
        var AutocompleteFocus = false;

        // get customer tickets for AgentTicketCustomer
        if (Core.Config.Get('Action') === 'AgentTicketCustomer') {
            GetCustomerTickets($('#CustomerAutoComplete').val(), $('#CustomerID').val());

            $Element.blur(function () {
                if ($Element.val() === '') {
                    TargetNS.ResetCustomerInfo();
                    DeactivateSelectionCustomerID();
                    $('#CustomerTickets').empty();
                }
            });
        }

        // Enable free selection or input of CustomerID field on AgentTicketProcess and AgentTicketCustomer.
        if ((Core.Config.Get('Action') === 'AgentTicketProcess'
            && !Core.Config.Get('Ticket::Frontend::AgentTicketProcess::CustomerIDReadOnly'))
            ||
            (Core.Config.Get('Action') === 'AgentTicketCustomer'
            && !Core.Config.Get('Ticket::Frontend::AgentTicketCustomer::CustomerIDReadOnly'))
// RotherOSS / AppointmentToTicket
            || Core.Config.Get('Action') === 'AgentAppointmentCalendarOverview'
// EO AppointmentToTicket
            ) {
            $('#CustomerAutoComplete').on('blur keyup' , function() {
                if($('#CustomerAutoComplete').val()) {
                    ActivateSelectionCustomerID();
                }
                else {
                    DeactivateSelectionCustomerID();
                }
            });
        }

        // get customer tickets for AgentTicketPhone and AgentTicketEmail
        if ((Core.Config.Get('Action') === 'AgentTicketEmail' || Core.Config.Get('Action') === 'AgentTicketPhone') && $('#SelectedCustomerUser').val() !== '') {
            GetCustomerTickets($('#SelectedCustomerUser').val());
        }

        // just save the initial state of the customer info
        if ($('#CustomerInfo').length) {
            BackupData.CustomerInfo = $('#CustomerInfo .Content').html();
        }

        if (isJQueryObject($Element)) {
            // Hide tooltip in autocomplete field, if user already typed something to prevent the autocomplete list
            // to be hidden under the tooltip. (Only needed for serverside errors)
            $Element.off('keyup.Validate').on('keyup.Validate', function () {
               var Value = $Element.val();
               if ($Element.hasClass('ServerError') && Value.length) {
                   $('#OTOBO_UI_Tooltips_ErrorTooltip').hide();
               }
            });

            Core.App.Subscribe('Event.CustomerUserAddressBook.AddTicketCustomer.Callback.' + $Element.attr('id'), function(UserLogin, CustomerTicketText) {
                $Element.val(CustomerTicketText);
                TargetNS.AddTicketCustomer($Element.attr('id'), CustomerTicketText, UserLogin);
            });

            Core.UI.Autocomplete.Init($Element, function (Request, Response) {
                var URL = Core.Config.Get('Baselink'),
                    Data = {
                        Action: 'AgentCustomerSearch',
                        Term: Request.term,
                        MaxResults: Core.UI.Autocomplete.GetConfig('MaxResultsDisplayed')
                    };

                $Element.data('AutoCompleteXHR', Core.AJAX.FunctionCall(URL, Data, function (Result) {
                    var ValueData = [];
                    $Element.removeData('AutoCompleteXHR');
                    $.each(Result, function () {
                        ValueData.push({
                            label: this.Label + " (" + this.Value + ")",
                            // customer list representation (see CustomerUserListFields from Defaults.pm)
                            value: this.Label,
                            // customer user id
                            key: this.Value
                        });
                    });
                    Response(ValueData);
                }));
            }, function (Event, UI) {
                var CustomerKey = UI.item.key,
                    CustomerValue = UI.item.value;

                BackupData.CustomerKey = CustomerKey;
                BackupData.CustomerEmail = CustomerValue;

                $Element.val(CustomerValue);

                if (
                    Core.Config.Get('Action') === 'AgentTicketEmail'
                    || Core.Config.Get('Action') === 'AgentTicketCompose'
                    || Core.Config.Get('Action') === 'AgentTicketForward'
                    || Core.Config.Get('Action') === 'AgentTicketEmailOutbound'
                    || Core.Config.Get('Action') === 'AgentTicketEmailResend'
// RotherOSS / AppointmentToTicket
                    || Core.Config.Get('Action') === 'AgentAppointmentCalendarOverview'
// EO AppointmentToTicket
                    )
                {
                    $Element.val('');
                }

                if (
                    Core.Config.Get('Action') !== 'AgentTicketPhone'
                    && Core.Config.Get('Action') !== 'AgentTicketEmail'
                    && Core.Config.Get('Action') !== 'AgentTicketCompose'
                    && Core.Config.Get('Action') !== 'AgentTicketForward'
                    && Core.Config.Get('Action') !== 'AgentTicketEmailOutbound'
                    && Core.Config.Get('Action') !== 'AgentTicketEmailResend'
// RotherOSS / AppointmentToTicket
                    && Core.Config.Get('Action') !== 'AgentAppointmentCalendarOverview'
// Eo AppointmentToTicket
                    )
                {
                    // set hidden field SelectedCustomerUser
                    $('#SelectedCustomerUser').val(CustomerKey);

                    ActivateSelectionCustomerID();

                    // needed for AgentTicketCustomer.pm
                    if ($('#CustomerUserID').length) {
                        $('#CustomerUserID').val(CustomerKey);
                        if ($('#CustomerUserOption').length) {
                            $('#CustomerUserOption').val(CustomerKey);
                        }
                        else {
                            $('<input type="hidden" name="CustomerUserOption" id="CustomerUserOption">').val(CustomerKey).appendTo($Element.closest('form'));
                        }
                    }

                    // get customer tickets
                    GetCustomerTickets(CustomerKey);

                    // get customer data for customer info table
                    GetCustomerInfo(CustomerKey);
                }
                else {
                    TargetNS.AddTicketCustomer($(Event.target).attr('id'), CustomerValue, CustomerKey);
                }
            }, 'CustomerSearch');

            // Remember if autocomplete item was focused (by keyboard navigation or mouse).
            $Element.on('autocompletefocus', function() {
                AutocompleteFocus = true;
            });

            if (typeof $Element.data("ui-autocomplete") === 'object') {

                // Remember if the autocomplete widget is left by mouse.
                $($Element.data("ui-autocomplete").menu.element).on('mouseleave', function() {
                    AutocompleteFocus = false;
                });

                // Remember if the autocomplete widget is left by keyboard navigation.
                // This is done by override the _move method because there is no opposite event of autocompletefocus.
                $Element.data("ui-autocomplete")._move = function(direction, event) {

                    if (!this.menu.element.is(":visible")) {
                        this.search(null, event);
                        return;
                    }

                    if (this.menu.isFirstItem() && /^previous/.test(direction) ||
                        this.menu.isLastItem() && /^next/.test(direction)
                    ) {
                        this._value(this.term);

                        // Trigger mouseleave for removing selection of autocomplete widget.
                        $(this.menu.element).trigger('mouseleave');

                        AutocompleteFocus = false;
                        return;
                    }

                    this.menu[ direction ](event);
                };
            }

            // If autocomplete was focused, but then closed by a blur, clear the search field since this value was
            //   never explicitly confirmed. Do this also when user decides to click outside the autocomplete list,
            //   which causes the list to close. Please see bug#13537 for more information.
            $Element.on('autocompleteclose', function(Event) {
                if (
                    AutocompleteFocus
                    && (
                        Event.originalEvent === undefined
                        || (
                            Event.originalEvent
                            && Event.originalEvent.type == 'blur'
                        )
                    )
                    )
                {
                    $Element.val('');
                }

                AutocompleteFocus = false;
            });

            if (
                Core.Config.Get('Action') !== 'AgentTicketPhone'
                && Core.Config.Get('Action') !== 'AgentTicketEmail'
                && Core.Config.Get('Action') !== 'AgentTicketCompose'
                && Core.Config.Get('Action') !== 'AgentTicketForward'
                && Core.Config.Get('Action') !== 'AgentTicketEmailOutbound'
                && Core.Config.Get('Action') !== 'AgentTicketEmailResend'
// RotherOSS / AppointmentToTicket
                && Core.Config.Get('Action') !== 'AgentAppointmentCalendarOverview'
// EO AppointmentToTicket
                )
            {
                $Element.blur(function () {
                    var FieldValue = $(this).val();
                    if (FieldValue !== BackupData.CustomerEmail && FieldValue !== BackupData.CustomerKey) {
                        $('#SelectedCustomerUser').val('');
                        $('#CustomerUserID').val('');
                        $('#CustomerUserOption').val('');
                        $('#ShowCustomerID').html('');

                        // Restore customer info table.
                        if (Core.Config.Get('Action') !== 'AgentTicketCustomer') {
                            $('#CustomerInfo .Content').html(BackupData.CustomerInfo);
                            $('#CustomerID').val('');
                        }

                        if (Core.Config.Get('Action') === 'AgentTicketProcess') {
                            // update services (trigger ServiceID change event)
                            Core.AJAX.FormUpdate($('#CustomerID').closest('form'), 'AJAXUpdate', 'ServiceID');
                        }
                    }
                });
            }
            else {
                // Initializes the customer field.
                TargetNS.InitCustomerField($Element);
            }
        }

        // On unload remove old selected data. If the page is reloaded (with F5) this data
        // stays in the field and invokes an ajax request otherwise. We need to use beforeunload
        // here instead of unload because the URL of the window does not change on reload which
        // doesn't trigger pagehide.
        $(window).on('beforeunload.CustomerSearch', function () {
            $('#SelectedCustomerUser').val('');
            return; // return nothing to suppress the confirmation message
        });

        CheckPhoneCustomerCountLimit();
    };

    function htmlDecode(Text){
        return Text.replace(/&amp;/g, '&');
    }

    /**
     * @name AddTicketCustomer
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @returns {Boolean} Returns false.
     * @param {String} Field
     * @param {String} CustomerValue - The readable customer identifier.
     * @param {String} CustomerKey - Customer key on system.
     * @param {String} SetAsTicketCustomer -  Set this customer as main ticket customer.
     * @description
     *      This function adds a new ticket customer
     */
    TargetNS.AddTicketCustomer = function (Field, CustomerValue, CustomerKey, SetAsTicketCustomer) {

        var $Clone = $('.CustomerTicketTemplate' + Field).clone(),
            CustomerTicketCounter = $('#CustomerTicketCounter' + Field).val(),
            TicketCustomerIDs = 0,
            IsDuplicated = false,
            IsFocused = ($(document.activeElement).attr('id') == Field),
            Suffix;

        if (typeof CustomerKey !== 'undefined') {
            CustomerKey = htmlDecode(CustomerKey);
        }

        if (CustomerValue === '') {
            return false;
        }

        var CurrentQuotation,
            MultiEntry = [''],
            SeenAt     = 0,
            n          = 0;

        // do a manual split that keeps track of quotation
        for ( var i = 0; i < CustomerValue.length; i++ ) {
            var Char = CustomerValue.charAt(i);

            if ( CurrentQuotation ) {
                MultiEntry[n] += Char;
                if ( Char === CurrentQuotation ) {
                    CurrentQuotation = undefined;
                }
            }
            else if ( Char === '"' || Char === "'" ) {
                MultiEntry[n]    += Char;
                CurrentQuotation  = Char;
            }
            else if ( SeenAt === 1 && ( Char === ',' || Char === ";" ) ) {
                n++;
                SeenAt        = 0;
                MultiEntry[n] = '';
            }
            else {
                if ( Char === '@' ) {
                    SeenAt = 1;
                }
                MultiEntry[n] += Char;
            }
        }

        if ( n > 0 ) {
            for ( var m = 0; m <= n; m++ ) {
                TargetNS.AddTicketCustomer( Field, MultiEntry[m].trim() );
            }

            return true;
        }

        // check for duplicated entries
        $('[class*=CustomerTicketText]').each(function() {
            if ($(this).val() === CustomerValue) {
                IsDuplicated = true;
            }
        });
        if (IsDuplicated) {
            TargetNS.ShowDuplicatedDialog(Field);
            return false;
        }

        // get number of how much customer ticket are present
        TicketCustomerIDs = $('.CustomerContainer input[type="radio"]').length;

        // increment customer counter
        CustomerTicketCounter++;

        // set sufix
        Suffix = '_' + CustomerTicketCounter;

        // remove unnecessary classes
        $Clone.removeClass('Hidden CustomerTicketTemplate' + Field);

        // copy values and change ids and names
        $Clone.find(':input, a').each(function(){
            var ID = $(this).attr('id');
            $(this).attr('id', ID + Suffix);
            $(this).val(CustomerValue);
            if (ID !== 'CustomerSelected') {
                $(this).attr('name', ID + Suffix);
            }

            // add event handler to radio button
            if($(this).hasClass('CustomerTicketRadio')) {

                if (TicketCustomerIDs === 0) {
                    $(this).prop('checked', true);
                }

                // set counter as value
                $(this).val(CustomerTicketCounter);

                // bind change function to radio button to select customer
                $(this).on('change', function () {
                    // remove row
                    if ($(this).prop('checked')){
                        TargetNS.ReloadCustomerInfo(CustomerKey);
                    }
                    return false;
                });
            }

            // set customer key if present
            if($(this).hasClass('CustomerKey')) {
                $(this).val(CustomerKey);
            }

            // add event handler to remove button
            if($(this).hasClass('RemoveButton')) {

                // bind click function to remove button
                $(this).on('click', function () {
                    // remove row
                    TargetNS.RemoveCustomerTicket($(this));

                    // clear CustomerHistory table if there are no selected customer users
                    if ($('#TicketCustomerContent' + Field + ' .CustomerTicketRadio').length === 0) {
                        $('#CustomerTickets').empty();
                    }
                    return false;
                });
                // set button value
                $(this).val(CustomerValue);
            }

            if($(this).hasClass('MoveCustomerButton')) {
                $(this).on('click', function () {
                    var MoveCustomerKey = $('.CustomerKey', $(this).parent()).val(),
                        MoveCustomerVal = $('.CustomerTicketText', $(this).parent()).val(),
                        TargetField     =
                            $(this).hasClass('ToMove')  ? 'ToCustomer'  :
                            $(this).hasClass('CcMove')  ? 'CcCustomer'  :
                            $(this).hasClass('BccMove') ? 'BccCustomer' : '';

                    // remove the current entry
                    $('.RemoveButton', $(this).parent()).click();

                    // add the customer to the target field
                    TargetNS.AddTicketCustomer(TargetField, MoveCustomerVal, MoveCustomerKey);
                });
            }
        });
        // show container
        $('#TicketCustomerContent' + Field).parent().removeClass('Hidden');
        // append to container
        $('#TicketCustomerContent' + Field).append($Clone);

        // set new value for CustomerTicketCounter
        $('#CustomerTicketCounter' + Field).val(CustomerTicketCounter);
        if ((CustomerKey !== '' && TicketCustomerIDs === 0 && (Field === 'ToCustomer' || Field === 'FromCustomer')) || SetAsTicketCustomer) {
            if (SetAsTicketCustomer) {
                $('#CustomerSelected_' + CustomerTicketCounter).prop('checked', true).trigger('change');
            }
            else {
                $('.CustomerContainer input[type="radio"]:first').prop('checked', true).trigger('change');
            }
        }

        // Return the value to the search field.
        $('#' + Field).val('');

        // Re-focus the field, but only if it was previously focused.
        if (IsFocused) {
            $('#' + Field).focus();
        }

        CheckPhoneCustomerCountLimit();

        // Reload Crypt options on specific screens.
        if (
            (
                Core.Config.Get('Action') === 'AgentTicketEmail'
                || Core.Config.Get('Action') === 'AgentTicketCompose'
                || Core.Config.Get('Action') === 'AgentTicketForward'
                || Core.Config.Get('Action') === 'AgentTicketEmailOutbound'
                || Core.Config.Get('Action') === 'AgentTicketEmailResend'
            )
            && $('#CryptKeyID').length
            )
        {
            Core.AJAX.FormUpdate($('#' + Field).closest('form'), 'AJAXUpdate');
        }

        // now that we know that at least one customer has been added,
        // we can remove eventual errors from the customer field
        $('#FromCustomer, #ToCustomer')
            .removeClass('Error ServerError')
            .closest('.Field')
            .prev('label')
            .removeClass('LabelError');
        Core.Form.ErrorTooltips.HideTooltip();

        ActivateSelectionCustomerID();

        return false;
    };

    /**
     * @name RemoveCustomerTicket
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {jQueryObject} Object - JQuery object used as base to delete it's parent.
     * @description
     *      This function removes a customer ticket entry.
     */
    TargetNS.RemoveCustomerTicket = function (Object) {
        var TicketCustomerIDs,
        $Field = Object.closest('.Field'),
        $Form;

        if (
            Core.Config.Get('Action') === 'AgentTicketEmail'
            || Core.Config.Get('Action') === 'AgentTicketCompose'
            || Core.Config.Get('Action') === 'AgentTicketForward'
            || Core.Config.Get('Action') === 'AgentTicketEmailOutbound'
            || Core.Config.Get('Action') === 'AgentTicketEmailResend'
            )
        {
            $Form = Object.closest('form');
        }
        Object.parent().remove();
        TicketCustomerIDs = $('.CustomerContainer input[type="radio"]').length;
        if (TicketCustomerIDs === 0) {
            TargetNS.ResetCustomerInfo();
        }

        // Reload Crypt options on specific screens.
        if (
            (
                Core.Config.Get('Action') === 'AgentTicketEmail'
                || Core.Config.Get('Action') === 'AgentTicketCompose'
                || Core.Config.Get('Action') === 'AgentTicketForward'
                || Core.Config.Get('Action') === 'AgentTicketEmailOutbound'
                || Core.Config.Get('Action') === 'AgentTicketEmailResend'
            )
            && $('#CryptKeyID').length
            )
        {
            Core.AJAX.FormUpdate($Form, 'AJAXUpdate');
        }

        if(!$('.CustomerContainer input[type="radio"]').is(':checked')){
            //set the first one as checked
            $('.CustomerContainer input[type="radio"]:first').prop('checked', true).trigger('change');
        }

        if ($Field.find('.CustomerTicketText:visible').length === 0) {
            $Field.addClass('Hidden');

            DeactivateSelectionCustomerID();
        }

        CheckPhoneCustomerCountLimit();
    };

    /**
     * @name ResetCustomerInfo
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @description
     *      This function clears all selected customer info.
     */
    TargetNS.ResetCustomerInfo = function () {
            $('#SelectedCustomerUser').val('');
            $('#CustomerUserID').val('');
            $('#CustomerID').val('');
            $('#CustomerUserOption').val('');
            $('#ShowCustomerID').html('');

            // reset customer info table
            $('#CustomerInfo .Content').html(Core.Language.Translate('none'));
    };

    /**
     * @name ReloadCustomerInfo
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} CustomerKey
     * @description
     *      This function reloads info for selected customer.
     */
    TargetNS.ReloadCustomerInfo = function (CustomerKey) {

        // get customer tickets
        GetCustomerTickets(CustomerKey);

        // get customer data for customer info table
        GetCustomerInfo(CustomerKey);

        // set hidden field SelectedCustomerUser
        $('#SelectedCustomerUser').val(CustomerKey);
    };

    /**
     * @name InitCustomerField
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} $Element - JQuery object.
     * @description
     *      This function initializes the customer fields.
     */
    TargetNS.InitCustomerField = function ($Element) {
        var ObjectId = $Element.attr('id');

        $('#' + ObjectId).on('change', function () {

            if (!$('#' + ObjectId).val() || $('#' + ObjectId).val() === '') {
                return false;
            }

            // if autocompletion is disabled and only avaible via the click
            // of a button next to the input field, we cannot handle this
            // change event the normal way.
            if (!Core.UI.Autocomplete.GetConfig('ActiveAutoComplete')) {
                // we wait some time after this event to check, if the search button
                // for this field was pressed. If so, no action is needed
                // If the change event was fired without clicking the search button,
                // probably the user clicked out of the field.
                // This should also add the customer (the enetered value) to the list

                if (typeof CustomerFieldChangeRunCount[ObjectId] === 'undefined') {
                    CustomerFieldChangeRunCount[ObjectId] = 1;
                }
                else {
                    CustomerFieldChangeRunCount[ObjectId]++;
                }

                if (Core.UI.Autocomplete.SearchButtonClicked[ObjectId]) {
                    delete CustomerFieldChangeRunCount[ObjectId];
                    delete Core.UI.Autocomplete.SearchButtonClicked[ObjectId];
                    return false;
                }
                else {
                    if (CustomerFieldChangeRunCount[ObjectId] === 1) {
                        window.setTimeout(function () {
                            $('#' + ObjectId).trigger('change');
                        }, 200);
                        return false;
                    }
                    delete CustomerFieldChangeRunCount[ObjectId];
                }
            }


            // If the autocomplete popup window is visible, delay this change event.
            // It might be caused by clicking with the mouse into the autocomplete list.
            // Wait until it is closed to be sure that we don't add a customer twice.

            if ($Element.autocomplete("widget").is(':visible')) {
                window.setTimeout(function(){
                    $('#' + ObjectId).trigger('change');
                }, 200);
                return false;
            }

            Core.Agent.CustomerSearch.AddTicketCustomer(ObjectId, $('#' + ObjectId).val());
            return false;
        });

        $('#' + ObjectId).on('keypress', function (e) {
            if (e.which === 13){
                Core.Agent.CustomerSearch.AddTicketCustomer(ObjectId, $('#' + ObjectId).val());
                return false;
            }
        });
    };

    /**
     * @name ShowDuplicatedDialog
     * @memberof Core.Agent.CustomerSearch
     * @function
     * @param {String} Field - ID object of the element should receive the focus on close event.
     * @description
     *      This function shows an alert dialog for duplicated entries.
     */
    TargetNS.ShowDuplicatedDialog = function(Field){
        Core.UI.Dialog.ShowAlert(
            Core.Language.Translate('Duplicated entry'),
            Core.Language.Translate('This address already exists on the address list.') + ' ' + Core.Language.Translate('It is going to be deleted from the field, please try again.'),
            function () {
                Core.UI.Dialog.CloseDialog($('.Alert'));
                $('#' + Field).val('');
                $('#' + Field).focus();
                return false;
            }
        );
    };

    return TargetNS;
}(Core.Agent.CustomerSearch || {}));
 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