ITSM-CIAttributeCollection 1.9.4 c.a.p.e. IT GmbH http://www.cape-it.de/ GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007 Bugfix: T2011111699000048 (import/export encrypted text), T2011102490000247 (check encrypted text), T2011102490000238 (attribute DummyX), T2011102890000311 (autocomplete for sub-attributes), T2011102490000229 (AgentITSMConfigItemEdit.dtl). CR: T2011101290000242 (added attribute text link). Bugfix: T2011091690000149 encrypted text. Bugfix: missing DataRef in Kernel::System::CIAttachmentStorage::AttachmentStorageFS::AttachmentGet, S2011081999000031 (Linkadd in Event CIClassReference), S2011081999000031 (JS for AutoComplete). CR: changed install information according to new standard in OTRS 3, new CI-Attribute "EncryptedText". ITSM-CIAttributeCollection - provides additional CI-attributes. ITSM-CIAttributeCollection - stellt zusaetzliche CI-Attribute bereit. 3.0.x WELCOME You are about to install the OTRS module ITSM-CIAttributeCollection. This package provides additional CI-attribute types. Please note, that due to missing functionality it is required to modify an existing file of another package. Therefore, after installation ITSMConfigurationManagement will be shown as corrupt. This modification is essential for use of the CI-attachment functionality. If you update or restore ITSMConfigurationManagement you won't be able to upload new attachments to config items anymore. You can fix this by reinstalling this package. Required OTRS Packages: <ul> <li>ITSMConfigutrationManagement 3.0.4 or higher</li> </ul> Required Perl Packages: <ul> <li>Digest::MD5</li> <li>Encode</li> </ul> c.a.p.e. IT ...easy. The package has been installed. Your configuration has been changed NOTICE (1) Verify the installation and check your OTRS-SysLog. (2) If your OTRS-ITSM Configuration Management Package is now marked as not properly installed. As mentioned before, there's no need to worry. In order to keep ITSM-CIAttribute functionality you must not reinstall ITSMConfigItem! (3) Please see OTRS_HOME/doc/en/USAGE_itsm-ciattributecollection.pod or USAGE_itsm-ciattributecollection.html for documentation. c.a.p.e. IT ...easy. WELCOME You are about to UNINSTALL the ITSM-CIAttributeCollection extensions package for OTRS. c.a.p.e. IT ...easy. WELCOME You are about to upgrade the ITSM-CIAttributeCollection extensions package for OTRS. c.a.p.e. IT ...easy. ITSMConfigurationManagement my $FunctionName = 'CodeInstall'; my $ModuleName = $Param{Structure}->{Name}->{Content}; $ModuleName =~ s/-/_/g; my $CodeModule = 'var::packagesetup::' . $ModuleName; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUpgrade'; my $ModuleName = $Param{Structure}->{Name}->{Content}; $ModuleName =~ s/-/_/g; my $CodeModule = 'var::packagesetup::' . $ModuleName; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUninstall'; my $ModuleName = $Param{Structure}->{Name}->{Content}; $ModuleName =~ s/-/_/g; my $CodeModule = 'var::packagesetup::' . $ModuleName; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeReinstall'; my $ModuleName = $Param{Structure}->{Name}->{Content}; $ModuleName =~ s/-/_/g; my $CodeModule = 'var::packagesetup::' . $ModuleName; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } 2011-11-17 13:04:25 cvs.intra.cape-it.de # --
# CHANGES_ITSM-CIAttributeCollection - change log of ITSM-CIAttributeCollection
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de/
# --
# $Id: CHANGES_ITSM-CIAttributeCollection,v 1.69 2011-11-17 12:03:06 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
#
#-------------------- 1.9.4 (2011/11/17) ---------------------------------------
# * (2011/11/17) - Bugfix: T2011111699000048 (import/export encrypted text) (smehlig)
# * (2011/11/14) - Bugfix: T2011102490000247 (check encrypted text) (ddoerffel)
# * (2011/11/14) - Bugfix: T2011102490000238 (attribute DummyX) (ddoerffel)
# * (2011/10/28) - Bugfix: T2011102890000311 (autocomplete for sub-attributes) (maba)
# * (2011/10/25) - Bugfix: T2011102490000229 (AgentITSMConfigItemEdit.dtl) (tto)
#
#-------------------- 1.9.3 (2011/10/13) ---------------------------------------
# * (2011/10/13) - CR: T2011101290000242 added attribute text link (smehlig)
#
#-------------------- 1.9.2 (2011/09/19) ---------------------------------------
# * (2011/09/19) - Bugfix: T2011091690000149 encrypted text (smehlig)
#
#-------------------- 1.9.1 (2011/09/05) ---------------------------------------
# * (2011/09/05) - Bugfix: S2011081999000031 (JS for AutoComplete) (maba)
# * (2011/08/26) - Bugfix: S2011081999000031 (Linkadd in Event CIClassReference) (smehlig)
# * (2011/08/17) - Bugfix: missing DataRef in Kernel::System::CIAttachmentStorage::AttachmentStorageFS::AttachmentGet (tto)
#
#-------------------- 1.9.0 (2011/08/05) ---------------------------------------
# * (2011/08/05) - CR: changed install information according to new standard in OTRS 3 (maba)
# * (2011/08/01) - CR: new CI-Attribute "EncryptedText" (smehlig)
#
#-------------------- 1.8.6 (2011/07/25) ---------------------------------------
# * (2011/07/25) - CR: changes for perl critic (smehlig)
# * (2011/07/25) - Bugfix: use of not existing object in AttachmentStorage.pm (smehlig)
# * (2011/07/22) - Bugfix: added check for EncodeObject to AgentAttachmentStorage (tto)
# * (2011/07/18) - Bugfix: added missing option in AgentConfigItemEdit for dis/enabling CIAttachment check (size + md5) (tto)
#
#-------------------- 1.8.5 (2011/07/18) ---------------------------------------
# * (2011/07/18) - CR: added sysconfig option for dis/enabling CIAttachment check (size + md5) (tto)
# * (2011/07/18) - Bugfix: croak in md5_hex whil caluclating md5-sum (tto)
# * (2011/06/14) - Bugfix: use of not existing object in Kernel::System::ITSMConfigItem::XML::Type::CIAttachment (tto)
# * (2011/05/19) - CR: added translations to dtl for AgentITSMConfigItemEdit (if KIXCore is used) (tto)
#
#-------------------- 1.8.4 (2011/05/10) ---------------------------------------
# * (2011/05/10) - Bugfix: T2011051090000292 (missing conversion for ex-/import of service- and user attributes)
# * (2011/05/05) - CR: added script to check perl module dependencies 
# * (2011/04/28) - Bugfix: T2011041890002321 (debug output caused index.pl to be downloaded if attribute type CustomerUserCompany is used)
#
#-------------------- 1.8.3 (2011/04/18) ---------------------------------------
# * (2011/04/18) - Bugfix: wrong return value in backend CustomerUserCompany
# * (2011/04/18) - Bugfix: missing "common" wildcard replacement to Perl-regexp in AgentQueueSearch
# * (2011/04/18) - Bugfix: use of undeclared variable in ITSMConfigItemLayoutCustomerUserCompany
# * (2011/04/18) - Bugfix: type in pod-documentation
#
#-------------------- 1.8.2 (2011/04/18) ---------------------------------------
# * (2011/04/15) - Bugfix: wide character print error in md5 caused software error (missing UTF8-encode)
# * (2011/04/13) - CR: added pod- and html documentation for User/CustomerCompany/CustomerUserCompany
# * (2011/04/13) - CR: removed HTML-version of documentation
# * (2011/03/30) - CR: modify AgentITSMConfigItemEdit.dtl only if KIXCore is not installed/available
# * (2011/03/30) - CR: added autocomplete functionality for Customer(User)Company
# * (2011/03/29) - Bugfix: fixed wrong groups in configuration 
# * (2011/03/18) - Bugfix: fixed pod-error
#
#-------------------- 1.8.1 (2011/03/18) ---------------------------------------
# * (2011/03/18) - CR: added pod- and html documentation
# * (2011/03/17) - Bugfix: added search for referenced CIclass CI-number
# * (2011/03/16) - Bugfix: added search for referenced CIclass CI-name
# * (2011/03/16) - Bugfix: added missing stats- and im-/export methods to XML::Type::CIAttachment
# * (2011/03/16) - Bugfix: added session ID to CIattachment-download link
# * (2011/03/14) - CR: changed SysConfig to framework 3.0
# * (2011/03/14) - CR: added pre-installation note and required Perl-package
#
#-------------------- 1.8.0 (2011/03/14) ---------------------------------------
# * (2011/03/14) - CR: new CI-Attribute "CIAttachment"
# * (2011/02/22) - CR: added documentation
# * (2011/02/22) - CR: added autocomplete functionality for Queue, Service and CIClass
# * (2011/02/22) - CR: added new attribut QueueReference
#
# NOTE: further 1.6.x + 1.7.x CRs/bugfixes (OTRS 2.4.x) contained in branch 1.6
#
#-------------------- 1.6.0 (2011/02/15) ---------------------------------------
# * (2011/02/15) - CR: added documentation for ServiceReference usage, removed STDERR-print
# * (2011/02/14) - CR: make ServiceReference, CIClassReference searchable in AgentITSMConfigItemSearch
# * (2011/02/08) - CR: added new attribut ServiceReference
#
#-------------------- 1.5.0 (2010/07/01) ---------------------------------------
# * (2010/07/01) - CR: added new attribut CIClassReference as a more general approach than CICostCenter/CILocation
# * (2010/07/01) - CR: set new default - disabled events for link update (CICostCenter, CILocation)
#
#-------------------- 1.4.5 (2010/05/30) ---------------------------------------
# * (2010/05/30) - CR: replaced use of CiCSUtilsObject->GetLinkedObjects to LinkObject->GetLinkedObjects
#
#-------------------- 1.4.4 (2010/03/15) ---------------------------------------
# * (2010/03/15) - Bugfix:  added missing file
#
#-------------------- 1.4.3 (2010/03/15) ---------------------------------------
# * (2010/03/15) - Bugfix:  added missing encode object
# * (2010/01/18) - CR:  added CI-number to CostCenter-attribute presentation
# * (2010/01/08) - Bugfix:  improved error handling in CI-Events (CC & location)
# * (2010/01/08) - Bugfix:  re-added missing config option 
#                  CILocationLinkRemoveLinksToOtherCIs
# * (2010/01/08) - Bugfix:  fixed methods ExportValuePrepare, 
#                  ImportSearchValuePrepare, ImportValuePrepare for CICostCenter
#                  and CILocation
# * (2009/01/08) - new CI-Attribute "CICostCenter"
#
#-------------------- 1.4.2 (2009/11/25) ---------------------------------------
# * (2009/11/25) - Bugfix: changed SearchString for LDAP 
#
#-------------------- 1.4.1 (2009/11/21) ---------------------------------------
# * (2009/11/13) - Bugfix: changed method for search of CustomerID(Company) - 
#
#-------------------- 1.4.0 (2009/10/21) ---------------------------------------
# * (2009/10/21) - CR: add searchfield for CustomerID(Company)
# * (2009/10/20) - CR: initial import for OTRS 2.4.x
#
#-------------------- 1.3.0 (2009/07/15) ---------------------------------------
# * (2009/07/15) - CR: add BackendMapping for User and CustomerCompany
# * (2009/07/13) - CR: new CIAttribute User and CustomerCompany
#
#-------------------- 1.2.0 (2009/07/10) ---------------------------------------
# * (2009/07/10) - CR: remove links to other CIs if specified CIlocation is set
#
#
#-------------------- 1.1.0 (2009/04/01) ---------------------------------------
# * (2009/04/01) - CR: new CI-Attribute "CILocation"
# * (2009/04/02) - CR: new CI-Event for automatic update of links from/to CI-
#                  location
#
#
#-------------------- 1.0.3 (2009/02/26) ---------------------------------------
# * (2009/02/26) - CR: new CI-Attribute "DummyX"
# * (way ago)    - CR: new package
#
#
#------------------------ no content below this line ---------------------------
 # --
# AgentITSMConfigItemEdit.dtl - provides HTML form for AgentITSMConfigItemEdit
# Copyright (C) 2001-2011 OTRS AG, http://otrs.org/
# Extensions Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
#
# --
# $Id: AgentITSMConfigItemEdit.dtl,v 1.4 2011-10-28 22:28:37 maba Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

<!--dtl:block:StartNormal-->
<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarLast">
# KIX4OTRS-capeIT
#    <h1>$Text{"Edit"}: $Text{"Config Item"}: $QData{"Number"} - $Text{"Class"}: $QData{"Class"}</h1>
    <h1>$Text{"Edit"}: $Text{"Config Item"}: $Text{"$QData{"Number"}"} - $Text{"Class"}: $Text{"$QData{"Class"}"}</h1>
# EO KIX4OTRS-capeIT
    <div class="ContentColumn">
<!--dtl:block:StartNormal-->
$Include{"AgentITSMCustomerSearch"}
# KIX4OTRS-capeIT
#        <form action="$Env{"CGIHandle"}" method="post" name="ClassItem" class="Validate PreventMultipleSubmits" id="ClassItem">
         <form action="$Env{"CGIHandle"}" method="post" name="ClassItem" class="Validate PreventMultipleSubmits" id="ClassItem" enctype="multipart/form-data">
# EO KIX4OTRS-capeIT
<!--dtl:block:StartSmall-->
            <div class="LayoutPopup ARIARoleMain">
                <div class="Header">
# KIX4OTRS-capeIT
#                    <h1>$Text{"Edit"}: $Text{"Config Item"}: $QData{"Number"} - $Text{"Class"}: $QData{"Class"}</h1>
                    <h1>$Text{"Edit"}: $Text{"Config Item"}: $QData{"Number"} - $Text{"Class"}: $Text{"$Data{"Class"}"}</h1>
# EO KIX4OTRS-capeIT
                    <p>
                        <a class="CancelClosePopup" href="#">$Text{"Cancel & close window"}</a>
                    </p>
                </div>
                <input type="hidden" name="ScreenType" value="Popup"/>
<!--dtl:block:StartSmall-->
                <div class="Content">
                    <input type="hidden" name="Action" value="$Env{"Action"}"/>
                    <input type="hidden" name="Subaction" value="VersionSave"/>
                    <input type="hidden" name="ClassID" value="$QData{"ClassID"}"/>
                    <input type="hidden" name="ConfigItemID" value="$QData{"ConfigItemID"}"/>
# KIX4OTRS-capeIT
<!-- dtl:block:PlausiCheckNote -->
                      <div class="MessageBox Notice">
                          <p>$Text{"$Data{"Text"}"}&nbsp;$Data{"Code"}</p>
                      </div>
<!-- dtl:block:PlausiCheckNote -->
# EO KIX4OTRS-capeIT
                    <fieldset class="TableLike">
<!-- dtl:block:RowName -->
                        <label class="Mandatory" for="Name"><span class="Marker">*</span> $Text{"Name"}: </label>
                        <div class="Field">
                            <input type="text" name="Name" id="Name" class="W50pc Validate_Required $QData{"RowNameInvalid"}" maxlength="250" value="$QData{"Name"}" title="$Text{"The name of this config item"}"/>
                            <div id="NameError" class="TooltipErrorMessage" ><p>$Text{"This field is required."}</p></div>
                            <div id="NameServerError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                        </div>
                        <div class="Clear"></div>
<!-- dtl:block:RowName -->
<!-- dtl:block:RowDeplState -->
                        <label class="Mandatory" for="DeplStateID"><span class="Marker">*</span> $Text{"Deployment State"}: </label>
                        <div class="Field">
                            $Data{"DeplStateOptionStrg"}
                            <div id="DeplStateIDError" class="TooltipErrorMessage" ><p>$Text{"This field is required."}</p></div>
                            <div id="DeplStateIDServerError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                        </div>
                        <div class="Clear"></div>
<!-- dtl:block:RowDeplState -->
<!-- dtl:block:RowInciState -->
                        <label class="Mandatory" for="InciStateID"><span class="Marker">*</span> $Text{"Incident State"}: </label>
                        <div class="Field">
                            $Data{"InciStateOptionStrg"}
                            <div id="InciStateIDError" class="TooltipErrorMessage" ><p>$Text{"This field is required."}</p></div>
                            <div id="InciStateIDServerError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                        </div>
                        <div class="Clear"></div>
<!-- dtl:block:RowInciState -->
                    </fieldset>

<!-- dtl:block:XMLRow -->
<!-- dtl:block:XMLRowFieldsetStart -->
                    <fieldset class="TableLike">
<!-- dtl:block:XMLRowFieldsetStart -->
<!-- dtl:block:XMLRowValue -->
                        <label $Data{"LabelClass"} $Data{"LabelFor"}>
<!-- dtl:block:XMLRowValueContentRequired -->
                            <span class="Marker">*</span>
<!-- dtl:block:XMLRowValueContentRequired -->
                            $Text{"$Data{"Name"}"}:
                        </label>
                        <div class="$Data{"Class"} Field">
                            $Data{"InputString"}
<!-- dtl:block:XMLRowValueContentDelete -->
                            <button class="DisableValidation Remove" type="submit" name="$QData{"InputKey"}::Delete" value="$Text{"Delete"}">$Text{"Delete"}</button>
<!-- dtl:block:XMLRowValueContentDelete -->
                            <div id="$QData{"ItemID"}Error" class="TooltipErrorMessage" ><p>$Text{"This field is required."}</p></div>
                            <div id="$QData{"ItemID"}ServerError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                        </div>
<!-- dtl:block:XMLRowValue -->

<!-- dtl:block:XMLRowAddContent -->
                        <label $Data{"Class"} for="$QData{"ItemID"}">$Text{"$Data{"Name"}"}: </label>
                        <div class="Field">
                            <button class="DisableValidation Add" id="$QData{"ItemID"}" type="submit" name="$QData{"InputKey"}::Add" value="$Text{"Add"}" title="$Text{"$Data{"Description"}"}" ></button>
                        </div>
<!-- dtl:block:XMLRowAddContent -->

<!-- dtl:block:XMLRowFieldsetEnd -->
                    </fieldset>
<!-- dtl:block:XMLRowFieldsetEnd -->
<!-- dtl:block:XMLRow -->
                    <fieldset class="TableLike">
                        <div class="Field SpacingTop">
                            <button name="SubmitSave" class="Primary" type="submit" value="$Text{"Save"}">$Text{"Submit"}</button>
                        </div>
                    </fieldset>
                </div>

<!-- dtl:block:EndSmall -->
            </div>
<!-- dtl:block:EndSmall -->
        </form>
<!-- dtl:block:EndNormal -->
    </div>
    <div class="Clear"></div>
</div>
<!-- dtl:block:EndNormal -->


<!-- dtl:js_on_document_complete -->
        <script type="text/javascript">//<![CDATA[
            $('.DisableValidation').bind('click', function (Event) {
                Core.Form.Validate.DisableValidation($('#ClassItem'));
                // fix for Safari: race condition with submit in Core.Form.Validate.js
                // fixed in OTRS 3.0.5, this line remains here for backwards compatibility reasons
                $('#ClassItem').removeClass('PreventMultipleSubmits');
            });
        //]]></script>
