File Coverage

blib/lib/Zabbix/API/Graph.pm

Criterion	Covered	Total	%
statement	14	71	19.7
branch	0	14	0.0
condition	0	6	0.0
subroutine	5	13	38.4
pod	8	8	100.0
total	27	112	24.1

package Zabbix::API::Graph;

use strict;
use warnings;
use 5.010;
use Carp;

use parent qw/Zabbix::API::CRUDE/;

sub new {
	my ($class, %args) = @_;

	my $self = $class->SUPER::new(%args);

	$self->data->{gitems} = [] unless defined $self->data->{gitems};

	return $self;
}


sub id {

    ## mutator for id

    my ($self, $value) = @_;

    if (defined $value) {

        $self->data->{graphid} = $value;
        return $self->data->{graphid};

    } else {

        return $self->data->{graphid};

    }

}

sub prefix {

    my (undef, $suffix) = @_;

    if ($suffix) {

        return 'graph'.$suffix;

    } else {

        return 'graph';

    }

}

sub extension {

    return ( output => 'extend',
             select_graph_items => 'extend' );

}

sub collides {

    my $self = shift;

    return @{$self->{root}->query(method => $self->prefix('.get'),
                                  params => { filter => { name => $self->data->{name} },
                                              $self->extension })};

}

sub items {

    ## mutator for graph_items

    my ($self, $value) = @_;

    if (defined $value) {

        $self->data->{gitems} = $value;
        return $self->data->{gitems};

    } else {

        return $self->data->{gitems};

    }

}

sub push {

    # override CRUDE's push()

    my ($self, $data) = @_;

    $data //= $self->data;

    foreach my $item (@{$data->{gitems}}) {

        if (exists $item->{item}) {

            if (eval { $item->{item}->isa('Zabbix::API::Item') }) {

                $item->{item}->push;

                $item->{itemid} = $item->{item}->id;

            } else {

                croak 'Type mismatch: item attribute should be an instance of Zabbix::API::Item';

            }

        }

    }

    # copying the anonymous hashes so we can delete stuff without touching the
    # originals
    my $gitems_copy = [ map { { %{$_} } } @{$data->{gitems}} ];

    foreach my $item (@{$gitems_copy}) {

        delete $item->{item};

    }

    # copying the data hashref so we can replace its gitems with the fake
    my $data_copy = { %{$data} };

    # the old switcheroo
    $data_copy->{gitems} = $gitems_copy;

    return $self->SUPER::push($data_copy);

}

sub pull {

    # override CRUDE's pull()

    my ($self, $data) = @_;

    if (defined $data) {

        $self->{data} = $data;

    } else {

        my %stash = map { $_->id => $_ } grep { eval { $_->isa('Zabbix::API::Item') } } @{$self->items};

        $self->SUPER::pull;

        ## no critic (ProhibitCommaSeparatedStatements)
        # restore stashed items that have been removed by pulling
        $self->items(
            [map {
                { %{$_},
                  item =>
                      $stash{$_->{itemid}} // Zabbix::API::Item->new(root => $self->{root},
                                                                     data => { itemid => $_->{itemid} })->pull
                }
             }
             @{$self->items}]
            );
        ## use critic

    }

    return $self;

}

1;
__END__