<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;"># --
# Kernel/System/ProcessManagement/Activity.pm - Process Management DB Activity backend
# Copyright (C) 2001-2014 OTRS AG, http://otrs.com/
# --
# 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::ProcessManagement::DB::Activity;

use strict;
use warnings;

use Kernel::System::YAML;

use Kernel::System::Cache;
use Kernel::System::VariableCheck qw(:all);

use Kernel::System::ProcessManagement::DB::ActivityDialog;

=head1 NAME

Kernel::System::ProcessManagement::DB::Activity.pm

=head1 SYNOPSIS

Process Management DB Activity backend

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an Activity object

    use Kernel::Config;
    use Kernel::System::Encode;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::Time;
    use Kernel::System::DB;
    use Kernel::System::ProcessManagement::DB::Activity;

    my $ConfigObject = Kernel::Config-&gt;new();
    my $EncodeObject = Kernel::System::Encode-&gt;new(
        ConfigObject =&gt; $ConfigObject,
    );
    my $LogObject = Kernel::System::Log-&gt;new(
        ConfigObject =&gt; $ConfigObject,
        EncodeObject =&gt; $EncodeObject,
    );
    my $MainObject = Kernel::System::Main-&gt;new(
        ConfigObject =&gt; $ConfigObject,
        EncodeObject =&gt; $EncodeObject,
        LogObject    =&gt; $LogObject,
    );
    my $TimeObject = Kernel::System::Time-&gt;new(
        ConfigObject =&gt; $ConfigObject,
        LogObject    =&gt; $LogObject,
    );
    my $DBObject = Kernel::System::DB-&gt;new(
        ConfigObject =&gt; $ConfigObject,
        EncodeObject =&gt; $EncodeObject,
        LogObject    =&gt; $LogObject,
        MainObject   =&gt; $MainObject,
    );
    my $ActivityObject = Kernel::System::ProcessManagement::DB::Activity-&gt;new(
        ConfigObject        =&gt; $ConfigObject,
        EncodeObject        =&gt; $EncodeObject,
        LogObject           =&gt; $LogObject,
        MainObject          =&gt; $MainObject,
        DBObject            =&gt; $DBObject,
    );

=cut

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

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

    # get needed objects
    for my $Needed (qw(ConfigObject EncodeObject LogObject TimeObject MainObject DBObject)) {
        die "Got no $Needed!" if !$Param{$Needed};

        $Self-&gt;{$Needed} = $Param{$Needed};
    }

    # create additional objects
    $Self-&gt;{CacheObject} = Kernel::System::Cache-&gt;new( %{$Self} );
    $Self-&gt;{YAMLObject}  = Kernel::System::YAML-&gt;new( %{$Self} );

    # get the cache TTL (in seconds)
    $Self-&gt;{CacheTTL}
        = int( $Self-&gt;{ConfigObject}-&gt;Get('Process::CacheTTL') || 3600 );

    # set lower if database is case sensitive
    $Self-&gt;{Lower} = '';
    if ( $Self-&gt;{DBObject}-&gt;GetDatabaseFunction('CaseSensitive') ) {
        $Self-&gt;{Lower} = 'LOWER';
    }

    $Self-&gt;{ActivityDialogObject}
        = Kernel::System::ProcessManagement::DB::ActivityDialog-&gt;new( %{$Self} );

    return $Self;
}

=item ActivityAdd()

add new Activity

returns the id of the created activity if success or undef otherwise

    my $ID = $ActivityObject-&gt;ActivityAdd(
        EntityID    =&gt; 'A1'              # mandatory, exportable unique identifier
        Name        =&gt; 'NameOfActivity', # mandatory
        Config      =&gt; $ConfigHashRef,   # mandatory, activity configuration to be stored in YAML
                                         #   format
        UserID      =&gt; 123,              # mandatory
    );

Returns:

    $ID = 567;

