File Coverage

blib/lib/Net/BaruwaAPI.pm

Criterion	Covered	Total	%
statement	254	284	89.4
branch	20	32	62.5
condition	0	9	0.0
subroutine	78	79	98.7
pod	68	69	98.5
total	420	473	88.7

# -*- coding: utf-8 -*-
# vim: ai ts=4 sts=4 et sw=4
# Net::BaruwaAPI Perl bindings for the Baruwa REST API
# Copyright (C) 2015-2019 Andrew Colin Kissa
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
package Net::BaruwaAPI;

# use utf8;
use feature 'state';
use JSON::MaybeXS;
use HTTP::Request;
use Carp qw/croak/;
use LWP::UserAgent;
use Type::Params qw/compile/;
use Types::Standard qw(Str InstanceOf Object Int Bool Dict Num ArrayRef Optional);
use Moo;

our $VERSION = '0.06';
our $AUTHORITY = 'cpan:DATOPDOG';

my $api_path = '/api/v1';

has 'api_url' => (is => 'ro', isa => Str, predicate => 'has_api_url', required => 1);

has 'api_token' => (is => 'ro', isa => Str, predicate => 'has_api_token', required => 1);

has 'ua' => (
    isa     => InstanceOf['LWP::UserAgent'],
    is      => 'ro',
    lazy    => 1,
    default => sub {
        LWP::UserAgent->new(
            agent       => "BaruwaAPI-Perl",
            cookie_jar  => {},
            keep_alive  => 4,
            timeout     => 60,
        );
    },
);

has 'json' => (
    is => 'ro',
    isa => Object,
    lazy => 1,
    default => sub {
        return JSON::MaybeXS->new( utf8 => 1 );
    }
);

sub _call {
    my ($self) = @_;
    my $request_method = shift @_;
    my $url = shift @_;
    my $data = shift @_;

    my $ua = $self->ua;
    $ua->default_header('Authorization', "Bearer " . $self->api_token);
    $url = $self->api_url . $url;

    my $req = HTTP::Request->new( $request_method, $url );
    $req->accept_decodable;

    if ($data) {
        $req->content($data);
    }
    $req->header( 'Content-Length' => length $req->content );

    my $res = $ua->request($req);

    if ($res->header('Content-Type') and $res->header('Content-Type') =~ 'application/json') {
        my $json = $res->decoded_content;
        $data = eval { $self->json->decode($json) };
        unless ($data) {
            die unless $res->is_error;
            $data = { code => $res->code, message => $res->message };
        }
    } else {
        $data = { code => $res->code, message => $res->message };
    }

    if (not $res->is_success and ref $data eq 'HASH' and exists $data->{message}) {
        my $message = $data->{message};

        if (exists $data->{errors}) {
            $message .= ': '.join(' - ', map { $_->{message} } grep { exists $_->{message} } @{ $data->{errors} });
        }
        croak $message;
    }
    return $data;
}


sub get_users {
    state $check = compile(Object, Optional[Int]);
    my ($self, $page) = $check->(@_);
    my $path = "$api_path/users";
    $path = "$api_path/users?page=$page" unless @_ == 1;
    return $self->_call('GET', $path);
}

sub get_user {
    state $check = compile(Object, Int);
    my ($self, $userid) = $check->(@_);
    return $self->_call('GET', "$api_path/users/$userid");
}