<!-- dtl:js_on_document_complete -->
 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 IyAtLQojIEtlcm5lbC9Nb2R1bGVzL0FnZW50QXR0YWNobWVudFN0b3JhZ2UucG0gLSB0byBnZXQgdGhlIGF0dGFjaG1lbnRzCiMgQ29weXJpZ2h0IChDKSAyMDA2LTIwMTEgYy5hLnAuZS4gSVQgR21iSCwgaHR0cDovL3d3dy5jYXBlLWl0LmRlCiMKIyB3cml0dGVuL2VkaXRlZCBieToKIyAqIFRvcnN0ZW4oZG90KVRoYXUoYXQpY2FwZS1pdChkb3QpZGUKIyAqIEFubmEoZG90KUxpdHZpbm92YShhdCljYXBlLWl0KGRvdClkZQojIC0tCiMgJElkOiBBZ2VudEF0dGFjaG1lbnRTdG9yYWdlLnBtLHYgMS40IDIwMTEtMDctMjUgMDk6MDE6MzMgc21laGxpZyBFeHAgJAojIC0tCiMgVGhpcyBzb2Z0d2FyZSBjb21lcyB3aXRoIEFCU09MVVRFTFkgTk8gV0FSUkFOVFkuIEZvciBkZXRhaWxzLCBzZWUKIyB0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChHUEwpLiBJZiB5b3UKIyBkaWQgbm90IHJlY2VpdmUgdGhpcyBmaWxlLCBzZWUgaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC50eHQuCiMgLS0KCnBhY2thZ2UgS2VybmVsOjpNb2R1bGVzOjpBZ2VudEF0dGFjaG1lbnRTdG9yYWdlOwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEtlcm5lbDo6U3lzdGVtOjpDSUF0dGFjaG1lbnRTdG9yYWdlOjpBdHRhY2htZW50U3RvcmFnZTsKCnVzZSB2YXJzIHF3KCRWRVJTSU9OKTsKJFZFUlNJT04gPSBxdygkUmV2aXNpb246IDEuNCAkKSBbMV07Cgo9aGVhZDEgTkFNRQoKS2VybmVsOjpNb2R1bGVzOjpBZ2VudEF0dGFjaG1lbnRTdG9yYWdlIC0gZnJvbnRlbmQgbW9kdWxlIGZvciBhY2Nlc3MgdG8gYXR0YWNobWVudHMKCj1oZWFkMSBTWU5PUFNJUwoKQSBmcm9udGVuZCBtb2R1bGUgd2hpY2ggcHJvdmlkZXMgc3lzdGVtIHVzZXJzIGFjY2VzcyB0byBzdG9yZWQgYXR0YWNobWVudHMuCgo9b3ZlciA0Cgo9Y3V0Cgo9aXRlbSBuZXcoKQoKY3JlYXRlIGEgb2JqZWN0CgogICAgdXNlIEtlcm5lbDo6Q29uZmlnOwogICAgdXNlIEtlcm5lbDo6U3lzdGVtOjpMb2c7CiAgICB1c2UgS2VybmVsOjpTeXN0ZW06OkRCOwogICAgdXNlIEtlcm5lbDo6U3lzdGVtOjpDSUF0dGFjaG1lbnRTdG9yYWdlOjpBdHRhY2htZW50U3RvcmFnZTsKCiAgICBteSAkQXR0YWNobWVudFN0b3JhZ2VPYmplY3QgPSBLZXJuZWw6Ok1vZHVsZXM6OkFnZW50QXR0YWNobWVudFN0b3JhZ2UtPm5ldygKICAgICAgICBQYXJhbU9iamVjdCAgPT4gJFBhcmFtT2JqZWN0LAogICAgICAgIERCT2JqZWN0ICA9PiAkREJPYmplY3QsCiAgICAgICAgTGF5b3V0T2JqZWN0ICA9PiAkTGF5b3V0T2JqZWN0LAogICAgICAgIExvZ09iamVjdCAgPT4gJExvZ09iamVjdCwKICAgICAgICBDb25maWdPYmplY3QgPT4gJENvbmZpZ09iamVjdCwKICAgICk7Cgo9Y3V0CgpzdWIgbmV3IHsKICAgIG15ICggJFR5cGUsICVQYXJhbSApID0gQF87CiAgICBteSAkU2VsZiA9IHt9OwogICAgYmxlc3MoICRTZWxmLCAkVHlwZSApOwoKICAgIGZvcmVhY2ggKCBrZXlzICVQYXJhbSApIHsKICAgICAgICAkU2VsZi0+eyRffSA9ICRQYXJhbXskX307CiAgICB9CgogICAgI2NoZWNrIHJlcXVpcmVkIG9iamVjdHMuLi4KICAgIGZvcmVhY2ggKHF3KFBhcmFtT2JqZWN0IERCT2JqZWN0IExheW91dE9iamVjdCBMb2dPYmplY3QgQ29uZmlnT2JqZWN0IEVuY29kZU9iamVjdCkpIHsKICAgICAgICBpZiAoICEkU2VsZi0+eyRffSApIHsKICAgICAgICAgICAgJFNlbGYtPntMYXlvdXRPYmplY3R9LT5GYXRhbEVycm9yKCBNZXNzYWdlID0+ICJHb3Qgbm8gJF8hIiApOwogICAgICAgIH0KICAgIH0KCiAgICAkU2VsZi0+e0F0dGFjaG1lbnRTdG9yYWdlT2JqZWN0fSA9CiAgICAgICAgS2VybmVsOjpTeXN0ZW06OkNJQXR0YWNobWVudFN0b3JhZ2U6OkF0dGFjaG1lbnRTdG9yYWdlLT5uZXcoICV7JFNlbGZ9ICk7CgogICAgI2dldCBBdHRhY2htZW50RGlyZWN0b3J5SUQuLi4KICAgICRTZWxmLT57QXR0YWNobWVudERpcmVjdG9yeUlEfSA9CiAgICAgICAgJFNlbGYtPntQYXJhbU9iamVjdH0tPkdldFBhcmFtKCBQYXJhbSA9PiAnQXR0YWNobWVudERpcmVjdG9yeUlEJyApOwogICAgJFNlbGYtPntWaWV3ZXJ9ID0gJFNlbGYtPntQYXJhbU9iamVjdH0tPkdldFBhcmFtKCBQYXJhbSA9PiAnVmlld2VyJyApIHx8IDA7CgogICAgcmV0dXJuICRTZWxmOwp9CgpzdWIgUnVuIHsKICAgIG15ICggJFNlbGYsICVQYXJhbSApID0gQF87CiAgICBteSAkT3V0cHV0ICA9ICcnOwogICAgbXkgJEFsbG93ZWQgPSAxOwoKICAgICNjaGVjayBwYXJhbXMuLi4KICAgIGlmICggISRTZWxmLT57QXR0YWNobWVudERpcmVjdG9yeUlEfSApIHsKICAgICAgICAkU2VsZi0+e0xvZ09iamVjdH0tPkxvZygKICAgICAgICAgICAgTWVzc2FnZSAgPT4gJ0F0dGFjaG1lbnREaXJlY3RvcnlJRCBpcyBuZWVkZWQhJywKICAgICAgICAgICAgUHJpb3JpdHkgPT4gJ2Vycm9yJywKICAgICAgICApOwogICAgICAgIHJldHVybiAkU2VsZi0+e0xheW91dE9iamVjdH0tPkVycm9yU2NyZWVuKCk7CiAgICB9CgogICAgI2dldCB0aGUgYXR0YWNobWVudC4uLgogICAgbXkgJUF0dGFjaG1lbnREYXRhID0gJXsKICAgICAgICAkU2VsZi0+e0F0dGFjaG1lbnRTdG9yYWdlT2JqZWN0fS0+QXR0YWNobWVudFN0b3JhZ2VHZXQoCiAgICAgICAgICAgIElEID0+ICRTZWxmLT57QXR0YWNobWVudERpcmVjdG9yeUlEfSwKICAgICAgICAgICAgKQogICAgICAgIH07CgogICAgaWYgKCVBdHRhY2htZW50RGF0YSkgewogICAgICAgICRBdHRhY2htZW50RGF0YXtDb250ZW50fSAgICAgPSAkeyAkQXR0YWNobWVudERhdGF7Q29udGVudFJlZn0gfTsKICAgICAgICAkQXR0YWNobWVudERhdGF7RmlsZW5hbWV9ICAgID0gJEF0dGFjaG1lbnREYXRhe0ZpbGVOYW1lfTsKICAgICAgICAkQXR0YWNobWVudERhdGF7Q29udGVudFR5cGV9ID0gJEF0dGFjaG1lbnREYXRhe1ByZWZlcmVuY2VzfS0+e0RhdGFUeXBlfTsKICAgICAgICByZXR1cm4gJFNlbGYtPntMYXlvdXRPYmplY3R9LT5BdHRhY2htZW50KCVBdHRhY2htZW50RGF0YSk7CgogICAgfQogICAgZWxzZSB7CiAgICAgICAgJFNlbGYtPntMb2dPYmplY3R9LT5Mb2coCiAgICAgICAgICAgIE1lc3NhZ2UgID0+ICJObyBzdWNoIGF0dGFjaG1lbnQgaW4gZGlyZWN0b3J5IGluZGV4ICgkU2VsZi0+e0F0dGFjaG1lbnREaXJlY3RvcnlJRH0pISAiLAogICAgICAgICAgICBQcmlvcml0eSA9PiAnZXJyb3InLAogICAgICAgICk7CiAgICAgICAgcmV0dXJuICRTZWxmLT57TGF5b3V0T2JqZWN0fS0+RXJyb3JTY3JlZW4oKTsKICAgIH0KfQoKMTsK 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 IyAtLQojIEFnZW50UXVldWVTZWFyY2guZHRsIC0gcHJvdmlkZXMgYXV0b2NvbXBsZXRlIGZlYXR1cmUgZm9yIHF1ZXVlIHNlYXJjaAojIENvcHlyaWdodCAoQykgMjAwNi0yMDExIGMuYS5wLmUuIElUIEdtYkgsIGh0dHA6Ly93d3cuY2FwZS1pdC5kZQojCiMgd3JpdHRlbi9lZGl0ZWQgYnk6CiMgKiBGcmFuayhkb3QpT2JlcmVuZGVyKGF0KWNhcGUoZGFzaClpdChkb3QpZGUKIyAqIE1hcnRpbihkb3QpQmFsemFyZWsoYXQpY2FwZShkYXNoKWl0KGRvdClkZQojCiMgLS0KIyAkSWQ6IEFnZW50UXVldWVTZWFyY2guZHRsLHYgMS4yIDIwMTEtMDktMDUgMTA6MDU6MTggbWFiYSBFeHAgJAojIC0tCiMgVGhpcyBzb2Z0d2FyZSBjb21lcyB3aXRoIEFCU09MVVRFTFkgTk8gV0FSUkFOVFkuIEZvciBkZXRhaWxzLCBzZWUKIyB0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChBR1BMKS4gSWYgeW91CiMgZGlkIG5vdCByZWNlaXZlIHRoaXMgZmlsZSwgc2VlIGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy9hZ3BsLnR4dC4KIyAtLQoKPCEtLSBkdGw6YmxvY2s6UXVldWVTZWFyY2hBdXRvQ29tcGxldGUgLS0+CjwhLS0gZHRsOmpzX29uX2RvY3VtZW50X2NvbXBsZXRlIC0tPgo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+Ly88IVtDREFUQVsKICAgIENvcmUuQ29uZmlnLlNldCgnUXVldWVBdXRvY29tcGxldGUuTWluUXVlcnlMZW5ndGgnLCAiJFFEYXRheyJtaW5RdWVyeUxlbmd0aCJ9Iik7CiAgICBDb3JlLkNvbmZpZy5TZXQoJ1F1ZXVlQXV0b2NvbXBsZXRlLlF1ZXJ5RGVsYXknLCAiJFFEYXRheyJxdWVyeURlbGF5In0iKTsKICAgIENvcmUuQ29uZmlnLlNldCgnUXVldWVBdXRvY29tcGxldGUuTWF4UmVzdWx0c0Rpc3BsYXllZCcsICIkUURhdGF7Im1heFJlc3VsdHNEaXNwbGF5ZWQifSIpOwogICAgQ29yZS5Db25maWcuU2V0KCdRdWV1ZUF1dG9jb21wbGV0ZS5EeW5hbWljV2lkdGgnLCAiJFFEYXRheyJkeW5hbWljV2lkdGgifSIpOwogICAgQ29yZS5Db25maWcuU2V0KCdRdWV1ZUF1dG9jb21wbGV0ZS5TZWFyY2hCdXR0b25UZXh0JywgIiRKU1RleHR7IlNlYXJjaCBRdWV1ZSJ9Iik7Ci8vXV0+PC9zY3JpcHQ+Cgo8IS0tIGR0bDpibG9jazpRdWV1ZVNlYXJjaEluaXQgLS0+CjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4vLzwhW0NEQVRBWwogICAgdmFyIEZpZWxkSUQgPSAnJFFEYXRheyJJdGVtSUQifSc7CiAgICBGaWVsZElEID0gRmllbGRJRC5yZXBsYWNlKC86L2csICdcXDonKTsKICAgIENvcmUuQWdlbnQuUXVldWVTZWFyY2guSW5pdCgkKCIjIitGaWVsZElEKSwgJFFEYXRheyJBY3RpdmVBdXRvQ29tcGxldGUifSk7Ci8vXV0+PC9zY3JpcHQ+CjwhLS0gZHRsOmJsb2NrOlF1ZXVlU2VhcmNoSW5pdCAtLT4KCjwhLS0gZHRsOmpzX29uX2RvY3VtZW50X2NvbXBsZXRlIC0tPgo8IS0tIGR0bDpibG9jazpRdWV1ZVNlYXJjaEF1dG9Db21wbGV0ZSAtLT4KCg== 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 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutCustomerCompany.pm - layout backend module
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# Extensions Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape-it(dot)de
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Frank(dot)Oberender(at)cape-it(dot)de
#
# --
# $Id: ITSMConfigItemLayoutCustomerCompany.pm,v 1.10 2011-04-18 07:53:49 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutCustomerCompany;

use strict;
use warnings;

use Kernel::System::CustomerCompany;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.10 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutCustomerCompany - layout backend module

=head1 SYNOPSIS

All layout functions of CustomerCompany objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutCustomerCompany->new(
        %Param,
    );

