AppointmentToTicket 10.1.7 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Tidied. Issue #1: Fixed variable initialization and scoping in js. - Add CustomerKey for TicketCreation. - Translations & OTOBO Updates Fix AJAXUpdate for Queues. Fixed service selection treeview. Updated to OTOBO 10.1.8. Add more fields, activate FormUpdates which also enables ACL content (not visibility) restrictions. Initial release. 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. Ez a csomag azt a funkciót adja hozzá, hogy automatikusan létre lehessen hozni egy beállítható paraméterekkel rendelkező jegyet egy szabadon választható időpontra egy naptáridőponttal kapcsolatban. 10.1.x # create the package name my $CodeModule = 'var::packagesetup::AppointmentToTicket'; $Kernel::OM->Get($CodeModule)->CodeUninstall(); d38f5072fcde4fd3d7c60ec140962ab2c1d70dfc 2026-10-28 10:53:41 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-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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
    $Self->{DynamicField} = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket', 'Article' ],
        FieldFilter => $Config->{DynamicField} || {},
    );

    # 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 ) = @_;

    my $Output;

    # 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 ( @{ $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="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="checked"';
        }
        elsif ( $Appointment{NotificationCustom} eq 'relative' ) {
            $Param{NotificationCustomRelativeInputRadio} = 'checked="checked"';
        }
        else {
            $Param{NotificationCustomRelativeInputRadio} = 'checked="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; charset=' . $LayoutObject->{Charset},
                    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; charset=' . $LayoutObject->{Charset},
        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-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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;

    # parent ID supplied
    my $ParentIDCol = my $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 parent appointment
    else {
        return if !$DBObject->Prepare(
            SQL => '
                SELECT id FROM calendar_appointment
                WHERE unique_id = ? AND parent_id IS NULL
            ',
            Bind  => [ \$Param{UniqueID} ],
            Limit => 1,
        );

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

        # 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
    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;

            $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 $Result = '';

    $Param{OriginalTime} =~ /(.*?)\s(.*?)$/;
    my $OriginalDate = $1;
    my $OriginalTime = $2;

    $Param{Time} =~ /(.*?)\s(.*?)$/;
    my $Date = $1;

    $Result = "$Date $OriginalTime";
    return $Result;
}

=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-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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;

use MIME::Base64;
use Time::HiRes;

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;
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPG90b2JvX2NvbmZpZyB2ZXJzaW9uPSIyLjAiIGluaXQ9IkFwcGxpY2F0aW9uIj4KICAgIDxTZXR0aW5nIE5hbWU9IlRpY2tldDo6RnJvbnRlbmQ6OkFnZW50QXBwb2ludG1lbnRFZGl0IyMjRHluYW1pY0ZpZWxkIiBSZXF1aXJlZD0iMCIgVmFsaWQ9IjEiPgogICAgICAgIDxEZXNjcmlwdGlvbiBUcmFuc2xhdGFibGU9IjEiPkR5bmFtaWMgZmllbGRzIHNob3duIGluIHRoZSBhcHBvaW50bWVudCBlZGl0IHNjcmVlbiBvZiB0aGUgYWdlbnQgaW50ZXJmYWNlLjwvRGVzY3JpcHRpb24+CiAgICAgICAgPE5hdmlnYXRpb24+RnJvbnRlbmQ6OkFnZW50OjpWaWV3OjpBZ2VudEFwcG9pbnRtZW50RWRpdDwvTmF2aWdhdGlvbj4KICAgICAgICA8VmFsdWU+CiAgICAgICAgICAgIDxIYXNoPgogICAgICAgICAgICAgICAgPERlZmF1bHRJdGVtIFZhbHVlVHlwZT0iU2VsZWN0Ij4KICAgICAgICAgICAgICAgICAgICA8SXRlbSBWYWx1ZVR5cGU9Ik9wdGlvbiIgVmFsdWU9IjAiIFRyYW5zbGF0YWJsZT0iMSI+MCAtIERpc2FibGVkPC9JdGVtPgogICAgICAgICAgICAgICAgICAgIDxJdGVtIFZhbHVlVHlwZT0iT3B0aW9uIiBWYWx1ZT0iMSIgVHJhbnNsYXRhYmxlPSIxIj4xIC0gRW5hYmxlZDwvSXRlbT4KICAgICAgICAgICAgICAgICAgICA8SXRlbSBWYWx1ZVR5cGU9Ik9wdGlvbiIgVmFsdWU9IjIiIFRyYW5zbGF0YWJsZT0iMSI+MiAtIEVuYWJsZWQgYW5kIHJlcXVpcmVkPC9JdGVtPgogICAgICAgICAgICAgICAgPC9EZWZhdWx0SXRlbT4KICAgICAgICAgICAgPC9IYXNoPgogICAgICAgIDwvVmFsdWU+CiAgICA8L1NldHRpbmc+CiAgICA8U2V0dGluZyBOYW1lPSJUaWNrZXQ6OkZyb250ZW5kOjpBZ2VudEFwcG9pbnRtZW50RWRpdCMjI1ByaW9yaXR5IiBSZXF1aXJlZD0iMSIgVmFsaWQ9IjEiPgogICAgICAgIDxEZXNjcmlwdGlvbiBUcmFuc2xhdGFibGU9IjEiPlNldHMgdGhlIGRlZmF1bHQgcHJpb3JpdHkgZm9yIG5ldyB0aWNrZXRzIGluIHRoZSBBZ2VudEFwcG9pbnRtZW50RWRpdCBpbnRlcmZhY2UuPC9EZXNjcmlwdGlvbj4KICAgICAgICA8TmF2aWdhdGlvbj5Gcm9udGVuZDo6QWdlbnQ6OlZpZXc6OkFnZW50QXBwb2ludG1lbnRFZGl0PC9OYXZpZ2F0aW9uPgogICAgICAgIDxWYWx1ZT4KICAgICAgICAgICAgPEl0ZW0gVmFsdWVUeXBlPSJFbnRpdHkiIFZhbHVlRW50aXR5VHlwZT0iUHJpb3JpdHkiIFZhbHVlUmVnZXg9IiI+MyBub3JtYWw8L0l0ZW0+CiAgICAgICAgPC9WYWx1ZT4KICAgIDwvU2V0dGluZz4KICAgIDxTZXR0aW5nIE5hbWU9IlRpY2tldDo6RnJvbnRlbmQ6OkFnZW50QXBwb2ludG1lbnRFZGl0IyMjU2VydmljZU1hbmRhdG9yeSIgVXNlclByZWZlcmVuY2VzR3JvdXA9IkFkdmFuY2VkIiBVc2VyTW9kaWZpY2F0aW9uUG9zc2libGU9IjEiIFJlcXVpcmVkPSIwIiBWYWxpZD0iMSI+CiAgICAgICAgPERlc2NyaXB0aW9uIFRyYW5zbGF0YWJsZT0iMSI+U2V0cyBpZiBzZXJ2aWNlIG11c3QgYmUgc2VsZWN0ZWQgYnkgdGhlIGFnZW50LjwvRGVzY3JpcHRpb24+CiAgICAgICAgPE5hdmlnYXRpb24+RnJvbnRlbmQ6OkFnZW50OjpWaWV3OjpBZ2VudEFwcG9pbnRtZW50RWRpdDwvTmF2aWdhdGlvbj4KICAgICAgICA8VmFsdWU+CiAgICAgICAgICAgIDxJdGVtIFZhbHVlVHlwZT0iQ2hlY2tib3giPjA8L0l0ZW0+CiAgICAgICAgPC9WYWx1ZT4KICAgIDwvU2V0dGluZz4KICAgIDxTZXR0aW5nIE5hbWU9IlRpY2tldDo6RnJvbnRlbmQ6OkFnZW50QXBwb2ludG1lbnRFZGl0IyMjU0xBTWFuZGF0b3J5IiBVc2VyUHJlZmVyZW5jZXNHcm91cD0iQWR2YW5jZWQiIFVzZXJNb2RpZmljYXRpb25Qb3NzaWJsZT0iMSIgUmVxdWlyZWQ9IjAiIFZhbGlkPSIxIj4KICAgICAgICA8RGVzY3JpcHRpb24gVHJhbnNsYXRhYmxlPSIxIj5TZXRzIGlmIFNMQSBtdXN0IGJlIHNlbGVjdGVkIGJ5IHRoZSBhZ2VudC48L0Rlc2NyaXB0aW9uPgogICAgICAgIDxOYXZpZ2F0aW9uPkZyb250ZW5kOjpBZ2VudDo6Vmlldzo6QWdlbnRBcHBvaW50bWVudEVkaXQ8L05hdmlnYXRpb24+CiAgICAgICAgPFZhbHVlPgogICAgICAgICAgICA8SXRlbSBWYWx1ZVR5cGU9IkNoZWNrYm94Ij4wPC9JdGVtPgogICAgICAgIDwvVmFsdWU+CiAgICA8L1NldHRpbmc+CiAgICA8U2V0dGluZyBOYW1lPSJUaWNrZXQ6OkZyb250ZW5kOjpBZ2VudEFwcG9pbnRtZW50RWRpdCMjI1N0YXRlRGVmYXVsdCIgUmVxdWlyZWQ9IjEiIFZhbGlkPSIxIj4KICAgICAgICA8RGVzY3JpcHRpb24gVHJhbnNsYXRhYmxlPSIxIj5TZXRzIHRoZSBkZWZhdWx0IG5leHQgc3RhdGUgZm9yIG5ldyB0aWNrZXRzIGluIHRoZSBBZ2VudEFwcG9pbnRtZW50RWRpdCBpbnRlcmZhY2UuPC9EZXNjcmlwdGlvbj4KICAgICAgICA8TmF2aWdhdGlvbj5Gcm9udGVuZDo6QWdlbnQ6OlZpZXc6OkFnZW50QXBwb2ludG1lbnRFZGl0PC9OYXZpZ2F0aW9uPgogICAgICAgIDxWYWx1ZT4KICAgICAgICAgICAgPEl0ZW0gVmFsdWVUeXBlPSJFbnRpdHkiIFZhbHVlRW50aXR5VHlwZT0iU3RhdGUiIFZhbHVlUmVnZXg9IiI+b3BlbjwvSXRlbT4KICAgICAgICA8L1ZhbHVlPgogICAgPC9TZXR0aW5nPgogICAgPFNldHRpbmcgTmFtZT0iVGlja2V0OjpGcm9udGVuZDo6QWdlbnRBcHBvaW50bWVudEVkaXQjIyNTdGF0ZVR5cGUiIFJlcXVpcmVkPSIxIiBWYWxpZD0iMSI+CiAgICAgICAgPERlc2NyaXB0aW9uIFRyYW5zbGF0YWJsZT0iMSI+RGV0ZXJtaW5lcyB0aGUgbmV4dCBwb3NzaWJsZSB0aWNrZXQgc3RhdGVzLCBhZnRlciB0aGUgY3JlYXRpb24gb2YgYSBuZXcgdGlja2V0IGZyb20gYSBjYWxlbmRhciBhcHBvaW50bWVudCBpbiB0aGUgYWdlbnQgaW50ZXJmYWNlLjwvRGVzY3JpcHRpb24+CiAgICAgICAgPE5hdmlnYXRpb24+RnJvbnRlbmQ6OkFnZW50OjpWaWV3OjpUaWNrZXRDYWxlbmRhcjwvTmF2aWdhdGlvbj4KICAgICAgICA8VmFsdWU+CiAgICAgICAgICAgIDxBcnJheT4KICAgICAgICAgICAgICAgIDxJdGVtIFRyYW5zbGF0YWJsZT0iMSI+b3BlbjwvSXRlbT4KICAgICAgICAgICAgICAgIDxJdGVtIFRyYW5zbGF0YWJsZT0iMSI+cGVuZGluZyBhdXRvPC9JdGVtPgogICAgICAgICAgICAgICAgPEl0ZW0gVHJhbnNsYXRhYmxlPSIxIj5wZW5kaW5nIHJlbWluZGVyPC9JdGVtPgogICAgICAgICAgICAgICAgPEl0ZW0gVHJhbnNsYXRhYmxlPSIxIj5jbG9zZWQ8L0l0ZW0+CiAgICAgICAgICAgIDwvQXJyYXk+CiAgICAgICAgPC9WYWx1ZT4KICAgIDwvU2V0dGluZz4KICAgIDxTZXR0aW5nIE5hbWU9IkxvYWRlcjo6TW9kdWxlOjpBZ2VudEFwcG9pbnRtZW50Q2FsZW5kYXJPdmVydmlldyMjIzAwOS1BcHBvaW50bWVudFRpY2tldCIgUmVxdWlyZWQ9IjAiIFZhbGlkPSIxIj4KICAgICAgICA8RGVzY3JpcHRpb24gVHJhbnNsYXRhYmxlPSIxIj5Mb2FkZXIgbW9kdWxlIHJlZ2lzdHJhdGlvbiBmb3IgdGhlIGFnZW50IGludGVyZmFjZS48L0Rlc2NyaXB0aW9uPgogICAgICAgIDxOYXZpZ2F0aW9uPkZyb250ZW5kOjpBZ2VudDo6TW9kdWxlUmVnaXN0cmF0aW9uOjpMb2FkZXI8L05hdmlnYXRpb24+CiAgICAgICAgPFZhbHVlPgogICAgICAgICAgICA8SGFzaD4KICAgICAgICAgICAgICAgIDxJdGVtIEtleT0iSmF2YVNjcmlwdCI+CiAgICAgICAgICAgICAgICAgICAgPEFycmF5PgogICAgICAgICAgICAgICAgICAgICAgICA8SXRlbT5Db3JlLkFKQVguanM8L0l0ZW0+CiAgICAgICAgICAgICAgICAgICAgICAgIDxJdGVtPkNvcmUuRGF0YS5qczwvSXRlbT4KICAgICAgICAgICAgICAgICAgICAgICAgPEl0ZW0+Q29yZS5BZ2VudC5DdXN0b21lclNlYXJjaEF1dG9Db21wbGV0ZS5qczwvSXRlbT4KICAgICAgICAgICAgICAgICAgICAgICAgPEl0ZW0+Q29yZS5BZ2VudC5DdXN0b21lclNlYXJjaC5qczwvSXRlbT4KICAgICAgICAgICAgICAgICAgICAgICAgPEl0ZW0+Q29yZS5BZ2VudC5UaWNrZXRBY3Rpb24uanM8L0l0ZW0+CiAgICAgICAgICAgICAgICAgICAgPC9BcnJheT4KICAgICAgICAgICAgICAgIDwvSXRlbT4KICAgICAgICAgICAgPC9IYXNoPgogICAgICAgIDwvVmFsdWU+CiAgICA8L1NldHRpbmc+CiAgICA8U2V0dGluZyBOYW1lPSJEeW5hbWljRmllbGRTY3JlZW5zIyMjQXBwb2ludG1lbnRUaWNrZXRzIiBSZXF1aXJlZD0iMCIgVmFsaWQ9IjEiPgogICAgICAgIDxEZXNjcmlwdGlvbiBUcmFuc2xhdGFibGU9IjEiPlRoaXMgY29uZmlndXJhdGlvbiBkZWZpbmVzIGFsbCBwb3NzaWJsZSBzY3JlZW5zIHRvIGVuYWJsZSBvciBkaXNhYmxlIGR5bmFtaWMgZmllbGRzLjwvRGVzY3JpcHRpb24+CiAgICAgICAgPE5hdmlnYXRpb24+RnJvbnRlbmQ6OkJhc2U6OkR5bmFtaWNGaWVsZFNjcmVlbnM8L05hdmlnYXRpb24+CiAgICAgICAgPFZhbHVlPgogICAgICAgICAgICA8SGFzaD4KICAgICAgICAgICAgICAgIDxJdGVtIEtleT0iVGlja2V0OjpGcm9udGVuZDo6QWdlbnRBcHBvaW50bWVudEVkaXQjIyNEeW5hbWljRmllbGQiPkFnZW50QXBwb2ludG1lbnRFZGl0PC9JdGVtPgogICAgICAgICAgICA8L0hhc2g+CiAgICAgICAgPC9WYWx1ZT4KICAgIDwvU2V0dGluZz4KPC9vdG9ib19jb25maWc+Cg== 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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-2024 Rother OSS GmbH, https://otobo.de/
# --
# 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-2024 Rother OSS GmbH, https://otobo.de/
# --
# 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;

use vars qw($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-2025 Rother OSS GmbH, https://otobo.io/
// --
// $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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 */

"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);
            }
        });

        var SessionIDCookie = Core.Config.Get('SessionIDCookie'),
            SessionID = SessionIDCookie ? '' : Core.Config.Get('SessionID'),
            SessionName = Core.Config.Get('SessionName'),
            CustomerPanelSessionName = Core.Config.Get('CustomerPanelSessionName');
        $.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')
            };
            if (!SessionIDCookie) {
                CalendarData[SessionName] = SessionID;
                CalendarData[CustomerPanelSessionName] = SessionID;
            }
            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-2025 Rother OSS GmbH, https://otobo.io/
