File Coverage

blib/lib/Zabbix2/API/CRUDE.pm

Criterion	Covered	Total	%
statement	17	74	22.9
branch	0	26	0.0
condition	0	3	0.0
subroutine	6	17	35.2
pod	9	9	100.0
total	32	129	24.8

package Zabbix2::API::CRUDE;

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

use Scalar::Util qw/blessed/;
use Moo::Lax;

has 'data' => (is => 'ro',
               writer => '_set_data',
               default => sub { {} });
has 'root' => (is => 'ro',
               required => 1);

sub short_class {
    my $self = shift;
    my $class = blessed($self) // $self;
    $class =~ s/^Zabbix2::API:://;
    return $class;
}

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

sub node_id {
    my $self = shift;
    croak(sprintf(q{%s class object does not have a local ID, can't tell the node ID},
                  $self->short_class)) unless $self->id;
    return unless $self->id > 100_000_000_000_000;
    # this is how Zabbix operates, don't blame me
    return int($self->id/100_000_000_000_000);
}

sub _prefix {
    croak 'Class '.(ref shift).' does not implement required method _prefix()';
}

sub _extension {
    croak 'Class '.(ref shift).' does not implement required method _extension()';
}

sub name {
    croak 'Class '.(ref shift).' does not implement required method name()';
}

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 ],
                                              $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;
    if (my $id = $self->id) {
        my $response = $self->root->query(method => $self->_prefix('.get'),
                                          params => { $self->_prefix('ids') => [$id],
                                                      countOutput => 1 });
        return !!$response;
    } else {
        croak(sprintf(q{Cannot tell if a '%s' object exists on the server without the %s property},
                      $self->_prefix, $self->_prefix('id')));
    }
}

sub create {

    my $self = shift;

    ## remove the readonly properties
    my %data = %{$self->data};
    if ($self->can('_readonly_properties')) {
        delete @data{keys(%{$self->_readonly_properties})};
    }

    my $results = $self->root->query(method => $self->_prefix('.create'),
                                     params => \%data);
    my $id = $results->{$self->_prefix('ids')}->[0];
    $self->id($id);

    ## if lazy_push: done, else fetch the new updated data

    if ($self->root->pull_after_push_mode) {
        $self->pull;
    }

    return $self;

}

sub update {

    my $self = shift;

    ## save the ID because it is likely to be one of the readonly
    ## properties

    if (my $id = $self->id) {
        ## remove the readonly properties
        my %data = %{$self->data};
        if ($self->can('_readonly_properties')) {
            delete @data{keys(%{$self->_readonly_properties})};
        }

        eval {
            $self->root->query(method => $self->_prefix('.update'),
                               params => { $self->_prefix('id') => $id,
                                           %data });
        };
        croak $@ if $@;

        if ($self->root->pull_after_push_mode) {
            $self->pull;
        }
    } else {
        croak(sprintf(q{Cannot update new %s, need to create it or fetch it first},
                      $self->short_class));
    }

    return $self;

}

sub delete {
    my $self = shift;
    if ($self->id) {
        my $response = $self->root->query(method => $self->_prefix('.delete'),
                                          params => [ $self->id ]);
    } else {
        croak(sprintf(q{Useless call of delete() on a %s that does not have a %s},
                      $self->_prefix, $self->_prefix('id')));
    }
    return $self;
}

1;
__END__