=cut

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

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

    # check needed objects
    for my $Object (
        qw(ConfigObject LogObject MainObject ParamObject TimeObject DBObject LayoutObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    $Self->{CustomerCompanyObject} = Kernel::System::CustomerCompany->new( %{$Self} );

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    # transform ascii to html
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    # get selected CustomerCompany
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    # check search button
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    # check select button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    # check clear button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        # reset value if search field is emty
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        # check required option
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }
    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $Search       = '';
    my $StringOption = '';
    my $StringSelect = '';
    my $Class        = 'W50pc CustomerCompanySearch';
    my $Required     = $Param{Required} || '';
    my $Invalid      = $Param{Invalid} || '';
    my $ItemId       = $Param{ItemId} || '';

    # CustomerCompany search
    if ( $Param{Item}->{Form}->{ $Param{Key} }->{Search} ) {
        my @SearchArray = split( ' ', $Param{Item}->{Form}->{ $Param{Key} }->{Search} );
        my $SearchString = join( '+', @SearchArray );

        # start search
        my %CustomerCompanySearchList = $Self->{CustomerCompanyObject}->CustomerCompanyList(
            Search => '*' . $SearchString . '*',
        );

        if ( %CustomerCompanySearchList && scalar( keys %CustomerCompanySearchList ) > 1 ) {

            # create option list
            $StringOption = $Self->{LayoutObject}->BuildSelection(
                Name => $Param{Key} . '::Select',
                Data => \%CustomerCompanySearchList,
            );
            $StringOption .= '<br>';

            # create select button
            $StringSelect = '<input class="button" type="submit" name="'
                . $Param{Key}
                . '::ButtonSelect" '
                . 'value="$Text{"Select"}">&nbsp;';

            # set search
            $Search = $Param{Item}->{Form}->{ $Param{Key} }->{Search};
        }
        elsif (%CustomerCompanySearchList) {

            # get CustomerCompany data
            $Value = ( keys %CustomerCompanySearchList )[0];
            my %CustomerCompanySearchList = $Self->{CustomerCompanyObject}->CustomerCompanyGet(
                CustomerID => $Value,
            );

# transform ascii to html
#$Search = $CustomerCompanySearchList{CustomerID}." ".$CustomerCompanySearchList{CustomerCompanyStreet}
#." ".$CustomerCompanySearchList{CustomerCompanyZIP}." ".$CustomerCompanySearchList{CustomerCompanyCity};
            my $CustCompanyMapRef =
                $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::CompanyBackendMapping');

            if ( $CustCompanyMapRef && ref($CustCompanyMapRef) eq 'HASH' ) {

                for my $MappingField ( sort( keys( %{$CustCompanyMapRef} ) ) ) {
                    if ( $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} } ) {
                        $Search .= ' '
                            . $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} };
                    }
                }

            }

            $Search =~ s/\s+$//g;
            $Search =~ s/^\s+//g;

        }
    }

    # create CustomerCompany string
    elsif ($Value) {

        # get CustomerCompany data
        my %CustomerCompanySearchList = $Self->{CustomerCompanyObject}->CustomerCompanyGet(
            CustomerID => $Value,
        );

# transform ascii to html
#$Search = $CustomerCompanySearchList{CustomerID}." ".$CustomerCompanySearchList{CustomerCompanyStreet}
#." ".$CustomerCompanySearchList{CustomerCompanyZIP}." ".$CustomerCompanySearchList{CustomerCompanyCity};
        my $CustCompanyMapRef =
            $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::CompanyBackendMapping');

        if ( $CustCompanyMapRef && ref($CustCompanyMapRef) eq 'HASH' ) {

            for my $MappingField ( sort( keys( %{$CustCompanyMapRef} ) ) ) {
                if ( $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} } ) {
                    $Search .= ' '
                        . $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} };
                }
            }

        }

        $Search =~ s/\s+$//g;
        $Search =~ s/^\s+//g;

    }

    # AutoComplete CIClass
    my $AutoCompleteConfig
        = $Self->{ConfigObject}
        ->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if (
        $AutoCompleteConfig
        && ref($AutoCompleteConfig) eq 'HASH'
        && $AutoCompleteConfig->{Active}
        )
    {

        $Self->{LayoutObject}->Block(
            Name => 'CustomerCompanySearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'CustomerCompanySearchInit',
            Data => {
                ItemID             => $ItemId,
                ActiveAutoComplete => 'true',
                }
        );

        $String
            = '$Include{"AgentCustomerCompanySearch"}'
            . '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Search . '"/>';
    }
    else {
        $String
            = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Search . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    # get form data
    #my @Values = $Self->{ParamObject}->GetArray( Param => $Param{Key} );

    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    return if scalar(@SearchValues) < 1 || !$SearchValues[0];

    my @Values = ();
    foreach my $SearchValue (@SearchValues) {
        my %CustomerCompanyList = $Self->{CustomerCompanyObject}->CustomerCompanyList(
            Search => '*' . $SearchValue . '*',
        );

        for my $CustomerCompanyID ( keys %CustomerCompanyList ) {
            push( @Values, $CustomerCompanyID );
        }
    }

    if ( scalar(@Values) < 1 || !$Values[0] ) {
        @Values = @SearchValues;
    }

    return \@Values;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"60\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.10 $ $Date: 2011-04-18 07:53:49 $

=cut
 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutCustomerUserCompany.pm - layout backend module
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# Extensions Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape-it(dot)de
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Frank(dot)Oberender(at)cape-it(dot)de
#
# --
# $Id: ITSMConfigItemLayoutCustomerUserCompany.pm,v 1.9 2011-04-18 08:08:13 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutCustomerUserCompany;

use strict;
use warnings;

use Kernel::System::CustomerUser;
use Kernel::System::CustomerCompany;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.9 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutCustomerUserCompany - layout backend module

=head1 SYNOPSIS

All layout functions of CustomerUserCompany objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutCustomerUserCompany->new(
        %Param,
    );

=cut

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

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

    # check needed objects
    for my $Object (
        qw(ConfigObject LogObject MainObject ParamObject TimeObject DBObject LayoutObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    $Self->{CustomerUserObject}    = Kernel::System::CustomerUser->new( %{$Self} );
    $Self->{CustomerCompanyObject} = Kernel::System::CustomerCompany->new( %{$Self} );

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    # transform ascii to html
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    # get selected CustomerUserCompany
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    # check search button
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    # check select button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    # check clear button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        # reset value if search field is emty
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        # check required option
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }
    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $StringOption = '';
    my $StringSelect = '';
    my $Class        = 'W50pc CustomerUserCompanySearch';
    my $Required     = $Param{Required} || '';
    my $Invalid      = $Param{Invalid} || '';
    my $ItemId       = $Param{ItemId} || '';

    # AutoComplete
    my $AutoCompleteConfig
        = $Self->{ConfigObject}
        ->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if (
        $AutoCompleteConfig
        && ref($AutoCompleteConfig) eq 'HASH'
        && $AutoCompleteConfig->{Active}
        )
    {

        $Self->{LayoutObject}->Block(
            Name => 'CustomerUserCompanySearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'CustomerUserCompanySearchInit',
            Data => {
                ItemID             => $ItemId,
                ActiveAutoComplete => 'true',
                }
        );

        $String
            = '$Include{"AgentCustomerUserCompanySearch"}'
            . '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Value . '"/>';
    }
    else {
        $String
            = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Value . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    # get form data
    #my @Values = $Self->{ParamObject}->GetArray( Param => $Param{Key} );
    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    my @Values = ();
    for my $SearchValue (@SearchValues) {
        next if !$SearchValue;

        # start search
        my %CustomerUserSearchList = $Self->{CustomerUserObject}->CustomerSearch(
            Search => $SearchValue,
        );
        for my $keys ( keys %CustomerUserSearchList ) {
            my @CustomerIDs = $Self->{CustomerUserObject}->CustomerIDs(
                User => $keys,
            );

            push( @Values, $CustomerIDs[0] );
        }
    }

    if ( scalar(@Values) < 1 || !$Values[0] ) {
        @Values = @SearchValues;
    }

    return \@Values;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"60\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.9 $ $Date: 2011-04-18 08:08:13 $

=cut
 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 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutEncryptedText.pm - layout backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape(dash)it(dot)de
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
#
# --
# $Id: ITSMConfigItemLayoutEncryptedText.pm,v 1.4 2011-11-14 12:55:52 ddoerffel Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutEncryptedText;

use strict;
use warnings;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.4 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutText - layout backend module

=head1 SYNOPSIS

All layout functions of text objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutText->new(
        %Param,
    );

=cut

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

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

    # check needed objects
    for my $Object (
        qw(ConfigObject EncodeObject LogObject MainObject ParamObject LayoutObject DBObject UserID)
        )
    {
        $Self->{$Object} = $Param{$Object}
            || die "ITSMConfigItemLayoutEncryptedText: Got no $Object!";
    }

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Item} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Item!',
        );
        return;
    }

    if ( !defined $Param{Value} ) {
        $Param{Value} = '';
    }

    my $GroupsRef = $Param{Item}->{Group};
    my @Groups    = ();
    if ( $GroupsRef && ref $GroupsRef eq 'HASH' ) {
        @Groups = keys %{$GroupsRef};
    }

    my $Access = 0;
    for my $Group (@Groups) {

        next
            if (
            !$Self->{LayoutObject}->{"UserIsGroup[$Group]"}
            || $Self->{LayoutObject}->{"UserIsGroup[$Group]"} ne 'Yes'
            );

        $Access = 1;
        last;
    }

    if ($Access) {
        $Param{Value} = $Self->_Decrypt( $Param{Value} );
    }
    else {
        while ( $Param{Value} =~ /[a-zA-Z0-9_]/ ) {
            $Param{Value} =~ s/[a-zA-Z0-9_]/*/;
        }
    }

    # translate
    if ( $Param{Item}->{Input}->{Translation} ) {
        $Param{Value} =
            $Self->{LayoutObject}->{LanguageObject}->Get( $Param{Value} );
    }

    my $LinkFeature    = 1;
    my $HTMLResultMode = 1;

    # do not transform links in print view
    if ( $Param{Print} ) {
        $LinkFeature = 0;

        # do not convert whitespace and newlines in PDF mode
        if ( $Self->{ConfigObject}->Get('PDF') ) {
            $HTMLResultMode = 0;
        }
    }

    # transform ascii to html
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text           => $Param{Value},
        HTMLResultMode => $HTMLResultMode,
        LinkFeature    => $LinkFeature,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my %FormData;

    # get form data
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    my $GroupsRef = $Param{Item}->{Group};
    my @Groups    = ();
    if ( $GroupsRef && ref $GroupsRef eq 'HASH' ) {
        @Groups = keys %{$GroupsRef};
    }
    my $Access = 0;
    for my $Group (@Groups) {

        next
            if (
            !$Self->{LayoutObject}->{"UserIsGroup[$Group]"}
            || $Self->{LayoutObject}->{"UserIsGroup[$Group]"} ne 'Yes'
            );

        $Access = 1;
        last;
    }
    if ($Access) {

        # do encryption
        $FormData{Value} = $Self->_Encrypt( $FormData{Value} );
    }

    # set invalid param
    if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
        $FormData{Invalid} = 1;
        $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,                # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $Value = $Param{Value};
    if ( !defined $Param{Value} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault} || '';
    }

    my $Class    = '';
    my $Size     = 'W50pc';
    my $Required = $Param{Required};
    my $Invalid  = $Param{Invalid};
    my $ItemId   = $Param{ItemId};

    if ($Required) {
        $Class .= ' Validate_Required';
    }

    if ($Invalid) {
        $Class .= ' ServerError';
    }
    $Class .= ' ' . $Size;
    my $String = "<input type=\"input\" name=\"$Param{Key}\" class=\"$Class\" ";

    if ($ItemId) {
        $String .= "id=\"$ItemId\" ";
    }

    my $GroupsRef = $Param{Item}->{Group};
    my @Groups    = ();
    if ( $GroupsRef && ref $GroupsRef eq 'HASH' ) {
        @Groups = keys %{$GroupsRef};
    }

    my $Access = 0;
    for my $Group (@Groups) {

        next
            if (
            !$Self->{LayoutObject}->{"UserIsGroup[$Group]"}
            || $Self->{LayoutObject}->{"UserIsGroup[$Group]"} ne 'Yes'
            );

        $Access = 1;
        last;
    }

    # check if value can be edited and if so decrypt value
    if ( !$Access ) {
        $String .= "readonly=\"readonly\" ";
    }
    else {
        $Value = $Self->_Decrypt($Value);
    }

    $String .= "value=\"$Value\" ";

    # add maximum length
    if ( $Param{Item}->{Input}->{MaxLength} ) {
        $String .= "maxlength=\"$Param{Item}->{Input}->{MaxLength}\" ";
    }

    $String .= '/> ';

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!',
        );
        return;
    }

    # get form data
    my $Value;
    if ( $Param{Value} ) {
        $Value = $Param{Value};
    }
    else {
        $Value = $Self->{ParamObject}->GetParam( Param => $Param{Key} );
    }
    return $Value;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $Value = $Self->SearchFormDataGet(%Param);
    if ( !defined $Value ) {
        $Value = '';
    }

    my $String =
        qq{<input type="text" name="$Param{Key}" value="$Value" class="W50pc" >};

    return $String;
}

sub _Decrypt {
    my ( $Self, $Pw ) = @_;

    return '' if !$Pw;

    my $Length = length($Pw) * 4;
    $Pw = pack "h$Length", $Pw;
    $Pw = unpack "B$Length", $Pw;
    $Pw =~ s/1/A/g;
    $Pw =~ s/0/1/g;
    $Pw =~ s/A/0/g;
    $Pw = pack "B$Length", $Pw;

    return $Pw;
}

sub _Encrypt {
    my ( $Self, $Pw ) = @_;

    return '' if !$Pw;

    my $Length = length($Pw) * 8;
    chomp $Pw;

    # get bit code
    my $T = unpack( "B$Length", $Pw );

    # crypt bit code
    $T =~ s/1/A/g;
    $T =~ s/0/1/g;
    $T =~ s/A/0/g;

    # get ascii code
    $T = pack( "B$Length", $T );

    # get hex code
    my $H = unpack( "h$Length", $T );

    return $H;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (L<http://otrs.org/>).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.

=cut

=head1 VERSION

$Revision: 1.4 $ $Date: 2011-11-14 12:55:52 $

=cut
 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutUser.pm - layout backend module
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de/
#
# written/changed by: 
# Stefan Mehlig
# --
# $Id: ITSMConfigItemLayoutUser.pm,v 1.10 2011-03-30 13:12:57 fober Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutUser;

use strict;
use warnings;

use Kernel::System::User;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.10 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutUser - layout backend module

=head1 SYNOPSIS

All layout functions of User objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutUser->new(
        %Param,
    );

=cut

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

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

    # check needed objects
    for my $Object (qw(ConfigObject LogObject MainObject ParamObject TimeObject DBObject LayoutObject EncodeObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    $Self->{UserObject} = Kernel::System::User->new( %{$Self} );

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    # transform ascii to html
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    # get selected user
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    # check search button
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    # check select button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    # check clear button
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        # reset value if search field is emty
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        # check required option
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }
 
    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }
    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $StringOption = '';
    my $StringSelect = '';
    my $Class    = 'W50pc AgentUserSearch';
    my $Search   = '';
    my $Required = $Param{Required} || '';
    my $Invalid  = $Param{Invalid} || '';
    my $ItemId   = $Param{ItemId} || '';

    if ($Required) {
        $Class .= ' Validate_Required';
    }

    if ($Invalid) {
        $Class .= ' ServerError';
    }

    # create User string
    if ($Value) {

        # get User data
        my %UserSearchList = $Self->{UserObject}->GetUserData(
            UserID => $Value,
        );
        my $UserName = '';
        if ( %UserSearchList ) {
            $UserName = '"'.$UserSearchList{UserFirstname}.' '.$UserSearchList{UserLastname}.'" <'.$UserSearchList{UserEmail}.'>';
        }
        # transform ascii to html       
        $Search = $Self->{LayoutObject}->Ascii2Html(
            Text => $UserName || '',
            HTMLResultMode => 1,
        );
    }

    my $AutoCompleteConfig
        = $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if ($AutoCompleteConfig && ref($AutoCompleteConfig) eq 'HASH' && $AutoCompleteConfig->{Active}) {
    
        $Self->{LayoutObject}->Block(
            Name => 'AgentUserSearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'AgentUserSearchInit',
            Data => {
                ItemID             => $ItemId,
                ActiveAutoComplete => 'true',
                }
        );

        # create string
        $String
            = '$Include{"AgentUserSearch"}'
            .'<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Search . '"/>';
    }
    else {
        $String
            = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Search . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    # get form data
    my @UserList;
    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );
    for my $SearchValue (@SearchValues) {
        next if !$SearchValue;
        my %UserSearchList = $Self->{UserObject}->UserSearch(
            Search => '*'.$SearchValue.'*', 
        );
        
        @UserList = keys %UserSearchList;
    }

    if (scalar(@UserList) < 1 || !$UserList[0]) {
        @UserList = @SearchValues;
    }

    return \@UserList;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"30\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.10 $ $Date: 2011-03-30 13:12:57 $

=cut
 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutCIClassReference.pm - layout backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
#
# --
# $Id: ITSMConfigItemLayoutCIClassReference.pm,v 1.13 2011-09-05 09:39:38 maba Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutCIClassReference;

use strict;
use warnings;

use Kernel::System::ITSMConfigItem;
use Kernel::System::GeneralCatalog;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.13 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutCIClassReference - layout backend module

=head1 SYNOPSIS

All layout functions of CIClassReference objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutCIClassReference->new(
        %Param,
    );

=cut

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

    #allocate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #check needed objects...
    for my $Object (
        qw(ConfigObject LogObject MainObject ParamObject DBObject LayoutObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    $Self->{ConfigItemObject}        = Kernel::System::ITSMConfigItem->new( %{$Self} );
    $Self->{GeneralCatalogObject}    = Kernel::System::GeneralCatalog->new( %{$Self} );
    $Self->{CIClassReferenceClassID} = 0;

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    #transform ascii to html...
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    #get selected CIClassReference...
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    #check search button..
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    #check select button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    #check clear button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        #reset value if search field is empty...
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        #check required option...
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }

    if (
        !$Param{Item}->{Input}->{ReferencedCIClassID}
        && $Param{Item}->{Input}->{ReferencedCIClassName}
        )
    {

        my $ItemDataRef = $Self->{GeneralCatalogObject}->ItemGet(
            Class => 'ITSM::ConfigItem::Class',
            Name  => $Param{Item}->{Input}->{ReferencedCIClassName},
        );

        if ( !$ItemDataRef || !( $ItemDataRef->{ItemID} ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "ITSMConfigItemLayoutCIClassReference: CI-Class <"
                    . $Param{Item}->{Input}->{ReferencedCIClassName}
                    . "> not defined in GeneralCatalog!",
            );
        }
        else {
            $Self->{CIClassReferenceClassID} = $ItemDataRef->{ItemID};
        }

    }
    elsif ( $Param{Item}->{Input}->{ReferencedCIClassID} ) {
        $Self->{CIClassReferenceClassID} = $Param{Item}->{Input}->{ReferencedCIClassID};
    }

    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $Search       = '';
    my $StringOption = '';
    my $StringSelect = '';

    # AutoComplete CIClass
    my $Class = 'W50pc CIClassSearch';

    #my $Search   = '';
    my $Required = $Param{Required} || '';
    my $Invalid  = $Param{Invalid}  || '';
    my $ItemId   = $Param{ItemId}   || '';

    # EO AutoComplete CIClass

    # CIClassReference search...
    if ( $Param{Item}->{Form}->{ $Param{Key} }->{Search} ) {

        #-----------------------------------------------------------------------
        # search for name....
        my %CISearchList    = ();
        my $CISearchListRef = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
            Name     => '*' . $Param{Item}->{Form}->{ $Param{Key} }->{Search} . '*',
            ClassIDs => [ $Self->{CIClassReferenceClassID} ],
        );

        for my $SearchResult ( @{$CISearchListRef} ) {
            my $CurrVersionData = $Self->{ConfigItemObject}->VersionGet(
                ConfigItemID => $SearchResult,
                XMLDataGet   => 0,
            );
            if (
                $CurrVersionData
                &&
                ( ref($CurrVersionData) eq 'HASH' ) &&
                $CurrVersionData->{Name} &&
                $CurrVersionData->{Number}
                )
            {
                $CISearchList{$SearchResult} = $CurrVersionData->{Name}
                    . " ("
                    . $CurrVersionData->{Number}
                    . ")";
            }
        }

        #-----------------------------------------------------------------------
        # search for number....
        $CISearchListRef = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
            Number   => '*' . $Param{Item}->{Form}->{ $Param{Key} }->{Search} . '*',
            ClassIDs => [ $Self->{CIClassReferenceClassID} ],
        );

        for my $SearchResult ( @{$CISearchListRef} ) {
            my $CurrVersionData = $Self->{ConfigItemObject}->VersionGet(
                ConfigItemID => $SearchResult,
                XMLDataGet   => 0,
            );
            if (
                $CurrVersionData
                &&
                ( ref($CurrVersionData) eq 'HASH' ) &&
                $CurrVersionData->{Name} &&
                $CurrVersionData->{Number}
                )
            {
                $CISearchList{$SearchResult} = $CurrVersionData->{Name}
                    . " ("
                    . $CurrVersionData->{Number}
                    . ")";
            }
        }

        #-----------------------------------------------------------------------
        # build search result presentation....
        if ( %CISearchList && scalar( keys %CISearchList ) > 1 ) {

            #create option list...
            $StringOption = $Self->{LayoutObject}->BuildSelection(
                Name => $Param{Key} . '::Select',
                Data => \%CISearchList,
            );
            $StringOption .= '<br>';

            #create select button...
            $StringSelect = '<input class="button" type="submit" name="'
                . $Param{Key}
                . '::ButtonSelect" '
                . 'value="$Text{"Select"}">&nbsp;';

            #set search...
            $Search = $Param{Item}->{Form}->{ $Param{Key} }->{Search};
        }
        elsif (%CISearchList) {

            $Value = ( keys %CISearchList )[0];
            my $CIVersionDataRef = $Self->{ConfigItemObject}->VersionGet(
                ConfigItemID => $Value,
                XMLDataGet   => 0,
            );
            my $CIName = "";

            if (
                $CIVersionDataRef
                &&
                ( ref($CIVersionDataRef) eq 'HASH' ) &&
                $CIVersionDataRef->{Name} &&
                $CIVersionDataRef->{Number}
                )
            {
                $CIName = $CIVersionDataRef->{Name}
                    . " ("
                    . $CIVersionDataRef->{Number}
                    . ")";
            }

            #transform ascii to html...
            $Search = $Self->{LayoutObject}->Ascii2Html(
                Text => $CIName || '',
                HTMLResultMode => 1,
            );
        }

    }

    #create CIClassReference string...
    elsif ($Value) {

        my $CIVersionDataRef = $Self->{ConfigItemObject}->VersionGet(
            ConfigItemID => $Value,
            XMLDataGet   => 0,
        );
        my $CIName = "";

        if (
            $CIVersionDataRef
            &&
            ( ref($CIVersionDataRef) eq 'HASH' ) &&
            $CIVersionDataRef->{Name} &&
            $CIVersionDataRef->{Number}
            )
        {
            $CIName = $CIVersionDataRef->{Name}
                . " ("
                . $CIVersionDataRef->{Number}
                . ")";
        }

        #transform ascii to html...
        $Search = $Self->{LayoutObject}->Ascii2Html(
            Text => $CIName || '',
            HTMLResultMode => 1,
        );
    }

    # AutoComplete CIClass
    my $AutoCompleteConfig
        = $Self->{ConfigObject}
        ->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if (
        $AutoCompleteConfig
        && ref($AutoCompleteConfig) eq 'HASH'
        && $AutoCompleteConfig->{Active}
        )
    {

        $Self->{LayoutObject}->Block(
            Name => 'CIClassSearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'CIClassSearchInit',
            Data => {
                ItemID             => $ItemId,
                ClassID            => $Self->{CIClassReferenceClassID},
                ActiveAutoComplete => 'true',
            },
        );

        $String = '$Include{"AgentCIClassSearch"}'
            . '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Search . '"/>';
    }
    else {
        $String = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Search . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

sub SearchFormDataGet {
    my ( $Self, %Param ) = @_;
    my @Values = qw{};

    #check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    if ( !$Self->{CIClassReferenceClassID} ) {

        my $ItemDataRef = $Self->{GeneralCatalogObject}->ItemGet(
            Class => 'ITSM::ConfigItem::Class',
            Name  => $Param{Item}->{Input}->{ReferencedCIClassName},
        );

        if ( !$ItemDataRef || !( $ItemDataRef->{ItemID} ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "ITSMConfigItemLayoutCIClassReference: CI-Class <"
                    . $Param{Item}->{Input}->{ReferencedCIClassName}
                    . "> not defined in GeneralCatalog!",
            );
        }
        else {
            $Self->{CIClassReferenceClassID} = $ItemDataRef->{ItemID};
        }

    }

    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    for my $CurrSearchValue (@SearchValues) {
        next if !$CurrSearchValue;
        my $CISearchListRef = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
            Name     => $CurrSearchValue,
            ClassIDs => [ $Self->{CIClassReferenceClassID} ],
        );
        for my $SearchResult ( @{$CISearchListRef} ) {
            push( @Values, $SearchResult );
        }

        $CISearchListRef = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
            Number   => $CurrSearchValue,
            ClassIDs => [ $Self->{CIClassReferenceClassID} ],
        );
        for my $SearchResult ( @{$CISearchListRef} ) {
            push( @Values, $SearchResult );
        }
    }

    if ( scalar(@Values) < 1 || !$Values[0] ) {
        @Values = @SearchValues;
    }

    return \@Values;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"30\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.13 $ $Date: 2011-09-05 09:39:38 $

=cut

 #--
#Kernel/Output/HTML/ITSMConfigItemLayoutQueueReference.pm - layout backend module
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
#--
#$Id: ITSMConfigItemLayoutQueueReference.pm,v 1.6 2011-07-06 13:51:43 fober Exp $
#--
#This software comes with ABSOLUTELY NO WARRANTY. For details, see
#the enclosed file COPYING for license information (GPL). If you
#did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
#--

package Kernel::Output::HTML::ITSMConfigItemLayoutQueueReference;

use strict;
use warnings;

use Kernel::System::Queue;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.6 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutQueueReference - layout backend module

=head1 SYNOPSIS

All layout functions of Service objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutQueueReference->new(
        %Param,
    );

=cut

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

    #allocate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #check needed objects...
    for my $Object (
        qw(ConfigObject LogObject MainObject ParamObject DBObject LayoutObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    $Self->{QueueObject} = Kernel::System::Queue->new( %{$Self} );

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    #transform ascii to html...
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    #get selected CIClassReference...
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    #check search button..
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    #check select button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    #check clear button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        #reset value if search field is empty...
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        #check required option...
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }
    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }

    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $Search       = '';
    my $StringOption = '';
    my $StringSelect = '';
    my $Class    = 'W50pc QueueSearch';
    my $Required = $Param{Required} || '';
    my $Invalid  = $Param{Invalid} || '';
    my $ItemId   = $Param{ItemId} || '';

    # QueueReference search...
    if ( $Param{Item}->{Form}->{ $Param{Key} }->{Search} ) {

        #-----------------------------------------------------------------------
        # search for name....
        my %Queues = $Self->{QueueObject}->QueueList(
            Valid   => 1,
        );

        my %QueueList = ();
        for my $QueueID (keys %Queues) {
            if ( $Queues{$QueueID} =~ /\Q$Param{Item}->{Form}->{ $Param{Key} }->{Search}\E/i ) {
                $QueueList{$QueueID} = $Queues{$QueueID};
            }
        }
        
        #-----------------------------------------------------------------------
        # build search result presentation....
        if (%QueueList && scalar(keys %QueueList) > 1) {

            #create option list...
            $StringOption = $Self->{LayoutObject}->BuildSelection(
                Name => $Param{Key} . '::Select',
                Data => \%QueueList,
                Translation => 0,
            );
            $StringOption .= '<br>';

            #create select button...
            $StringSelect = '<input class="button" type="submit" name="'
                . $Param{Key}
                . '::ButtonSelect" '
                . 'value="$Text{"Select"}">&nbsp;';

            #set search...
            $Search = $Param{Item}->{Form}->{ $Param{Key} }->{Search};
        }
        elsif (%QueueList) {
            $Value = (keys %QueueList)[0];
            my %QueueData = $Self->{QueueObject}->QueueGet(
                ID => $Value,
            );
            my $QueueName = "";

            if ( %QueueData && $QueueData{Name} ) {
                $QueueName = $QueueData{Name};
            }

            #transform ascii to html...
            $Search = $Self->{LayoutObject}->Ascii2Html(
                Text => $QueueName || '',
                HTMLResultMode => 1,
            );
        }

    }

    #create CIClassReference string...
    elsif ($Value) {

        my %QueueData = $Self->{QueueObject}->QueueGet(
            ID => $Value,
        );
        my $QueueName = "";

        if ( %QueueData && $QueueData{Name} ) {
            $QueueName = $QueueData{Name};
        }

        #transform ascii to html...
        $Search = $Self->{LayoutObject}->Ascii2Html(
            Text => $QueueName || '',
            HTMLResultMode => 1,
        );
    }

    # AutoComplete CIClass
    my $AutoCompleteConfig
        = $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if ($AutoCompleteConfig && ref($AutoCompleteConfig) eq 'HASH' && $AutoCompleteConfig->{Active}) {
    
        $Self->{LayoutObject}->Block(
            Name => 'QueueSearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'QueueSearchInit',
            Data => {
                ItemID             => $ItemId,
                ActiveAutoComplete => 'true',
                }
        );

        $String
            = '$Include{"AgentQueueSearch"}'
            .'<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Search . '"/>';
    }
    else {
        $String
            = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Search . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    #get form data
    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    my %Queues = $Self->{QueueObject}->QueueList(
        Valid   => 1,
    );

    my @QueueList;
    foreach my $SearchValue (@SearchValues) {
        next if !$SearchValue;
        for my $QueueID (keys %Queues) {
            if ( $Queues{$QueueID} =~ /$SearchValue/i ) {
                push(@QueueList, $QueueID);
            }
        }
    }

    if (scalar(@QueueList) < 1 || !$QueueList[0]) {
        @QueueList = @SearchValues;
    }

    return \@QueueList;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"30\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.6 $ $Date: 2011-07-06 13:51:43 $

=cut

 #--
#Kernel/Output/HTML/ITSMConfigItemLayoutServiceReference.pm - layout backend module
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
#--
#$Id: ITSMConfigItemLayoutServiceReference.pm,v 1.7 2011-03-30 13:12:57 fober Exp $
#--
#This software comes with ABSOLUTELY NO WARRANTY. For details, see
#the enclosed file COPYING for license information (GPL). If you
#did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
#--

package Kernel::Output::HTML::ITSMConfigItemLayoutServiceReference;

use strict;
use warnings;

use Kernel::System::Service;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.7 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutServiceReference - layout backend module

=head1 SYNOPSIS

All layout functions of Service objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutServiceReference->new(
        %Param,
    );

=cut

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

    #allocate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #check needed objects...
    for my $Object (
        qw(ConfigObject LogObject MainObject ParamObject DBObject LayoutObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    $Self->{ServiceObject} = Kernel::System::Service->new( %{$Self} );

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
    );

=cut

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

    #transform ascii to html...
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text => $Param{Value} || '',
        HTMLResultMode => 1,
    );

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my %FormData;

    #get selected CIClassReference...
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    #check search button..
    if ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSearch' ) ) {
        $Param{Item}->{Form}->{ $Param{Key} }->{Search}
            = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' );
    }

    #check select button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonSelect' ) ) {
        $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Select' );
    }

    #check clear button...
    elsif ( $Self->{ParamObject}->GetParam( Param => $Param{Key} . '::ButtonClear' ) ) {
        $FormData{Value} = '';
    }
    else {

        #reset value if search field is empty...
        if (
            !$Self->{ParamObject}->GetParam( Param => $Param{Key} . '::Search' )
            && defined $FormData{Value}
            )
        {
            $FormData{Value} = '';
        }

        #check required option...
        if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
            $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
            $FormData{Invalid} = 1;
        }
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff...
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    my $Value = '';
    if ( defined $Param{Value} ) {
        $Value = $Param{Value};
    }
    elsif ( $Param{Item}->{Input}->{ValueDefault} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault};
    }

    my $Size         = $Param{Item}->{Input}->{Size} || 50;
    my $Search       = '';
    my $StringOption = '';
    my $StringSelect = '';
    my $Class    = 'W50pc ServiceSearch';
    my $Required = $Param{Required} || '';
    my $Invalid  = $Param{Invalid} || '';
    my $ItemId   = $Param{ItemId} || '';

    # ServiceReference search...
    if ( $Param{Item}->{Form}->{ $Param{Key} }->{Search} ) {

        #-----------------------------------------------------------------------
        # search for name....
        my @ServiceIDs = $Self->{ServiceObject}->ServiceSearch(
            Name   => '*' . $Param{Item}->{Form}->{ $Param{Key} }->{Search} . '*',
            UserID => 1,
        );
        my %ServiceList = ();
        for my $CurrKey (@ServiceIDs) {
            my %ServiceData = $Self->{ServiceObject}->ServiceGet(
                ServiceID => $CurrKey,
                UserID    => 1,
            );
            next if ( !%ServiceData );
            $ServiceList{$CurrKey} = $ServiceData{Name};
        }

        #-----------------------------------------------------------------------
        # build search result presentation....
        if (%ServiceList && scalar(keys %ServiceList) > 1) {

            #create option list...
            $StringOption = $Self->{LayoutObject}->BuildSelection(
                Name => $Param{Key} . '::Select',
                Data => \%ServiceList,
            );
            $StringOption .= '<br>';

            #create select button...
            $StringSelect = '<input class="button" type="submit" name="'
                . $Param{Key}
                . '::ButtonSelect" '
                . 'value="$Text{"Select"}">&nbsp;';

            #set search...
            $Search = $Param{Item}->{Form}->{ $Param{Key} }->{Search};
        }
        elsif (%ServiceList) {
            $Value = (keys %ServiceList)[0];
            my %ServiceData = $Self->{ServiceObject}->ServiceGet(
                ServiceID => $Value,
                UserID    => 1,
            );
            my $ServiceName = "";

            if ( %ServiceData && $ServiceData{Name} ) {
                $ServiceName = $ServiceData{Name};
            }

            #transform ascii to html...
            $Search = $Self->{LayoutObject}->Ascii2Html(
                Text => $ServiceName || '',
                HTMLResultMode => 1,
            );
        }

    }

    #create CIClassReference string...
    elsif ($Value) {

        my %ServiceData = $Self->{ServiceObject}->ServiceGet(
            ServiceID => $Value,
            UserID    => 1,
        );
        my $ServiceName = "";

        if ( %ServiceData && $ServiceData{Name} ) {
            $ServiceName = $ServiceData{Name};
        }

        #transform ascii to html...
        $Search = $Self->{LayoutObject}->Ascii2Html(
            Text => $ServiceName || '',
            HTMLResultMode => 1,
        );
    }

    # AutoComplete CIClass
    my $AutoCompleteConfig
        = $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete');

    #create string...
    my $String = '';
    if ($AutoCompleteConfig && ref($AutoCompleteConfig) eq 'HASH' && $AutoCompleteConfig->{Active}) {
    
        $Self->{LayoutObject}->Block(
            Name => 'ServiceSearchAutoComplete',
            Data => {
                minQueryLength      => $AutoCompleteConfig->{MinQueryLength}      || 2,
                queryDelay          => $AutoCompleteConfig->{QueryDelay}          || 0.1,
                typeAhead           => $AutoCompleteConfig->{TypeAhead}           || 'false',
                maxResultsDisplayed => $AutoCompleteConfig->{MaxResultsDisplayed} || 20,
                dynamicWidth        => $AutoCompleteConfig->{DynamicWidth}        || 1,
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'ServiceSearchInit',
            Data => {
                ItemID             => $ItemId,
                ActiveAutoComplete => 'true',
                }
        );

        $String
            = '$Include{"AgentServiceSearch"}'
            .'<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value
            . '" id="'
            . $ItemId . 'Selected'
            . '"/>'
            . '<input type="text" name="'
            . $Param{Key}
            . '::Search" class="'
            . $Class
            . '" id="'
            . $ItemId
            . '" value="'
            . $Search . '"/>';
    }
    else {
        $String
            = '<input type="hidden" name="'
            . $Param{Key}
            . '" value="'
            . $Value . '">'
            . '<input type="Text" name="'
            . $Param{Key}
            . '::Search" size="'
            . $Size
            . '" value="'
            . $Search . '">' . '<br>'
            . $StringOption
            . $StringSelect
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonSearch" value="$Text{"Search"}">'
            . '&nbsp;'
            . '<input class="button" type="submit" name="'
            . $Param{Key}
            . '::ButtonClear" value="$Text{"Clear"}">';
    }

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my @ServiceIDs;

    #get form data
    my @SearchValues = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    foreach my $SearchValue (@SearchValues) {
        next if !$SearchValue;
        my @ServiceIDDummys = $Self->{ServiceObject}->ServiceSearch(
            Name   => '*' . $SearchValue . '*',
            UserID => 1,
        );
        push(@ServiceIDs,@ServiceIDDummys);
    }

    if (scalar(@ServiceIDs) < 1 || !$ServiceIDs[0]) {
        @ServiceIDs = @SearchValues;
    }

    return \@ServiceIDs;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!'
        );
        return;
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"30\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.7 $ $Date: 2011-03-30 13:12:57 $

=cut

 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutCIAttachment.pm - layout backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Anna(dot)Litvinova(at)cape-it(dot)de
# --
# $Id: ITSMConfigItemLayoutCIAttachment.pm,v 1.6 2011-07-25 09:02:01 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutCIAttachment;

use strict;
use warnings;

use Kernel::System::CIAttachmentStorage::AttachmentStorage;

use vars qw(@ISA $VERSION);
$VERSION = qw($Revision: 1.6 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutCIAttachment - layout backend module

=head1 SYNOPSIS

All layout functions of CIAttachment objects

=over 4

=cut

=item new()

create a object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutCIAttachment->new(
        %Param,
    );

=cut

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

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

    #check required objects...
    foreach (qw(ConfigObject LogObject MainObject ParamObject DBObject LayoutObject EncodeObject)) {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    if ( !$Self->{AttachmentStorageObject} ) {
        $Self->{AttachmentStorageObject} =
            Kernel::System::CIAttachmentStorage::AttachmentStorage->new( %{$Self} );
    }

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

sub OutputStringCreate {
    my ( $Self, %Param ) = @_;
    my $String = "";

    #check required stuff...
    foreach (qw(Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    if ( $Param{Value} ) {
        my %AttDirData   = ();
        my $SizeNote     = "";
        my $RealFileSize = 0;
        my $MD5Note      = "";
        my $RealMD5Sum   = "";

        # get saved properties (attachment directory info)
        %AttDirData = $Self->{AttachmentStorageObject}->AttachmentStorageGetDirectory(
            ID => $Param{Value},
        );

        if (
            $AttDirData{Preferences}->{FileSizeBytes}
            &&
            $AttDirData{Preferences}->{MD5Sum}
            )
        {

            # get real properties to check if the attachment content has been changed
            my %RealProperties =
                $Self->{AttachmentStorageObject}->AttachmentStorageGetRealProperties(
                %AttDirData,
                );

            $RealMD5Sum   = $RealProperties{RealMD5Sum};
            $RealFileSize = $RealProperties{RealFileSize};

            my $MD5CheckEnabled =
                $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::AttachmentMD5Check') || '';
            my $SizeCheckEnabled =
                $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::AttachmentSizeCheck') || '';

            if ( $SizeCheckEnabled && $RealFileSize != $AttDirData{Preferences}->{FileSizeBytes} ) {
                $SizeNote = "Invalid content - file size on disk "
                    . "has been changed";

                if ( $RealFileSize > ( 1024 * 1024 ) ) {
                    $RealFileSize = sprintf "%.1f MBytes", ( $RealFileSize / ( 1024 * 1024 ) );
                }
                elsif ( $RealFileSize > 1024 ) {
                    $RealFileSize = sprintf "%.1f KBytes", ( ( $RealFileSize / 1024 ) );
                }
                else {
                    $RealFileSize = $RealFileSize . ' Bytes';
                }
            }
            elsif ( $MD5CheckEnabled && $RealMD5Sum ne $AttDirData{Preferences}->{MD5Sum} ) {
                $MD5Note = "Invalid md5sum - The file might have been changed";
            }
        }

        # build the attachment part of the output
        $String = $Self->BuildAttachmentPresentation(
            FileName   => $AttDirData{FileName},
            FileSize   => $AttDirData{Preferences}->{FileSize},
            DataType   => $AttDirData{Preferences}->{DataType},
            SizeNote   => $SizeNote,
            SizeOnDisk => $RealFileSize,
            MD5Note    => $MD5Note,
            AttachID   => $AttDirData{AttDirID},
        );
    }

    return $String;
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

sub FormDataGet {
    my ( $Self, %Param ) = @_;
    my %FormData;
    my $AttDirID = $Self->{ParamObject}->GetParam( Param => $Param{Key} . "ID" ) || '';
    my $AttDirDel = $Self->{ParamObject}->GetParam( Param => $Param{Key} . "Delete" );
    my $ConfigItemID = $Param{ConfigItemID};

    #my $ConfigItemID = $Self->{ParamObject}->GetParam(Param => 'ConfigItemID');

    #check required stuff...
    foreach (qw(Key Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    #get the upload file....
    my %UploadStuff = $Self->{ParamObject}->GetUploadAll(
        Param  => $Param{Key} . "Upload",
        Source => 'string',
    );

    #save the attachment if there is one...
    if ( (%UploadStuff) && $ConfigItemID ) {

        #store the attachment in the default storage backend....
        $AttDirID = $Self->{AttachmentStorageObject}->AttachmentStorageAdd(
            DataRef  => \$UploadStuff{Content},
            FileName => $UploadStuff{Filename},
            StorageBackend =>
                $Self->{ConfigObject}->Get('AttachmentStorage::DefaultStorageBackendModule'),
            UserID      => 1,
            Preferences => {
                DataType => $UploadStuff{ContentType},
                }
        );

    }

    #xml_storage stores only the reference to the attachment directory entry
    #get the AttachmentDirectory-ID (either existing or just uploaded)...
    $FormData{Value} = undef;

    if ($AttDirID) {
        $FormData{Value} = $AttDirID;
    }

    if ( ($AttDirDel) ) {    # && !(%UploadStuff)
        $FormData{Value} = '';
    }

    #set invalid param...
    if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
        $FormData{Invalid} = 1;
        $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

sub InputCreate {
    my ( $Self, %Param ) = @_;
    my %AttDirData   = ();
    my $SizeNote     = "";
    my $RealFileSize = 0;
    my $MD5Note      = "";
    my $RealMD5Sum   = "";

    #check required stuff...
    foreach (qw(Key Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    if ( $Param{Value} ) {

        # get saved attachment properties und preferences
        %AttDirData = $Self->{AttachmentStorageObject}->AttachmentStorageGetDirectory(
            ID => $Param{Value}
        );

        if (
            $AttDirData{Preferences}->{FileSizeBytes}
            &&
            $AttDirData{Preferences}->{MD5Sum}
            )
        {

            # get real properties to check if the attachment content has been changed
            my %RealProperties =
                $Self->{AttachmentStorageObject}->AttachmentStorageGetRealProperties(
                %AttDirData,
                );

            $RealMD5Sum   = $RealProperties{RealMD5Sum};
            $RealFileSize = $RealProperties{RealFileSize};

            my $MD5CheckEnabled =
                $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::AttachmentMD5Check') || '';
            my $SizeCheckEnabled =
                $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::AttachmentSizeCheck') || '';

            if ( $SizeCheckEnabled && $RealFileSize != $AttDirData{Preferences}->{FileSizeBytes} ) {
                $SizeNote = "Invalid content - file size on disk "
                    . "has been changed";

                if ( $RealFileSize > ( 1024 * 1024 ) ) {
                    $RealFileSize = sprintf "%.1f MBytes", ( $RealFileSize / ( 1024 * 1024 ) );
                }
                elsif ( $RealFileSize > 1024 ) {
                    $RealFileSize = sprintf "%.1f KBytes", ( ( $RealFileSize / 1024 ) );
                }
                else {
                    $RealFileSize = $RealFileSize . ' Bytes';
                }
            }
            elsif ( $MD5CheckEnabled && $RealMD5Sum ne $AttDirData{Preferences}->{MD5Sum} ) {
                $MD5Note = "Invalid md5sum - The file might have been changed";
            }
        }
    }

    # build the attachment part of the output
    my $String = $Self->BuildAttachmentModification(
        FileName   => $AttDirData{FileName},
        FileSize   => $AttDirData{Preferences}->{FileSize},
        DataType   => $AttDirData{Preferences}->{DataType},
        SizeNote   => $SizeNote,
        SizeOnDisk => $RealFileSize,
        MD5Note    => $MD5Note,
        AttachID   => $Param{Value},
        Key        => $Param{Key},
    );

    return $String;
}

=cut item BuildAttachmentModification()
build the attachment part of the output in ConfigItem Edit window
=cut

sub BuildAttachmentModification {
    my ( $Self, %Param ) = @_;
    my $ExistingAttachment = "";
    my $AttDirIDName       = $Param{Key} . "ID";
    my $AttDirDel          = $Param{Key} . "Delete";
    my $AttDirIDUploadName = $Param{Key} . "Upload";

    my $AttachID = $Param{AttachID} || '';

    my $Advice =
        $Self->{LayoutObject}->{LanguageObject}->Get('Select a file to replace current attachment');

    #    my $DeleteText = $Self->{LayoutObject}->{LanguageObject}->Get('Remove attachment');
    #    my $YesText    = $Self->{LayoutObject}->{LanguageObject}->Get('Yes');

    if ( defined( $Param{FileName} ) && ( $Param{FileName} ) ) {
        my $ahref =
            "<a href=\""
            . $Self->{LayoutObject}->{Baselink}
            . "Action=AgentAttachmentStorage;"
            . "AttachmentDirectoryID=$Param{AttachID}";

        # add session id if needed
        if ( !$Self->{LayoutObject}->{SessionIDCookie} ) {
            $ahref .= ";"
                . $Self->{LayoutObject}->{SessionName}
                . "="
                . $Self->{LayoutObject}->{SessionID};
        }
        $ahref .= "\">";

        $ExistingAttachment = " <li>"
            . $ahref
            . "<b>$Param{FileName}</b></a>&nbsp;&nbsp;"
            . "($Param{FileSize})"

       #           . "</li>"
       #           . " <li>"
       #           . "<label for=\"$AttDirDel\">$DeleteText: </label>"
       #           . " <input type=\"checkbox\" id= \"$AttDirDel\" name=\"$AttDirDel\" value=\"1\">"
            . " </li>";

        if ( $Param{SizeNote} ) {
            $ExistingAttachment .= " <li><font color=\"red\">"
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{SizeNote} )
                . " ("
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{SizeOnDisk} )
                . ")"
                . "! </font></li>";
        }
        elsif ( $Param{MD5Note} ) {
            $ExistingAttachment .= " <li><font color=\"red\">"
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{MD5Note} )
                . "! </font></li>";
        }
        $ExistingAttachment .= "<li> <label for=\"$AttDirIDName\">$Advice:</label></li>";
    }
    my $Output = "<ul>" . $ExistingAttachment
        . "</ul>"
        . "<input type=\"hidden\" name=\"$AttDirIDName\" value=\"$AttachID\"/> "
        . "<input type=\"file\" id=\"$AttDirIDName\" name=\"$AttDirIDUploadName\" class=\"fixed\"/> ";

    return $Output;
}

=cut item BuildAttachmentModification()
build the attachment part of the output for ConfigItem Details
=cut

sub BuildAttachmentPresentation {
    my ( $Self, %Param ) = @_;
    my $Output = '';

    if ( $Param{AttachID} && $Param{FileName} ) {

        my $ahref = "<a href=\""
            . $Self->{LayoutObject}->{Baselink}
            . "Action=AgentAttachmentStorage;"
            . "AttachmentDirectoryID=$Param{AttachID}";

        # add session id if needed
        if ( !$Self->{LayoutObject}->{SessionIDCookie} ) {
            $ahref .= ";"
                . $Self->{LayoutObject}->{SessionName}
                . "="
                . $Self->{LayoutObject}->{SessionID};
        }
        $ahref .= "\">";

        $Output = $ahref . "$Param{FileName}</a>&nbsp;&nbsp;" .
            "&nbsp;($Param{FileSize})&nbsp;";

        if ( $Param{SizeNote} ) {
            $Output .= '<font color="red">'
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{SizeNote} )
                . " ("
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{SizeOnDisk} )
                . ")"
                . '!</font>';
        }
        elsif ( $Param{MD5Note} ) {
            $Output .= '<font color="red">'
                . $Self->{LayoutObject}->{LanguageObject}->Get( $Param{MD5Note} )
                . '!</font>';
        }
    }
    return $Output;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check required stuff...
    foreach (qw(Key Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    # get form data
    my @Values = $Self->{ParamObject}->GetArray( Param => $Param{Key} );

    # find all attachment_directory IDs for the given FileName
    if ( ( $Param{Key} eq 'Attachment' ) && $Values[0] ) {
        my $FileName = $Values[0];

        my $UsingWildcards = 0;
        if ( ( $FileName =~ s/\*/%/g ) || ( $FileName =~ m/%/ ) ) {
            $UsingWildcards = 1;
        }

        @Values = $Self->{AttachmentStorageObject}->AttachmentStorageSearch(
            FileName       => $FileName,
            UsingWildcards => $UsingWildcards,
        );
        if ( !$Values[0] ) {
            $Values[0] = -1;
        }
    }
    return \@Values;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    #check required stuff...
    foreach (qw(Key Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    my $String = "<input type=\"Text\" name=\"$Param{Key}\" size=\"60\">";

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl.txt.

=cut

=head1 VERSION

$Revision: 1.6 $ $Date: 2011-07-25 09:02:01 $

=cut
 # --
# Kernel/Output/HTML/ITSMConfigItemLayoutTextLink.pm - layout backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape(dash)it(dot)de
#
# --
# $Id: ITSMConfigItemLayoutTextLink.pm,v 1.1 2011-10-13 11:26:01 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::Output::HTML::ITSMConfigItemLayoutTextLink;

use strict;
use warnings;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];

=head1 NAME

Kernel::Output::HTML::ITSMConfigItemLayoutText - layout backend module

=head1 SYNOPSIS

All layout functions of text objects

=over 4

=cut

=item new()

create an object

    $BackendObject = Kernel::Output::HTML::ITSMConfigItemLayoutText->new(
        %Param,
    );

=cut

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

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

    # check needed objects
    for my $Object (qw(ConfigObject EncodeObject LogObject MainObject ParamObject LayoutObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    return $Self;
}

=item OutputStringCreate()

create output string

    my $Value = $BackendObject->OutputStringCreate(
        Value => 11,       # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Item} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Item!',
        );
        return;
    }

    if ( !defined $Param{Value} ) {
        $Param{Value} = '';
    }

    # translate
    if ( $Param{Item}->{Input}->{Translation} ) {
        $Param{Value} = $Self->{LayoutObject}->{LanguageObject}->Get( $Param{Value} );
    }

    my $LinkFeature    = 1;
    my $HTMLResultMode = 1;

    # do not transform links in print view
    if ( $Param{Print} ) {
        $LinkFeature = 0;

        # do not convert whitespace and newlines in PDF mode
        if ( $Self->{ConfigObject}->Get('PDF') ) {
            $HTMLResultMode = 0;
        }
    }

    # transform ascii to html
    $Param{Value} = $Self->{LayoutObject}->Ascii2Html(
        Text           => $Param{Value},
        HTMLResultMode => $HTMLResultMode,
        LinkFeature    => $LinkFeature,
    );

    my $Link = $Param{Item}->{Input}->{URL};
    $Link =~ s/<VALUE>/$Param{Value}/;
    $Param{Value} =
          '<a href="' 
        . $Link
        . '" title="$Text{"Open link in new window"}" target="_blank">'
        . $Param{Value} . '</a>';

    return $Param{Value};
}