=cut

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

    # check needed stuff
    for my $Key (qw(EntityID Name Config UserID)) {
        if ( !$Param{$Key} ) {
            $Self-&gt;{LogObject}-&gt;Log(
                Priority =&gt; 'error',
                Message  =&gt; "Need $Key!",
            );
            return;
        }
    }

    # check if EntityID already exists
    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL =&gt; "
            SELECT id
            FROM pm_activity
            WHERE $Self-&gt;{Lower}(entity_id) = $Self-&gt;{Lower}(?)",
        Bind  =&gt; [ \$Param{EntityID} ],
        Limit =&gt; 1,
    );

    my $EntityExists;
    while ( my @Data = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        $EntityExists = 1;
    }

    if ($EntityExists) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; "The EntityID:$Param{EntityID} already exists for an activity!"
        );
        return;
    }

    # check config valid format
    if ( ref $Param{Config} ne 'HASH' ) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; "Config needs to be a valid Hash reference!",
        );
        return;
    }

    # dump config as string
    my $Config = $Self-&gt;{YAMLObject}-&gt;Dump( Data =&gt; $Param{Config} );

    # Make sure the resulting string has the UTF-8 flag. YAML only sets it if
    #   part of the data already had it.
    utf8::upgrade($Config);

    # sql
    return if !$Self-&gt;{DBObject}-&gt;Do(
        SQL =&gt; '
            INSERT INTO pm_activity (entity_id, name, config, create_time, create_by, change_time,
                change_by)
            VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?)',
        Bind =&gt; [
            \$Param{EntityID}, \$Param{Name}, \$Config, \$Param{UserID}, \$Param{UserID},
        ],
    );

    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL  =&gt; 'SELECT id FROM pm_activity WHERE entity_id = ?',
        Bind =&gt; [ \$Param{EntityID} ],
    );

    my $ID;
    while ( my @Row = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        $ID = $Row[0];
    }

    # delete cache
    $Self-&gt;{CacheObject}-&gt;CleanUp(
        Type =&gt; 'ProcessManagement_Activity',
    );

    return if !$ID;

    return $ID;
}

=item ActivityDelete()

delete an Activity

returns 1 if success or undef otherwise

    my $Success = $ActivityObject-&gt;ActivityDelete(
        ID      =&gt; 123,
        UserID  =&gt; 123,
    );

=cut

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

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

    # check if exists
    my $Activity = $Self-&gt;ActivityGet(
        ID     =&gt; $Param{ID},
        UserID =&gt; 1,
    );
    return if !IsHashRefWithData($Activity);

    # delete activity
    return if !$Self-&gt;{DBObject}-&gt;Do(
        SQL  =&gt; 'DELETE FROM pm_activity WHERE id = ?',
        Bind =&gt; [ \$Param{ID} ],
    );

    # delete cache
    $Self-&gt;{CacheObject}-&gt;CleanUp(
        Type =&gt; 'ProcessManagement_Activity',
    );

    return 1;
}

=item ActivityGet()

get Activity attributes

    my $Activity = $ActivityObject-&gt;ActivityGet(
        ID                  =&gt; 123,      # ID or EntityID is needed
        EntityID            =&gt; 'A1',
        ActivityDialogNames =&gt; 1,        # default 0, 1 || 0, if 0 returns an ActivityDialogs array
                                         #     with the activity dialog entity IDs, if 1 returns an
                                         #     ActivitiDialogs hash with the activity entity IDs as
                                         #     keys and ActivityDialog Names as values
        UserID        =&gt; 123,            # mandatory
    );

Returns:

    $Activity = {
        ID             =&gt; 123,
        EntityID       =&gt; 'A1',
        Name           =&gt; 'some name',
        Config         =&gt; $ConfigHashRef,
        ActiviyDialogs =&gt; ['AD1','AD2','AD3'],
        CreateTime     =&gt; '2012-07-04 15:08:00',
        ChangeTime     =&gt; '2012-07-04 15:08:00',
    };

    $Activity = {
        ID           =&gt; 123,
        EntityID     =&gt; 'P1',
        Name         =&gt; 'some name',
        Config       =&gt; $ConfigHashRef,
        ActivityDialogs =&gt; {
            'AD1' =&gt; 'ActivityDialog1',
            'AD2' =&gt; 'ActivityDialog2',
            'AD3' =&gt; 'ActivityDialog3',
        };
        CreateTime   =&gt; '2012-07-04 15:08:00',
        ChangeTime   =&gt; '2012-07-04 15:08:00',
    };