// --
// $origin: otobo - c14ca55a8b1d3d686e803c1398813b83d22091e5 - 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', ['Dest', 'SelectedCustomerUser', 'Signature', 'NextStateID', 'PriorityID', 'ServiceID', 'SLAID', 'CryptKeyID', 'OwnerAll', 'ResponsibleAll', 'TicketFreeText1', 'TicketFreeText2', 'TicketFreeText3', 'TicketFreeText4', 'TicketFreeText5', 'TicketFreeText6', 'TicketFreeText7', 'TicketFreeText8', 'TicketFreeText9', 'TicketFreeText10', 'TicketFreeText11', 'TicketFreeText12', 'TicketFreeText13', 'TicketFreeText14', 'TicketFreeText15', 'TicketFreeText16']);

                // 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();
                    if (!Core.Config.Get('SessionIDCookie')) {
                        SignatureURL += ';' + Core.Config.Get('SessionName') + '=' + Core.Config.Get('SessionID');
                    }
                    $('#Signature').attr('src', SignatureURL);
                }
            }
            if (Core.Config.Get('Action') === 'AgentTicketProcess' &&
                typeof Core.Config.Get('CustomerFieldsToUpdate') !== 'undefined'){
                // reset service
                $('#ServiceID').attr('selectedIndex', 0);
                // update services (trigger ServiceID change event)
                Core.AJAX.FormUpdate($('#CustomerID').closest('form'), 'AJAXUpdate', 'ServiceID', Core.Config.Get('CustomerFieldsToUpdate'));
            }
        });
    }

    /**
     * @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' && typeof Core.Config.Get('CustomerFieldsToUpdate') !== 'undefined') {
                            // update services (trigger ServiceID change event)
                            Core.AJAX.FormUpdate($('#CustomerID').closest('form'), 'AJAXUpdate', 'ServiceID', Core.Config.Get('CustomerFieldsToUpdate'));
                        }
                    }
                });
            }
            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', '', ['CryptKeyID']);
        }

        // 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 = 0,
        $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', '', ['CryptKeyID']);
        }

        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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