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