=cut

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

    # check needed stuff
    if ( !$Param{ID} &amp;&amp; !$Param{EntityID} ) {
        $Self-&gt;{LogObject}-&gt;Log( Priority =&gt; 'error', Message =&gt; 'Need ID or EntityID!' );
        return;
    }

    if ( !$Param{UserID} ) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; 'Need UserID!',
        );
        return;
    }

    my $ActivityDialogNames = 0;
    if ( defined $Param{ActivityDialogNames} &amp;&amp; $Param{ActivityDialogNames} == 1 ) {
        $ActivityDialogNames = 1;
    }

    # check cache
    my $CacheKey;
    if ( $Param{ID} ) {
        $CacheKey = 'ActivityGet::ID::' . $Param{ID} . '::ActivityDialogNames::'
            . $ActivityDialogNames;
    }
    else {
        $CacheKey = 'ActivityGet::EntityID::' . $Param{EntityID} . '::ActivityDialogNames::'
            . $ActivityDialogNames;
    }

    my $Cache = $Self-&gt;{CacheObject}-&gt;Get(
        Type =&gt; 'ProcessManagement_Activity',
        Key  =&gt; $CacheKey,
    );
    return $Cache if $Cache;

    # sql
    if ( $Param{ID} ) {
        return if !$Self-&gt;{DBObject}-&gt;Prepare(
            SQL =&gt; '
                SELECT id, entity_id, name, config, create_time, change_time
                FROM pm_activity
                WHERE id = ?',
            Bind  =&gt; [ \$Param{ID} ],
            Limit =&gt; 1,
        );
    }
    else {
        return if !$Self-&gt;{DBObject}-&gt;Prepare(
            SQL =&gt; '
                SELECT id, entity_id, name, config, create_time, change_time
                FROM pm_activity
                WHERE entity_id = ?',
            Bind  =&gt; [ \$Param{EntityID} ],
            Limit =&gt; 1,
        );
    }

    my %Data;

    while ( my @Data = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        my $Config = $Self-&gt;{YAMLObject}-&gt;Load( Data =&gt; $Data[3] );

        %Data = (
            ID         =&gt; $Data[0],
            EntityID   =&gt; $Data[1],
            Name       =&gt; $Data[2],
            Config     =&gt; $Config,
            CreateTime =&gt; $Data[4],
            ChangeTime =&gt; $Data[5],
        );
    }

    return if !$Data{ID};

    # create the ActivityDialogsList
    if ($ActivityDialogNames) {
        my %ActivityDialogs;

        if ( IsHashRefWithData( $Data{Config}-&gt;{ActivityDialog} ) ) {

            my $ActivityDialogList = $Self-&gt;{ActivityDialogObject}-&gt;ActivityDialogList(
                UseEntities =&gt; 1,
                UserID      =&gt; 1,
            );

            for my $ActivityOrder ( sort { $a &lt;=&gt; $b } keys %{ $Data{Config}-&gt;{ActivityDialog} } ) {
                $ActivityDialogs{ $Data{Config}-&gt;{ActivityDialog}-&gt;{$ActivityOrder} }
                    = $ActivityDialogList-&gt;{ $Data{Config}-&gt;{ActivityDialog}-&gt;{$ActivityOrder} };
            }
        }
        $Data{ActivityDialogs} = \%ActivityDialogs;
    }
    else {
        my @ActivityDialogList;

        if ( IsHashRefWithData( $Data{Config}-&gt;{ActivityDialog} ) ) {
            @ActivityDialogList = map { $Data{Config}-&gt;{ActivityDialog}-&gt;{$_} }
                sort { $a &lt;=&gt; $b } keys %{ $Data{Config}-&gt;{ActivityDialog} };
        }
        $Data{ActivityDialogs} = \@ActivityDialogList;
    }

    # set cache
    $Self-&gt;{CacheObject}-&gt;Set(
        Type  =&gt; 'ProcessManagement_Activity',
        Key   =&gt; $CacheKey,
        Value =&gt; \%Data,
        TTL   =&gt; $Self-&gt;{CacheTTL},
    );

    return \%Data;
}