=item FormDataGet()

get form data as hash reference

    my $FormDataRef = $BackendObject->FormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my %FormData;

    # get form data
    $FormData{Value} = $Self->{ParamObject}->GetParam( Param => $Param{Key} );

    # set invalid param
    if ( $Param{Item}->{Input}->{Required} && !$FormData{Value} ) {
        $FormData{Invalid} = 1;
        $Param{Item}->{Form}->{ $Param{Key} }->{Invalid} = 1;
    }

    return \%FormData;
}

=item InputCreate()

create a input string

    my $Value = $BackendObject->InputCreate(
        Key => 'Item::1::Node::3',
        Value => 11,                # (optional)
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $Value = $Param{Value};
    if ( !defined $Param{Value} ) {
        $Value = $Param{Item}->{Input}->{ValueDefault} || '';
    }

    my $Class    = '';
    my $Size     = 'W50pc';
    my $Required = $Param{Required};
    my $Invalid  = $Param{Invalid};
    my $ItemId   = $Param{ItemId};

    if ($Required) {
        $Class .= ' Validate_Required';
    }

    if ($Invalid) {
        $Class .= ' ServerError';
    }
    $Class .= ' ' . $Size;
    my $String = "<input type=\"text\" name=\"$Param{Key}\" class=\"$Class\" ";

    if ($ItemId) {
        $String .= "id=\"$ItemId\" ";
    }

    if ($Value) {

        # translate
        if ( $Param{Item}->{Input}->{Translation} ) {
            $Value = $Self->{LayoutObject}->{LanguageObject}->Get($Value);
        }

        # transform ascii to html
        $Value = $Self->{LayoutObject}->Ascii2Html(
            Text           => $Value,
            HTMLResultMode => 1,
        );
    }

    $String .= "value=\"$Value\" ";

    # add maximum length
    if ( $Param{Item}->{Input}->{MaxLength} ) {
        $String .= "maxlength=\"$Param{Item}->{Input}->{MaxLength}\" ";
    }

    $String .= '/> ';

    return $String;
}

=item SearchFormDataGet()

get search form data

    my $Value = $BackendObject->SearchFormDataGet(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    if ( !$Param{Key} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Key!',
        );
        return;
    }

    # get form data
    my $Value;
    if ( $Param{Value} ) {
        $Value = $Param{Value};
    }
    else {
        $Value = $Self->{ParamObject}->GetParam( Param => $Param{Key} );
    }
    return $Value;
}

=item SearchInputCreate()

create a search input string

    my $Value = $BackendObject->SearchInputCreate(
        Key => 'Item::1::Node::3',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $Value = $Self->SearchFormDataGet(%Param);
    if ( !defined $Value ) {
        $Value = '';
    }

    my $String = qq{<input type="text" name="$Param{Key}" value="$Value" class="W50pc" >};

    return $String;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (L<http://otrs.org/>).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.

=cut

=head1 VERSION

$Revision: 1.1 $ $Date: 2011-10-13 11:26:01 $

=cut
 # --
# Kernel/System/ITSMConfigItem/XML/Type/CIClassReference.pm - xml backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# --
# $Id: CIClassReference.pm,v 1.3 2011-04-18 07:53:07 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ITSMConfigItem::XML::Type::CIClassReference;

use strict;
use warnings;

use Kernel::System::ITSMConfigItem;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.3 $) [1];

=head1 NAME

Kernel::System::ITSMConfigItem::XML::Type::CIClassReference - xml backend module

=head1 SYNOPSIS

All xml functions of CIClassReference objects

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::ConfigItem;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ConfigItemObject = Kernel::System::ConfigItem->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
    );
    $BackendObject = $ConfigItemObject->_LoadXMLTypeBackend(
        Type => 'CIClassReference',
    );

=cut

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

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

    # check needed objects
    for my $Object (qw(DBObject ConfigObject LogObject MainObject EncodeObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    $Self->{ConfigItemObject} = Kernel::System::ITSMConfigItem->new( %{$Self} );

    return $Self;
}

=item ValueLookup()

get the xml data of a version

    my $Value = $BackendObject->ValueLookup(
        Value => 11, # (optional)
    );

=cut

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

    return '' if !$Param{Value};

    my $CIVersionDataRef = $Self->{ConfigItemObject}->VersionGet(
        ConfigItemID => $Param{Value},
        XMLDataGet   => 0,
    );
    my $CIName = $Param{Value};

    if (
        $CIVersionDataRef
        &&
        ( ref($CIVersionDataRef) eq 'HASH' ) &&
        $CIVersionDataRef->{Name}
        )
    {
        $CIName = $CIVersionDataRef->{Name}
            . " ("
            . $CIVersionDataRef->{Number}
            . ")";
    }

    return $CIName;
}

=item StatsAttributeCreate()

create a attribute array for the stats framework

    my $Attribute = $BackendObject->StatsAttributeCreate(
        Key => 'Key::Subkey',
        Name => 'Name',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Name Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # create arrtibute
    my $Attribute = [
        {
            Name             => $Param{Name},
            UseAsXvalue      => 0,
            UseAsValueSeries => 0,
            UseAsRestriction => 1,
            Element          => $Param{Key},
            Block            => 'InputField',
        },
    ];

    return $Attribute;
}

=item ExportSearchValuePrepare()

prepare search value for export

    my $ArrayRef = $BackendObject->ExportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};
    return $Param{Value};
}

=item ExportValuePrepare()

prepare value for export

    my $Value = $BackendObject->ExportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    #get CI number from CI-ID...
    my $CIRef = $Self->{ConfigItemObject}->ConfigItemGet(
        ConfigItemID => $Param{Value},

        #Cache        => 0,
    );

    #return CI-Number...
    if ( $CIRef && ( ref($CIRef) eq 'HASH' ) && $CIRef->{Number} ) {
        return $CIRef->{Number};
    }

    return;
}

=item ImportSearchValuePrepare()

prepare search value for import

    my $ArrayRef = $BackendObject->ImportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my $ResultArrayRef = $Self->{ConfigItemObject}->ConfigItemSearch(
        Number => $Param{Value},
    );

    if (
        $ResultArrayRef
        && ( ref($ResultArrayRef) eq 'ARRAY' )
        && ( scalar( @{$ResultArrayRef} ) == 1 )
        )
    {
        return $ResultArrayRef->[0];
    }

    return $Param{Value};
}

=item ImportValuePrepare()

prepare value for import

    my $Value = $BackendObject->ImportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my $ResultArrayRef = $Self->{ConfigItemObject}->ConfigItemSearch(
        Number => $Param{Value},
    );

    if (
        $ResultArrayRef
        && ( ref($ResultArrayRef) eq 'ARRAY' )
        && ( scalar( @{$ResultArrayRef} ) == 1 )
        )
    {
        return $ResultArrayRef->[0];
    }

    return $Param{Value};
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.3 $ $Date: 2011-04-18 07:53:07 $

=cut
 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 # --
# Kernel/System/ITSMConfigItem/XML/Type/CIAttachment.pm - xml backend module
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
# original Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Anna(dot)Litvinova(at)cape-it(dot)de
# --
# based upon Customer.pm - 1.2.2.1 from 2007/10/09 by mh
# $Id: CIAttachment.pm,v 1.6 2011-07-25 09:23:46 smehlig Exp $
#
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::ITSMConfigItem::XML::Type::CIAttachment;

use strict;
use warnings;
use Kernel::System::CIAttachmentStorage::AttachmentStorage;

use vars qw(@ISA $VERSION);
$VERSION = qw($Revision: 1.6 $) [1];

=head1 NAME

Kernel::System::ITSMConfigItem::XML::Type::CIAttachment - xml backend module

=head1 SYNOPSIS

All xml functions of CIAttachment objects

=over 4

=cut

=item new()

create a object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::ConfigItem;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject => $LogObject,
    );
    my $ConfigItemObject = Kernel::System::ConfigItem->new(
        ConfigObject => $ConfigObject,
        LogObject => $LogObject,
        DBObject => $DBObject,
    );
    $BackendObject = $ConfigItemObject->_LoadXMLTypeBackend(
        Type => 'CIAttachment',
    );

=cut

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

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

    # check needed objects
    foreach (qw(DBObject ConfigObject LogObject MainObject EncodeObject)) {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    $Self->{AttachmentStorageObject} =
        Kernel::System::CIAttachmentStorage::AttachmentStorage->new( %{$Self} );

    return $Self;
}

=item ValueLookup()

get the xml data of a version

    my $Value = $BackendObject->ValueLookup(
        Item => $ItemRef,
        Value => 1.1.1.1,
    );

=cut

sub ValueLookup {
    my ( $Self, %Param ) = @_;
    my $Value = '';

    # check needed stuff
    foreach (qw(Item)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "$Param{Item}->{Input}->{Type} :: Need $_!"
            );
            return;
        }
    }
    if ( ( defined $Param{Value} ) ) {
        my $retVal = $Param{Value};

        #retrieve the attachment data from the attachment storage...
        #
        # ...nope, not yet - think it's better if just the attachment-
        # directory-id is returned...
        #

        return $retVal;
    }

    return '';

}

=item StatsAttributeCreate()

create a attribute array for the stats framework

    my $Attribute = $BackendObject->StatsAttributeCreate(
        Key => 'Key::Subkey',
        Name => 'Name',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Name Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # create arrtibute
    my $Attribute = [
        {
            Name             => $Param{Name},
            UseAsXvalue      => 0,
            UseAsValueSeries => 0,
            UseAsRestriction => 0,
            Element          => $Param{Key},
            Block            => 'InputField',
        },
    ];

    return $Attribute;
}

=item ExportSearchValuePrepare()

prepare search value for export

    my $ArrayRef = $BackendObject->ExportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};
    return $Param{Value};
}

=item ExportValuePrepare()

