File Coverage

blib/lib/Zabbix/API/CRUDE.pm

Criterion	Covered	Total	%
statement	11	66	16.6
branch	0	34	0.0
condition	0	9	0.0
subroutine	4	15	26.6
pod	11	11	100.0
total	26	135	19.2

package Zabbix::API::CRUDE;

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

sub new {

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

    my $self = \%args;

    bless $self, $class;

    return $self;

}

sub id {

    croak 'Class '.(ref shift).' does not implement required mutator id()';

}

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 data {

    ## accessor for data

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

    if (defined $value) {

        croak 'Accessor data() called as mutator';

    } else {

        $self->{data} = {} unless exists $self->{data};

        return $self->{data};

    }

}

sub pull {

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

    if (defined $data) {

        $self->{data} = $data;

    } else {

        croak sprintf('Cannot pull data from server into a %s without ID', $self->prefix)
            unless $self->id;

        $self->{data} = $self->{root}->query(method => $self->prefix('.get'),
                                             params => {
                                                 $self->prefix('ids') => [ $self->id ],
                                                 $self->extension
                                             })->[0];

        # uniquify objects
        if (my $replacement = $self->{root}->refof($self)) {

            $self = $replacement;

        } else {

            $self->{root}->reference($self);

        }

    }

    return $self;

}

sub created {

    my $self = shift;

    return $self->id if $self->{root}->{lazy};

    return @{$self->{root}->query(method => $self->prefix('.get'),
                                  params => {
                                      $self->prefix('ids') => [$self->id],
                                      $self->extension
                                  })};

}

sub collides {

    croak 'Class '.(ref shift).' does not implement required method collides()';

}

sub push {

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

    $data //= $self->data;

    my @colliders;

    if ($self->id and $self->created) {

        say sprintf('Updating %s %s', $self->prefix, $self->id)
            if $self->{root}->{verbosity};

        $self->{root}->query(method => $self->prefix('.update'),
                             params => $data);

        $self->pull unless $self->{root}->{lazy};

    } elsif ($self->id) {

        croak sprintf('%s has a %s but does not exist on server', $self->id, $self->prefix('id'));

    } elsif (@colliders = $self->collides and $colliders[0]) {

        say sprintf('Updating %s (match by collisions)', $self->prefix)
            if $self->{root}->{verbosity};

        if (@colliders > 1) {

            croak sprintf('Cannot push %s: too many possible targets', $self->prefix);

        }

        my $class = ref $self;

        # not referenced! and that's the way we want it
        my $collider = $class->new(root => $self->{root}, data => $colliders[0]);

        $self->id($collider->id);

        $self->push;

    } else {

        say 'Creating '.$self->prefix
            if $self->{root}->{verbosity};

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

        $self->id($id);

        $self->pull unless $self->{root}->{lazy};

    }

    return $self;

}

sub delete {

    my $self = shift;

    if ($self->id) {

        say sprintf('Deleting %s %s', $self->prefix, $self->id)
            if $self->{root}->{verbosity};

        $self->{root}->query(method => $self->prefix('.delete'),
                             params => [ $self->id ]);

        delete $self->{root}->{stash}->{$self->prefix('s')}->{$self->id};

        $self->{root}->dereference($self);

    } else {

        carp sprintf(q{Useless call of delete() on a %s that does not have a %s}, $self->prefix, $self->prefix('id'));

    }

    return $self;

}

1;
__END__