=item ActivityUpdate()

update Activity attributes

returns 1 if success or undef otherwise

    my $Success = $ActivityObject-&gt;ActivityUpdate(
        ID          =&gt; 123,             # mandatory
        EntityID    =&gt; 'A1'             # mandatory, exportable unique identifier
        Name        =&gt; 'NameOfProcess', # mandatory
        Config      =&gt; $ConfigHashRef,  # mandatory, process configuration to be stored in YAML
                                        #   format
        UserID      =&gt; 123,             # mandatory
    );

=cut

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

    # check needed stuff
    for my $Key (qw(ID EntityID Name Config UserID)) {
        if ( !$Param{$Key} ) {
            $Self-&gt;{LogObject}-&gt;Log( Priority =&gt; 'error', Message =&gt; "Need $Key!" );
            return;
        }
    }

    # check if EntityID already exists
    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL =&gt; "
            SELECT id FROM pm_activity
            WHERE $Self-&gt;{Lower}(entity_id) = $Self-&gt;{Lower}(?)
            AND id != ?",
        Bind =&gt; [ \$Param{EntityID}, \$Param{ID} ],
        LIMIT =&gt; 1,
    );

    my $EntityExists;
    while ( my @Data = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        $EntityExists = 1;
    }

    if ($EntityExists) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; "The EntityID:$Param{Name} already exists for a activity!",
        );
        return;
    }

    # check config valid format
    if ( ref $Param{Config} ne 'HASH' ) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; "Config needs to be a valid Hash reference!",
        );
        return;
    }

    # dump config as string
    my $Config = $Self-&gt;{YAMLObject}-&gt;Dump( Data =&gt; $Param{Config} );

    # Make sure the resulting string has the UTF-8 flag. YAML only sets it if
    #   part of the data already had it.
    utf8::upgrade($Config);

    # check if need to update db
    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL =&gt; '
            SELECT entity_id, name, config
            FROM pm_activity
            WHERE id = ?',
        Bind  =&gt; [ \$Param{ID} ],
        Limit =&gt; 1,
    );

    my $CurrentEntityID;
    my $CurrentName;
    my $CurrentConfig;
    while ( my @Data = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        $CurrentEntityID = $Data[0];
        $CurrentName     = $Data[1];
        $CurrentConfig   = $Data[2];
    }

    if ($CurrentEntityID) {

        return 1 if $CurrentEntityID eq $Param{EntityID}
            &amp;&amp; $CurrentName eq $Param{Name}
            &amp;&amp; $CurrentConfig eq $Config;
    }

    # sql
    return if !$Self-&gt;{DBObject}-&gt;Do(
        SQL =&gt; '
            UPDATE pm_activity
            SET entity_id = ?, name = ?,  config = ?, change_time = current_timestamp, change_by = ?
            WHERE id = ?',
        Bind =&gt; [
            \$Param{EntityID}, \$Param{Name}, \$Config, \$Param{UserID},
            \$Param{ID},
        ],
    );

    # delete cache
    $Self-&gt;{CacheObject}-&gt;CleanUp(
        Type =&gt; 'ProcessManagement_Activity',
    );

    return 1;
}

=item ActivityList()

get an Activity list

    my $List = $ActivityObject-&gt;ActivityList(
        UseEntities =&gt; 0,                       # default 0, 1 || 0. if 0 the return hash keys are
                                                #    the activity IDs otherwise keys are the
                                                #    activity entity IDs
        UserID      =&gt; 1,
    );

    Returns:

    $List = {
        1 =&gt; 'Activity1',
    }

    or

    $List = {
        'A1' =&gt; 'Activity1',
    }