prepare value for export

    my $Value = $BackendObject->ExportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my $RetVal       = "";
    my %AttDirData   = ();
    my $SizeNote     = "";
    my $RealFileSize = 0;
    my $MD5Note      = "";
    my $RealMD5Sum   = "";

    # get saved properties (attachment directory info)
    %AttDirData = $Self->{AttachmentStorageObject}->AttachmentStorageGetDirectory(
        ID => $Param{Value},
    );

    if (
        $AttDirData{Preferences}->{FileSizeBytes}
        &&
        $AttDirData{Preferences}->{MD5Sum}
        )
    {

        my %RealProperties =
            $Self->{AttachmentStorageObject}->AttachmentStorageGetRealProperties(
            %AttDirData,
            );

        $RetVal       = "(size " . $AttDirData{Preferences}->{FileSizeBytes} . ")";
        $RealMD5Sum   = $RealProperties{RealMD5Sum};
        $RealFileSize = $RealProperties{RealFileSize};

        if ( $RealFileSize != $AttDirData{Preferences}->{FileSizeBytes} ) {
            $SizeNote = " Invalid content - file size on disk has been changed";

            if ( $RealFileSize > ( 1024 * 1024 ) ) {
                $RealFileSize = sprintf "%.1f MBytes", ( $RealFileSize / ( 1024 * 1024 ) );
            }
            elsif ( $RealFileSize > 1024 ) {
                $RealFileSize = sprintf "%.1f KBytes", ( ( $RealFileSize / 1024 ) );
            }
            else {
                $RealFileSize = $RealFileSize . ' Bytes';
            }

            $RetVal = "(real size " . $RealFileSize . $SizeNote . ")";
        }
        elsif ( $RealMD5Sum ne $AttDirData{Preferences}->{MD5Sum} ) {
            $MD5Note = " Invalid md5sum - The file might have been changed.";
            $RetVal =~ s/\)/$MD5Note\)/g;
        }

    }
    $RetVal = $AttDirData{FileName};

    #return file information...
    return $RetVal;
}

=item ImportSearchValuePrepare()

prepare search value for import

    my $ArrayRef = $BackendObject->ImportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    # this attribute is not intended for import yet...
    $Param{Value} = "";

    return $Param{Value};
}

=item ImportValuePrepare()

prepare value for import

    my $Value = $BackendObject->ImportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    # this attribute is not intended for import yet...
    $Param{Value} = "";

    return $Param{Value};
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl.txt.

=cut

=head1 VERSION

$Revision: 1.6 $ $Date: 2011-07-25 09:23:46 $

=cut
 # --
# Kernel/System/ITSMConfigItem/XML/Type/CustomerCompany.pm - xml backend module
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape-it(dot)de
#
# --
# $Id: CustomerCompany.pm,v 1.10 2011-04-28 13:08:46 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ITSMConfigItem::XML::Type::CustomerCompany;

use strict;
use warnings;

use Kernel::System::CustomerCompany;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.10 $) [1];

=head1 NAME

Kernel::System::ITSMConfigItem::XML::Type::CustomerCompany - xml backend module

=head1 SYNOPSIS

All xml functions of CustomerCompany objects

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::ConfigItem;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ConfigItemObject = Kernel::System::ConfigItem->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
    );
    $BackendObject = $ConfigItemObject->_LoadXMLTypeBackend(
        Type => 'CustomerCompany',
    );

=cut

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

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

    # check needed objects
    for my $Object (qw(DBObject ConfigObject LogObject MainObject EncodeObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    $Self->{CustomerCompanyObject} = Kernel::System::CustomerCompany->new( %{$Self} );

    return $Self;
}

=item ValueLookup()

get the xml data of a version

    my $Value = $BackendObject->ValueLookup(
        Value => 11, # (optional)
    );

=cut

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

    return '' if !$Param{Value};

    my %CustomerCompanySearchList = $Self->{CustomerCompanyObject}->CustomerCompanyGet(
        CustomerID => $Param{Value},
    );

    my $CustomerCompanyDataStr = '';
    my $CustCompanyMapRef =
        $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::CompanyBackendMapping');

    if ( $CustCompanyMapRef && ref($CustCompanyMapRef) eq 'HASH' ) {

        for my $MappingField ( sort( keys( %{$CustCompanyMapRef} ) ) ) {
            if ( $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} } ) {
                $CustomerCompanyDataStr .= ' '
                    . $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} };
            }
        }

    }

    $CustomerCompanyDataStr =~ s/\s+$//g;
    $CustomerCompanyDataStr =~ s/^\s+//g;

    return $CustomerCompanyDataStr;
}

=item StatsAttributeCreate()

create a attribute array for the stats framework

    my $Attribute = $BackendObject->StatsAttributeCreate(
        Key => 'Key::Subkey',
        Name => 'Name',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Name Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # create arrtibute
    my $Attribute = [
        {
            Name             => $Param{Name},
            UseAsXvalue      => 0,
            UseAsValueSeries => 0,
            UseAsRestriction => 1,
            Element          => $Param{Key},
            Block            => 'InputField',
        },
    ];

    return $Attribute;
}

=item ExportSearchValuePrepare()

prepare search value for export

    my $ArrayRef = $BackendObject->ExportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};
    return $Param{Value};
}

=item ExportValuePrepare()

prepare value for export

    my $Value = $BackendObject->ExportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    my %CustomerCompanySearchList = $Self->{CustomerCompanyObject}->CustomerCompanyGet(
        CustomerID => $Param{Value},
    );

    my $CustomerCompanyDataStr = '';
    my $CustCompanyMapRef =
        $Self->{ConfigObject}->Get('ITSMCIAttributeCollection::CompanyBackendMapping');

    if ( $CustCompanyMapRef && ref($CustCompanyMapRef) eq 'HASH' ) {

        for my $MappingField ( sort( keys( %{$CustCompanyMapRef} ) ) ) {
            if ( $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} } ) {
                $CustomerCompanyDataStr .= ' '
                    . $CustomerCompanySearchList{ $CustCompanyMapRef->{$MappingField} };
            }
        }

    }

    $CustomerCompanyDataStr =~ s/\s+$//g;
    $CustomerCompanyDataStr =~ s/^\s+//g;

    return $CustomerCompanyDataStr;

    #return if !defined $Param{Value};
    #return $Param{Value};
}

=item ImportSearchValuePrepare()

prepare search value for import

    my $ArrayRef = $BackendObject->ImportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    # search for name....
    my %CustomerCompanyList = $Self->{CustomerCompanyObject}->CustomerCompanyList(
        Search => '*' . $Param{Value} . '*',
    );

    if (
        %CustomerCompanyList
        && ( scalar( keys %CustomerCompanyList ) == 1 )
        )
    {
        my @Result = keys %CustomerCompanyList;
        return $Result[0];
    }

    return $Param{Value};
}

=item ImportValuePrepare()

prepare value for import

    my $Value = $BackendObject->ImportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};
    return $Param{Value};
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.10 $ $Date: 2011-04-28 13:08:46 $

=cut
 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 # --
# Kernel/System/ITSMConfigItem/XML/Type/User.pm - xml backend module
# Copyright (C) 2001-2008 OTRS AG, http://otrs.org/
# Extensions Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# Stefan Mehlig
# --
# $Id: User.pm,v 1.8 2011-05-10 13:31:45 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ITSMConfigItem::XML::Type::User;

use strict;
use warnings;

use Kernel::System::User;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.8 $) [1];

=head1 NAME

Kernel::System::ITSMConfigItem::XML::Type::User - xml backend module

=head1 SYNOPSIS

All xml functions of User objects

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::ConfigItem;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ConfigItemObject = Kernel::System::ConfigItem->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
    );
    $BackendObject = $ConfigItemObject->_LoadXMLTypeBackend(
        Type => 'User',
    );

=cut

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

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

    # check needed objects
    for my $Object (qw(DBObject ConfigObject TimeObject LogObject MainObject EncodeObject)) {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    $Self->{UserObject} = Kernel::System::User->new( %{$Self} );

    return $Self;
}

=item ValueLookup()

get the xml data of a version

    my $Value = $BackendObject->ValueLookup(
        Value => 11, # (optional)
    );

=cut

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

    return '' if !$Param{Value};

    # get User data
    my %UserSearchList = $Self->{UserObject}->GetUserData(
        UserID => $Param{Value},
    );
    my $UserName = '';
    if (%UserSearchList) {
        $UserName = '"'
            . $UserSearchList{UserFirstname} . ' '
            . $UserSearchList{UserLastname} . '" <'
            . $UserSearchList{UserEmail} . '>';
    }

    return $UserName || '';

}

=item StatsAttributeCreate()

create a attribute array for the stats framework

    my $Attribute = $BackendObject->StatsAttributeCreate(
        Key => 'Key::Subkey',
        Name => 'Name',
        Item => $ItemRef,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(Key Name Item)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!"
            );
            return;
        }
    }

    # create arrtibute
    my $Attribute = [
        {
            Name             => $Param{Name},
            UseAsXvalue      => 0,
            UseAsValueSeries => 0,
            UseAsRestriction => 1,
            Element          => $Param{Key},
            Block            => 'InputField',
        },
    ];

    return $Attribute;
}

=item ExportSearchValuePrepare()

prepare search value for export

    my $ArrayRef = $BackendObject->ExportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my %UserData = $Self->{UserObject}->GetUserData(
        UserID => $Param{Value},
    );

    $Self->{LogObject}->Log(
        Priority => 'error',
        Message  => "No user found for ID <$Param{Value}>!"
    );

    return $Param{Value};
}

=item ExportValuePrepare()

prepare value for export

    my $Value = $BackendObject->ExportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my %UserData = $Self->{UserObject}->GetUserData(
        UserID => $Param{Value},
    );

    $Self->{LogObject}->Log(
        Priority => 'error',
        Message  => "No user found for ID <$Param{Value}>!"
    );

    return $UserData{UserLogin} || '';
}

=item ImportSearchValuePrepare()

prepare search value for import

    my $ArrayRef = $BackendObject->ImportSearchValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my %UserData = $Self->{UserObject}->GetUserData(
        User => $Param{Value},
    );

    if ( !$UserData{UserID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No user found for login <$Param{Value}>!"
        );
        return;
    }

    return $UserData{UserID};
}

=item ImportValuePrepare()

prepare value for import

    my $Value = $BackendObject->ImportValuePrepare(
        Value => 11, # (optional)
    );

=cut

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

    return if !defined $Param{Value};

    my %UserData = $Self->{UserObject}->GetUserData(
        User => $Param{Value},
    );

    if ( !$UserData{UserID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No user found for login <$Param{Value}>!"
        );
        return;
    }

    return $UserData{UserID};
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.8 $ $Date: 2011-05-10 13:31:45 $

=cut
 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 # --
# Kernel/System/ITSMConfigItem/Event/CIClassReference_RefreshLinks.pm
#
# Searches for attributes of type CIClassReference in the new CIs version data
# and refreshes all links to that class, if configured in CI-class definition.
# It deletes links to any objects of the referenced CI-class if the value does
# not exis in the CIs version data.
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# --
# $Id: CIClassReference_RefreshLinks.pm,v 1.16 2011-08-26 13:35:15 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::ITSMConfigItem::Event::CIClassReference_RefreshLinks;

use strict;
use warnings;

use Kernel::System::LinkObject;
use Kernel::System::GeneralCatalog;
use Kernel::System::ITSMCIAttributCollectionUtils;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.16 $) [1];

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

    #alCoCentate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #get required objects...
    foreach (
        qw(ConfigObject LogObject DBObject MainObject TimeObject
        ConfigItemObject EncodeObject)
        )
    {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    if ( !$Self->{LinkObject} ) {
        $Self->{LinkObject} = Kernel::System::LinkObject->new( %{$Self} );
    }

    if ( !$Self->{GeneralCatalogObject} ) {
        $Self->{GeneralCatalogObject} =
            Kernel::System::GeneralCatalog->new( %{$Self} );
    }

    if ( !$Self->{CIAttributCollectionUtilsObject} ) {
        $Self->{CIAttributCollectionUtilsObject} =
            Kernel::System::ITSMCIAttributCollectionUtils->new( %{$Self} );
    }

    return $Self;
}

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

    #check required stuff...
    foreach (qw(Event ConfigItemID)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Event::CIClassReference_RefreshLinks: Need $_!"
            );
            return;
        }
    }

    #get config item...
    my $ConfigItemRef =
        $Self->{ConfigItemObject}
        ->ConfigItemGet( ConfigItemID => $Param{ConfigItemID}, );
    return if ( !$ConfigItemRef || ref($ConfigItemRef) ne 'HASH' );

    #check if there is a version at all...
    my $VersionListRef =
        $Self->{ConfigItemObject}
        ->VersionList( ConfigItemID => $Param{ConfigItemID}, );
    return if ( !$VersionListRef->[0] );

    #get the most current version...
    my $VersionData =
        $Self->{ConfigItemObject}
        ->VersionGet( ConfigItemID => $Param{ConfigItemID}, );
    return if ( !$VersionData || ref($VersionData) ne 'HASH' );

    #---------------------------------------------------------------------------
    # get hash with all attribute-keys, referenced CI-classes,
    # corresponding link types and -directions from CI-class definition...

    my %RelAttr = ();
    my $XMLDefinition =
        $Self->{ConfigItemObject}
        ->DefinitionGet( ClassID => $VersionData->{ClassID}, );

    # _CreateCIReferencesHash() returns a hash ref with following structure:
    # $RelAttr{Key}->{ReferencedCIClassLinkType}
    # $RelAttr{Key}->{ReferencedCIClassLinkDirection}
    # $RelAttr{Key}->{ReferencedCIClassName}
    %RelAttr = $Self->_CreateCIReferencesHash(
        XMLData       => $VersionData->{XMLData}->[1]->{Version}->[1],
        XMLDefinition => $XMLDefinition->{DefinitionRef},
    );

    my %CIReferenceAttrData = ();

    #---------------------------------------------------------------------------
    # update ConfigItem-links...
    if ( $VersionData && $XMLDefinition && %RelAttr ) {

        for my $CurrKeyname ( keys(%RelAttr) ) {

            next if !$RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassLinkType};

            #get current links from this CI..
            #my @LinkedSrcRefereceIDs = @{
            #$Self->GetLinkedObjects(
            #FromObject   => 'ITSMConfigItem',
            #FromObjectID => $Param{ConfigItemID},
            #ToObject     => 'ITSMConfigItem',
            #ToSubObject  => $RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassName},
            #LinkType     => $RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassLinkType},
            #Direction    => 'Source',
            #)
            #};
            my %Links = $Self->{LinkObject}->LinkKeyList(
                Object1 => 'ITSMConfigItem',
                Key1    => $Param{ConfigItemID},
                Object2 => 'ITSMConfigItem',
                State   => 'Valid',
                Type =>
                    $RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassLinkType},
                Direction => 'Source',
                UserID    => 1,
            );
            my @LinkedSrcRefereceIDs = keys %Links;

            %Links = $Self->{LinkObject}->LinkKeyList(
                Object1 => 'ITSMConfigItem',
                Key1    => $Param{ConfigItemID},
                Object2 => 'ITSMConfigItem',
                State   => 'Valid',
                Type =>
                    $RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassLinkType},
                Direction => 'Target',
                UserID    => 1,
            );
            my @LinkedTargetReferenceIDs = keys %Links;

            #-----------------------------------------------------------------------
            # delete existing links...
            #if possible, do what we're here for...

            %CIReferenceAttrData = %{
                $Self->_GetAttributeDataByKey(
                    XMLData       => $VersionData->{XMLData}->[1]->{Version}->[1],
                    XMLDefinition => $XMLDefinition->{DefinitionRef},
                    KeyName       => $CurrKeyname,
                    Content => 1,    #need the CI-ID, not the shown value
                    )
                };

            #delete all existing links...
            if ( keys(%CIReferenceAttrData) ) {
                for my $CurrLinkPartnerID (@LinkedSrcRefereceIDs) {

                    $Self->{LinkObject}->LinkDelete(
                        Object1 => 'ITSMConfigItem',
                        Key1    => $Param{ConfigItemID},
                        Object2 => 'ITSMConfigItem',
                        Key2    => $CurrLinkPartnerID,
                        Type    => $RelAttr{$CurrKeyname}->[0]
                            ->{ReferencedCIClassLinkType},
                        UserID => 1,
                    );
                }
            }

            #delete all existing Target  links...
            for my $CurrLinkPartnerID (@LinkedTargetReferenceIDs) {

                $Self->{LinkObject}->LinkDelete(
                    Object1 => 'ITSMConfigItem',
                    Key1    => $Param{ConfigItemID},
                    Object2 => 'ITSMConfigItem',
                    Key2    => $CurrLinkPartnerID,
                    Type =>
                        $RelAttr{$CurrKeyname}->[0]->{ReferencedCIClassLinkType},
                    UserID => 1,
                );
            }
        }    #EO for my $CurrKeyname ( keys( %RelAttr ))

        for my $CurrKeyname ( keys(%RelAttr) ) {

            %CIReferenceAttrData = %{
                $Self->_GetAttributeDataByKey(
                    XMLData       => $VersionData->{XMLData}->[1]->{Version}->[1],
                    XMLDefinition => $XMLDefinition->{DefinitionRef},
                    KeyName       => $CurrKeyname,
                    Content => 1,    #need the CI-ID, not the shown value
                    )
                };

            #-----------------------------------------------------------------------
            # create all links from available data...
            for my $SearchResult ( keys(%CIReferenceAttrData) ) {

                my @ReferenceCIIDs = @{ $CIReferenceAttrData{$SearchResult} };
                for my $CurrCIReferenceID (@ReferenceCIIDs) {

                    #create link between this CI and current CIReference-attribute...
                    if ( $CurrCIReferenceID && $Param{ConfigItemID} ) {

                        if (
                            $RelAttr{$CurrKeyname}->[0]
                            ->{ReferencedCIClassLinkDirection}
                            && $RelAttr{$CurrKeyname}->[0]
                            ->{ReferencedCIClassLinkDirection} eq 'Reverse'
                            )
                        {
                            $Self->{LinkObject}->LinkAdd(
                                SourceObject => 'ITSMConfigItem',
                                SourceKey    => $CurrCIReferenceID,
                                TargetObject => 'ITSMConfigItem',
                                TargetKey    => $Param{ConfigItemID},
                                Type         => $RelAttr{$CurrKeyname}->[0]
                                    ->{ReferencedCIClassLinkType},
                                State  => 'Valid',
                                UserID => 1,
                            );

                        }
                        else {
                            $Self->{LinkObject}->LinkAdd(
                                TargetObject => 'ITSMConfigItem',
                                TargetKey    => $CurrCIReferenceID,
                                SourceObject => 'ITSMConfigItem',
                                SourceKey    => $Param{ConfigItemID},
                                Type         => $RelAttr{$CurrKeyname}->[0]
                                    ->{ReferencedCIClassLinkType},
                                State  => 'Valid',
                                UserID => 1,
                            );
                        }

                    }    #EO if( $CurrCIReferenceID && $Param{ConfigItemID})

                }    #EO for my $CurrCIReferenceID( @ReferenceCIIDs )

            }    #EO foreach my $SearchResult ( keys( %CIReferenceAttrData))

        }    #EO for my $CurrKeyname ( keys( %RelAttr ))

    }    #EO if ( $VersionData && $XMLDefinition && %RelAttr)
    return;
}

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

    # check required params...
    if (
        ( !$Param{XMLData} )
        || ( !$Param{XMLDefinition} )
        || ( ref $Param{XMLData} ne 'HASH' )
        || ( ref $Param{XMLDefinition} ne 'ARRAY' )
        )
    {
        return;
    }

    my $CIRelAttr =

        #$Self->{ConfigItemObject}->GetAttributeDataByType(
        $Self->{CIAttributCollectionUtilsObject}->GetAttributeDataByType(
        XMLData       => $Param{XMLData},
        XMLDefinition => $Param{XMLDefinition},
        AttributeType => 'CIClassReference',
        );

    my %SumRelAttr = ();
    my $ParamRef;
    for my $Key ( keys %{$CIRelAttr} ) {

        my %RetHash = ();
        ITEM:
        for my $Item ( @{ $Param{XMLDefinition} } ) {

            COUNTER:
            for my $Counter ( 1 .. $Item->{CountMax} ) {

                # no content then stop loop...
                last COUNTER
                    if !
                        defined $Param{XMLData}->{ $Item->{Key} }->[$Counter]
                        ->{Content};

                if ( $Item->{Key} eq $Key ) {

                    foreach my $ParamRef (
                        qw(ReferencedCIClassName ReferencedCIClassLinkType ReferencedCIClassLinkDirection)
                        )
                    {
                        $RetHash{$ParamRef} = $Item->{Input}->{$ParamRef};

                    }
                }
                next COUNTER if !$Item->{Sub};
            }
        }
        push @{ $SumRelAttr{$Key} }, \%RetHash;

    }
    return %SumRelAttr;
}

=item _GetAttributeDataByKey()

    Returns a hashref with names and attribute values from the 
    XML-DataHash for a specified data type.

    $ConfigItemObject->GetAttributeDataByKey( 
        XMLData       => $XMLData,
        XMLDefinition => $XMLDefinition,
        KeyName => $Key,
    );

=cut

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

    my %Result;

    if ( $Param{Content} ) {
        my $CurrContent =

            #$Self->{ConfigItemObject}->GetAttributeContentsByKey(
            $Self->{CIAttributCollectionUtilsObject}->GetAttributeContentsByKey(
            KeyName       => $Param{KeyName},
            XMLData       => $Param{XMLData},
            XMLDefinition => $Param{XMLDefinition},
            );
        $Result{ $Param{KeyName} } = $CurrContent;
    }
    else {
        my $CurrVal =

            #$Self->{ConfigItemObject}->GetAttributeValuesByKey(
            $Self->{CIAttributCollectionUtilsObject}->GetAttributeValuesByKey(
            KeyName       => $Param{KeyName},
            XMLData       => $Param{XMLData},
            XMLDefinition => $Param{XMLDefinition},
            );
        $Result{ $Param{KeyName} } = $CurrVal;
    }
    return \%Result;

}

1;
 # --
# Kernel/System/ITSMConfigItem/Event/ServiceReference_RefreshLinks.pm
#
# Searches for attributes of type ServiceReference in the new CIs version data
# and refreshes all links to that class, if configured in CI-class definition.
# It deletes links to any objects of the referenced CI-class if the value does
# not exis in the CIs version data.
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/changed by:
# * Stefan(dot)Mehlig(at)cape-it(dot)de
#
# --
# $Id: ServiceReference_RefreshLinks.pm,v 1.6 2011-08-26 13:34:57 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::ITSMConfigItem::Event::ServiceReference_RefreshLinks;

use strict;
use warnings;