sub create_user {
    state $check = compile(Object,
    Dict[
        username => Str,
        firstname => Str,
        lastname => Str,
        password1 => Str,
        password2 => Str,
        email => Str,
        timezone => Str,
        account_type => Int,
        domains => Int,
        active => Bool,
        send_report => Bool,
        spam_checks => Bool,
        low_score => Num,
        high_score => Num,
        block_macros => Bool,
    ]);
    my ($self, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/users", $data);
}

sub update_user {
    state $check = compile(Object,
    Dict[
        username => Str,
        firstname => Str,
        lastname => Str,
        email => Str,
        timezone => Str,
        domains => Int,
        active => Bool,
        send_report => Bool,
        spam_checks => Bool,
        low_score => Num,
        high_score => Num,
        block_macros => Bool,
    ]);
    my ($self, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/users", $data);
}

sub delete_user {
    state $check = compile(Object,
    Dict[
        username => Str,
        firstname => Str,
        lastname => Str,
        email => Str,
        timezone => Str,
        domains => Int,
        active => Bool,
        send_report => Bool,
        spam_checks => Bool,
        low_score => Num,
        high_score => Num,
        block_macros => Bool,
    ]);
    my ($self, $data) = $check->(@_);
    # my ($self, $data) = @_;
    return $self->_call('DELETE', "$api_path/users", $data);
}

sub set_user_passwd {
    state $check = compile(Object, Int,
    Dict[
        password1 => Str,
        password2 => Str,
    ]);
    my ($self, $userid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/users/chpw/$userid");
}

sub get_aliases {
    state $check = compile(Object, Int);
    my ($self, $addressid) = $check->(@_);
    return $self->_call('GET', "$api_path/aliasaddresses/$addressid");
}

sub create_alias {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        enabled => Bool,
    ]);
    my ($self, $userid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/aliasaddresses/$userid", $data);
}

sub update_alias {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        enabled => Bool,
    ]);
    my ($self, $addressid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/aliasaddresses/$addressid", $data);
}

sub delete_alias {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        enabled => Bool,
    ]);
    my ($self, $addressid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/aliasaddresses/$addressid", $data);
}

sub get_domains {
    state $check = compile(Object, Optional[Int]);
    my ($self, $page) = $check->(@_);
    my $path = "$api_path/domains";
    $path = "$api_path/domains?page=$page" unless @_ == 1;
    return $self->_call('GET', $path);
}

sub get_domain {
    state $check = compile(Object, Int);
    my ($self, $domainid) = $check->(@_);
    return $self->_call('GET', "$api_path/domains/$domainid");
}

sub get_domain_by_name {
    state $check = compile(Object, Str);
    my ($self, $domain_name) = $check->(@_);
    return $self->_call('GET', "$api_path/domains/byname/$domain_name");
}

