1# --
2# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
3# --
4# This software comes with ABSOLUTELY NO WARRANTY. For details, see
5# the enclosed file COPYING for license information (GPL). If you
6# did not receive this file, see https://www.gnu.org/licenses/gpl-3.0.txt.
7# --
8
9package Kernel::System::DynamicField::Driver::Checkbox;
10
11use strict;
12use warnings;
13
14use Kernel::System::VariableCheck qw(:all);
15
16use parent qw(Kernel::System::DynamicField::Driver::Base);
17
18our @ObjectDependencies = (
19    'Kernel::Config',
20    'Kernel::System::DB',
21    'Kernel::System::DynamicFieldValue',
22    'Kernel::System::Ticket::ColumnFilter',
23    'Kernel::System::Log',
24    'Kernel::System::Main',
25);
26
27=head1 NAME
28
29Kernel::System::DynamicField::Driver::Checkbox
30
31=head1 DESCRIPTION
32
33DynamicFields Checkbox Driver delegate
34
35=head1 PUBLIC INTERFACE
36
37This module implements the public interface of L<Kernel::System::DynamicField::Backend>.
38Please look there for a detailed reference of the functions.
39
40=head2 new()
41
42usually, you want to create an instance of this
43by using Kernel::System::DynamicField::Backend->new();
44
45=cut
46
47sub new {
48    my ( $Type, %Param ) = @_;
49
50    # allocate new hash for object
51    my $Self = {};
52    bless( $Self, $Type );
53
54    # set field behaviors
55    $Self->{Behaviors} = {
56        'IsACLReducible'               => 0,
57        'IsNotificationEventCondition' => 1,
58        'IsSortable'                   => 1,
59        'IsFiltrable'                  => 1,
60        'IsStatsCondition'             => 1,
61        'IsCustomerInterfaceCapable'   => 1,
62    };
63
64    # get the Dynamic Field Backend custom extensions
65    my $DynamicFieldDriverExtensions
66        = $Kernel::OM->Get('Kernel::Config')->Get('DynamicFields::Extension::Driver::Checkbox');
67
68    EXTENSION:
69    for my $ExtensionKey ( sort keys %{$DynamicFieldDriverExtensions} ) {
70
71        # skip invalid extensions
72        next EXTENSION if !IsHashRefWithData( $DynamicFieldDriverExtensions->{$ExtensionKey} );
73
74        # create a extension config shortcut
75        my $Extension = $DynamicFieldDriverExtensions->{$ExtensionKey};
76
77        # check if extension has a new module
78        if ( $Extension->{Module} ) {
79
80            # check if module can be loaded
81            if (
82                !$Kernel::OM->Get('Kernel::System::Main')->RequireBaseClass( $Extension->{Module} )
83                )
84            {
85                die "Can't load dynamic fields backend module"
86                    . " $Extension->{Module}! $@";
87            }
88        }
89
90        # check if extension contains more behaviors
91        if ( IsHashRefWithData( $Extension->{Behaviors} ) ) {
92
93            %{ $Self->{Behaviors} } = (
94                %{ $Self->{Behaviors} },
95                %{ $Extension->{Behaviors} }
96            );
97        }
98    }
99
100    return $Self;
101}
102
103sub ValueGet {
104    my ( $Self, %Param ) = @_;
105
106    my $DFValue = $Kernel::OM->Get('Kernel::System::DynamicFieldValue')->ValueGet(
107        FieldID  => $Param{DynamicFieldConfig}->{ID},
108        ObjectID => $Param{ObjectID},
109    );
110
111    return if !$DFValue;
112    return if !IsArrayRefWithData($DFValue);
113    return if !IsHashRefWithData( $DFValue->[0] );
114
115    return $DFValue->[0]->{ValueInt};
116}
117
118sub ValueSet {
119    my ( $Self, %Param ) = @_;
120
121    # check value for just 1 or 0
122    if ( defined $Param{Value} && !$Param{Value} ) {
123        $Param{Value} = 0;
124    }
125    elsif ( $Param{Value} && $Param{Value} !~ m{\A [0|1]? \z}xms ) {
126        $Kernel::OM->Get('Kernel::System::Log')->Log(
127            Priority => 'error',
128            Message  => "Value $Param{Value} is invalid for Checkbox fields!",
129        );
130        return;
131    }
132
133    my $Success = $Kernel::OM->Get('Kernel::System::DynamicFieldValue')->ValueSet(
134        FieldID  => $Param{DynamicFieldConfig}->{ID},
135        ObjectID => $Param{ObjectID},
136        Value    => [
137            {
138                ValueInt => $Param{Value},
139            },
140        ],
141        UserID => $Param{UserID},
142    );
143
144    return $Success;
145}
146
147sub ValueValidate {
148    my ( $Self, %Param ) = @_;
149
150    # check value for just 1 or 0
151    if ( defined $Param{Value} && !$Param{Value} ) {
152        $Param{Value} = 0;
153    }
154    elsif ( $Param{Value} && $Param{Value} !~ m{\A [0|1]? \z}xms ) {
155        $Kernel::OM->Get('Kernel::System::Log')->Log(
156            Priority => 'error',
157            Message  => "Value $Param{Value} is invalid for Checkbox fields!",
158        );
159        return;
160    }
161
162    my $Success = $Kernel::OM->Get('Kernel::System::DynamicFieldValue')->ValueValidate(
163        Value => {
164            ValueInt => $Param{Value},
165        },
166        UserID => $Param{UserID}
167    );
168
169    return $Success;
170}
171
172sub SearchSQLGet {
173    my ( $Self, %Param ) = @_;
174
175    if ( !IsInteger( $Param{SearchTerm} ) ) {
176        $Kernel::OM->Get('Kernel::System::Log')->Log(
177            'Priority' => 'error',
178            'Message'  => "Unsupported Search Term $Param{SearchTerm}, should be an integer",
179        );
180        return;
181    }
182
183    my %Operators = (
184        Equals => '=',
185    );
186
187    if ( $Param{Operator} eq 'Empty' ) {
188        if ( $Param{SearchTerm} ) {
189            return " $Param{TableAlias}.value_int IS NULL ";
190        }
191        else {
192            return " $Param{TableAlias}.value_int IS NOT NULL ";
193        }
194    }
195    elsif ( !$Operators{ $Param{Operator} } ) {
196        $Kernel::OM->Get('Kernel::System::Log')->Log(
197            'Priority' => 'error',
198            'Message'  => "Unsupported Operator $Param{Operator}",
199        );
200        return;
201    }
202
203    my $SQL = " $Param{TableAlias}.value_int $Operators{ $Param{Operator} } ";
204    $SQL
205        .= $Kernel::OM->Get('Kernel::System::DB')->Quote( $Param{SearchTerm}, 'Integer' ) . ' ';
206    return $SQL;
207}
208
209sub SearchSQLOrderFieldGet {
210    my ( $Self, %Param ) = @_;
211
212    return "$Param{TableAlias}.value_int";
213}
214
215sub EditFieldRender {
216    my ( $Self, %Param ) = @_;
217
218    # take config from field config
219    my $FieldConfig = $Param{DynamicFieldConfig}->{Config};
220    my $FieldName   = 'DynamicField_' . $Param{DynamicFieldConfig}->{Name};
221    my $FieldLabel  = $Param{DynamicFieldConfig}->{Label};
222
223    my $Value;
224
225    # set the field value or default
226    if ( $Param{UseDefaultValue} ) {
227        $Value = $FieldConfig->{DefaultValue} || '';
228    }
229    $Value = $Param{Value} // $Value;
230
231    # extract the dynamic field value from the web request
232    my $FieldValue = $Self->EditFieldValueGet(
233        ReturnValueStructure => 1,
234        %Param,
235    );
236
237    # set values from ParamObject if present
238    if ( defined $FieldValue && IsHashRefWithData($FieldValue) ) {
239        if (
240            !defined $FieldValue->{FieldValue}
241            && defined $FieldValue->{UsedValue}
242            && $FieldValue->{UsedValue} eq '1'
243            )
244        {
245            $Value = '0';
246        }
247        elsif (
248            defined $FieldValue->{FieldValue}
249            && $FieldValue->{FieldValue} eq '1'
250            && defined $FieldValue->{UsedValue}
251            && $FieldValue->{UsedValue} eq '1'
252            )
253        {
254            $Value = '1';
255        }
256    }
257
258    # set as checked if necessary
259    my $FieldChecked = ( defined $Value && $Value eq '1' ? 'checked="checked"' : '' );
260
261    # check and set class if necessary
262    my $FieldClass = 'DynamicFieldCheckbox';
263    if ( defined $Param{Class} && $Param{Class} ne '' ) {
264        $FieldClass .= ' ' . $Param{Class};
265    }
266
267    # set field as mandatory
268    if ( $Param{Mandatory} ) {
269        $FieldClass .= ' Validate_Required';
270    }
271
272    # set error css class
273    if ( $Param{ServerError} ) {
274        $FieldClass .= ' ServerError';
275    }
276
277    my $FieldNameUsed = $FieldName . "Used";
278
279    my $HTMLString = <<"EOF";
280<input type="hidden" id="$FieldNameUsed" name="$FieldNameUsed" value="1" />
281EOF
282
283    if ( $Param{ConfirmationNeeded} ) {
284
285        # set checked property
286        my $FieldUsedChecked0 = '';
287        my $FieldUsedChecked1 = '';
288        if ( $FieldValue->{UsedValue} ) {
289            $FieldUsedChecked1 = 'checked="checked"';
290        }
291        else {
292            $FieldUsedChecked0 = 'checked="checked"';
293        }
294
295        my $FieldNameUsed0 = $FieldNameUsed . '0';
296        my $FieldNameUsed1 = $FieldNameUsed . '1';
297        my $TranslatedDesc = $Param{LayoutObject}->{LanguageObject}->Translate(
298            'Ignore this field.',
299        );
300
301        if ( !$Param{NoIgnoreField} ) {
302            $HTMLString = <<"EOF";
303<input type="radio" id="$FieldNameUsed0" name="$FieldNameUsed" value="" $FieldUsedChecked0 />
304$TranslatedDesc
305<div class="clear"></div>
306<input type="radio" id="$FieldNameUsed1" name="$FieldNameUsed" value="1" $FieldUsedChecked1 />
307EOF
308        }
309    }
310
311    my $FieldLabelEscaped = $Param{LayoutObject}->Ascii2Html(
312        Text => $FieldLabel,
313    );
314
315    $HTMLString .= <<"EOF";
316<input type="checkbox" class="$FieldClass" id="$FieldName" name="$FieldName" title="$FieldLabelEscaped" $FieldChecked value="1" />
317EOF
318
319    if ( $Param{Mandatory} ) {
320        my $DivID = $FieldName . 'Error';
321
322        my $FieldRequiredMessage = $Param{LayoutObject}->{LanguageObject}->Translate("This field is required.");
323
324        # for client side validation
325        $HTMLString .= <<"EOF";
326<div id="$DivID" class="TooltipErrorMessage">
327    <p>
328        $FieldRequiredMessage
329    </p>
330</div>
331EOF
332    }
333
334    if ( $Param{ServerError} ) {
335
336        my $ErrorMessage = $Param{ErrorMessage} || 'This field is required.';
337        $ErrorMessage = $Param{LayoutObject}->{LanguageObject}->Translate($ErrorMessage);
338        my $DivID = $FieldName . 'ServerError';
339
340        # for server side validation
341        $HTMLString .= <<"EOF";
342<div id="$DivID" class="TooltipErrorMessage">
343    <p>
344        $ErrorMessage
345    </p>
346</div>
347EOF
348    }
349
350    if ( $Param{AJAXUpdate} ) {
351
352        my $FieldsToUpdate = '';
353        if ( IsArrayRefWithData( $Param{UpdatableFields} ) ) {
354
355            # Remove current field from updatable fields list.
356            my @FieldsToUpdate = grep { $_ ne $FieldName } @{ $Param{UpdatableFields} };
357
358            # Quote all fields, put commas between them.
359            $FieldsToUpdate = join( ', ', map {"'$_'"} @FieldsToUpdate );
360        }
361
362        # Add JS to call FormUpdate() on change event.
363        $Param{LayoutObject}->AddJSOnDocumentComplete( Code => <<"EOF");
364\$('#$FieldName').on('change', function () {
365    Core.AJAX.FormUpdate(\$(this).parents('form'), 'AJAXUpdate', '$FieldName', [ $FieldsToUpdate ]);
366});
367EOF
368    }
369
370    # call EditLabelRender on the common backend
371    my $LabelString = $Self->EditLabelRender(
372        %Param,
373        Mandatory => $Param{Mandatory} || '0',
374        FieldName => $FieldName,
375    );
376
377    my $Data = {
378        Field => $HTMLString,
379        Label => $LabelString,
380    };
381
382    return $Data;
383}
384
385sub EditFieldValueGet {
386    my ( $Self, %Param ) = @_;
387
388    my $FieldName = 'DynamicField_' . $Param{DynamicFieldConfig}->{Name};
389
390    my %Data;
391
392    # check if there is a Template and retrieve the dynamic field value from there
393    if (
394        IsHashRefWithData( $Param{Template} ) && (
395            defined $Param{Template}->{$FieldName}
396            || defined $Param{Template}->{ $FieldName . 'Used' }
397        )
398        )
399    {
400        # get dynamic field value form Template
401        $Data{FieldValue} = $Param{Template}->{$FieldName};
402
403        # get dynamic field used value form Template
404        $Data{UsedValue} = $Param{Template}->{ $FieldName . 'Used' };
405    }
406
407    # otherwise get dynamic field value from the web request
408    elsif (
409        defined $Param{ParamObject}
410        && ref $Param{ParamObject} eq 'Kernel::System::Web::Request'
411        )
412    {
413
414        # get dynamic field value from param
415        $Data{FieldValue} = $Param{ParamObject}->GetParam( Param => $FieldName );
416
417        # get dynamic field used value from param
418        $Data{UsedValue} = $Param{ParamObject}->GetParam( Param => $FieldName . 'Used' );
419    }
420
421    # check if return value structure is needed
422    if ( defined $Param{ReturnValueStructure} && $Param{ReturnValueStructure} eq '1' ) {
423        return \%Data;
424    }
425
426    # check if return template structure is needed
427    if ( defined $Param{ReturnTemplateStructure} && $Param{ReturnTemplateStructure} eq '1' ) {
428        return {
429            $FieldName          => $Data{FieldValue},
430            $FieldName . 'Used' => $Data{UsedValue},
431        };
432    }
433
434    # return undef if the hidden value is not present
435    return if !$Data{UsedValue};
436
437    # set the correct return value
438    my $Value = '0';
439    if ( $Data{FieldValue} ) {
440        $Value = $Data{FieldValue};
441    }
442
443    return $Value;
444}
445
446sub EditFieldValueValidate {
447    my ( $Self, %Param ) = @_;
448
449    # get the field value from the http request
450    my $FieldValue = $Self->EditFieldValueGet(
451        DynamicFieldConfig => $Param{DynamicFieldConfig},
452        ParamObject        => $Param{ParamObject},
453
454        # not necessary for this backend but place it for consistency reasons
455        ReturnValueStructure => 1,
456    );
457    my $Value = $FieldValue->{FieldValue} || '';
458
459    my $ServerError;
460    my $ErrorMessage;
461
462    # perform necessary validations
463    if ( $Param{Mandatory} && !$Value ) {
464        $ServerError = 1;
465    }
466
467    # validate only 0 or 1 as possible values
468    if ( $Value && $Value ne 1 ) {
469        $ServerError  = 1;
470        $ErrorMessage = 'The field content is invalid';
471    }
472
473    # create resulting structure
474    my $Result = {
475        ServerError  => $ServerError,
476        ErrorMessage => $ErrorMessage,
477    };
478
479    return $Result;
480}
481
482sub DisplayValueRender {
483    my ( $Self, %Param ) = @_;
484
485    # check for Null value
486    if ( !defined $Param{Value} ) {
487        return {
488            Value => '',
489            Title => '',
490            Link  => '',
491        };
492    }
493
494    # convert value to user friendly string
495    my $Value = 'Checked';
496    if ( $Param{Value} ne 1 ) {
497        $Value = 'Unchecked';
498    }
499
500    # always translate value
501    $Value = $Param{LayoutObject}->{LanguageObject}->Translate($Value);
502
503    # in this backend there is no need for HTMLOutput
504    # Title is always equal to Value
505    my $Title = $Value;
506
507    # this field type does not support the Link Feature
508    my $Link;
509
510    # create return structure
511    my $Data = {
512        Value => $Value,
513        Title => $Title,
514        Link  => $Link,
515    };
516
517    return $Data;
518}
519
520sub SearchFieldRender {
521    my ( $Self, %Param ) = @_;
522
523    # take config from field config
524    my $FieldConfig = $Param{DynamicFieldConfig}->{Config};
525    my $FieldName   = 'Search_DynamicField_' . $Param{DynamicFieldConfig}->{Name};
526    my $FieldLabel  = $Param{DynamicFieldConfig}->{Label};
527
528    my $Value;
529    my @DefaultValue;
530
531    if ( defined $Param{DefaultValue} ) {
532        @DefaultValue = split /;/, $Param{DefaultValue};
533    }
534
535    # set the field value
536    if (@DefaultValue) {
537        $Value = \@DefaultValue;
538    }
539
540    # get the field value, this function is always called after the profile is loaded
541    my $FieldValue = $Self->SearchFieldValueGet(%Param);
542
543    # set values from profile if present
544    if ( defined $FieldValue ) {
545        $Value = $FieldValue;
546    }
547
548    for my $Item ( @{$Value} ) {
549
550        # value must be 1, '' or -1
551        if ( !defined $Item || !$Item ) {
552            $Item = '';
553        }
554        elsif ( $Item && $Item >= 1 ) {
555            $Item = 1;
556        }
557        else {
558            $Item = -1;
559        }
560    }
561
562    # check and set class if necessary
563    my $FieldClass = 'DynamicFieldDropdown Modernize';
564
565    my $HTMLString = $Param{LayoutObject}->BuildSelection(
566        Data => {
567            1  => 'Checked',
568            -1 => 'Unchecked',
569        },
570        Name         => $FieldName,
571        SelectedID   => $Value || '',
572        Translation  => 1,
573        PossibleNone => 1,
574        Class        => $FieldClass,
575        Multiple     => 1,
576        HTMLQuote    => 1,
577    );
578
579    # call EditLabelRender on the common backend
580    my $LabelString = $Self->EditLabelRender(
581        %Param,
582        FieldName => $FieldName,
583    );
584
585    my $Data = {
586        Field => $HTMLString,
587        Label => $LabelString,
588    };
589
590    return $Data;
591}
592
593sub SearchFieldValueGet {
594    my ( $Self, %Param ) = @_;
595
596    my $Value;
597
598    # get dynamic field value from param object
599    if ( defined $Param{ParamObject} ) {
600        my @FieldValues = $Param{ParamObject}->GetArray(
601            Param => 'Search_DynamicField_' . $Param{DynamicFieldConfig}->{Name}
602        );
603
604        $Value = \@FieldValues;
605    }
606
607    # otherwise get the value from the profile
608    elsif ( defined $Param{Profile} ) {
609        $Value = $Param{Profile}->{ 'Search_DynamicField_' . $Param{DynamicFieldConfig}->{Name} };
610    }
611    else {
612        return;
613    }
614
615    if ( defined $Param{ReturnProfileStructure} && $Param{ReturnProfileStructure} eq 1 ) {
616        return {
617            'Search_DynamicField_' . $Param{DynamicFieldConfig}->{Name} => $Value,
618        };
619    }
620
621    return $Value;
622}
623
624sub SearchFieldParameterBuild {
625    my ( $Self, %Param ) = @_;
626
627    # get field value
628    my $Value = $Self->SearchFieldValueGet(%Param);
629
630    my $DisplayValue;
631
632    if ( defined $Value && !$Value ) {
633        $DisplayValue = '';
634    }
635
636    if ($Value) {
637
638        if ( ref $Value eq "ARRAY" ) {
639            my @DisplayItemList;
640            ITEM:
641            for my $Item ( @{$Value} ) {
642
643                # set the display value
644                my $DisplayItem = $Item eq 1
645                    ? 'Checked'
646                    : $Item eq -1 ? 'Unchecked'
647                    :               '';
648
649                # translate the value
650                if ( defined $Param{LayoutObject} ) {
651                    $DisplayItem = $Param{LayoutObject}->{LanguageObject}->Translate($DisplayItem);
652                }
653
654                push @DisplayItemList, $DisplayItem;
655
656                # set the correct value for "unchecked" (-1) search options
657                if ( $Item && $Item eq -1 ) {
658                    $Item = '0';
659                }
660            }
661
662            # combine different values into one string
663            $DisplayValue = join ' + ', @DisplayItemList;
664
665        }
666        else {
667
668            # set the display value
669            $DisplayValue = $Value eq 1
670                ? 'Checked'
671                : $Value eq -1 ? 'Unchecked'
672                :                '';
673
674            # translate the value
675            if ( defined $Param{LayoutObject} ) {
676                $DisplayValue = $Param{LayoutObject}->{LanguageObject}->Translate($DisplayValue);
677            }
678        }
679
680        # set the correct value for "unchecked" (-1) search options
681        if ( $Value && $Value eq -1 ) {
682            $Value = '0';
683        }
684    }
685
686    # return search parameter structure
687    return {
688        Parameter => {
689            Equals => $Value,
690        },
691        Display => $DisplayValue,
692    };
693}
694
695sub StatsFieldParameterBuild {
696    my ( $Self, %Param ) = @_;
697
698    return {
699        Values => {
700            '1'  => 'Checked',
701            '-1' => 'Unchecked',
702        },
703        Name               => $Param{DynamicFieldConfig}->{Label},
704        Element            => 'DynamicField_' . $Param{DynamicFieldConfig}->{Name},
705        TranslatableValues => 1,
706    };
707}
708
709sub StatsSearchFieldParameterBuild {
710    my ( $Self, %Param ) = @_;
711
712    my $Operator = 'Equals';
713    my $Value    = $Param{Value};
714
715    if ( IsArrayRefWithData($Value) ) {
716        for my $Item ( @{$Value} ) {
717
718            # set the correct value for "unchecked" (-1) search options
719            if ( $Item && $Item eq '-1' ) {
720                $Item = '0';
721            }
722        }
723    }
724    else {
725
726        # set the correct value for "unchecked" (-1) search options
727        if ( $Value && $Value eq '-1' ) {
728            $Value = '0';
729        }
730    }
731
732    return {
733        $Operator => $Value,
734    };
735}
736
737sub ReadableValueRender {
738    my ( $Self, %Param ) = @_;
739
740    my $Value = defined $Param{Value} ? $Param{Value} : '';
741
742    # Title is always equal to Value
743    my $Title = $Value;
744
745    # create return structure
746    my $Data = {
747        Value => $Value,
748        Title => $Title,
749    };
750
751    return $Data;
752}
753
754sub TemplateValueTypeGet {
755    my ( $Self, %Param ) = @_;
756
757    my $FieldName = 'DynamicField_' . $Param{DynamicFieldConfig}->{Name};
758
759    # set the field types
760    my $EditValueType   = 'SCALAR';
761    my $SearchValueType = 'ARRAY';
762
763    # return the correct structure
764    if ( $Param{FieldType} eq 'Edit' ) {
765        return {
766            $FieldName => $EditValueType,
767        };
768    }
769    elsif ( $Param{FieldType} eq 'Search' ) {
770        return {
771            'Search_' . $FieldName => $SearchValueType,
772        };
773    }
774    else {
775        return {
776            $FieldName             => $EditValueType,
777            'Search_' . $FieldName => $SearchValueType,
778        };
779    }
780}
781
782sub RandomValueSet {
783    my ( $Self, %Param ) = @_;
784
785    my $Value = int( rand(2) );
786
787    my $Success = $Self->ValueSet(
788        %Param,
789        Value => $Value,
790    );
791
792    if ( !$Success ) {
793        return {
794            Success => 0,
795        };
796    }
797    return {
798        Success => 1,
799        Value   => $Value,
800    };
801}
802
803sub ObjectMatch {
804    my ( $Self, %Param ) = @_;
805
806    my $FieldName = 'DynamicField_' . $Param{DynamicFieldConfig}->{Name};
807
808    # return false if field is not defined
809    return 0 if ( !defined $Param{ObjectAttributes}->{$FieldName} );
810
811    # return false if not match
812    if ( $Param{ObjectAttributes}->{$FieldName} ne $Param{Value} ) {
813        return 0;
814    }
815
816    return 1;
817}
818
819sub HistoricalValuesGet {
820    my ( $Self, %Param ) = @_;
821
822    # get historical values from database
823    my $HistoricalValues = $Kernel::OM->Get('Kernel::System::DynamicFieldValue')->HistoricalValueGet(
824        FieldID   => $Param{DynamicFieldConfig}->{ID},
825        ValueType => 'Integer',
826    );
827
828    # return the historical values from database
829    return $HistoricalValues;
830}
831
832sub ValueLookup {
833    my ( $Self, %Param ) = @_;
834
835    return if !defined $Param{Key};
836
837    return '' if $Param{Key} eq '';
838
839    my $Value = defined $Param{Key} && $Param{Key} eq '1' ? 'Checked' : 'Unchecked';
840
841    # check if translation is possible
842    if ( defined $Param{LanguageObject} ) {
843
844        # translate value
845        $Value = $Param{LanguageObject}->Translate($Value);
846    }
847
848    return $Value;
849}
850
851sub ColumnFilterValuesGet {
852    my ( $Self, %Param ) = @_;
853
854    # set PossibleValues
855    my $SelectionData = {
856        0 => 'Unchecked',
857        1 => 'Checked',
858    };
859
860    # get historical values from database
861    my $ColumnFilterValues = $Kernel::OM->Get('Kernel::System::Ticket::ColumnFilter')->DynamicFieldFilterValuesGet(
862        TicketIDs => $Param{TicketIDs},
863        FieldID   => $Param{DynamicFieldConfig}->{ID},
864        ValueType => 'Integer',
865    );
866
867    # get the display value if still exist in dynamic field configuration
868    for my $Key ( sort keys %{$ColumnFilterValues} ) {
869        if ( $SelectionData->{$Key} ) {
870            $ColumnFilterValues->{$Key} = $SelectionData->{$Key};
871        }
872    }
873
874    # translate the value
875    for my $ValueKey ( sort keys %{$ColumnFilterValues} ) {
876
877        my $OriginalValueName = $ColumnFilterValues->{$ValueKey};
878        $ColumnFilterValues->{$ValueKey} = $Param{LayoutObject}->{LanguageObject}->Translate($OriginalValueName);
879    }
880
881    return $ColumnFilterValues;
882}
883
8841;
885
886=head1 TERMS AND CONDITIONS
887
888This software is part of the OTRS project (L<https://otrs.org/>).
889
890This software comes with ABSOLUTELY NO WARRANTY. For details, see
891the enclosed file COPYING for license information (GPL). If you
892did not receive this file, see L<https://www.gnu.org/licenses/gpl-3.0.txt>.
893
894=cut
895