use Kernel::System::LinkObject;
use Kernel::System::GeneralCatalog;
use Kernel::System::ITSMCIAttributCollectionUtils;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.6 $) [1];

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

    #alCoCentate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #get required objects...
    foreach (
        qw(ConfigObject LogObject DBObject MainObject TimeObject
        ConfigItemObject EncodeObject)
        )
    {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    if ( !$Self->{LinkObject} ) {
        $Self->{LinkObject} = Kernel::System::LinkObject->new( %{$Self} );
    }

    if ( !$Self->{GeneralCatalogObject} ) {
        $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
    }

    if ( !$Self->{CIAttributCollectionUtilsObject} ) {
        $Self->{CIAttributCollectionUtilsObject} =
            Kernel::System::ITSMCIAttributCollectionUtils->new( %{$Self} );
    }

    return $Self;
}

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

    #check required stuff...
    foreach (qw(Event ConfigItemID)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Event::ServiceReference_RefreshLinks: Need $_!"
            );
            return;
        }
    }

    #get config item...
    my $ConfigItemRef = $Self->{ConfigItemObject}->ConfigItemGet(
        ConfigItemID => $Param{ConfigItemID},
    );
    return if ( !$ConfigItemRef || ref($ConfigItemRef) ne 'HASH' );

    #check if there is a version at all...
    my $VersionListRef = $Self->{ConfigItemObject}->VersionList(
        ConfigItemID => $Param{ConfigItemID},
    );
    return if ( !$VersionListRef->[0] );

    #get the most current version...
    my $VersionData = $Self->{ConfigItemObject}->VersionGet(
        ConfigItemID => $Param{ConfigItemID},
    );
    return if ( !$VersionData || ref($VersionData) ne 'HASH' );

    #---------------------------------------------------------------------------
    # get hash with all attribute-keys, referenced CI-classes,
    # corresponding link types and -directions from CI-class definition...

    my %RelAttr       = ();
    my $XMLDefinition = $Self->{ConfigItemObject}->DefinitionGet(
        ClassID => $VersionData->{ClassID},
    );

    # _CreateCIReferencesHash() returns a hash ref with following structure:
    # $RelAttr{Key}->{ReferencedServiceLinkType}
    # $RelAttr{Key}->{ReferencedServiceLinkDirection}
    %RelAttr = $Self->_CreateCIReferencesHash(
        XMLData       => $VersionData->{XMLData}->[1]->{Version}->[1],
        XMLDefinition => $XMLDefinition->{DefinitionRef},
    );

    my %CIReferenceAttrData = ();

    #---------------------------------------------------------------------------
    # update ConfigItem-links...
    if ( $VersionData && $XMLDefinition && %RelAttr ) {

        for my $CurrKeyname ( keys(%RelAttr) ) {

            next if !$RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType};

            #get current links from this CI..
            my @LinkedSrcRefereceIDs = @{
                $Self->GetLinkedObjects(
                    FromObject   => 'ITSMConfigItem',
                    FromObjectID => $Param{ConfigItemID},
                    ToObject     => 'Service',
                    ToSubObject  => '',
                    LinkType     => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                    Direction    => 'Source',
                    )
                };

            #get current  links to this CI..
            my @LinkedTargetReferenceIDs = @{
                $Self->GetLinkedObjects(
                    FromObject   => 'Service',
                    FromObjectID => $Param{ConfigItemID},
                    ToObject     => 'ITSMConfigItem',
                    ToSubObject  => '',
                    LinkType     => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                    Direction    => 'Target',
                    )
                };

            #-----------------------------------------------------------------------
            # delete existing links...
            #if possible, do what we're here for...
            if ( $VersionData && $XMLDefinition ) {

                %CIReferenceAttrData = %{
                    $Self->_GetAttributeDataByKey(
                        XMLData       => $VersionData->{XMLData}->[1]->{Version}->[1],
                        XMLDefinition => $XMLDefinition->{DefinitionRef},
                        KeyName       => $CurrKeyname,
                        Content => 1,    #need the CI-ID, not the shown value
                        )
                    };

                #delete all existing links...
                if ( keys(%CIReferenceAttrData) ) {
                    for my $CurrLinkPartnerID (@LinkedSrcRefereceIDs) {

                        $Self->{LinkObject}->LinkDelete(
                            Object1 => 'ITSMConfigItem',
                            Key1    => $Param{ConfigItemID},
                            Object2 => 'Service',
                            Key2    => $CurrLinkPartnerID,
                            Type    => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                            UserID  => 1,
                        );
                    }
                }

                #delete all existing Target  links...
                for my $CurrLinkPartnerID (@LinkedTargetReferenceIDs) {

                    $Self->{LinkObject}->LinkDelete(
                        Object1 => 'ITSMConfigItem',
                        Key1    => $Param{ConfigItemID},
                        Object2 => 'Service',
                        Key2    => $CurrLinkPartnerID,
                        Type    => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                        UserID  => 1,
                    );
                }
            }

            #-----------------------------------------------------------------------
            # create all links from available data...
            for my $SearchResult ( keys(%CIReferenceAttrData) ) {
                my @ReferenceCIIDs = @{ $CIReferenceAttrData{$SearchResult} };
                for my $CurrCIReferenceID (@ReferenceCIIDs) {

                    #create link between this CI and current CIReference-attribute...
                    if ( $CurrCIReferenceID && $Param{ConfigItemID} ) {
                        if (
                            $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkDirection}
                            &&
                            $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkDirection} eq
                            'Reverse'
                            )
                        {
                            $Self->{LinkObject}->LinkAdd(
                                SourceObject => 'Service',
                                SourceKey    => $CurrCIReferenceID,
                                TargetObject => 'ITSMConfigItem',
                                TargetKey    => $Param{ConfigItemID},
                                Type   => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                                State  => 'Valid',
                                UserID => 1,
                            );

                        }
                        else {
                            $Self->{LinkObject}->LinkAdd(
                                TargetObject => 'Service',
                                TargetKey    => $CurrCIReferenceID,
                                SourceObject => 'ITSMConfigItem',
                                SourceKey    => $Param{ConfigItemID},
                                Type   => $RelAttr{$CurrKeyname}->[0]->{ReferencedServiceLinkType},
                                State  => 'Valid',
                                UserID => 1,
                            );
                        }

                    }    #EO if( $CurrCIReferenceID && $Param{ConfigItemID})

                }    #EO for my $CurrCIReferenceID( @ReferenceCIIDs )

            }    #EO foreach my $SearchResult ( keys( %CIReferenceAttrData))

        }    #EO for my $CurrKeyname ( keys( %RelAttr ))

    }    #EO if ( $VersionData && $XMLDefinition && %RelAttr)
    return;
}

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

    # check required params...
    if (
        ( !$Param{XMLData} ) ||
        ( !$Param{XMLDefinition} ) ||
        ( ref $Param{XMLData} ne 'HASH' ) ||
        ( ref $Param{XMLDefinition} ne 'ARRAY' )
        )
    {
        return;
    }

    my $CIRelAttr =

        #$Self->{ConfigItemObject}->GetAttributeDataByType(
        $Self->{CIAttributCollectionUtilsObject}->GetAttributeDataByType(
        XMLData       => $Param{XMLData},
        XMLDefinition => $Param{XMLDefinition},
        AttributeType => 'ServiceReference',
        );

    my %SumRelAttr = ();
    my $ParamRef;
    for my $Key ( keys %{$CIRelAttr} ) {

        my %RetHash = ();
        ITEM:
        for my $Item ( @{ $Param{XMLDefinition} } ) {

            COUNTER:
            for my $Counter ( 1 .. $Item->{CountMax} ) {

                # no content then stop loop...
                last COUNTER if !defined $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content};

                if ( $Item->{Key} eq $Key ) {

                    foreach my $ParamRef (
                        qw(ReferencedServiceName ReferencedServiceLinkType ReferencedServiceLinkDirection)
                        )
                    {
                        $RetHash{$ParamRef} = $Item->{Input}->{$ParamRef};

                    }
                }
                next COUNTER if !$Item->{Sub};
            }
        }
        push @{ $SumRelAttr{$Key} }, \%RetHash;

    }
    return %SumRelAttr;
}

=item _GetAttributeDataByKey()

    Returns a hashref with names and attribute values from the 
    XML-DataHash for a specified data type.

    $ConfigItemObject->GetAttributeDataByKey( 
        XMLData       => $XMLData,
        XMLDefinition => $XMLDefinition,
        KeyName => $Key,
    );

=cut

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

    my %Result;

    if ( $Param{Content} ) {
        my $CurrContent =    #$Self->{ConfigItemObject}->GetAttributeContentsByKey(
            $Self->{CIAttributCollectionUtilsObject}->GetAttributeContentsByKey(
            KeyName       => $Param{KeyName},
            XMLData       => $Param{XMLData},
            XMLDefinition => $Param{XMLDefinition},
            );
        $Result{ $Param{KeyName} } = $CurrContent;
    }
    else {
        my $CurrVal =        #$Self->{ConfigItemObject}->GetAttributeValuesByKey(
            $Self->{CIAttributCollectionUtilsObject}->GetAttributeValuesByKey(
            KeyName       => $Param{KeyName},
            XMLData       => $Param{XMLData},
            XMLDefinition => $Param{XMLDefinition},
            );
        $Result{ $Param{KeyName} } = $CurrVal;
    }
    return \%Result;

}

#-------------------------------------------------------------------------------
#

=item GetLinkedObjects()

   returns an array ref with IDs of linked objects
   
   NOTE: remove this method as soon as (KIX) 
   Kernel::System::LinkObject::GetLinkedObjects has been modified and is 
   available !!!
   
   my @LinkedLocationIDs = @{$Self->GetLinkedObjects(
       FromObject   => 'ITSMConfigItem',
       FromObjectID => 123,
       ToObject     => 'ITSMConfigItem' | 'Ticket',
       ToSubObject  => 'Location-Some CI Class' | 'OrSomeTicketType',
       LinkType     => 'ParentChild',        #LinkType - optional
       Direction    => (Source|Target|Both), #LinkDirection - optional
   )};

=cut

sub GetLinkedObjects {
    my ( $Self, %Param ) = @_;
    my @IDArr = qw{};

    # check required params...
    if ( ( !$Param{ToObject} ) || ( !$Param{FromObject} ) || ( !$Param{FromObjectID} ) )
    {
        return \@IDArr;
    }

    #as long as it's not implemented...
    if (
        ( $Param{ToObject} ne 'ITSMConfigItem' )
        && ( $Param{ToObject} ne 'Ticket' )
        && ( $Param{ToObject} ne 'Service' )
        )
    {
        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => "LinkObject::GetLinkedObjects: "
                . "unknown ToObject $Param{ToObject} - won't do anything.",
        );
        return \@IDArr;
    }

    if ( !$Param{ToSubObject} ) {
        $Param{ToSubObject} = "";
    }

    #get all linked ToObjects...
    my $PartnerLinkList = $Self->{LinkObject}->LinkListWithData(
        Object    => $Param{FromObject},
        Key       => $Param{FromObjectID},
        Object2   => $Param{ToObject},
        State     => 'Valid',
        Type      => $Param{LinkType} || '',
        Direction => $Param{Direction} || 'Both',
        UserID    => 1,
    );

    #---------------------------------------------------------------------------
    # ToPartner "ITSMConfigItem"
    if ( $Param{ToObject} eq 'ITSMConfigItem' ) {

        #for each existing link type
        for my $LinkType ( keys( %{ $PartnerLinkList->{'ITSMConfigItem'} } ) ) {

            #if linked object is a source
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) eq 'HASH' )
                )
            {
                for my $CurrCIID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} } )
                    )
                {
                    my $CurrCI =
                        $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source}->{$CurrCIID};

                    if ( $Param{ToSubObject} && ( $CurrCI->{Class} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $CurrCIID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $CurrCIID );
                    }
                }
            }

            #if linked object is target
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) eq 'HASH' )
                )
            {
                for my $CurrCIID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} } )
                    )
                {
                    my $CurrCI = $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target}
                        ->{$CurrCIID};

                    if ( $Param{ToSubObject} && ( $CurrCI->{Class} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $CurrCIID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $CurrCIID );
                    }
                }
            }

        }    #EO for each existing link type

    }

    # EO ToPartner "ITSMConfigItem"
    #---------------------------------------------------------------------------

    #---------------------------------------------------------------------------
    # ToPartner "Ticket"
    if ( $Param{ToObject} eq 'Ticket' ) {

        #for each existing link type
        for my $LinkType ( keys( %{ $PartnerLinkList->{'Ticket'} } ) ) {

            #if linked object is a source
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) eq 'HASH' )
                )
            {
                for my $TicketID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} } )
                    )
                {
                    my $CurrTicket = $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source}
                        ->{$TicketID};

                    if ( $Param{ToSubObject} && ( $CurrTicket->{Type} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $TicketID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $TicketID );
                    }
                }
            }

            #if linked object is target
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) eq 'HASH' )
                )
            {
                for my $TicketID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} } )
                    )
                {
                    my $CurrTicket = $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target}
                        ->{$TicketID};

                    if ( $Param{ToSubObject} && ( $CurrTicket->{Type} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $TicketID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $TicketID );
                    }
                }
            }

        }    #EO for each existing link type

    }

    # EO ToPartner "Ticket"
    #---------------------------------------------------------------------------

    #---------------------------------------------------------------------------
    # ToPartner "Service"
    if ( $Param{ToObject} eq 'Service' ) {

        #for each existing link type
        for my $LinkType ( keys( %{ $PartnerLinkList->{'Service'} } ) ) {

            #if linked object is a source
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} ) eq 'HASH' )
                )
            {
                for my $ServiceID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source} } )
                    )
                {
                    my $CurrService = $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Source}
                        ->{$ServiceID};

                    if ( $Param{ToSubObject} && ( $CurrService->{Type} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $ServiceID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $ServiceID );
                    }
                }
            }

            #if linked object is target
            if (
                ( defined( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) )
                &&
                ( ref( $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} ) eq 'HASH' )
                )
            {
                for my $ServiceID (
                    keys( %{ $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target} } )
                    )
                {
                    my $CurrService = $PartnerLinkList->{ $Param{ToObject} }->{$LinkType}->{Target}
                        ->{$ServiceID};

                    if ( $Param{ToSubObject} && ( $CurrService->{Type} eq $Param{ToSubObject} ) ) {
                        push( @IDArr, $ServiceID );
                    }
                    elsif ( !$Param{ToSubObject} ) {
                        push( @IDArr, $ServiceID );
                    }
                }
            }

        }    #EO for each existing link type

    }

    # EO ToPartner "Service"
    #---------------------------------------------------------------------------

    return \@IDArr;
}

#
#-------------------------------------------------------------------------------

1;
 # --
# Kernel/System/ITSMCIAttributCollectionUtils.pm - additional config item functions
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Rene(dot)Boehm(at)cape-it(dot)de
# * Martin(dot)Balzarek(at)cape-it(dot)de
# * Frank(dot)Oberender(at)cape-it(dot)de
#
# --
# $Id: ITSMCIAttributCollectionUtils.pm,v 1.2 2011-03-14 14:33:15 alitvinova Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::System::ITSMCIAttributCollectionUtils;

use strict;
use warnings;

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

    #alCoCentate new hash for object...
    my $Self = {};
    bless( $Self, $Type );

    #get required objects...
    foreach (
        qw(ConfigObject LogObject DBObject MainObject TimeObject
        ConfigItemObject EncodeObject)
        )
    {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    return $Self;
}

#-------------------------------------------------------------------------------
# capeIT
# Thefollowing methods are meant to ease the handling of the XML-LIKE data hash.
# They do not replace any internal/original methods.

=item GetAttributeValuesByKey()

    Returns values first found, for a given attribute key.
        _GetAttributeValuesByKey (
            KeyName       => 'FQDN',
            XMLData       => $XMLDataRef,
            XMLDefinition => $XMLDefRef,
        );
=cut

sub GetAttributeValuesByKey {
    my ( $Self, %Param ) = @_;
    my @RetArray = qw{};

    # check required params...
    if (
        !$Param{KeyName}
        ||
        ( !$Param{XMLData} ) ||
        ( !$Param{XMLDefinition} ) ||
        ( ref $Param{XMLData} ne 'HASH' ) ||
        ( ref $Param{XMLDefinition} ne 'ARRAY' )
        )
    {
        return \@RetArray;
    }

    ITEM:
    for my $Item ( @{ $Param{XMLDefinition} } ) {

        COUNTER:
        for my $Counter ( 1 .. $Item->{CountMax} ) {

            # no content then stop loop...
            last COUNTER if !defined $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content};

            # get the value...
            my $Value = $Self->{ConfigItemObject}->XMLValueLookup(
                Item => $Item,
                Value => $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content} || '',
            );

            if ( ( $Item->{Key} eq $Param{KeyName} ) && $Value ) {
                push( @RetArray, $Value );
            }

            next COUNTER if !$Item->{Sub};

            #recurse if subsection available...
            my $SubResult = $Self->GetAttributeValuesByKey(
                KeyName       => $Param{KeyName},
                XMLDefinition => $Item->{Sub},
                XMLData       => $Param{XMLData}->{ $Item->{Key} }->[$Counter],
            );

            if ( ref($SubResult) eq 'ARRAY' ) {
                for my $ArrayElem ( @{$SubResult} ) {
                    push( @RetArray, $ArrayElem );
                }
            }
        }
    }

    return \@RetArray;
}

=item GetAttributeContentsByKey()

    Returns contents first found, for a given attribute key.
        GetAttributeContentsByKey (
            KeyName       => 'FQDN',
            XMLData       => $XMLDataRef,
            XMLDefinition => $XMLDefRef,
        );
=cut

sub GetAttributeContentsByKey {
    my ( $Self, %Param ) = @_;
    my @RetArray = qw{};

    # check required params...
    if (
        !$Param{KeyName}
        ||
        ( !$Param{XMLData} ) ||
        ( !$Param{XMLDefinition} ) ||
        ( ref $Param{XMLData} ne 'HASH' ) ||
        ( ref $Param{XMLDefinition} ne 'ARRAY' )
        )
    {
        return \@RetArray;
    }

    ITEM:
    for my $Item ( @{ $Param{XMLDefinition} } ) {

        COUNTER:
        for my $Counter ( 1 .. $Item->{CountMax} ) {

            # no content then stop loop...
            last COUNTER if !defined $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content};

            # get the value...
            my $Content = $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content} || '';

            if ( ( $Item->{Key} eq $Param{KeyName} ) && $Content ) {
                push( @RetArray, $Content );
            }

            next COUNTER if !$Item->{Sub};

            #recurse if subsection available...
            my $SubResult = $Self->GetAttributeContentsByKey(
                KeyName       => $Param{KeyName},
                XMLDefinition => $Item->{Sub},
                XMLData       => $Param{XMLData}->{ $Item->{Key} }->[$Counter],
            );

            if ( ref($SubResult) eq 'ARRAY' ) {
                for my $ArrayElem ( @{$SubResult} ) {
                    push( @RetArray, $ArrayElem );
                }
            }
        }
    }

    return \@RetArray;
}

=item GetAttributeDataByType()

    Returns a hashref with names and attribute values from the 
    XML-DataHash for a specified data type.

    $ConfigItemObject->GetAttributeDataByType( 
        XMLData       => $XMLData,
        XMLDefinition => $XMLDefinition,
        AttributeType => $AttributeType,
    );

=cut

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

    my @Keys = ();
    my %Result;

    #get all keys for specified input type...
    @Keys = @{
        $Self->GetKeyNamesByType(
            XMLDefinition => $Param{XMLDefinition},
            AttributeType => $Param{AttributeType}
            )
        };

    if ( $Param{Content} ) {
        for my $CurrKey (@Keys) {
            my $CurrContent = $Self->GetAttributeContentsByKey(
                KeyName       => $CurrKey,
                XMLData       => $Param{XMLData},
                XMLDefinition => $Param{XMLDefinition},
            );
            $Result{$CurrKey} = $CurrContent;
        }
    }
    else {
        for my $CurrKey (@Keys) {
            my $CurrVal = $Self->GetAttributeValuesByKey(
                KeyName       => $CurrKey,
                XMLData       => $Param{XMLData},
                XMLDefinition => $Param{XMLDefinition},
            );
            $Result{$CurrKey} = $CurrVal;
        }
    }

    return \%Result;

}

=item GetKeyNamesByType()

    Returns an array of keynames which are of a specified data type.

    $ConfigItemObject->GetKeyNamesByType( 
        XMLDefinition => $XMLDefinition,
        AttributeType => $AttributeType,
    );

=cut

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

    my @Keys = ();
    my %Result;

    if ( defined( $Param{XMLDefinition} ) ) {

        for my $AttrDef ( @{ $Param{XMLDefinition} } ) {
            if ( $AttrDef->{Input}->{Type} eq $Param{AttributeType} ) {
                push( @Keys, $AttrDef->{Key} )
            }

            next if !$AttrDef->{Sub};

            my @SubResult = @{
                $Self->GetKeyNamesByType(
                    AttributeType => $Param{AttributeType},
                    XMLDefinition => $AttrDef->{Sub},
                    )
                };

            @Keys = ( @Keys, @SubResult );
        }

    }

    return \@Keys;
}

=item _GetKeyNamesByType()

    Sames as GetKeyNamesByType - returns an array of keynames which are of a 
    specified data type. => use GetKeyNamesByType instead !
    !!! DEPRECATED - ONLY FOR COMPATIBILITY - WILL BE REMOVED !!! 

    $ConfigItemObject->_GetKeyNamesByType( 
        XMLDefinition => $XMLDefinition,
        AttributeType => $AttributeType,
    );

=cut

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

    my @Keys = ();
    my %Result;

    if ( defined( $Param{XMLDefinition} ) ) {

        for my $AttrDef ( @{ $Param{XMLDefinition} } ) {
            if ( $AttrDef->{Input}->{Type} eq $Param{AttributeType} ) {
                push( @Keys, $AttrDef->{Key} )
            }

            next if !$AttrDef->{Sub};

            my @SubResult = @{
                $Self->_GetKeyNamesByType(
                    AttributeType => $Param{AttributeType},
                    XMLDefinition => $AttrDef->{Sub},
                    )
                };

            @Keys = ( @Keys, @SubResult );
        }

    }

    return \@Keys;
}

=item GetAttributeDefByTagKey()

Returns choosen CI attribute definition, for a given tag key.
    my %AttrDef = $ConfigItemObject->GetAttributeDefByTagKey (
        TagKey        => "[1]{'Version'}[1]{'Model'}[1]",
        XMLData       => $XMLDataRef,
        XMLDefinition => $XMLDefRef,
    );

returns

    Input => {
        Type
        Class
        Required
        Translation
        Size
        MaxLength
    }
    Key
    Name
    Searchable
    CountMin
    CountMax
    CountDefault

=cut

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

    # check required params...
    return
        if (
        !$Param{XMLData}       || ref( $Param{XMLData} )       ne 'HASH' ||
        !$Param{XMLDefinition} || ref( $Param{XMLDefinition} ) ne 'ARRAY' ||
        !$Param{TagKey}
        );

    ITEM:
    for my $Item ( @{ $Param{XMLDefinition} } ) {
        next ITEM if ( !$Param{XMLData}->{ $Item->{Key} } );

        COUNTER:
        for my $Counter ( 1 .. $Item->{CountMax} ) {
            if ( $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{TagKey} eq $Param{TagKey} ) {
                return \%{$Item};
            }

            next COUNTER if !$Item->{Sub};

            # recurse if subsection available...
            my $SubResult = $Self->GetAttributeDefByTagKey(
                TagKey        => $Param{TagKey},
                XMLDefinition => $Item->{Sub},
                XMLData       => $Param{XMLData}->{ $Item->{Key} }->[$Counter],
            );

            if ( $SubResult && ref($SubResult) eq 'HASH' ) {
                return \%{$SubResult};
            }
        }
    }

    return ();
}

=item VersionDataUpdate()

    Returns a the current version data in the most current definition format
    (usually this is done in the frontend). The version data might be structured
    in a previous definition. 

    $NewVersionXMLData = $ConfigItemObject->VersionDataUpdate( 
        XMLDefinition => $NewDefinitionRef->{DefinitionRef},
        XMLData       => $CurrentVersionRef->{XMLData}->[1]->{Version}->[1],
    );

=cut

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

    # check needed stuff
    return if !$Param{XMLData};
    return if ref $Param{XMLData} ne 'HASH';
    return if !$Param{XMLDefinition};
    return if ref $Param{XMLDefinition} ne 'ARRAY';

    my $FormData = {};

    ITEM:
    for my $Item ( @{ $Param{XMLDefinition} } ) {
        my $CounterInsert = 1;

        COUNTER:
        for my $Counter ( 1 .. $Item->{CountMax} ) {

            # create inputkey and addkey
            my $InputKey = $Item->{Key} . '::' . $Counter;
            if ( $Param{Prefix} ) {
                $InputKey = $Param{Prefix} . '::' . $InputKey;
            }

            #get content...
            my $Content = $Param{XMLData}->{ $Item->{Key} }->[1]->{Content} || '';

            # start recursion, if "Sub" was found
            if ( $Item->{Sub} ) {
                my $SubFormData = $Self->VersionDataUpdate(
                    XMLDefinition => $Item->{Sub},
                    XMLData       => $Param{XMLData}->{ $Item->{Key} }->[1],
                    Prefix        => $InputKey,
                );
                $FormData->{ $Item->{Key} }->[$CounterInsert] = $SubFormData;
            }

            $FormData->{ $Item->{Key} }->[$CounterInsert]->{Content} = $Content;
            $CounterInsert++;

        }
    }

    return $FormData;
}

=item SetAttributeContentsByKey()

    Sets the content of the specified keyname in the XML data hash. 

    $ConfigItemObject->SetAttributeContentsByKey( 
        KeyName       => 'Location',
        NewContent    => $RetireCILocationID,
        XMLData       => $NewVersionData,
        XMLDefinition => $UsedVersion,
    );