sub create_domain {
    state $check = compile(Object,
    Dict[
        name => Str,
        site_url => Str,
        status => Bool,
        accept_inbound => Bool,
        discard_mail => Bool,
        smtp_callout => Bool,
        ldap_callout => Bool,
        virus_checks => Bool,
        virus_checks_at_smtp => Bool,
        block_macros => Bool,
        spam_checks => Bool,
        spam_actions => Num,
        highspam_actions => Num,
        virus_actions => Num,
        low_score => Num,
        high_score => Num,
        message_size => Str,
        delivery_mode => Num,
        language => Str,
        timezone => Str,
        report_every => Num,
        organizations => Num
    ]);
    my ($self, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/domains", $data);
}

sub update_domain {
    state $check = compile(Object, Int,
    Dict[
        name => Str,
        site_url => Str,
        status => Bool,
        accept_inbound => Bool,
        discard_mail => Bool,
        smtp_callout => Bool,
        ldap_callout => Bool,
        virus_checks => Bool,
        virus_checks_at_smtp => Bool,
        block_macros => Bool,
        spam_checks => Bool,
        spam_actions => Num,
        highspam_actions => Num,
        virus_actions => Num,
        low_score => Num,
        high_score => Num,
        message_size => Str,
        delivery_mode => Num,
        language => Str,
        timezone => Str,
        report_every => Num,
        organizations => Num
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/domains/$domainid", $data);
}

sub delete_domain {
    state $check = compile(Object, Int);
    my ($self, $domainid) = $check->(@_);
    return $self->_call('DELETE', "$api_path/domains/$domainid");
}

sub get_domainaliases {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $domainid, $page) = $check->(@_);
    my $path = "$api_path/domainaliases/$domainid";
    $path = "$api_path/domainaliases/$domainid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_domainalias {
    state $check = compile(Object, Int, Int);
    my ($self, $domainid, $aliasid) = $check->(@_);
    return $self->_call('GET', "$api_path/domainaliases/$domainid/$aliasid");
}

sub create_domainalias {
    state $check = compile(Object, Int,
    Dict[
        name => Str,
        status => Bool,
        accept_inbound => Bool,
        domain => Int
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/domainaliases/$domainid", $data);
}

sub update_domainalias {
    state $check = compile(Object, Int, Int,
    Dict[
        name => Str,
        status => Bool,
        accept_inbound => Bool,
        domain => Int
    ]);
    my ($self, $domainid, $aliasid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/domainaliases/$domainid/$aliasid", $data);
}

sub delete_domainalias {
    state $check = compile(Object, Int, Int,
    Dict[
        name => Str,
        status => Bool,
        accept_inbound => Bool,
        domain => Int
    ]);
    my ($self, $domainid, $aliasid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/domainaliases/$domainid/$aliasid", $data);
}

sub get_deliveryservers {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $domainid, $page) = $check->(@_);
    my $path = "$api_path/deliveryservers/$domainid";
    $path = "$api_path/deliveryservers/$domainid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_deliveryserver {
    state $check = compile(Object, Int, Int);
    my ($self, $domainid, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/deliveryservers/$domainid/$serverid");
}

sub create_deliveryserver {
    state $check = compile(Object, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/deliveryservers/$domainid", $data);
}

sub update_deliveryserver {
    state $check = compile(Object, Int, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/deliveryservers/$domainid/$serverid", $data);
}

sub delete_deliveryserver {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        require_tls => Bool,
        verification_only => Bool,
        enabled => Bool
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/deliveryservers/$domainid/$serverid", $data);
}

sub get_user_deliveryservers {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $domainid, $page) = $check->(@_);
    my $path = "$api_path/userdeliveryservers/$domainid";
    $path = "$api_path/userdeliveryservers/$domainid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_user_deliveryserver {
    state $check = compile(Object, Int, Int);
    my ($self, $domainid, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/userdeliveryservers/$domainid/$serverid");
}

sub create_user_deliveryserver {
    state $check = compile(Object, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/userdeliveryservers/$domainid", $data);
}

sub update_user_deliveryserver {
    state $check = compile(Object, Int, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/userdeliveryservers/$domainid/$serverid", $data);
}

sub delete_user_deliveryserver {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        require_tls => Bool,
        verification_only => Bool,
        enabled => Bool
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/userdeliveryservers/$domainid/$serverid", $data);
}

sub get_domain_smarthosts {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $domainid, $page) = $check->(@_);
    my $path = "$api_path/domains/smarthosts/$domainid";
    $path = "$api_path/domains/smarthosts/$domainid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_domain_smarthost {
    state $check = compile(Object, Int, Int);
    my ($self, $domainid, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/domains/smarthosts/$domainid/$serverid");
}

sub create_domain_smarthost {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/domains/smarthosts/$domainid", $data);
}

sub update_domain_smarthost {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/domains/smarthosts/$domainid/$serverid", $data);
}

sub delete_domain_smarthost {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/domains/smarthosts/$domainid/$serverid", $data);
}

sub get_org_smarthosts {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $orgid, $page) = $check->(@_);
    my $path = "$api_path/organizations/smarthosts/$orgid";
    $path = "$api_path/organizations/smarthosts/$orgid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_org_smarthost {
    state $check = compile(Object, Int, Int);
    my ($self, $orgid, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/organizations/smarthosts/$orgid/$serverid");
}

sub create_org_smarthost {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $orgid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/organizations/smarthosts/$orgid", $data);
}

sub update_org_smarthost {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $orgid, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/organizations/smarthosts/$orgid/$serverid", $data);
}

sub delete_org_smarthost {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        username => Str,
        password => Str,
        port => Int,
        require_tls => Bool,
        enabled => Bool,
        description => Str,
    ]);
    my ($self, $orgid, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/organizations/smarthosts/$orgid/$serverid", $data);
}

sub get_fallbackservers {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $orgid, $page) = $check->(@_);
    my $path = "$api_path/fallbackservers/list/$orgid";
    $path = "$api_path/fallbackservers/list/$orgid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_fallbackserver {
    state $check = compile(Object, Int);
    my ($self, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/fallbackservers/$serverid");
}

sub create_fallbackserver {
    state $check = compile(Object, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $orgid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/fallbackservers/$orgid", $data);
}

sub update_fallbackserver {
    state $check = compile(Object, Int,
    Dict[
     address => Str,
     protocol => Int,
     port => Int,
     require_tls => Bool,
     verification_only => Bool,
     enabled => Bool
    ]);
    my ($self, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/fallbackservers/$serverid", $data);
}

sub delete_fallbackserver {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        require_tls => Bool,
        verification_only => Bool,
        enabled => Bool
    ]);
    my ($self, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/fallbackservers/$serverid", $data);
}

sub get_authservers {
    state $check = compile(Object, Int, Optional[Int]);
    my ($self, $domainid, $page) = $check->(@_);
    my $path = "$api_path/authservers/$domainid";
    $path = "$api_path/authservers/$domainid?page=$page" unless @_ == 2;
    return $self->_call('GET', $path);
}

sub get_authserver {
    state $check = compile(Object, Int, Int);
    my ($self, $domainid, $serverid) = $check->(@_);
    return $self->_call('GET', "$api_path/authservers/$domainid/$serverid");
}

sub create_authserver {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        enabled => Bool,
        split_address => Bool,
        user_map_template => Str
    ]);
    my ($self, $domainid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/authservers/$domainid", $data);
}

sub update_authserver {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        enabled => Bool,
        split_address => Bool,
        user_map_template => Str
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/authservers/$domainid/$serverid", $data);
}

sub delete_authserver {
    state $check = compile(Object, Int, Int,
    Dict[
        address => Str,
        protocol => Int,
        port => Int,
        enabled => Bool,
        split_address => Bool,
        user_map_template => Str
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/authservers/$domainid/$serverid", $data);
}

sub get_ldapsettings {
    state $check = compile(Object, Int, Int, Int);
    my ($self, $domainid, $serverid, $settingsid) = $check->(@_);
    return $self->_call('GET', "$api_path/ldapsettings/$domainid/$serverid/$settingsid");
}

sub create_ldapsettings {
    state $check = compile(Object, Int, Int,
    Dict[
        basedn => Str,
        nameattribute => Str,
        emailattribute => Str,
        binddn => Str,
        bindpw => Str,
        usetls => Bool,
        usesearch => Bool,
        searchfilter => Str,
        search_scope => Str,
        emailsearchfilter => Str,
        emailsearch_scope => Str
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/ldapsettings/$domainid/$serverid", $data);
}

sub update_ldapsettings {
    state $check = compile(Object, Int, Int, Int,
    Dict[
        basedn => Str,
        nameattribute => Str,
        emailattribute => Str,
        binddn => Str,
        bindpw => Str,
        usetls => Bool,
        usesearch => Bool,
        searchfilter => Str,
        search_scope => Str,
        emailsearchfilter => Str,
        emailsearch_scope => Str
    ]);
    my ($self, $domainid, $serverid, $settingsid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/ldapsettings/$domainid/$serverid/$settingsid", $data);
}

sub delete_ldapsettings {
    state $check = compile(Object, Int, Int, Int,
    Dict[
        basedn => Str,
        nameattribute => Str,
        emailattribute => Str,
        binddn => Str,
        bindpw => Str,
        usetls => Bool,
        usesearch => Bool,
        searchfilter => Str,
        search_scope => Str,
        emailsearchfilter => Str,
        emailsearch_scope => Str
    ]);
    my ($self, $domainid, $serverid, $settingsid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/ldapsettings/$domainid/$serverid/$settingsid", $data);
}

sub get_radiussettings {
    state $check = compile(Object, Int, Int, Int);
    my ($self, $domainid, $serverid, $settingsid) = $check->(@_);
    return $self->_call('GET', "$api_path/radiussettings/$domainid/$serverid/$settingsid");
}

sub create_radiussettings {
    state $check = compile(Object, Int, Int,
    Dict[
        secret => Str,
        timeout => Int
    ]);
    my ($self, $domainid, $serverid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/radiussettings/$domainid/$serverid", $data);
}

sub update_radiussettings {
    state $check = compile(Object, Int, Int, Int,
    Dict[
        secret => Str,
        timeout => Int
    ]);
    my ($self, $domainid, $serverid, $settingsid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/radiussettings/$domainid/$serverid/$settingsid", $data);
}

sub delete_radiussettings {
    state $check = compile(Object, Int, Int, Int,
    Dict[
        secret => Str,
        timeout => Int
    ]);
    my ($self, $domainid, $serverid, $settingsid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/radiussettings/$domainid/$serverid/$settingsid", $data);
}

sub get_organizations {
    state $check = compile(Object, Optional[Int]);
    my ($self, $page) = $check->(@_);
    my $path = "$api_path/organizations";
    $path = "$api_path/organizations?page=$page" unless @_ == 1;
    return $self->_call('GET', $path);
}

sub get_organization {
    state $check = compile(Object, Int);
    my ($self, $orgid) = $check->(@_);
    return $self->_call('GET', "$api_path/organizations/$orgid");
}

sub create_organization {
    state $check = compile(Object,
    Dict[
        name => Str,
        domains => ArrayRef,
        admins => ArrayRef
    ]);
    my ($self, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/organizations", $data);
}

sub update_organization {
    state $check = compile(Object, Int,
    Dict[
        name => Str,
        domains => ArrayRef,
        admins => ArrayRef
    ]);
    my ($self, $orgid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/organizations/$orgid", $data);
}

sub delete_organization {
    state $check = compile(Object, Int);
    my ($self, $orgid) = $check->(@_);
    return $self->_call('DELETE', "$api_path/organizations/$orgid");
}

sub get_relay {
    state $check = compile(Object, Int);
    my ($self, $relayid) = $check->(@_);
    return $self->_call('GET', "$api_path/relays/$relayid");
}

sub create_relay {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        username => Str,
        enabled => Bool,
        require_tls => Bool,
        password1 => Str,
        password2 => Str,
        description => Str,
        low_score => Num,
        high_score => Num,
        spam_actions => Int,
        highspam_actions => Int,
        block_macros => Bool,
        ratelimit => Int
    ]);
    my ($self, $orgid, $data) = $check->(@_);
    return $self->_call('POST', "$api_path/relays/$orgid", $data);
}

sub update_relay {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        username => Str,
        enabled => Bool,
        require_tls => Bool,
        password1 => Str,
        password2 => Str,
        description => Str,
        low_score => Num,
        high_score => Num,
        spam_actions => Int,
        highspam_actions => Int,
        block_macros => Bool,
        ratelimit => Int
    ]);
    my ($self, $relayid, $data) = $check->(@_);
    return $self->_call('PUT', "$api_path/relays/$relayid", $data);
}

sub delete_relay {
    state $check = compile(Object, Int,
    Dict[
        address => Str,
        username => Str,
        enabled => Bool,
        require_tls => Bool,
        password1 => Str,
        password2 => Str,
        description => Str,
        low_score => Num,
        high_score => Num,
        spam_actions => Int,
        highspam_actions => Int,
        block_macros => Bool,
        ratelimit => Int
    ]);
    my ($self, $relayid, $data) = $check->(@_);
    return $self->_call('DELETE', "$api_path/relays/$relayid", $data);
}

sub get_status {
    state $check = compile(Object);
    my ($self) = $check->(@_);
    return $self->_call('GET', "$api_path/status");
}

no Moo;

1;

__END__