File Coverage

blib/lib/Zabbix2/API/Macro.pm

Criterion	Covered	Total	%
statement	23	63	36.5
branch	0	34	0.0
condition			n/a
subroutine	8	17	47.0
pod	6	6	100.0
total	37	120	30.8

package Zabbix2::API::Macro;

use strict;
use warnings;
use 5.010;
use Carp;
use autodie;
use utf8;

use Moo;
use JSON;
extends qw/Zabbix2::API::CRUDE/;

sub id {
    ## mutator for id
    my ($self, $value) = @_;
    if (defined $value) {
        if ($self->globalp) {
            $self->data->{globalmacroid} = $value;
            delete $self->data->{hostmacroid};
            return $self->data->{globalmacroid};
        } else {
            $self->data->{hostmacroid} = $value;
            delete $self->data->{globalmacroid};
            return $self->data->{hostmacroid};
        }
    } else {
        if ($self->globalp) {
            return $self->data->{globalmacroid};
        } else {
            return $self->data->{hostmacroid};
        }
    }
}

sub _readonly_properties {
    # so, for some reason, the server returns a "hosts" property, but
    # it complains when that property is sent back.
    return {
        hosts => 1,
    };
}

sub _prefix {
    my ($self, $suffix) = @_;
    if ($suffix) {
        if ($suffix =~ m/ids?/) {
            return ($self->globalp?'globalmacro':'hostmacro').$suffix;
        } elsif ($suffix eq '.delete') {
            return 'usermacro.'.($self->globalp?'deleteglobal':'delete');
        } elsif ($suffix eq '.create') {
            return 'usermacro.'.($self->globalp?'createglobal':'create');
        } elsif ($suffix eq '.update') {
            return 'usermacro.'.($self->globalp?'updateglobal':'update');
        }
        return 'usermacro'.$suffix;
    } else {
        return 'usermacro';
    }
}

sub _extension {
    return (output => 'extend');
}

sub name {
    my $self = shift;
    return $self->data->{macro};
}

sub value {
    my ($self, $value) = @_;
    if (defined $value) {
        $self->data->{value} = $value;
    }
    return $self->data->{value};
}

sub globalp {
    my $self = shift;
    return !exists($self->data->{hostid});
}

# overridden from CRUDE to set the globalmacro flag
sub pull {
    my $self = shift;
    croak(sprintf(q{Cannot pull data from server into a %s without ID}, $self->short_class))
        unless $self->id;
    my $data = $self->root->query(method => $self->_prefix('.get'),
                                  params => { $self->_prefix('ids') => [ $self->id ],
                                              globalmacro => $self->globalp ? JSON::true : JSON::false,
                                              $self->_extension })->[0];
    croak(sprintf(q{%s class object has a local ID that does not appear to exist on the server},
                  $self->short_class)) unless $data;
    $self->_set_data($data);
    return $self;
}

sub exists {
    my $self = shift;
    my $response = $self->root->query(method => $self->_prefix('.get'),
                                      params => { $self->_prefix('ids') => [$self->id],
                                                  globalmacro => $self->globalp ? JSON::true : JSON::false,
                                                  countOutput => 1 });
    return !!$response;
}

1;
__END__