=cut

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

    # check required params...
    if (
        !$Param{KeyName}
        ||
        !length( $Param{NewContent} ) ||
        ( !$Param{XMLData} ) ||
        ( !$Param{XMLDefinition} ) ||
        ( ref $Param{XMLData} ne 'HASH' ) ||
        ( ref $Param{XMLDefinition} ne 'ARRAY' )
        )
    {
        return 0;
    }

    ITEM:
    for my $Item ( @{ $Param{XMLDefinition} } ) {

        COUNTER:
        for my $Counter ( 1 .. $Item->{CountMax} ) {

            # no content then stop loop...
            last COUNTER if !defined $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content};

            # get the value...
            if ( $Item->{Key} eq $Param{KeyName} ) {
                $Param{XMLData}->{ $Item->{Key} }->[$Counter]->{Content} = $Param{NewContent};
            }

            next COUNTER if !$Item->{Sub};

            #recurse if subsection available...
            my $SubResult = $Self->SetAttributeContentsByKey(
                KeyName       => $Param{KeyName},
                NewContent    => $Param{NewContent},
                XMLDefinition => $Item->{Sub},
                XMLData       => $Param{XMLData}->{ $Item->{Key} }->[$Counter],
            );

        }
    }

    return 0;
}

# EO capeIT
#-------------------------------------------------------------------------------

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see http://www.gnu.org/licenses/agpl.txt.

=cut

=head1 VERSION

$Revision: 1.2 $ $Date: 2011-03-14 14:33:15 $

=cut
 # --
# Kernel/System/CIAttachmentStorage/AttachmentStorage.pm - lib for attachment management
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Anna(dot)Litvinova(at)cape-it(dot)de
# --
# $Id: AttachmentStorage.pm,v 1.7 2011-07-25 09:23:46 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::CIAttachmentStorage::AttachmentStorage;

use strict;
use warnings;

use MIME::Base64;
use Digest::MD5 qw(md5_hex);
use Encode qw(encode_utf8);

use vars qw($VERSION);
$VERSION = qw($Revision: 1.7 $) [1];

=head1 NAME

Kernel::System::CIAttachmentStorage::AttachmentStorage - std. attachment lib

=head1 SYNOPSIS

All attachment storage functions.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create std. attachment object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::CIAttachmentStorage::AttachmentStorage;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        MainObject => $MainObject,
        LogObject => $LogObject,
    );
    my $AttachmentStorageObject = Kernel::System::CIAttachmentStorage::AttachmentStorage->new(
        ConfigObject => $ConfigObject,
        DBObject => $DBObject,
        LogObject => $LogObject,
    );

=cut

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

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

    #check required objects...
    for my $Object (
        qw(ConfigObject LogObject DBObject MainObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    # get configured storage backends...
    my $BackendRef = $Self->{ConfigObject}->Get('AttachmentStorage::StorageBackendModules');
    if ( !( ref($BackendRef) eq 'HASH' ) ) {
        return;
    }

    #retrieve required storage backend modules...
    my %StorageBackendHash = ();
    my $SQL                = "SELECT distinct(storage_backend) FROM attachment_directory ";
    if ( $Self->{DBObject}->Prepare( SQL => $SQL ) ) {
        my @Data = $Self->{DBObject}->FetchrowArray();
        while ( my @Data = $Self->{DBObject}->FetchrowArray() ) {
            $BackendRef->{ $Data[0] } = 1;
        }
    }

    #load storage backends...
    for my $CurrKey ( keys( %{$BackendRef} ) ) {
        if ( $BackendRef->{$CurrKey} && $Self->{MainObject}->Require($CurrKey) ) {
            $Self->{$CurrKey} = $CurrKey->new( %{$Self}, );
        }
    }

    return $Self;
}

=item AttachmentStorageGetDirectory()

get an attachment - returns attachment directory entry without attachment content

    my %Data = $AttachmentStorageObject->AttachmentStorageGetDirectory(
        ID => $ID,
    );

=cut

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

    #check required stuff...
    if ( !$Param{ID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need ID!" );
        return;
    }

    #--------------------------
    # get attachment directory
    #--------------------------

    #db quoting...
    foreach (qw( ID)) {
        $Param{$_} = $Self->{DBObject}->Quote( $Param{$_}, 'Integer' );
    }

    #build sql...
    my $SQL = "SELECT id, storage_backend, file_path, " .
        "file_name " .
        "FROM attachment_directory " .
        "WHERE id=$Param{ID}";

    $Self->{DBObject}->Prepare(
        SQL => $SQL,
    );

    while ( my @Data = $Self->{DBObject}->FetchrowArray() ) {
        %Data = (
            AttDirID       => $Data[0],
            StorageBackend => $Data[1],
            FilePath       => $Data[2],
            FileName       => $Data[3],
        );
    }

    #-------------------------------------
    # get attachment directory preferences
    #-------------------------------------

    #build sql...
    $SQL = "SELECT preferences_key, preferences_value " .
        "FROM attachment_dir_preferences " .
        "WHERE attachment_directory_id=$Param{ID}";

    $Self->{DBObject}->Prepare(
        SQL => $SQL,
    );

    my %Preferences;

    while ( my @Data = $Self->{DBObject}->FetchrowArray() ) {
        $Preferences{ $Data[0] } = $Data[1];
    }

    #add preferences
    $Data{Preferences} = \%Preferences;

    return %Data;
}

=item AttachmentStorageGet()

get an attachment

    my %Data = $AttachmentStorageObject->AttachmentStorageGet(
        ID => $ID,
    );

=cut

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

    #check required stuff...
    if ( !$Param{ID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need ID!" );
        return \%Data;
    }

    #get directory data...
    %Data = $Self->AttachmentStorageGetDirectory( ID => $Param{ID} );

    if ( !defined( $Data{AttDirID} ) ) {
        $Self->{LogObject}
            ->Log( Priority => 'error', Message => "No attachment with this ID exists!" );
        return \%Data;
    }

    #get the actual attachment...
    my $AttachmentRef = $Self->{ $Data{StorageBackend} }->AttachmentGet(
        %Param,
        AttDirID => $Data{AttDirID},
    );

    #$Data{ContentType} = $AttachmentRef->{DataType};

    # get ContentRef for DB backend
    if ( $AttachmentRef->{DataRef} ) {
        $Data{ContentRef} = $AttachmentRef->{DataRef};
    }

    # get ContentRef for FS backend
    elsif ( exists( $AttachmentRef->{Data} ) ) {
        $Data{ContentRef} = \$AttachmentRef->{Data};
    }

    $AttachmentRef = undef;
    $AttachmentRef = {};

    return \%Data;
}

=item  AttachmentStorageGetRealProperties()

get the attachment's size on disk and the md5sum

    my %Data = $AttachmentStorageObject->AttachmentStorageGetRealProperties(
        AttDirID      => $AttDirID,
       StorageBackend => "Kernel::System::AttachmentStorageDB",
    );

=cut

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

    # check required stuff...
    if ( !$Param{AttDirID} && !$Param{StorageBackend} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Need AttDirID and StorageBackend!"
        );
        return %RealProperties;
    }

    # get the actual attachment properties...
    %RealProperties = $Self->{ $Param{StorageBackend} }->AttachmentGetRealProperties(
        AttDirID => $Param{AttDirID},
    );

    return %RealProperties;
}

=item AttachmentStorageAdd()

create a new attachment directory entry and write attachment to the specified backend

    my $ID = $AttachmentStorageObject->AttachmentStorageAdd(
        StorageBackend => 'Kernel::System::AttachmentStorageDB',
        DataRef => $SomeContentReference,
        FileName => 'SomeFileName.zip',
        UserID => 123,
        Preferences  => {
           	           		DataType 		   => 'text/xml',
           	           		SomeCustomParams   => 'with our own value',
           				}
    );

=cut

sub AttachmentStorageAdd {
    my ( $Self, %Param ) = @_;
    my $ID     = 0;
    my $MD5sum = '';

    #check required stuff...
    foreach (qw(DataRef FileName UserID)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    if ( !( $Param{StorageBackend} ) ) {
        $Param{StorageBackend} =
            $Self->{ConfigObject}->Get('AttachmentStorage::DefaultStorageBackendModule');
    }

    #-----------------------------------------------------------------
    # (1) create attachment directory entry...
    #-----------------------------------------------------------------

    #db quoting...
    foreach (qw( StorageBackend FileName)) {
        $Param{$_} = $Self->{DBObject}->Quote( $Param{$_} );
    }
    foreach (qw( UserID )) {
        $Param{$_} = $Self->{DBObject}->Quote( $Param{$_}, 'Integer' );
    }

    #build sql...
    my $SQL = "INSERT INTO attachment_directory (" .
        " storage_backend, " .
        " file_path, file_name,  " .
        " create_time, create_by, change_time, change_by) " .
        " VALUES (" .
        " '$Param{StorageBackend}', " .
        " '', '$Param{FileName}', " .
        " current_timestamp, $Param{UserID}, current_timestamp, $Param{UserID})";

    #run SQL...
    if ( $Self->{DBObject}->Do( SQL => $SQL ) ) {

        #...and get the ID...
        $Self->{DBObject}->Prepare(
            SQL => "SELECT max(id) FROM attachment_directory WHERE " .
                "file_name = '$Param{FileName}' AND " .
                "storage_backend = '$Param{StorageBackend}' AND " .
                "create_by = $Param{UserID}",
        );
        while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
            $ID = $Row[0];
        }

    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could NOT insert attachment in attachment directory!",
        );
        return;
    }

    #-----------------------------------------------------------------
    # (2) save attachment directory preferences ...
    #-----------------------------------------------------------------

    # md5sum calculation
    $Self->{EncodeObject}->EncodeOutput( ${ $Param{DataRef} } );
    $Param{Preferences}->{MD5Sum} = md5_hex( ${ $Param{DataRef} } );

    # size calculation
    $Param{Preferences}->{FileSizeBytes} = bytes::length( ${ $Param{DataRef} } );

    my $FileSize = $Param{Preferences}->{FileSizeBytes};
    if ( $FileSize > ( 1024 * 1024 ) ) {
        $FileSize = sprintf "%.1f MBytes", ( $FileSize / ( 1024 * 1024 ) );
    }
    elsif ( $FileSize > 1024 ) {
        $FileSize = sprintf "%.1f KBytes", ( $FileSize / 1024 );
    }
    else {
        $FileSize = $FileSize . ' Bytes';
    }
    $Param{Preferences}->{FileSize} = $FileSize;

    # insert preferences
    for my $Key ( sort keys %{ $Param{Preferences} } ) {
        return if !$Self->{DBObject}->Do(
            SQL => 'INSERT INTO attachment_dir_preferences '
                . '(attachment_directory_id, preferences_key, preferences_value) VALUES ( ?, ?, ?)',
            Bind => [ \$ID, \$Key, \$Param{Preferences}->{$Key} ],
        );

    }

    #-----------------------------------------------------------------
    # (3) create attachment storage entry ( = save file)...
    #-----------------------------------------------------------------

    my $AttID = $Self->{ $Param{StorageBackend} }->AttachmentAdd(
        AttDirID => $ID,
        DataRef  => $Param{DataRef},
    );

    if ( !$AttID ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could NOT store attachment in storage ($Param{StorageBackend})!",
        );
        return;
    }

    #-----------------------------------------------------------------
    # (4) update attachment directory (i.e. file path)...
    #-----------------------------------------------------------------

    $AttID = $Self->{DBObject}->Quote($AttID);
    $SQL   = "UPDATE attachment_directory SET " .
        " file_path = '$AttID' " .
        " WHERE id = $ID";

    if ( $Self->{DBObject}->Do( SQL => $SQL ) ) {
        return $ID;
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could NOT update attachment directory (ID=$ID, file_path=$AttID)!",
        );
        return;
    }
}

=item AttachmentStorageSearch()

returns attachment directory IDs for the given FileName 

    my @Data = $AttachmentStorageObject->AttachmentStorageSearch(
        FileName => 'SomeFileName.zip',
        UsingWildcards => 1, (1 || 0, optional)
    );

=cut

sub AttachmentStorageSearch {
    my ( $Self, %Param ) = @_;
    my @Result = ();
    my $WHERE  = "(id > 0)";

    #check required stuff...
    if ( !$Param{FileName} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Need FileName!"
        );
        return;
    }

    #db quoting...
    foreach (qw( FileName)) {
        if ( defined( $Param{$_} ) && ( $Param{$_} ) ) {
            $Param{$_} = $Self->{DBObject}->Quote( $Param{$_} );
        }
    }

    #build WHERE-clause...
    if ( $Param{UsingWildcards} ) {
        $WHERE .= " AND (file_name LIKE '$Param{FileName}')";
    }
    else {
        $WHERE .= " AND (file_name = '$Param{FileName}')";
    }

    #build sql...
    my $SQL = "SELECT id FROM attachment_directory " .
        "WHERE " . $WHERE;

    $Self->{DBObject}->Prepare(
        SQL => $SQL,
    );

    while ( my @Data = $Self->{DBObject}->FetchrowArray() ) {
        push( @Result, $Data[0] );
    }

    return @Result;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl.txt.

=cut

=head1 VERSION

$Revision: 1.7 $ $Date: 2011-07-25 09:23:46 $

=cut

 # --
# Kernel/System/CIAttachmentStorage/AttachmentStorageFS.pm - attachment storage in file system
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Anna(dot)Litvinova(at)cape-it(dot)de
# --
# $Id: AttachmentStorageFS.pm,v 1.7 2011-08-17 10:04:09 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::CIAttachmentStorage::AttachmentStorageFS;

use strict;
use warnings;

use Kernel::System::Encode;

use MIME::Base64;
use File::stat;
use Digest::MD5 qw(md5_hex);

use vars qw($VERSION);
$VERSION = qw($Revision: 1.7 $) [1];

=head1 NAME

Kernel::System::CIAttachmentStorage::AttachmentStorageFS 

=head1 SYNOPSIS

Provides attachment handling for file system backend.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create AttachmentStorageFS object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::Attachment;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $AttachmentObject = Kernel::System::CIAttachmentStorage::AttachmentStorageFS->new(
        ConfigObject => $ConfigObject,
        DBObject => $DBObject,
        LogObject => $LogObject,
    );

=cut

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

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

    # get common objects
    foreach ( keys %Param ) {
        $Self->{$_} = $Param{$_};
    }

    # check all needed objects
    foreach (qw(ConfigObject LogObject)) {
        die "Got no $_" if ( !$Self->{$_} );
    }

    $Self->{EncodeObject} = Kernel::System::Encode->new(%Param);

    return $Self;
}

=item AttachmentAdd()

create a new std. attachment

    my $ID = $AttachmentObject->AttachmentAdd(
        AttDirID => 123,
        DataRef  => \$SomeContent,
    );

=cut

sub AttachmentAdd {
    my ( $Self, %Param ) = @_;
    my $retVal = 1;

    #check required stuff...
    foreach (qw(AttDirID DataRef)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    #build attachment data file path...
    $retVal = $Self->{ConfigObject}->Get('Home') .
        $Self->{ConfigObject}->Get('AttachmentStorageFS::StorageDirectory');

    #check if destination path exists...
    if ( !-d $retVal ) {
        if ( !File::Path::mkpath( [$retVal], 0, 0775 ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message =>
                    "AttachmentStorageFS path does not exist neither I can create it ($retVal): $!"
            );
            return;
        }
    }

    #build attachment data file path...
    $retVal .= "/" . $Param{AttDirID} . ".dat";

    #write the attachment data file...
    if ( open( my $DATA, ">", "$retVal" ) ) {
        binmode($DATA);
        print $DATA ${ $Param{DataRef} };
        close($DATA);
        return $retVal;
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can NOT write file ($retVal): $!",
        );
        return;
    }
}

=item AttachmentGet()

returns an entry in attachment_storage

    my %Data = $AttachmentObject->Attachment(
        AttDirID => 123, #(some attachment directory id) 
        #..OR...
        FilePath => '/path/to/the/attachment/file.dat',    
    );

=cut

sub AttachmentGet {
    my ( $Self, %Param ) = @_;
    my %Data     = ();
    my $FilePath = '';

    #check required stuff...
    if ( !$Param{AttDirID} && !$Param{FilePath} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need AttDirID or FilePath!" );
        return \%Data;
    }

    if ( defined( $Param{FilePath} ) && $Param{FilePath} ) {
        $FilePath = $Param{FilePath};
    }

    #check if ParamID is defined
    if ( defined( $Param{AttDirID} ) && $Param{AttDirID} ) {

        #db quoting...
        foreach (qw( AttDirID)) {
            $Param{$_} = $Self->{DBObject}->Quote( $Param{$_}, 'Integer' );
        }

        #build sql...
        my $SQL = "SELECT file_path FROM attachment_directory "
            . "WHERE id=$Param{AttDirID}";

        $Self->{DBObject}->Prepare(
            SQL => $SQL,
        );

        while ( my @Data = $Self->{DBObject}->FetchrowArray() ) {
            $FilePath = $Data[0];
        }
    }

    if ( !$FilePath ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Could NOT find file path for given attachment directory id ($Param{AttDirID})!"
        );
        return \%Data;
    }

    #get the attachment data file...
    if ( open( my $DATA, "<", $FilePath ) ) {
        my $Counter = 0;
        my $Data    = "";
        binmode($DATA);
        while (<$DATA>) {
            $Data .= $_;
        }
        close($DATA);

        # set DataRef param
        $Data{DataRef} = \$Data;
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not open $FilePath: $! !",
        );
        return \%Data;
    }

    return \%Data;
}

=item AttachmentGetRealProperties()

returns the size of the attachment in the storage backend and the md5sum.

    my RealProperties = AttachmentStorageObject->AttachmentGetRealProperties(
        AttDirID => 123, #(some attachment directory id) 
    );

=cut

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

    #check required stuff...
    if ( !$Param{AttDirID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need AttDirID!" );
        return %RealProperties;
    }

    my $Data = $Self->AttachmentGet(
        AttDirID => $Param{AttDirID}
    );

    my $Content = ${ $Data->{DataRef} };
    $Self->{EncodeObject}->EncodeOutput( \$Content );

    my $RealFileSize = bytes::length($Content);
    my $RealMD5Sum   = md5_hex($Content);

    $RealProperties{RealFileSize} = $RealFileSize;
    $RealProperties{RealMD5Sum}   = $RealMD5Sum;

    return %RealProperties;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl.txt.

=cut

=head1 VERSION

$Revision: 1.7 $ $Date: 2011-08-17 10:04:09 $

=cut
 # --
# Kernel/System/CIAttachmentStorage/AttachmentStorageDB.pm - attachment storage in local data base
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape-it(dot)de
# * Anna(dot)Litvinova(at)cape-it(dot)de
# --
# $Id: AttachmentStorageDB.pm,v 1.5 2011-07-25 09:01:33 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl.txt.
# --

package Kernel::System::CIAttachmentStorage::AttachmentStorageDB;

use strict;
use warnings;

use Kernel::System::Encode;
use Kernel::System::DB;

use MIME::Base64;
use Digest::MD5 qw(md5_hex);

use vars qw($VERSION);
$VERSION = qw($Revision: 1.5 $) [1];

=head1 NAME

Kernel::System::CIAttachmentStorage::AttachmentStorageDB 

=head1 SYNOPSIS

Provides attachment handling for data base backend - local, OTRS-data base.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create AttachmentStorageDB object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::DB;
    use Kernel::System::CIAttachmentStorage::AttachmentStorage;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        MainObject => $MainObject,
        LogObject => $LogObject,
    );
    my $AttachmentObject = Kernel::System::CIAttachmentStorage::AttachmentStorageDB->new(
        ConfigObject => $ConfigObject,
        DBObject => $DBObject,
        LogObject => $LogObject,
    );

=cut

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

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

    # get common objects
    foreach ( keys %Param ) {
        $Self->{$_} = $Param{$_};
    }

    # check all needed objects
    foreach (qw(DBObject ConfigObject LogObject)) {
        die "Got no $_" if ( !$Self->{$_} );
    }

    $Self->{EncodeObject} = Kernel::System::Encode->new(%Param);

    $Self->{DBObject2} = Kernel::System::DB->new(%Param);

    return $Self;
}

=item AttachmentAdd()

create a new std. attachment

    my $ID = $AttachmentObject->AttachmentAdd(
        AttDirID => 123,
        DataRef  => \$SomeContent,
    );

=cut

