← Back to branch summary

~ubuntu-branches/ubuntu/natty/otrs2/natty-updates

« back to all changes in this revision

Viewing changes to Kernel/Modules/AgentTicketOwner.pm

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2007-04-14 17:58:55 UTC
  • mto: (20.1.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: package-import@ubuntu.com-20070414175855-9ne0w01yu1q44ch0
Tags: upstream-2.1.7
Import upstream version 2.1.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
Kernel/Modules/AgentTicketOwner.pm
1
1
# --
2
 
# Kernel/Modules/AgentTicketOwner.pm - to set the ticket owner
3
 
# Copyright (C) 2001-2005 Martin Edenhofer <martin+code@otrs.org>
 
2
# Kernel/Modules/AgentTicketOwner.pm - set ticket owner
 
3
# Copyright (C) 2001-2007 OTRS GmbH, http://otrs.org/
4
4
# --
5
 
# $Id: AgentTicketOwner.pm,v 1.4 2005/09/04 13:17:47 martin Exp $
 
5
# $Id: AgentTicketOwner.pm,v 1.17.2.1 2007/02/26 11:12:28 martin Exp $
6
6
# --
7
7
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
8
8
# the enclosed file COPYING for license information (GPL). If you
12
12
package Kernel::Modules::AgentTicketOwner;
13
13
 
14
14
use strict;
 
15
use Kernel::System::State;
 
16
use Kernel::System::Web::UploadCache;
15
17
 
16
18
use vars qw($VERSION);
17
 
$VERSION = '$Revision: 1.4 $';
 
19
$VERSION = '$Revision: 1.17.2.1 $';
18
20
$VERSION =~ s/^\$.*:\W(.*)\W.+?$/$1/;
19
21
 
20
 
# --
21
22
sub new {
22
23
    my $Type = shift;
23
24
    my %Param = @_;
31
32
    }
32
33
 
33
34
    # check needed Opjects
34
 
    foreach (qw(ParamObject DBObject TicketObject LayoutObject LogObject ConfigObject)) {
 
35
    foreach (qw(ParamObject DBObject TicketObject LayoutObject LogObject QueueObject ConfigObject)) {
35
36
        if (!$Self->{$_}) {
36
37
            $Self->{LayoutObject}->FatalError(Message => "Got no $_!");
37
38
        }
38
39
    }
39
 
 
40
 
    # get params
41
 
    $Self->{NewUserID} = $Self->{ParamObject}->GetParam(Param => 'NewUserID') || '';
42
 
    $Self->{OldUserID} = $Self->{ParamObject}->GetParam(Param => 'OldUserID') || '';
43
 
    $Self->{UserSelection} = $Self->{ParamObject}->GetParam(Param => 'UserSelection') || '';
 
40
    $Self->{StateObject} = Kernel::System::State->new(%Param);
 
41
    $Self->{UploadCachObject} = Kernel::System::Web::UploadCache->new(%Param);
 
42
 
 
43
    # get form id
 
44
    $Self->{FormID} = $Self->{ParamObject}->GetParam(Param => 'FormID');
 
45
    my @InformUserID = $Self->{ParamObject}->GetArray(Param => 'InformUserID');
 
46
    $Self->{InformUserID} = \@InformUserID;
 
47
    my @InvolvedUserID = $Self->{ParamObject}->GetArray(Param => 'InvolvedUserID');
 
48
    $Self->{InvolvedUserID} = \@InvolvedUserID;
 
49
    # create form id
 
50
    if (!$Self->{FormID}) {
 
51
        $Self->{FormID} = $Self->{UploadCachObject}->FormIDCreate();
 
52
    }
 
53
 
 
54
    $Self->{Config} = $Self->{ConfigObject}->Get("Ticket::Frontend::$Self->{Action}");
44
55
 
45
56
    return $Self;
46
57
}
47
 
# --
 
58
 
48
59
sub Run {
49
60
    my $Self = shift;
50
61
    my %Param = @_;
51
62
    my $Output;
 
63
    # check needed stuff
 
64
    if (!$Self->{TicketID}) {
 
65
        # error page
 
66
        return $Self->{LayoutObject}->ErrorScreen(
 
67
            Message => "Need TicketID is given!",
 
68
            Comment => 'Please contact the admin.',
 
69
        );
 
70
    }
52
71
    # check permissions
53
72
    if (!$Self->{TicketObject}->Permission(
54
 
        Type => 'owner',
 
73
        Type => $Self->{Config}->{Permission},
55
74
        TicketID => $Self->{TicketID},
56
75
        UserID => $Self->{UserID})) {
57
76
        # error screen, don't show ticket
58
 
        return $Self->{LayoutObject}->NoPermission(WithHeader => 'yes');
 
77
        return $Self->{LayoutObject}->NoPermission(
 
78
            Message => "You need $Self->{Config}->{Permission} permissions!",
 
79
            WithHeader => 'yes',
 
80
        );
59
81
    }
 
82
    my %Ticket = $Self->{TicketObject}->TicketGet(TicketID => $Self->{TicketID});
 
83
    $Self->{LayoutObject}->Block(
 
84
        Name => 'Properties',
 
85
        Data => {
 
86
            FormID => $Self->{FormID},
 
87
            %Ticket,
 
88
            %Param,
 
89
        },
 
90
    );
60
91
 
 
92
    # get lock state
 
93
    if ($Self->{Config}->{RequiredLock}) {
 
94
        if (!$Self->{TicketObject}->LockIsTicketLocked(TicketID => $Self->{TicketID})) {
 
95
            $Self->{TicketObject}->LockSet(
 
96
                TicketID => $Self->{TicketID},
 
97
                Lock => 'lock',
 
98
                UserID => $Self->{UserID}
 
99
            );
 
100
            if ($Self->{TicketObject}->OwnerSet(
 
101
                TicketID => $Self->{TicketID},
 
102
                UserID => $Self->{UserID},
 
103
                NewUserID => $Self->{UserID},
 
104
            )) {
 
105
                # show lock state
 
106
                $Self->{LayoutObject}->Block(
 
107
                    Name => 'PropertiesLock',
 
108
                    Data => {
 
109
                        %Param,
 
110
                        TicketID => $Self->{TicketID},
 
111
                    },
 
112
                );
 
113
            }
 
114
        }
 
115
        else {
 
116
            my $AccessOk = $Self->{TicketObject}->OwnerCheck(
 
117
                TicketID => $Self->{TicketID},
 
118
                OwnerID => $Self->{UserID},
 
119
            );
 
120
            if (!$AccessOk) {
 
121
                my $Output = $Self->{LayoutObject}->Header(Value => $Ticket{Number});
 
122
                $Output .= $Self->{LayoutObject}->Warning(
 
123
                    Message => "Sorry, you need to be the owner to do this action!",
 
124
                    Comment => 'Please change the owner first.',
 
125
                );
 
126
                $Output .= $Self->{LayoutObject}->Footer();
 
127
                return $Output;
 
128
            }
 
129
            else {
 
130
                $Self->{LayoutObject}->Block(
 
131
                    Name => 'TicketBack',
 
132
                    Data => {
 
133
                        %Param,
 
134
                        TicketID => $Self->{TicketID},
 
135
                    },
 
136
                );
 
137
            }
 
138
        }
 
139
    }
 
140
    else {
 
141
        $Self->{LayoutObject}->Block(
 
142
            Name => 'TicketBack',
 
143
            Data => {
 
144
                %Param,
 
145
                %Ticket,
 
146
            },
 
147
        );
 
148
    }
61
149
 
62
150
    # get params
63
151
    my %GetParam = ();
64
 
    foreach (qw(NewStateID Comment Year Month Day Hour Minute)) {
65
 
            $GetParam{$_} = $Self->{ParamObject}->GetParam(Param => $_);
 
152
    foreach (qw(
 
153
        NewStateID NewPriorityID TimeUnits ArticleTypeID Title Body Subject
 
154
        Year Month Day Hour Minute NewOwnerID NewOwnerType OldOwnerID NewResponsibleID
 
155
        AttachmentUpload
 
156
        AttachmentDelete1 AttachmentDelete2 AttachmentDelete3 AttachmentDelete4
 
157
        AttachmentDelete5 AttachmentDelete6 AttachmentDelete7 AttachmentDelete8
 
158
        AttachmentDelete9 AttachmentDelete10 AttachmentDelete11 AttachmentDelete12
 
159
        AttachmentDelete13 AttachmentDelete14 AttachmentDelete15 AttachmentDelete16
 
160
    )) {
 
161
        $GetParam{$_} = $Self->{ParamObject}->GetParam(Param => $_);
 
162
    }
 
163
    # get ticket free text params
 
164
    foreach (1..16) {
 
165
        $GetParam{"TicketFreeKey$_"} =  $Self->{ParamObject}->GetParam(Param => "TicketFreeKey$_");
 
166
        $GetParam{"TicketFreeText$_"} =  $Self->{ParamObject}->GetParam(Param => "TicketFreeText$_");
 
167
    }
 
168
    # get ticket free text params
 
169
    foreach (1..2) {
 
170
        foreach my $Type (qw(Year Month Day Hour Minute)) {
 
171
            $GetParam{"TicketFreeTime".$_.$Type} =  $Self->{ParamObject}->GetParam(Param => "TicketFreeTime".$_.$Type);
 
172
        }
 
173
    }
 
174
    # get article free text params
 
175
    foreach (1..3) {
 
176
        $GetParam{"ArticleFreeKey$_"} =  $Self->{ParamObject}->GetParam(Param => "ArticleFreeKey$_");
 
177
        $GetParam{"ArticleFreeText$_"} =  $Self->{ParamObject}->GetParam(Param => "ArticleFreeText$_");
 
178
    }
 
179
    # rewrap body if exists
 
180
    if ($GetParam{Body}) {
 
181
        my $Size = $Self->{ConfigObject}->Get('Ticket::Frontend::TextAreaNote') || 70;
 
182
        $GetParam{Body} =~ s/(^>.+|.{4,$Size})(?:\s|\z)/$1\n/gm;
66
183
    }
67
184
 
68
 
    if ($Self->{Subaction} eq 'Update') {
69
 
        # check new/old user selection
70
 
        if ($Self->{UserSelection} eq 'Old') {
71
 
            if (!$Self->{OldUserID}) {
72
 
                $Output = $Self->{LayoutObject}->Header();
73
 
                $Output .= $Self->{LayoutObject}->Warning(
74
 
                    Message => "Sorry, you need to select a previous owner!",
75
 
                    Comment => 'Please go back and select one.',
76
 
                );
77
 
                $Output .= $Self->{LayoutObject}->Footer();
78
 
                return $Output;
79
 
            }
80
 
            else {
81
 
                $Self->{NewUserID} = $Self->{OldUserID};
82
 
            }
83
 
        }
84
 
        else {
85
 
            if (!$Self->{NewUserID}) {
86
 
                $Output = $Self->{LayoutObject}->Header();
87
 
                $Output .= $Self->{LayoutObject}->Warning(
88
 
                    Message => "Sorry, you need to select a new owner!",
89
 
                    Comment => 'Please go back and select one.',
90
 
                );
91
 
                $Output .= $Self->{LayoutObject}->Footer();
92
 
                return $Output;
93
 
            }
94
 
        }
95
 
        # lock ticket && set user id && send notify to new agent
96
 
        if ($Self->{TicketObject}->LockSet(
97
 
          TicketID => $Self->{TicketID},
98
 
          Lock => 'lock',
99
 
          UserID => $Self->{UserID},
100
 
        ) &&
101
 
          $Self->{TicketObject}->OwnerSet(
102
 
            TicketID => $Self->{TicketID},
103
 
            UserID => $Self->{UserID},
104
 
            NewUserID => $Self->{NewUserID},
105
 
            Comment => $GetParam{Comment},
106
 
                )) {
107
 
            # add note
108
 
            if ($GetParam{Comment}) {
109
 
              my $ArticleID = $Self->{TicketObject}->ArticleCreate(
 
185
    if ($Self->{Subaction} eq 'Store') {
 
186
        # store action
 
187
        my %Error = ();
 
188
        # check pending time
 
189
        if ($GetParam{NewStateID}) {
 
190
            my %StateData = $Self->{TicketObject}->{StateObject}->StateGet(
 
191
                ID => $GetParam{NewStateID},
 
192
            );
 
193
            # check state type
 
194
            if ($StateData{TypeName} =~ /^pending/i) {
 
195
                # check needed stuff
 
196
                foreach (qw(Year Month Day Hour Minute)) {
 
197
                    if (!defined($GetParam{$_})) {
 
198
                        $Error{"Date invalid"} = '* invalid';
 
199
                    }
 
200
                }
 
201
                # check date
 
202
                if (!$Self->{TimeObject}->Date2SystemTime(%GetParam, Second => 0)) {
 
203
                    $Error{"Date invalid"} = '* invalid';
 
204
                }
 
205
                if ($Self->{TimeObject}->Date2SystemTime(%GetParam, Second => 0) < $Self->{TimeObject}->SystemTime()) {
 
206
                    $Error{"Date invalid"} = '* invalid';
 
207
                }
 
208
            }
 
209
        }
 
210
        if ($Self->{Config}->{Note}) {
 
211
            # check subject
 
212
            if (!$GetParam{Subject}) {
 
213
                $Error{"Subject invalid"} = '* invalid';
 
214
            }
 
215
            # check body
 
216
            if (!$GetParam{Body}) {
 
217
                $Error{"Body invalid"} = '* invalid';
 
218
            }
 
219
        }
 
220
        # attachment delete
 
221
        foreach (1..16) {
 
222
            if ($GetParam{"AttachmentDelete$_"}) {
 
223
                $Error{AttachmentDelete} = 1;
 
224
                $Self->{UploadCachObject}->FormIDRemoveFile(
 
225
                    FormID => $Self->{FormID},
 
226
                    FileID => $_,
 
227
                );
 
228
            }
 
229
        }
 
230
        # attachment upload
 
231
        if ($GetParam{AttachmentUpload}) {
 
232
            $Error{AttachmentUpload} = 1;
 
233
            my %UploadStuff = $Self->{ParamObject}->GetUploadAll(
 
234
                Param => "file_upload",
 
235
                Source => 'string',
 
236
            );
 
237
            $Self->{UploadCachObject}->FormIDAddFile(
 
238
                FormID => $Self->{FormID},
 
239
                %UploadStuff,
 
240
            );
 
241
        }
 
242
        # get all attachments meta data
 
243
        my @Attachments = $Self->{UploadCachObject}->FormIDGetAllFilesMeta(
 
244
            FormID => $Self->{FormID},
 
245
        );
 
246
        # check errors
 
247
        if (%Error) {
 
248
            # ticket free text
 
249
            my %TicketFreeText = ();
 
250
            foreach (1..16) {
 
251
                $TicketFreeText{"TicketFreeKey$_"} = $Self->{TicketObject}->TicketFreeTextGet(
 
252
                    TicketID => $Self->{TicketID},
 
253
                    Type => "TicketFreeKey$_",
 
254
                    Action => $Self->{Action},
 
255
                    UserID => $Self->{UserID},
 
256
                );
 
257
                $TicketFreeText{"TicketFreeText$_"} = $Self->{TicketObject}->TicketFreeTextGet(
 
258
                    TicketID => $Self->{TicketID},
 
259
                    Type => "TicketFreeText$_",
 
260
                    Action => $Self->{Action},
 
261
                    UserID => $Self->{UserID},
 
262
                );
 
263
            }
 
264
            my %TicketFreeTextHTML = $Self->{LayoutObject}->AgentFreeText(
 
265
                Config => \%TicketFreeText,
 
266
                Ticket => \%GetParam,
 
267
            );
 
268
            # ticket free time
 
269
            my %TicketFreeTimeHTML = $Self->{LayoutObject}->AgentFreeDate(
 
270
                %Param,
 
271
                Ticket => \%GetParam,
 
272
            );
 
273
            # article free text
 
274
            my %ArticleFreeText = ();
 
275
            foreach (1..3) {
 
276
                $ArticleFreeText{"ArticleFreeKey$_"} = $Self->{TicketObject}->ArticleFreeTextGet(
 
277
                    TicketID => $Self->{TicketID},
 
278
                    Type => "ArticleFreeKey$_",
 
279
                    Action => $Self->{Action},
 
280
                    UserID => $Self->{UserID},
 
281
                );
 
282
                $ArticleFreeText{"ArticleFreeText$_"} = $Self->{TicketObject}->ArticleFreeTextGet(
 
283
                    TicketID => $Self->{TicketID},
 
284
                    Type => "ArticleFreeText$_",
 
285
                    Action => $Self->{Action},
 
286
                    UserID => $Self->{UserID},
 
287
                );
 
288
            }
 
289
            my %ArticleFreeTextHTML = $Self->{LayoutObject}->TicketArticleFreeText(
 
290
                Config => \%ArticleFreeText,
 
291
                Article => \%GetParam,
 
292
            );
 
293
            my $Output = $Self->{LayoutObject}->Header(Value => $Ticket{TicketNumber});
 
294
            $Output .= $Self->{LayoutObject}->NavigationBar();
 
295
            $Output .= $Self->_Mask(
 
296
                Attachments => \@Attachments,
 
297
                %Ticket,
 
298
                %TicketFreeTextHTML,
 
299
                %TicketFreeTimeHTML,
 
300
                %ArticleFreeTextHTML,
 
301
                %GetParam,
 
302
                %Error,
 
303
            );
 
304
            $Output .= $Self->{LayoutObject}->Footer();
 
305
            return $Output;
 
306
        }
 
307
        if ($Self->{Config}->{Title}) {
 
308
            if (defined($GetParam{Title})) {
 
309
                $Self->{TicketObject}->TicketTitleUpdate(
 
310
                    Title => $GetParam{Title},
 
311
                    TicketID => $Self->{TicketID},
 
312
                    UserID => $Self->{UserID},
 
313
                );
 
314
            }
 
315
        }
 
316
        if ($Self->{Config}->{Owner}) {
 
317
            if ($GetParam{NewOwnerType} eq 'Old' && $GetParam{OldOwnerID}) {
 
318
                $Self->{TicketObject}->LockSet(
 
319
                    TicketID => $Self->{TicketID},
 
320
                    Lock => 'lock',
 
321
                    UserID => $Self->{UserID},
 
322
                );
 
323
                $Self->{TicketObject}->OwnerSet(
 
324
                    TicketID => $Self->{TicketID},
 
325
                    UserID => $Self->{UserID},
 
326
                    NewUserID => $GetParam{OldOwnerID},
 
327
                    Comment => $GetParam{Body},
 
328
                );
 
329
                $GetParam{NoAgentNotify} = 1;
 
330
            }
 
331
            elsif ($GetParam{NewOwnerID}) {
 
332
                $Self->{TicketObject}->LockSet(
 
333
                    TicketID => $Self->{TicketID},
 
334
                    Lock => 'lock',
 
335
                    UserID => $Self->{UserID},
 
336
                );
 
337
                $Self->{TicketObject}->OwnerSet(
 
338
                    TicketID => $Self->{TicketID},
 
339
                    UserID => $Self->{UserID},
 
340
                    NewUserID => $GetParam{NewOwnerID},
 
341
                    Comment => $GetParam{Body},
 
342
                );
 
343
                $GetParam{NoAgentNotify} = 1;
 
344
            }
 
345
        }
 
346
        if ($Self->{Config}->{Responsible}) {
 
347
            if ($GetParam{NewResponsibleID}) {
 
348
                $Self->{TicketObject}->ResponsibleSet(
 
349
                    TicketID => $Self->{TicketID},
 
350
                    UserID => $Self->{UserID},
 
351
                    NewUserID => $GetParam{NewResponsibleID},
 
352
                    Comment => $GetParam{Body},
 
353
                );
 
354
                $GetParam{NoAgentNotify} = 1;
 
355
            }
 
356
        }
 
357
        # add note
 
358
        my $ArticleID = '';
 
359
        if ($Self->{Config}->{Note}) {
 
360
            $ArticleID = $Self->{TicketObject}->ArticleCreate(
110
361
                TicketID => $Self->{TicketID},
111
 
                ArticleType => 'note-internal',
112
362
                SenderType => 'agent',
113
363
                From => "$Self->{UserFirstname} $Self->{UserLastname} <$Self->{UserEmail}>",
114
 
                Subject => $Self->{LayoutObject}->Output(Template => $Self->{ConfigObject}->Get('Ticket::Frontend::OwnerSubject') || '$Text{"Owner Update"}'),
115
 
                Body => $GetParam{Comment},
116
364
                ContentType => "text/plain; charset=$Self->{LayoutObject}->{'UserCharset'}",
117
365
                UserID => $Self->{UserID},
118
 
                HistoryType => 'AddNote',
119
 
                HistoryComment => '%%Owner',
120
 
                NoAgentNotify => 1, # because of owner updated notify
121
 
              );
122
 
            }
123
 
            if ($Self->{ConfigObject}->Get('Ticket::Frontend::OwnerSetState') && $GetParam{NewStateID}) {
124
 
                $Self->{TicketObject}->StateSet(
125
 
                    TicketID => $Self->{TicketID},
126
 
                    StateID => $GetParam{NewStateID},
127
 
                    UserID => $Self->{UserID},
128
 
                );
129
 
                # unlock the ticket after close
130
 
                my %StateData = $Self->{TicketObject}->{StateObject}->StateGet(
131
 
                    ID => $GetParam{NewStateID},
132
 
                );
133
 
                # set unlock on close
134
 
                if ($StateData{TypeName} =~ /^close/i) {
135
 
                    $Self->{TicketObject}->LockSet(
136
 
                        TicketID => $Self->{TicketID},
137
 
                        Lock => 'unlock',
138
 
                        UserID => $Self->{UserID},
139
 
                    );
140
 
                }
141
 
                # set pending time
142
 
                elsif ($StateData{TypeName} =~ /^pending/i) {
143
 
                    $Self->{TicketObject}->TicketPendingTimeSet(
144
 
                        UserID => $Self->{UserID},
145
 
                        TicketID => $Self->{TicketID},
146
 
                        %GetParam,
147
 
                    );
148
 
                }
149
 
            }
150
 
          # redirect
151
 
          return $Self->{LayoutObject}->Redirect(OP => $Self->{LastScreenView});
152
 
        }
153
 
        else {
154
 
          return $Self->{LayoutObject}->ErrorScreen();
155
 
        }
 
366
                HistoryType => $Self->{Config}->{HistoryType},
 
367
                HistoryComment => $Self->{Config}->{HistoryComment},
 
368
                ForceNotificationToUserID => [@{$Self->{InformUserID}}, @{$Self->{InvolvedUserID}}, ],
 
369
                %GetParam,
 
370
                NoAgentNotify => 0,
 
371
            );
 
372
            if (!$ArticleID) {
 
373
                return $Self->{LayoutObject}->ErrorScreen();
 
374
            }
 
375
            # time accounting
 
376
            if ($GetParam{TimeUnits}) {
 
377
                $Self->{TicketObject}->TicketAccountTime(
 
378
                    TicketID => $Self->{TicketID},
 
379
                    ArticleID => $ArticleID,
 
380
                    TimeUnit => $GetParam{TimeUnits},
 
381
                    UserID => $Self->{UserID},
 
382
                );
 
383
            }
 
384
            # get pre loaded attachment
 
385
            my @AttachmentData = $Self->{UploadCachObject}->FormIDGetAllFilesData(
 
386
                FormID => $Self->{FormID},
 
387
            );
 
388
            foreach my $Ref (@AttachmentData) {
 
389
                $Self->{TicketObject}->ArticleWriteAttachment(
 
390
                    %{$Ref},
 
391
                    ArticleID => $ArticleID,
 
392
                    UserID => $Self->{UserID},
 
393
                );
 
394
            }
 
395
            # get submit attachment
 
396
            my %UploadStuff = $Self->{ParamObject}->GetUploadAll(
 
397
                Param => 'file_upload',
 
398
                Source => 'String',
 
399
            );
 
400
            if (%UploadStuff) {
 
401
                $Self->{TicketObject}->ArticleWriteAttachment(
 
402
                    %UploadStuff,
 
403
                    ArticleID => $ArticleID,
 
404
                    UserID => $Self->{UserID},
 
405
                );
 
406
            }
 
407
            # remove pre submited attachments
 
408
            $Self->{UploadCachObject}->FormIDRemove(FormID => $Self->{FormID});
 
409
        }
 
410
        # set ticket free text
 
411
        foreach (1..16) {
 
412
            if (defined($GetParam{"TicketFreeKey$_"})) {
 
413
                $Self->{TicketObject}->TicketFreeTextSet(
 
414
                    TicketID => $Self->{TicketID},
 
415
                    Key => $GetParam{"TicketFreeKey$_"},
 
416
                    Value => $GetParam{"TicketFreeText$_"},
 
417
                    Counter => $_,
 
418
                    UserID => $Self->{UserID},
 
419
                );
 
420
            }
 
421
        }
 
422
        # set ticket free time
 
423
        foreach (1..2) {
 
424
            if (defined($GetParam{"TicketFreeTime".$_."Year"}) &&
 
425
                defined($GetParam{"TicketFreeTime".$_."Month"}) &&
 
426
                defined($GetParam{"TicketFreeTime".$_."Day"}) &&
 
427
                defined($GetParam{"TicketFreeTime".$_."Hour"}) &&
 
428
                defined($GetParam{"TicketFreeTime".$_."Minute"})) {
 
429
                my %Time = $Self->{LayoutObject}->TransfromDateSelection(
 
430
                    %GetParam,
 
431
                    Prefix => "TicketFreeTime".$_,
 
432
                );
 
433
                $Self->{TicketObject}->TicketFreeTimeSet(
 
434
                    %Time,
 
435
                    Prefix => "TicketFreeTime",
 
436
                    TicketID => $Self->{TicketID},
 
437
                    Counter => $_,
 
438
                    UserID => $Self->{UserID},
 
439
                );
 
440
            }
 
441
        }
 
442
        # set article free text
 
443
        foreach (1..3) {
 
444
            if (defined($GetParam{"ArticleFreeKey$_"})) {
 
445
                $Self->{TicketObject}->ArticleFreeTextSet(
 
446
                    TicketID => $Self->{TicketID},
 
447
                    ArticleID => $ArticleID,
 
448
                    Key => $GetParam{"ArticleFreeKey$_"},
 
449
                    Value => $GetParam{"ArticleFreeText$_"},
 
450
                    Counter => $_,
 
451
                    UserID => $Self->{UserID},
 
452
                );
 
453
            }
 
454
        }
 
455
        # set priority
 
456
        if ($Self->{Config}->{Priority} && $GetParam{NewPriorityID}) {
 
457
            $Self->{TicketObject}->PrioritySet(
 
458
                TicketID => $Self->{TicketID},
 
459
                PriorityID => $GetParam{NewPriorityID},
 
460
                UserID => $Self->{UserID},
 
461
            );
 
462
        }
 
463
        # set state
 
464
        if ($Self->{Config}->{State} && $GetParam{NewStateID}) {
 
465
            $Self->{TicketObject}->StateSet(
 
466
                TicketID => $Self->{TicketID},
 
467
                StateID => $GetParam{NewStateID},
 
468
                UserID => $Self->{UserID},
 
469
            );
 
470
            # unlock the ticket after close
 
471
            my %StateData = $Self->{TicketObject}->{StateObject}->StateGet(
 
472
                ID => $GetParam{NewStateID},
 
473
            );
 
474
            # set unlock on close
 
475
            if ($StateData{TypeName} =~ /^close/i) {
 
476
                $Self->{TicketObject}->LockSet(
 
477
                    TicketID => $Self->{TicketID},
 
478
                    Lock => 'unlock',
 
479
                    UserID => $Self->{UserID},
 
480
                );
 
481
            }
 
482
            # set pending time
 
483
            elsif ($StateData{TypeName} =~ /^pending/i) {
 
484
                $Self->{TicketObject}->TicketPendingTimeSet(
 
485
                    UserID => $Self->{UserID},
 
486
                    TicketID => $Self->{TicketID},
 
487
                    %GetParam,
 
488
                );
 
489
            }
 
490
            return $Self->{LayoutObject}->Redirect(OP => $Self->{LastScreenOverview});
 
491
        }
 
492
        # redirect
 
493
        return $Self->{LayoutObject}->Redirect(OP => $Self->{LastScreenView});
156
494
    }
157
495
    else {
158
 
        # print form
159
 
        my %Ticket = $Self->{TicketObject}->TicketGet(TicketID => $Self->{TicketID});
160
 
        my $OwnerID = $Self->{TicketObject}->OwnerCheck(TicketID => $Self->{TicketID});
161
 
        $Output .= $Self->{LayoutObject}->Header(Value => $Ticket{TicketNumber});
 
496
        # fillup vars
 
497
        if (!defined($GetParam{Body}) && $Self->{Config}->{Body}) {
 
498
            $GetParam{Body} = $Self->{LayoutObject}->Output(Template => $Self->{Config}->{Body});
 
499
        }
 
500
        if (!defined($GetParam{Subject}) && $Self->{Config}->{Subject}) {
 
501
            $GetParam{Subject} = $Self->{LayoutObject}->Output(Template => $Self->{Config}->{Subject});
 
502
        }
 
503
        # get free text config options
 
504
        my %TicketFreeText = ();
 
505
        foreach (1..16) {
 
506
            $TicketFreeText{"TicketFreeKey$_"} = $Self->{TicketObject}->TicketFreeTextGet(
 
507
                TicketID => $Self->{TicketID},
 
508
                Type => "TicketFreeKey$_",
 
509
                Action => $Self->{Action},
 
510
                UserID => $Self->{UserID},
 
511
            );
 
512
            $TicketFreeText{"TicketFreeText$_"} = $Self->{TicketObject}->TicketFreeTextGet(
 
513
                TicketID => $Self->{TicketID},
 
514
                Type => "TicketFreeText$_",
 
515
                Action => $Self->{Action},
 
516
                UserID => $Self->{UserID},
 
517
            );
 
518
        }
 
519
        my %TicketFreeTextHTML = $Self->{LayoutObject}->AgentFreeText(
 
520
            Ticket => \%Ticket,
 
521
            Config => \%TicketFreeText,
 
522
        );
 
523
        # get free text params
 
524
        my %TicketFreeTime = ();
 
525
        foreach (1..2) {
 
526
            if ($Ticket{"TicketFreeTime".$_}) {
 
527
                ($TicketFreeTime{"TicketFreeTime".$_.'Secunde'}, $TicketFreeTime{"TicketFreeTime".$_.'Minute'}, $TicketFreeTime{"TicketFreeTime".$_.'Hour'}, $TicketFreeTime{"TicketFreeTime".$_.'Day'}, $TicketFreeTime{"TicketFreeTime".$_.'Month'},  $TicketFreeTime{"TicketFreeTime".$_.'Year'}) = $Self->{TimeObject}->SystemTime2Date(
 
528
                    SystemTime => $Self->{TimeObject}->TimeStamp2SystemTime(
 
529
                        String => $Ticket{"TicketFreeTime".$_},
 
530
                    ),
 
531
                );
 
532
            }
 
533
        }
 
534
        # free time
 
535
        my %TicketFreeTimeHTML = $Self->{LayoutObject}->AgentFreeDate(
 
536
            Ticket => \%TicketFreeTime,
 
537
        );
 
538
        # get article free text config options
 
539
        my %ArticleFreeText = ();
 
540
        foreach (1..3) {
 
541
            $ArticleFreeText{"ArticleFreeKey$_"} = $Self->{TicketObject}->ArticleFreeTextGet(
 
542
                TicketID => $Self->{TicketID},
 
543
                Type => "ArticleFreeKey$_",
 
544
                Action => $Self->{Action},
 
545
                UserID => $Self->{UserID},
 
546
            );
 
547
            $ArticleFreeText{"ArticleFreeText$_"} = $Self->{TicketObject}->ArticleFreeTextGet(
 
548
                TicketID => $Self->{TicketID},
 
549
                Type => "ArticleFreeText$_",
 
550
                Action => $Self->{Action},
 
551
                UserID => $Self->{UserID},
 
552
            );
 
553
        }
 
554
        my %ArticleFreeTextHTML = $Self->{LayoutObject}->TicketArticleFreeText(
 
555
            Config => \%ArticleFreeText,
 
556
            Article => \%GetParam,
 
557
        );
 
558
        # print form ...
 
559
        my $Output = $Self->{LayoutObject}->Header(Value => $Ticket{TicketNumber});
162
560
        $Output .= $Self->{LayoutObject}->NavigationBar();
 
561
        $Output .= $Self->_Mask(
 
562
            %GetParam,
 
563
            %Ticket,
 
564
            %TicketFreeTextHTML,
 
565
            %TicketFreeTimeHTML,
 
566
            %ArticleFreeTextHTML,
 
567
        );
 
568
        $Output .= $Self->{LayoutObject}->Footer();
 
569
        return $Output;
 
570
    }
 
571
}
 
572
 
 
573
sub _Mask {
 
574
    my $Self = shift;
 
575
    my %Param = @_;
 
576
    my %Ticket = $Self->{TicketObject}->TicketGet(TicketID => $Self->{TicketID});
 
577
 
 
578
    if ($Self->{Config}->{Title}) {
 
579
        $Self->{LayoutObject}->Block(
 
580
            Name => 'Title',
 
581
            Data => \%Param,
 
582
        );
 
583
    }
 
584
    if ($Self->{Config}->{Owner}) {
163
585
        # get user of own groups
164
586
        my %ShownUsers = ();
165
587
        my %AllGroupsMembers = $Self->{UserObject}->UserList(
183
605
        }
184
606
        # get old owner
185
607
        my @OldUserInfo = $Self->{TicketObject}->OwnerList(TicketID => $Self->{TicketID});
186
 
        # print change form
187
 
        $Output .= $Self->MaskOwner(
188
 
            %Ticket,
189
 
            OptionStrg => \%ShownUsers,
190
 
            OldUser => \@OldUserInfo,
191
 
            TicketID => $Self->{TicketID},
192
 
            OwnerID => $OwnerID,
193
 
            QueueID => $Self->{QueueID},
194
 
        );
195
 
        $Output .= $Self->{LayoutObject}->Footer();
196
 
    }
197
 
    return $Output;
198
 
}
199
 
# --
200
 
sub MaskOwner {
201
 
    my $Self = shift;
202
 
    my %Param = @_;
203
 
    # build string
204
 
    $Param{'OptionStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
205
 
        Data => $Param{OptionStrg},
206
 
        Selected => $Param{OwnerID},
207
 
        Name => 'NewUserID',
208
 
        Size => 10,
209
 
        OnClick => "change_selected(0)",
210
 
    );
211
 
    my %UserHash = ();
212
 
    if ($Param{OldUser}) {
213
 
        my $Counter = 0;
214
 
        foreach my $User (reverse @{$Param{OldUser}}) {
215
 
          if ($Counter) {
216
 
            if (!$UserHash{$User->{UserID}}) {
217
 
                $UserHash{$User->{UserID}} = "$Counter: $User->{UserLastname} ".
218
 
                  "$User->{UserFirstname} ($User->{UserLogin})";
219
 
            }
220
 
          }
221
 
          $Counter++;
222
 
        }
223
 
    }
224
 
    if (!%UserHash) {
225
 
        $UserHash{''} = '-';
226
 
    }
227
 
    # build string
228
 
    $Param{'OldUserStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
229
 
        Data => \%UserHash,
230
 
        SelectedID => $Param{OldUser}->[0]->{UserID}.'1',
231
 
        Name => 'OldUserID',
232
 
        OnClick => "change_selected(2)",
233
 
#        Size => 10,
234
 
    );
235
 
    # get next states
236
 
    if ($Self->{ConfigObject}->Get('Ticket::Frontend::OwnerSetState')) {
237
 
        my %NextStates = $Self->{TicketObject}->StateList(
238
 
            Type => 'DefaultNextOwner',
 
608
        $Param{'OwnerStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
609
            Data => \%ShownUsers,
 
610
            SelectedID => $Param{NewOwnerID},
 
611
            Name => 'NewOwnerID',
 
612
            Size => 10,
 
613
            OnClick => "change_selected(0)",
 
614
        );
 
615
        my %UserHash = ();
 
616
        if (@OldUserInfo) {
 
617
            my $Counter = 0;
 
618
            foreach my $User (reverse @OldUserInfo) {
 
619
                if ($Counter) {
 
620
                    if (!$UserHash{$User->{UserID}}) {
 
621
                        $UserHash{$User->{UserID}} = "$Counter: $User->{UserLastname} ".
 
622
                            "$User->{UserFirstname} ($User->{UserLogin})";
 
623
                    }
 
624
                }
 
625
                $Counter++;
 
626
            }
 
627
        }
 
628
        if (!%UserHash) {
 
629
            $UserHash{''} = '-';
 
630
        }
 
631
        my $OldOwnerSelectedID = '';
 
632
        if ($Param{OldOwnerID}) {
 
633
            $OldOwnerSelectedID = $Param{OldOwnerID};
 
634
        }
 
635
        elsif ($OldUserInfo[0]->{UserID}) {
 
636
            $OldOwnerSelectedID = $OldUserInfo[0]->{UserID} . '1';
 
637
        }
 
638
        # build string
 
639
        $Param{'OldOwnerStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
640
            Data => \%UserHash,
 
641
            SelectedID => $OldOwnerSelectedID,
 
642
            Name => 'OldOwnerID',
 
643
            OnClick => "change_selected(2)",
 
644
        );
 
645
        if ($Param{NewOwnerType} && $Param{NewOwnerType} eq 'Old') {
 
646
            $Param{'NewOwnerType::Old'} = 'checked="checked"';
 
647
        }
 
648
        else {
 
649
            $Param{'NewOwnerType::New'} = 'checked="checked"';
 
650
        }
 
651
        $Self->{LayoutObject}->Block(
 
652
            Name => 'OwnerJs',
 
653
            Data => \%Param,
 
654
        );
 
655
        $Self->{LayoutObject}->Block(
 
656
            Name => 'Owner',
 
657
            Data => \%Param,
 
658
        );
 
659
    }
 
660
    if ($Self->{Config}->{Responsible}) {
 
661
        # get user of own groups
 
662
        my %ShownUsers = ();
 
663
        my %AllGroupsMembers = $Self->{UserObject}->UserList(
 
664
            Type => 'Long',
 
665
            Valid => 1,
 
666
        );
 
667
        if ($Self->{ConfigObject}->Get('Ticket::ChangeOwnerToEveryone')) {
 
668
            %ShownUsers = %AllGroupsMembers;
 
669
        }
 
670
        else {
 
671
            my $GID = $Self->{QueueObject}->GetQueueGroupID(QueueID => $Ticket{QueueID});
 
672
            my %MemberList = $Self->{GroupObject}->GroupMemberList(
 
673
                GroupID => $GID,
 
674
                Type => 'rw',
 
675
                Result => 'HASH',
 
676
                Cached => 1,
 
677
            );
 
678
            foreach (keys %MemberList) {
 
679
                $ShownUsers{$_} = $AllGroupsMembers{$_};
 
680
            }
 
681
        }
 
682
        # get responsible
 
683
        $Param{'ResponsibleStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
684
            Data => \%ShownUsers,
 
685
            SelectedID => $Param{NewResponsibleID} || $Ticket{ResponsibleID},
 
686
            Name => 'NewResponsibleID',
 
687
            Size => 10,
 
688
        );
 
689
        $Self->{LayoutObject}->Block(
 
690
            Name => 'Responsible',
 
691
            Data => \%Param,
 
692
        );
 
693
    }
 
694
    if ($Self->{Config}->{State}) {
 
695
        my %State = ();
 
696
        my %StateList = $Self->{TicketObject}->StateList(
239
697
            Action => $Self->{Action},
240
698
            TicketID => $Self->{TicketID},
241
699
            UserID => $Self->{UserID},
242
700
        );
243
 
        $NextStates{''} = '-';
 
701
        if (!$Self->{Config}->{StateDefault}) {
 
702
            $StateList{''} = '-';
 
703
#            $State{SelectedID} = $Param{StateID};
 
704
        }
 
705
        if (!$Param{NewStateID}) {
 
706
            if ($Self->{Config}->{StateDefault}) {
 
707
                $State{Selected} = $Self->{Config}->{StateDefault};
 
708
            }
 
709
        }
 
710
        else {
 
711
            $State{SelectedID} = $Param{NewStateID};
 
712
        }
244
713
        # build next states string
245
 
        $Param{'NextStatesStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
246
 
            Data => \%NextStates,
 
714
        $Param{'StateStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
715
            Data => \%StateList,
247
716
            Name => 'NewStateID',
248
 
            SelectedID => $Param{NewStateID},
249
 
        );
250
 
        $Param{DateString} = $Self->{LayoutObject}->BuildDateSelection(
251
 
            Format => 'DateInputFormatLong',
252
 
            DiffTime => $Self->{ConfigObject}->Get('Ticket::Frontend::PendingDiffTime') || 0,
253
 
            %Param,
254
 
        );
255
 
        $Self->{LayoutObject}->Block(
256
 
            Name => 'NextState',
257
 
            Data => \%Param,
258
 
        );
259
 
    }
260
 
    # create & return output
261
 
    return $Self->{LayoutObject}->Output(
262
 
        TemplateFile => 'AgentTicketOwner',
263
 
        Data => \%Param,
264
 
    );
 
717
            %State,
 
718
        );
 
719
        $Self->{LayoutObject}->Block(
 
720
            Name => 'State',
 
721
            Data => \%Param,
 
722
        );
 
723
        foreach (sort keys %StateList) {
 
724
            if ($_) {
 
725
                my %StateData = $Self->{TicketObject}->{StateObject}->StateGet(
 
726
                    ID => $_,
 
727
                );
 
728
                if ($StateData{TypeName} =~ /pending/i) {
 
729
                    $Param{DateString} = $Self->{LayoutObject}->BuildDateSelection(
 
730
                        Format => 'DateInputFormatLong',
 
731
                        DiffTime => $Self->{ConfigObject}->Get('Ticket::Frontend::PendingDiffTime') || 0,
 
732
                        %Param,
 
733
                    );
 
734
                    $Self->{LayoutObject}->Block(
 
735
                        Name => 'StatePending',
 
736
                        Data => \%Param,
 
737
                    );
 
738
                    last;
 
739
                }
 
740
            }
 
741
        }
 
742
    }
 
743
    # get next states
 
744
    if ($Self->{Config}->{Priority}) {
 
745
        my %Priority = ();
 
746
        my %PriorityList = $Self->{TicketObject}->PriorityList(
 
747
            UserID => $Self->{UserID},
 
748
            TicketID => $Self->{TicketID},
 
749
        );
 
750
        if (!$Self->{Config}->{PriorityDefault}) {
 
751
            $PriorityList{''} = '-';
 
752
#            $Priority{SelectedID} = $Param{PriorityID};
 
753
        }
 
754
        if (!$Param{NewPriorityID}) {
 
755
            if ($Self->{Config}->{PriorityDefault}) {
 
756
                $Priority{Selected} = $Self->{Config}->{PriorityDefault};
 
757
            }
 
758
        }
 
759
        else {
 
760
            $Priority{SelectedID} = $Param{NewPriorityID};
 
761
        }
 
762
        $Param{'PriorityStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
763
            Data => \%PriorityList,
 
764
            Name => 'NewPriorityID',
 
765
            %Priority,
 
766
        );
 
767
        $Self->{LayoutObject}->Block(
 
768
            Name => 'Priority',
 
769
            Data => \%Param,
 
770
        );
 
771
    }
 
772
    if ($Self->{Config}->{Note}) {
 
773
        $Self->{LayoutObject}->Block(
 
774
            Name => 'NoteJs',
 
775
            Data => { %Param },
 
776
        );
 
777
        $Self->{LayoutObject}->Block(
 
778
            Name => 'Note',
 
779
            Data => { %Param },
 
780
        );
 
781
        # agent list
 
782
        if ($Self->{Config}->{InformAgent}) {
 
783
            my %ShownUsers = ();
 
784
            my %AllGroupsMembers = $Self->{UserObject}->UserList(
 
785
                Type => 'Long',
 
786
                Valid => 1,
 
787
            );
 
788
            my $GID = $Self->{QueueObject}->GetQueueGroupID(QueueID => $Ticket{QueueID});
 
789
            my %MemberList = $Self->{GroupObject}->GroupMemberList(
 
790
                GroupID => $GID,
 
791
                Type => 'rw',
 
792
                Result => 'HASH',
 
793
                Cached => 1,
 
794
            );
 
795
            foreach (keys %MemberList) {
 
796
                $ShownUsers{$_} = $AllGroupsMembers{$_};
 
797
            }
 
798
            $Param{'OptionStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
799
                Data => \%ShownUsers,
 
800
                SelectedIDRefArray => $Self->{InformUserID},
 
801
                Name => 'InformUserID',
 
802
                Multiple => 1,
 
803
                Size => 3,
 
804
            );
 
805
            $Self->{LayoutObject}->Block(
 
806
                Name => 'InformAgent',
 
807
                Data => \%Param,
 
808
            );
 
809
        }
 
810
        # get involved
 
811
        if ($Self->{Config}->{InvolvedAgent}) {
 
812
            my @UserIDs = $Self->{TicketObject}->InvolvedAgents(TicketID => $Self->{TicketID});
 
813
            my %UserHash = ();
 
814
            my $Counter = 0;
 
815
            foreach my $User (reverse @UserIDs) {
 
816
                $Counter++;
 
817
                if (!$UserHash{$User->{UserID}}) {
 
818
                    $UserHash{$User->{UserID}} = "$Counter: $User->{UserLastname} ".
 
819
                        "$User->{UserFirstname} ($User->{UserLogin})";
 
820
                }
 
821
            }
 
822
            $Param{'InvolvedAgentStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
823
                Data => \%UserHash,
 
824
                SelectedIDRefArray => $Self->{InvolvedUserID},
 
825
                Name => 'InvolvedUserID',
 
826
                Multiple => 1,
 
827
                Size => 3,
 
828
            );
 
829
            $Self->{LayoutObject}->Block(
 
830
                Name => 'InvolvedAgent',
 
831
                Data => \%Param,
 
832
            );
 
833
        }
 
834
        # show spell check
 
835
        if ($Self->{ConfigObject}->Get('SpellChecker') && $Self->{LayoutObject}->{BrowserJavaScriptSupport}) {
 
836
            $Self->{LayoutObject}->Block(
 
837
                Name => 'SpellCheck',
 
838
                Data => {},
 
839
            );
 
840
        }
 
841
        # show attachments
 
842
        foreach my $DataRef (@{$Param{Attachments}}) {
 
843
            $Self->{LayoutObject}->Block(
 
844
                Name => 'Attachment',
 
845
                Data => $DataRef,
 
846
            );
 
847
        }
 
848
        # build ArticleTypeID string
 
849
        my %ArticleType = ();
 
850
        if (!$Param{ArticleTypeID}) {
 
851
            $ArticleType{Selected} = $Self->{Config}->{ArticleTypeDefault};
 
852
        }
 
853
        else {
 
854
            $ArticleType{SelectedID} = $Param{ArticleTypeID};
 
855
        }
 
856
        # get possible notes
 
857
        my %DefaultNoteTypes = %{$Self->{Config}->{ArticleTypes}};
 
858
        my %NoteTypes = $Self->{DBObject}->GetTableData(
 
859
            Table => 'article_type',
 
860
            Valid => 1,
 
861
            What => 'id, name'
 
862
        );
 
863
        foreach (keys %NoteTypes) {
 
864
            if (!$DefaultNoteTypes{$NoteTypes{$_}}) {
 
865
                delete $NoteTypes{$_};
 
866
            }
 
867
        }
 
868
        $Param{'ArticleTypeStrg'} = $Self->{LayoutObject}->OptionStrgHashRef(
 
869
            Data => \%NoteTypes,
 
870
            Name => 'ArticleTypeID',
 
871
            %ArticleType,
 
872
        );
 
873
        $Self->{LayoutObject}->Block(
 
874
            Name => 'ArticleType',
 
875
            Data => \%Param,
 
876
        );
 
877
        # show time accounting box
 
878
        if ($Self->{ConfigObject}->Get('Ticket::Frontend::AccountTime')) {
 
879
            $Self->{LayoutObject}->Block(
 
880
                Name => 'TimeUnitsJs',
 
881
                Data => \%Param,
 
882
            );
 
883
            $Self->{LayoutObject}->Block(
 
884
                Name => 'TimeUnits',
 
885
                Data => \%Param,
 
886
            );
 
887
        }
 
888
    }
 
889
    # ticket free text
 
890
    my $Count = 0;
 
891
    foreach (1..16) {
 
892
        $Count++;
 
893
        if ($Self->{Config}->{'TicketFreeText'}->{$Count}) {
 
894
            $Self->{LayoutObject}->Block(
 
895
                Name => 'TicketFreeText',
 
896
                Data => {
 
897
                    TicketFreeKeyField => $Param{'TicketFreeKeyField'.$Count},
 
898
                    TicketFreeTextField => $Param{'TicketFreeTextField'.$Count},
 
899
                    Count => $Count,
 
900
                },
 
901
            );
 
902
            $Self->{LayoutObject}->Block(
 
903
                Name => 'TicketFreeText'.$Count,
 
904
                Data => {
 
905
                    %Param,
 
906
                    Count => $Count,
 
907
                },
 
908
            );
 
909
        }
 
910
    }
 
911
    $Count = 0;
 
912
    foreach (1..2) {
 
913
        $Count++;
 
914
        if ($Self->{Config}->{'TicketFreeTime'}->{$Count}) {
 
915
            $Self->{LayoutObject}->Block(
 
916
                Name => 'TicketFreeTime',
 
917
                Data => {
 
918
                    TicketFreeTimeKey => $Self->{ConfigObject}->Get('TicketFreeTimeKey'.$Count),
 
919
                    TicketFreeTime => $Param{'TicketFreeTime'.$Count},
 
920
                    Count => $Count,
 
921
                },
 
922
            );
 
923
            $Self->{LayoutObject}->Block(
 
924
                Name => 'TicketFreeTime'.$Count,
 
925
                Data => {
 
926
                    %Param,
 
927
                    Count => $Count,
 
928
                },
 
929
            );
 
930
        }
 
931
    }
 
932
    # article free text
 
933
    $Count = 0;
 
934
    foreach (1..3) {
 
935
        $Count++;
 
936
        if ($Self->{Config}->{'ArticleFreeText'}->{$Count}) {
 
937
            $Self->{LayoutObject}->Block(
 
938
                Name => 'ArticleFreeText',
 
939
                Data => {
 
940
                    ArticleFreeKeyField => $Param{'ArticleFreeKeyField'.$Count},
 
941
                    ArticleFreeTextField => $Param{'ArticleFreeTextField'.$Count},
 
942
                    Count => $Count,
 
943
                },
 
944
            );
 
945
            $Self->{LayoutObject}->Block(
 
946
                Name => 'ArticleFreeText'.$Count,
 
947
                Data => {
 
948
                    %Param,
 
949
                    Count => $Count,
 
950
                },
 
951
            );
 
952
        }
 
953
    }
 
954
    # get output back
 
955
    return $Self->{LayoutObject}->Output(TemplateFile => 'AgentTicketOwner', Data => \%Param);
265
956
}
266
 
# --
 
957
 
267
958
1;