=cut

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

    # check needed
    if ( !$Param{UserID} ) {
        $Self-&gt;{LogObject}-&gt;Log(
            Priority =&gt; 'error',
            Message  =&gt; "Need UserID!"
        );
        return;
    }

    # check cache
    my $UseEntities = 0;
    if ( defined $Param{UseEntities} &amp;&amp; $Param{UseEntities} ) {
        $UseEntities = 1;
    }
    my $CacheKey = 'ActivityList::UseEntities::' . $UseEntities;
    my $Cache    = $Self-&gt;{CacheObject}-&gt;Get(
        Type =&gt; 'ProcessManagement_Activity',
        Key  =&gt; $CacheKey,
    );
    return $Cache if ref $Cache;

    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL =&gt; '
            SELECT id, entity_id, name
            FROM pm_activity',
    );

    my %Data;
    while ( my @Row = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        if ( !$UseEntities ) {
            $Data{ $Row[0] } = $Row[2];
        }
        else {
            $Data{ $Row[1] } = $Row[2];
        }
    }

    # set cache
    $Self-&gt;{CacheObject}-&gt;Set(
        Type  =&gt; 'ProcessManagement_Activity',
        Key   =&gt; $CacheKey,
        Value =&gt; \%Data,
        TTL   =&gt; $Self-&gt;{CacheTTL},
    );

    return \%Data;
}

=item ActivityListGet()

get an Activity list with all activity details

    my $List = $ActivityObject-&gt;ActivityListGet(
        UserID      =&gt; 1,
    );

Returns:

    $List = [
        {
            ID             =&gt; 123,
            EntityID       =&gt; 'A1',
            Name           =&gt; 'some name',
            Config         =&gt; $ConfigHashRef,
            ActiviyDialogs =&gt; ['AD1','AD2','AD3'],
            CreateTime     =&gt; '2012-07-04 15:08:00',
            ChangeTime     =&gt; '2012-07-04 15:08:00',
        }
        {
            ID             =&gt; 456,
            EntityID       =&gt; 'A2',
            Name           =&gt; 'some name',
            Config         =&gt; $ConfigHashRef,
            ActiviyDialogs =&gt; ['AD3','AD4','AD5'],
            CreateTime     =&gt; '2012-07-04 15:09:00',
            ChangeTime     =&gt; '2012-07-04 15:09:00',
        }
    ];

=cut

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

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

    # check cache
    my $CacheKey = 'ActivityListGet';

    my $Cache = $Self-&gt;{CacheObject}-&gt;Get(
        Type =&gt; 'ProcessManagement_Activity',
        Key  =&gt; $CacheKey,
    );
    return $Cache if $Cache;

    # sql
    return if !$Self-&gt;{DBObject}-&gt;Prepare(
        SQL =&gt; '
            SELECT id, entity_id
            FROM pm_activity
            ORDER BY id',
    );

    my @ActivityIDs;
    while ( my @Row = $Self-&gt;{DBObject}-&gt;FetchrowArray() ) {
        push @ActivityIDs, $Row[0];
    }

    my @Data;
    for my $ItemID (@ActivityIDs) {

        my $ActivityData = $Self-&gt;ActivityGet(
            ID     =&gt; $ItemID,
            UserID =&gt; 1,
        );
        push @Data, $ActivityData;
    }

    # set cache
    $Self-&gt;{CacheObject}-&gt;Set(
        Type  =&gt; 'ProcessManagement_Activity',
        Key   =&gt; $CacheKey,
        Value =&gt; \@Data,
        TTL   =&gt; $Self-&gt;{CacheTTL},
    );

    return \@Data;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (L&lt;http://otrs.org/&gt;).

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&lt;http://www.gnu.org/licenses/agpl.txt&gt;.

=cut
</pre></body></html>