sub AttachmentAdd {
    my ( $Self, %Param ) = @_;
    my $ID    = 0;

    #check required stuff...
    foreach (qw(AttDirID DataRef)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    #encode attachment if it's a postgresql backend...
    if ( !$Self->{DBObject2}->GetDatabaseFunction('DirectBlob') ) {
        $Self->{EncodeObject}->EncodeOutput( $Param{DataRef} );

        #overwrite existing value instead of using another filesize of memory...
        ${ $Param{DataRef} } = encode_base64( ${ $Param{DataRef} } );
    }

    #db quoting...
    foreach (qw( AttDirID)) {
        $Param{$_} = $Self->{DBObject2}->Quote( $Param{$_}, 'Integer' );
    }

    #build sql...
    my $SQL = "";
    if ( $Self->{DBObject2}->{Backend}->{'DB::Type'} =~ /oracle/ ) {
        $SQL = "INSERT INTO attachment_storage " .
            " (attachment_directory_id, data) " .
            " VALUES " .
            " ( $Param{AttDirID}, EMPTY_CLOB())";

    }
    else {
        $SQL = "INSERT INTO attachment_storage " .
            " (attachment_directory_id, data) " .
            " VALUES " .
            " ( $Param{AttDirID}, ?)";
    }

    #run sql...
    my $DoResult = 0;
    $DoResult = $Self->{DBObject2}->Do(
        SQL => $SQL, Bind => [ $Param{DataRef} ],    # AttDirID => $Param{AttDirID}
    );

    if ($DoResult) {

        #return ID...
        $Self->{DBObject2}->Prepare(
            SQL => "SELECT id FROM attachment_storage WHERE " .
                "attachment_directory_id = $Param{AttDirID}",
        );
        while ( my @Row = $Self->{DBObject2}->FetchrowArray() ) {
            $ID = $Row[0];
        }
        return $ID;
    }
    else {
        $Self->{LogObject}
            ->Log( Priority => 'error', Message => "Failed to insert attachment data!" );
        return;
    }
}

=item AttachmentGet()

returns an entry in attachment_storage

    my %Data = $AttachmentObject->AttachmentGet(
        ID => 123, #(some attachment storage id) 
        # ...OR...
        AttDirID => 123 #(some attachment directory id),
    );
=cut

sub AttachmentGet {
    my ( $Self, %Param ) = @_;;
    my %Data  = ();
    my $WHERE = "";

    #check required stuff...
    if ( !$Param{ID} && !$Param{AttDirID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need AttDirID or ID!" );
        return \%Data;
    }

    #db quoting...
    foreach (qw( AttDirID ID)) {
        $Param{$_} = $Self->{DBObject2}->Quote( $Param{$_}, 'Integer' );
    }

    #build sql...
    if ( defined( $Param{AttDirID} ) && $Param{AttDirID} ) {
        $WHERE = " WHERE attachment_directory_id = $Param{AttDirID}";
    }
    else {
        $WHERE = " WHERE id = $Param{ID}";
    }

    my $SQL = "SELECT id, attachment_directory_id FROM attachment_storage " . $WHERE;

    if ( !$Self->{DBObject2}->Prepare( SQL => $SQL, Encode => [ 0, 0, 1 ] ) ) {
        return \%Data;
    }

    my @Data = $Self->{DBObject2}->FetchrowArray();

    if (@Data) {
        my $SQL = "SELECT data FROM attachment_storage " . $WHERE;

        if ( !$Self->{DBObject2}->Prepare( SQL => $SQL ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Failed to prepare SQL for FetchrowArray!"
            );
            return \%Data;
        }

        my @AttachData = $Self->{DBObject2}->FetchrowArray();

        my $AttachDataRef = \$AttachData[0];

        if ( !$AttachDataRef ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Failed to FetchrowArray!"
            );
            return \%Data;
        }

        #decode attachment if it's a postgresql backend...
        if ( !$Self->{DBObject2}->GetDatabaseFunction('DirectBlob') ) {
            ${$AttachDataRef} = decode_base64( ${$AttachDataRef} );
        }

        %Data = (
            ID       => $Data[0],
            AttDirID => $Data[1],

            #DataType => $Data[2],
            DataRef => $AttachDataRef,
        );

        $AttachDataRef = undef;
    }

    return \%Data;
}

=item AttachmentGetRealProperties()

returns the size of the attachment in the storage backend and the md5sum.

    my RealProperties = AttachmentStorageObject->AttachmentGetRealProperties(
        AttDirID => 123, #(some attachment directory id) 
        #..OR...
		ID => 123, #(some attachment storage id)    
    );

=cut

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

    my %RealProperties;

    #check required stuff...
    if ( !$Param{AttDirID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need AttDirID!" );
        return %RealProperties;
    }

    my $Data = $Self->AttachmentGet(
        AttDirID => $Param{AttDirID}
    );

    my $Content = ${ $Data->{DataRef} };
    $Self->{EncodeObject}->EncodeOutput(\$Content);

    my $RealFileSize = bytes::length($Content);
    my $RealMD5Sum   = md5_hex( $Content );

    $RealProperties{RealFileSize} = $RealFileSize;
    $RealProperties{RealMD5Sum}   = $RealMD5Sum;

    return %RealProperties;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl.txt.

=cut

=head1 VERSION

$Revision: 1.5 $ $Date: 2011-07-25 09:01:33 $

=cut
 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 <?xml version="1.0" encoding="iso-8859-1" ?>
<otrs_config version="1.0" init="Config">

    <ConfigItem Name="ITSMCIAttributeCollection::AgentBackendMapping" Required="1" Valid="1">
        <Description Lang="en">Defines values shown for agent user attributes.</Description>
        <Description Lang="de">Definiert Werte die fuer Attribut Agentennutzer angezeigt werden.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>User</SubGroup>
        <Setting>
            <Hash>
                <Item Key="1000">UserFirstname</Item>
                <Item Key="1001">UserLastname</Item>
                <Item Key="2000">UserLogin</Item>
                <Item Key="3000">UserEmail</Item>
            </Hash>
        </Setting>
    </ConfigItem>
     
    <ConfigItem Name="ITSMCIAttributeCollection::CompanyBackendMapping" Required="1" Valid="1">
        <Description Lang="en">Defines information shown for company attributes.</Description>
        <Description Lang="de">Definiert die zu einem Companyattribut angezeigten Werte.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>CustomerCompany</SubGroup>
        <Setting>
            <Hash>
                <Item Key="1000">CustomerCompanyName</Item>
                <Item Key="2000">CustomerCompanyStreet</Item>
                <Item Key="3000">CustomerCompanyZIP</Item>
                <Item Key="3001">CustomerCompanyCity</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    
    <!-- CI EVENT REGISTRATIONS -->
    <ConfigItem Name="ITSMConfigItem::EventModulePost###502-RefreshCIClassReferenceLinks" Required="0" Valid="1">
        <Description Lang="en">Searches for attributes of type CIClassReference in the new CIs version data and refreshes all links to that class. It deletes links to this class if the value is not existent in the CIs version data.</Description>
        <Description Lang="de">Sucht nach Attributen vom Typ CIClassReference in der neuen Version des CIs und aktualisiert alle Verknuepfungen zu CIs dieser Klasse. Alle Verknuepfungen zu dieser Klasse zu denen kein Wert in der CI-Version existiert werden geloescht.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Core::ITSMConfigItemEvents</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::ITSMConfigItem::Event::CIClassReference_RefreshLinks</Item>
                <Item Key="Event">(VersionCreate)</Item>
            </Hash>
        </Setting>
    </ConfigItem>        
    <ConfigItem Name="ITSMConfigItem::EventModulePost###502-RefreshServiceReferenceLinks" Required="0" Valid="1">
        <Description Lang="en">Searches for attributes of type ServiceReference in the new CIs version data and refreshes all links to that class. It deletes links to this class if the value is not existent in the CIs version data.</Description>
        <Description Lang="de">Sucht nach Attributen vom Typ ServiceReference in der neuen Version des CIs und aktualisiert alle Verknuepfungen zu CIs dieser Klasse. Alle Verknuepfungen zu dieser Klasse zu denen kein Wert in der CI-Version existiert werden geloescht.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Core::ITSMConfigItemEvents</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::ITSMConfigItem::Event::ServiceReference_RefreshLinks</Item>
                <Item Key="Event">(VersionCreate)</Item>
            </Hash>
        </Setting>
    </ConfigItem> 
    <!-- EO CI EVENT REGISTRATIONS -->

    <!-- registering for autocomplete functionality -->
    <ConfigItem Name="Loader::Agent::CommonJS###101-ITSMCIAttributeCollection" Required="1" Valid="1">
        <Description Translatable="1">List of JS files to always be loaded for the agent interface.</Description>
        <Group>Framework</Group>
        <SubGroup>Core::Web</SubGroup>
        <Setting>
            <Array>
                <Item>Core.Agent.QueueSearch.js</Item>
                <Item>Core.Agent.ServiceSearch.js</Item>
                <Item>Core.Agent.CustomerCompanySearch.js</Item>
                <Item>Core.Agent.CustomerUserCompanySearch.js</Item>
                <Item>Core.Agent.CIClassSearch.js</Item>
                <Item>Core.Agent.UserSearch.js</Item>
            </Array>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentQueueSearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of queues, used for autocompletion</Description>
                <Title>QueueSearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentUserSearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of users, used for autocompletion</Description>
                <Title>AgentUserSearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentServiceSearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of services, used for autocompletion</Description>
                <Title>ServiceSearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentCustomerCompanySearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of customer companies, used for autocompletion</Description>
                <Title>CustomerCompanySearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentCustomerUserCompanySearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of customer user companies, used for autocompletion</Description>
                <Title>CustomerUserCompanySearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="Frontend::Module###AgentCIClassSearch" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::ModuleRegistration</SubGroup>
        <Setting>
            <FrontendModuleReg>
                <Description>Lookup of CI classes, used for autocompletion</Description>
                <Title>CIClassSearch</Title>
<!--
                <NavBarName>Config Item</NavBarName>
-->
            </FrontendModuleReg>
        </Setting>
    </ConfigItem>

    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete###Active" Required="1" Valid="1">
        <Description Translatable="1">Enables or disables the autocomplete feature for the queue, service and CI-class search in the ITSM agent interface.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <Option SelectedID="1">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete::DynamicWidth" Required="1" Valid="1">
        <Description Translatable="1">Adapts the width of the autocomplete drop down to the length of the longest option.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <Option SelectedID="1">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete###MinQueryLength" Required="1" Valid="1">
        <Description Translatable="1">Sets the minimum number of characters before autocomplete query is sent.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <String Regex="^[1-9]$">2</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete###MaxResultsDisplayed" Required="1" Valid="1">
        <Description Translatable="1">Sets the maximal number of search results for the autocomplete feature.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <String>20</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete###QueryDelay" Required="1" Valid="1">
        <Description Translatable="1">Delay time between autocomplete queries.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <String Regex="^[1-9][0-9]*$">100</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete###TypeAhead" Required="1" Valid="1">
        <Description Translatable="1">Enables or disables TypeAhead for the autocomplete feature.</Description>
        <Group>ITSM-CIAttributeCollection</Group>
        <SubGroup>Frontend::Agent::CommonSearch</SubGroup>
        <Setting>
            <Option SelectedID="false">
                <Item Key="false">No</Item>
                <Item Key="true">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <!-- EO registering for autocomplete functionality -->

</otrs_config>
 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 IyAtLQojIEtlcm5lbC9MYW5ndWFnZS9kZV9JVFNNQ0lBdHRyaWJ1dGVDb2xsZWN0aW9uLnBtIC0gdGhlIGdlcm1hbiB0cmFuc2xhdGlvbiBvZiBJVFNNQ0lBdHRyaWJ1dGVDb2xsZWN0aW9uCiMgQ29weXJpZ2h0IChDKSAyMDA2LTIwMTEgYy5hLnAuZS4gSVQgR21iSCwgaHR0cDovL3d3dy5jYXBlLWl0LmRlCiMKIyB3cml0dGVuL2VkaXRlZCBieToKIyAqIFN0ZWZhbihkb3QpTWVobGlnKGF0KWNhcGUtaXQoZG90KWRlCiMgLS0KIyAkSWQ6IGRlX0lUU01DSUF0dHJpYnV0ZUNvbGxlY3Rpb24ucG0sdiAxLjEgMjAxMS0xMC0xMyAxMToyNjowMSBzbWVobGlnIEV4cCAkCiMKIyAtLQojIFRoaXMgc29mdHdhcmUgY29tZXMgd2l0aCBBQlNPTFVURUxZIE5PIFdBUlJBTlRZLiBGb3IgZGV0YWlscywgc2VlCiMgdGhlIGVuY2xvc2VkIGZpbGUgQ09QWUlORyBmb3IgbGljZW5zZSBpbmZvcm1hdGlvbiAoR1BMKS4gSWYgeW91CiMgZGlkIG5vdCByZWNlaXZlIHRoaXMgZmlsZSwgc2VlIGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy9ncGwudHh0LgojIC0tCnBhY2thZ2UgS2VybmVsOjpMYW5ndWFnZTo6ZGVfSVRTTUNJQXR0cmlidXRlQ29sbGVjdGlvbjsKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKc3ViIERhdGEgewogICAgbXkgJFNlbGYgPSBzaGlmdDsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J09wZW4gbGluayBpbiBuZXcgd2luZG93J30gPSAn1mZmbmV0IGRlbiBMaW5rIGluIGVpbmVtIG5ldWVtIEZlbnN0ZXInOwogICAgcmV0dXJuIDE7Cn0KMTsK # --
# ITSM_CIAttributeCollection.pm - code run during package de-/installation
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by
#	Anna(dot)Litvinova(at)cape-it(dot)de
#
# --
# $Id: ITSM_CIAttributeCollection.pm,v 1.7 2011-07-25 09:10:29 smehlig Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package var::packagesetup::ITSM_CIAttributeCollection;

use strict;
use warnings;

use Kernel::System::Package;

use vars qw(@ISA $VERSION);
$VERSION = qw($Revision: 1.7 $) [1];

=head1 NAME

OTRS_KIX4OTRS.pm - code to excecute during package installation

=head1 SYNOPSIS

All functions

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::Time;
    use Kernel::System::DB;
    use Kernel::System::XML;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject    = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $TimeObject = Kernel::System::Time->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );

    my $CodeObject = var::packagesetup::OTRS-KIX4OTRS-ITSM.pm->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
        TimeObject   => $TimeObject,
        DBObject     => $DBObject,
    );

=cut

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

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

    # check required params...
    for my $Object (
        qw(ConfigObject LogObject MainObject TimeObject DBObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    return $Self;
}

=item CodeInstall()

run the code install part

    my $Result = $CodeObject->CodeInstall();

=cut

sub CodeInstall {
    my ( $Self, %Param ) = @_;
    my $KIXCoreInstalled = 0;

    $Self->{PackageObject} = Kernel::System::Package->new( %{$Self} );
    my @InstalledPackages = $Self->{PackageObject}->RepositoryList();

    for my $Package (@InstalledPackages) {
        if ( $Package->{Name}->{Content} eq 'KIXCore' ) {
            $KIXCoreInstalled = 1;
            last;
        }
    }

    if ($KIXCoreInstalled) {
        $Self->_RegisterCustomModule();
    }
    else {
        $Self->_MakeChanges();
    }

    return 1;
}

=item CodeReinstall()

run the code reinstall part

    my $Result = $CodeObject->CodeReinstall();

=cut

sub CodeReinstall {
    my ( $Self, %Param ) = @_;
    $Self->CodeUninstall();
    $Self->CodeInstall();
    return 1;
}

=item CodeUpgrade()

run the code upgrade part

    my $Result = $CodeObject->CodeUpgrade();

=cut

sub CodeUpgrade {
    my ( $Self, %Param ) = @_;
    $Self->CodeInstall();
    return 1;
}

=item CodeUninstall()

run the code uninstall part

    my $Result = $CodeObject->CodeUninstall();

=cut

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

    $Self->_RemoveCustomModule();

    return 1;
}

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

    if ( $Self->{MainObject}->Require('Kernel::System::KIXUtils') ) {
        $Self->{KIXUtilsObject} = Kernel::System::KIXUtils->new( %{$Self} );
        $Self->{KIXUtilsObject}->RegisterCustomPackage(
            PackageName => 'ITSMCIAttributeCollection',
            Priority    => '0200',
        );
    }

    return;
}

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

    if ( $Self->{MainObject}->Require('Kernel::System::KIXUtils') ) {
        $Self->{KIXUtilsObject} = Kernel::System::KIXUtils->new( %{$Self} );
        $Self->{KIXUtilsObject}->UnRegisterCustomPackage(
            PackageName => 'ITSMCIAttributeCollection',
        );
    }
    else {
        $Self->_RestoreChanges();
    }

    return;
}

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

    my $CurrentOS    = $^O;
    my $FileToChange = "";

    my $FileName   = "AgentITSMConfigItemEdit.dtl";
    my $FileFolder = "";

    if ( $CurrentOS =~ /MSWin/ ) {
        $FileFolder = $Self->{ConfigObject}->Get('Home')
            . "\\Kernel\\Output\\HTML\\Standard\\";
    }
    else {
        $FileFolder = $Self->{ConfigObject}->Get('Home')
            . "/Kernel/Output/HTML/Standard/";
    }

    $FileToChange = $FileFolder . $FileName;

    # name for a backup file
    my $FileToChangeBackup = $FileFolder . $FileName . ".save";

    # check if the backup file already exists (in case of upgrade)
    # if not - rename the old file
    unless ( -e $FileToChangeBackup ) {
        if ( !rename( $FileToChange, $FileToChangeBackup ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Could not rename file $FileToChange!",
            );
            return;
        }
    }

    # read the file content
    my $FileNewContent;
    if ( open( my $IN, "<", $FileToChangeBackup ) ) {
        while (<$IN>) {
            my $CurrLine = $_;

            # this is the line that must be changed
            if ( (/^\s*<form action=/) && !(/enctype=\"multipart\/form-data\"/) ) {
                my $NewLine = "# KIX4OTRS-capeIT\n" .
                    "#$_";
                s/>/ enctype=\"multipart\/form-data\">/;
                $NewLine .= " $_" .
                    "# EO KIX4OTRS-capeIT\n";
                $CurrLine = $NewLine;
            }
            $FileNewContent .= $CurrLine;
        }
        close($IN);
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not open file $FileToChange!",
        );
        return;
    }

    # write new content to a new file with the old name
    if ( open( my $OUT, ">", $FileToChange ) ) {
        binmode($OUT);
        print $OUT $FileNewContent;
        close($OUT);

        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => "Updated $FileToChange.",
        );
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not write to file $FileToChange!",
        );
        return;
    }

    return 1;
}

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

    my $CurrentOS    = $^O;
    my $FileToChange = "";
    my $FileName     = "AgentITSMConfigItemEdit.dtl";
    my $FileFolder   = "";

    if ( $CurrentOS =~ /MSWin/ ) {
        $FileFolder = $Self->{ConfigObject}->Get('Home')
            . "\\Kernel\\Output\\HTML\\Standard\\";
    }
    else {
        $FileFolder = $Self->{ConfigObject}->Get('Home')
            . "/Kernel/Output/HTML/Standard/";
    }

    $FileToChange = $FileFolder . $FileName;

    # backup file created during the installation
    my $FileToChangeBackup = $FileFolder . $FileName . ".save";

    # if backup exists, remove the actual file
    if ( -e $FileToChangeBackup ) {
        if ( !unlink($FileToChange) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Could not delete file $FileToChange!",
            );
            return;
        }

        # and restore the backup file
        if ( !rename( $FileToChangeBackup, $FileToChange ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Could not rename file $FileToChangeBackup!",
            );
            return;
        }
        else {
            $Self->{LogObject}->Log(
                Priority => 'notice',
                Message  => "Restored initial file $FileToChange.",
            );
        }
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => "Could not find file $FileToChangeBackup!",
        );
    }
    return 1;
}

1;

=back

=head1 TERMS AND CONDITIONS

This Software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/agpl.txt.

=cut

=head1 VERSION
$Revision: 1.7 $ $Date: 2011-07-25 09:10:29 $
=cut
 # $Id: USAGE_itsm-ciattributecollection.pod,v 1.10 2011-10-13 11:34:52 smehlig Exp $

=head1 Usage Information 

This version does not require OTRS::CiCS anymore but needs to place a modification in a file contained in ITSMConfigurationManagement. Thus this file will be modified.

This package provides additional ITSM-CI-attributes for OTRS:ITSM, i.e. ITSMConfigurationManagement. Following you'll find a short documentation on the use and features of this extension.

=head2 Why a new attachment storage rather than using VirtualFileSystem

Virtual file system proved to be not suitable, since it builds some sort of directory path out of object-class and id. Thus it would require to know the CIs version ID before it's actually created. If this could be solved somehow, copying a CI with an attachment would also cause a copy of the attachment itself, which is not desirable from our point of view.


=head2 (i) Use of the CI-Attribute "CIClassReference"

=over 4

=item * behaves similar to customer user attribute but refers to another config item of some CI-class

=item * allows to automatically delete and create links to CIs of a referenced class

=item * eases the configuration of assembled config items, which consist (in parts) of other config items without annoying manual link creation

=item * attribute definition requires three additional attributes:

        ReferencedCIClassName or ReferencedCIClassID: defines the referenced CI-class
        ReferencedCIClassLinkType: defines the link type which should be used for automatic link creation and deletion, no link will be created if empty
        ReferencedCIClassLinkDirection: set to "Reverse" if you want to create a reverse link for directed link types (will only be relevant if ReferencedCIClassLinkType is set)

=item * IMPORTANT NOTE: The "Key" attribute has to be a UNIQUE name within the class definition!

=back

=head3 EXAMPLE

   {
       Key        => 'Location',
       Name       => 'Asset Location',
       Searchable => 1,
       Input => {
           Type                           => 'CIClassReference',
           ReferencedCIClassName          => 'Location',
           ReferencedCIClassLinkType      => 'Includes',
           ReferencedCIClassLinkDirection => 'Reverse',
       },
   },


=head2 (ii) Use of the CI-Attribute "ServiceReference"

=over 4

=item * behaves similar to customer user attribute but refers to a service

=item * allows to automatically delete and create links to Services

=item * attribute definition requires two additional attributes:

        ReferencedServiceLinkType: defines the link type which should be used for automatic link creation and deletion, no link will be created if empty
        ReferencedServiceLinkDirection: set to "Reverse" if you want to create a reverse link for directed link types (will only be relevant if ReferencedCIClassLinkType is set)

=item * IMPORTANT NOTE: The "Key" attribute has to be a UNIQUE name within the class definition!  

=back

=head3 EXAMPLE: 

   {
       Key        => 'AssignedService',
       Name       => 'Assigned Service',
       Searchable => 1,
       Input => {
           Type                            => 'ServiceReference',
           ReferencedServiceLinkType       => 'RelevantTo',
           ReferencedServiceLinkDirection  => 'Normal',
       },
   },
 

=head2 (iii) Use of the CI-Attribute "QueueReference"

=over 4

=item * behaves similar to customer user attribute but refers to a queue

=back

=head3  EXAMPLE: 

   {
       Key        => 'AssignedQueue',
       Name       => 'Assigned Queue',
       Searchable => 1,
       Input => {
           Type => 'QueueReference',
       },
   },


=head2 (iv) Autocomplete function for attribute types queue, service, CIclass, Users, CustomerCompany and CustomerUserCompany 

=over 4

=item * behaves similar to customer user autocomplete function

=item * activation can be configured in SysConfig
      * ITSMCIAttributeCollection::Frontend::CommonSearchAutoComplete

=item * further configuration in SysConfig

        Loader::Agent::CommonJS101-ITSMCIAttributeCollection
        Frontend::ModuleAgentQueueSearch
        Frontend::ModuleAgentServiceSearch
        Frontend::ModuleAgentCIClassSearch
        Frontend::ModuleAgentUserSearch
        Frontend::ModuleAgentCustomerCompanyassSearch
        Frontend::ModuleAgentCustomerUserCompanySearch

=item * further informations to CustomerCompany and CustomerUserCompany

      * CustomerCompanySearch uses CustomerCompany-Table as search base
      * CustomerUserCompanySearch uses CustomerIDs from CustomerData as search base; 

=back


=head2 (v) Use of the CI-Attribute "CIAttachment"

=over 4

=item * allows to add one or more attachments to a ConfigItem 

=item * see following SysConfig options for further configuration
        AttachmentStorage::StorageBackendModules
        AttachmentStorage::DefaultStorageBackendModule
        Frontend::Module###AgentAttachmentStorage
        AttachmentStorageFS::StorageDirectory

=item * IMPORTANT NOTE: The attributes CountMin and CountMax must always be defined! Otherwise you won't be able to delete attachments from CIs. If you set CountMin => 1, it will be impossible to delete the last attachment (the last n attachments for CountMin => n).

=back

=head3  EXAMPLE: 

   {
       Key => 'Attachment',
       Name => 'Attachment',
       Searchable => 1,
       Input => {
           Size => 50,
           MaxLength => 50,
           Type  => 'CIAttachment', 
       },
       CountMin => 0,
       CountMax => 1,
   },

=head2 (vi) Use of the CI-Attribute "User"

=over 4

=item * behaves similar to customer user attribute but refers to a user/agent

=back

=head3  EXAMPLE: 

   {
       Key        => 'Responsible',
       Name       => 'Responsible',
       Searchable => 1,
       Input => {
           Type => 'User',
       },
   },

 
=head2 (vii) Use of the CI-Attribute "CustomerUserCompany"

=over 4

=item * behaves similar to customer user attribute but refers to a CustomerCompany
      * looks in all CustomerDatas for CustomerCompany 

=back

=head3  EXAMPLE: 

    {
        Key => 'CustomerUserCompany',
        Name => 'CustomerUserCompany',
        Searchable => 1,
        Input => {
            Type => 'CustomerUserCompany',
        },
    },

 
=head2 (viii) Use of the CI-Attribute "CustomerCompany"

=over 4

=item * behaves similar to customer user attribute but refers to a user/agent
      * looks in CustomerCompany-Table for CustomerCompany 

=back

=head3  EXAMPLE: 

    {
        Key => 'CustomerCompany',
        Name => 'CustomerCompany',
        Searchable => 1,
        Input => {
            Type => 'CustomerCompany',
        },
    },


=head2 (ix) Use of the CI-Attribute "Password"

=over 4

=item * allows to deposite passwords
      * change and display of password only for configured groups

=back

=head3  EXAMPLE: 

    { 
         Key => 'Password', 
         Name => 'Password',
         Group => { 
                 admin => 1, 
                 groupname => 1, 
         }, 
         Input => { 
             Type => 'EncryptedText', 
             Size => 50, 
             MaxLength => 100, 
         }, 
     },
     
     
=head2 (ix) Use of the CI-Attribute "LinkText"

=over 4

=item * allows to use text in a configured link


=back

=head3  EXAMPLE: 

    {
        Key => 'TextLink',
        Name => 'Text Link',
        Searchable => 1,
        Input => {
            Type => 'TextLink',
            Size => 50,
            MaxLength => 100,
            URL => 'http://www.example.com/<VALUE>',
        },
    },    




=head1 COPYRIGHT

Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de/

The following persons have contributed to this extension:

=over 4

=item * Torsten(dot)Thau(at)cape(dash)it(dot)de

=item * Martin(dot)Balzarek(at)cape(dash)it(dot)de

=item * Frank(dot)Oberender(at)cape(dash)it(dot)de

=item * Anna(dot)Litvinova(at)cape(dash)it(dot)de

=item * Stefan(dot)Mehlig(at)cape(dash)it(dot)de

=back

This software comes with ABSOLUTELY NO WARRANTY. For details, see the enclosed file COPYING for license information (AGPL). If you did not receive this file, see http://www.gnu.org/licenses/agpl.txt.

=cut
