API-MailboxOrg

 view release on metacpan or  search on metacpan

cpanfile  view on Meta::CPAN

requires "Moo" => "1.003001";
requires "MooX::Singleton" => "0";
requires "Params::ValidationCompiler" => "0.30";
requires "Scalar::Util" => "0";
requires "Type::Library" => "1.012";
requires "Type::Utils" => "1.012";
requires "Types::Mojo" => "0.04";
requires "Types::Standard" => "1.012";
requires "perl" => "5.024";

on 'test' => sub {
    requires "Pod::Coverage::TrustPod" => "0";
    requires "Test::Exception" => "0";
    requires "Test::More" => "0";
    requires "Test::RequiresInternet" => "0";
    requires "Test::Spec" => "0";
};

on 'configure' => sub {
    requires "ExtUtils::MakeMaker" => "0";
};

on 'develop' => sub {
    requires "Pod::Coverage::TrustPod" => "0";
    requires "Test::BOM" => "0";
    requires "Test::More" => "0.88";
    requires "Test::NoTabs" => "0";
    requires "Test::Perl::Critic" => "0";
    requires "Test::Pod" => "1.41";
    requires "Test::Pod::Coverage" => "1.08";
};

lib/API/MailboxOrg.pm  view on Meta::CPAN

use Types::Standard qw(Str);

use feature 'signatures';
no warnings 'experimental::signatures';

our $VERSION = '1.0.2'; # VERSION

has user     => ( is => 'ro', isa => Str, required => 1 );
has password => ( is => 'ro', isa => Str, required => 1 );
has token    => ( is => 'rwp', isa => Str );
has host     => ( is => 'ro', isa => MojoURL["https?"], default => sub { 'https://api.mailbox.org' }, coerce => 1 );
has base_uri => ( is => 'ro', isa => Str, default => sub { 'v1/' } );

has client   => (
    is      => 'ro',
    lazy    => 1,
    isa     => MojoUserAgent,
    default => sub {
        Mojo::UserAgent->new
    }
);

sub _load_namespace ($package) {
    my @modules = find_modules $package . '::API', { recursive => 1 };

    for my $module ( @modules ) {
        load_class( $module );

        my $base = (split /::/, $module)[-1];

        no strict 'refs'; ## no critic
        *{ $package . '::' . decamelize( $base ) } = sub ($api) {
            weaken $api;
            state $object //= $module->instance(
                api => $api,
            );

            return $object;
        };
    }
}

lib/API/MailboxOrg/API/Account.pm  view on Meta::CPAN

            address_payment_town       => { type => Str, optional => 1 },
            av_contract_accept_name    => { type => Str, optional => 1 },
            tarifflimits               => { type => HashRefRestricted[qw(basic profi profixl reseller)], optional => 1 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.del', \%params, \%opt );
}

sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.get', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.list', \%params, \%opt );
}

sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Backup.pm  view on Meta::CPAN

    'list' => validation_for(
        params => {
            mail => { type => Str, optional => 0 },

        },
    ),

);


sub backup_import ($self, %params) {
    my $validator = $validators{'backup_import'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.backup.import', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.backup.list', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Base.pm  view on Meta::CPAN

    'search' => validation_for(
        params => {
            query => { type => Str, optional => 0 },

        },
    ),

);


sub auth ($self, %params) {
    my $validator = $validators{'auth'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'auth', \%params, \%opt );
}

sub deauth ($self, %params) {
    my $validator = $validators{'deauth'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'deauth', \%params, \%opt );
}

sub search ($self, %params) {
    my $validator = $validators{'search'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'search', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Blacklist.pm  view on Meta::CPAN

    'list' => validation_for(
        params => {
            mail => { type => Str, optional => 0 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.blacklist.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.blacklist.del', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.blacklist.list', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Capabilities.pm  view on Meta::CPAN

        params => {
            mail         => { type => Str, optional => 0 },
            capabilities => { type => ArrayRef[Enum[qw(MAIL_SPAMPROTECTION MAIL_BLACKLIST MAIL_BACKUPRECOVER MAIL_OTP MAIL_PASSWORDRESET_SMS BMBO_VIDEOCHAT)]], optional => 0 },

        },
    ),

);


sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.capabilities.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Context.pm  view on Meta::CPAN

    'list' => validation_for(
        params => {
            account => { type => Str, optional => 0 },

        },
    ),

);


sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'context.list', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Domain.pm  view on Meta::CPAN

            context_id            => { type => Str, optional => 1 },
            create_new_context_id => { type => Boolean, optional => 1 },
            memo                  => { type => Str, optional => 1 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.del', \%params, \%opt );
}

sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.get', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.list', \%params, \%opt );
}

sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Hello.pm  view on Meta::CPAN

use feature 'signatures';
no warnings 'experimental::signatures';

our $VERSION = '1.0.2'; # VERSION

my %validators = (

);


sub innerworld ($self, %params) {
    my $validator = $validators{'innerworld'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'hello.innerworld', \%params, \%opt );
}

sub world ($self, %params) {
    my $validator = $validators{'world'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'hello.world', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Invoice.pm  view on Meta::CPAN

    'list' => validation_for(
        params => {
            account => { type => Str, optional => 0 },

        },
    ),

);


sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'account.invoice.get', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'account.invoice.list', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Mail.pm  view on Meta::CPAN

            phone                  => { type => Str, optional => 1 },
            fax                    => { type => Str, optional => 1 },
            cell_phone             => { type => Str, optional => 1 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.del', \%params, \%opt );
}

sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.get', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.list', \%params, \%opt );
}

sub register ($self, %params) {
    my $validator = $validators{'register'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'mail.register', \%params, \%opt );
}

sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Mailinglist.pm  view on Meta::CPAN

            account     => { type => Str, optional => 0 },
            password    => { type => Str, optional => 1 },
            adminmail   => { type => Str, optional => 1 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mailinglist.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mailinglist.del', \%params, \%opt );
}

sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'mailinglist.get', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mailinglist.list', \%params, \%opt );
}

sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mailinglist.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Passwordreset.pm  view on Meta::CPAN

            mail     => { type => Str, optional => 0 },
            token    => { type => Str, optional => 0 },
            password => { type => Str, optional => 0 },

        },
    ),

);


sub listmethods ($self, %params) {
    my $validator = $validators{'listmethods'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'mail.passwordreset.listmethods', \%params, \%opt );
}

sub sendsms ($self, %params) {
    my $validator = $validators{'sendsms'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'mail.passwordreset.sendsms', \%params, \%opt );
}

sub setpassword ($self, %params) {
    my $validator = $validators{'setpassword'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'mail.passwordreset.setpassword', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Spamprotect.pm  view on Meta::CPAN

            tag2level            => { type => Str, optional => 0 },
            killevel             => { type => Enum[qw(reject route)], optional => 0 },
            route_to             => { type => Str, optional => 0 },

        },
    ),

);


sub get ($self, %params) {
    my $validator = $validators{'get'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.spamprotect.get', \%params, \%opt );
}

sub set ($self, %params) {
    my $validator = $validators{'set'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.spamprotect.set', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Test.pm  view on Meta::CPAN

    'domainallowed' => validation_for(
        params => {
            domain => { type => Str, optional => 0 },

        },
    ),

);


sub accountallowed ($self, %params) {
    my $validator = $validators{'accountallowed'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'test.accountallowed', \%params, \%opt );
}

sub domainallowed ($self, %params) {
    my $validator = $validators{'domainallowed'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'test.domainallowed', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Utils.pm  view on Meta::CPAN

        params => {
            value => { type => Str, optional => 0 },
            type  => { type => Enum[qw(hostname domain mailhost mail account pass pass2 memo user contextid name)], optional => 0 },

        },
    ),

);


sub validator ($self, %params) {
    my $validator = $validators{'validator'};
    %params       = $validator->(%params) if $validator;

    my %opt = ();

    return $self->_request( 'utils.validator', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Validate.pm  view on Meta::CPAN

    'spf' => validation_for(
        params => {
            domain => { type => Str, optional => 0 },

        },
    ),

);


sub spf ($self, %params) {
    my $validator = $validators{'spf'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'domain.validate.spf', \%params, \%opt );
}


1;

lib/API/MailboxOrg/API/Videochat.pm  view on Meta::CPAN

            room_password       => { type => Str, optional => 1 },
            room_admin_password => { type => Str, optional => 1 },
            room_memo           => { type => Str, optional => 1 },

        },
    ),

);


sub add ($self, %params) {
    my $validator = $validators{'add'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.videochat.add', \%params, \%opt );
}

sub del ($self, %params) {
    my $validator = $validators{'del'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.videochat.del', \%params, \%opt );
}

sub list ($self, %params) {
    my $validator = $validators{'list'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.videochat.list', \%params, \%opt );
}

sub update ($self, %params) {
    my $validator = $validators{'update'};
    %params       = $validator->(%params) if $validator;

    my %opt = (needs_auth => 1);

    return $self->_request( 'mail.videochat.update', \%params, \%opt );
}


1;

lib/API/MailboxOrg/APIBase.pm  view on Meta::CPAN

use Params::ValidationCompiler qw(validation_for);
use Types::Mojo qw(:all);
use Types::Standard qw(Str Object Int);

use feature 'signatures';
no warnings 'experimental::signatures';

our $VERSION = '1.0.2'; # VERSION

has api      => ( is => 'ro', isa => Object, required => 1 );
has json_rpc => ( is => 'ro', isa => Str, default => sub { '2.0' } );

state $request_id = 1;

sub _request ( $self, $method, $params = {}, $opts = {} ) {
    my $rpc_data = {
        jsonrpc => $self->json_rpc,
        id      => $request_id++,
        method  => $method,
    };

    $rpc_data->{params} = $params->%* ? $params : "";

    my $api = $self->api;

lib/API/MailboxOrg/Types.pm  view on Meta::CPAN

use JSON::PP;
use Scalar::Util qw(blessed);

our $VERSION = '1.0.2'; # VERSION

my $meta = __PACKAGE__->meta;

$meta->add_type(
    name => 'HashRefRestricted',
    parent => HashRef,
    constraint_generator => sub {
        return $meta->get_type('HashRefRestricted') if !@_;

        my @keys = @_;

        croak "Need a list of valid keys" if !@keys;

        my %valid_keys = map { $_ => 1 } @keys;

        return sub {
            return if ref $_ ne 'HASH';
            return 1 if !$_->%*;

            for my $key ( keys $_->%* ) {
                return if !$valid_keys{$key};
            }

            return 1;
        };
    },
    coercion_generator => sub {
        my ($parent, $child, $param) = @_;
        return $parent->coercion;
    },
    #inline_generator => sub {},
    #deep_explanation => sub {},
);

$meta->add_type(
    name => 'Boolean',
    parent => InstanceOf['JSON::PP::Boolean'],
    constraint_generator => sub {
        return $meta->get_type('Boolean') if !@_;

        return sub {
            return if ! ( blessed $_ and $_->isa('JSON::PP::Boolean') );
            return 1;
        };
    },
    coercion_generator => sub {
        my ($parent, $child, $param) = @_;
        return $parent->coercion;
    },
);

coerce Boolean,
    from Bool,
        via {
            my $new = $_ ? $JSON::PP::true : $JSON::PP::false;
            $new;

t/types/001_hashref_restricted.t  view on Meta::CPAN

use warnings;

use Test::Spec;
use Test::Exception;

use File::Basename;
use lib dirname(__FILE__);

use API::MailboxOrg::Types qw(HashRefRestricted);

describe 'HashRefRestricted' => sub {
    it 'allows an empty hash' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        ok $type->( {} );
    };

    it 'allows only the defined keys, using all allowed keys' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        ok $type->( { a => 1, b => 2 } );
    };

    it 'allows only the defined keys, using a subset of the keys' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        ok $type->( { a => 1 } );
    };

    it 'dies on disallowed keys' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        dies_ok { $type->( { c => 1 } ) };
    };

    it 'dies on disallowed keys, even when allowed keys are present' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        dies_ok { $type->( { c => 1, a => 2 } ) };
    };

    it 'dies on non-hashrefs - arrayref' => sub {
        my $type = HashRefRestricted([qw/a b/]); # allow keys a and b only
        dies_ok { $type->( [] ) };
    };
};

runtests if !caller;

t/types/002_boolean.t  view on Meta::CPAN

        TestClass;

    use Moo;
    use API::MailboxOrg::Types qw(Boolean);

    has true_or_false => ( is => 'rw', isa => Boolean, coerce => 1 );

    1;
}

describe 'Boolean' => sub {

    it 'allows a JSON::PP::true' => sub {
        my $type = Boolean();
        ok $type->( $JSON::PP::true );
    };

    it 'allows a JSON::PP::false' => sub {
        my $type = Boolean();
        is $type->( $JSON::PP::false ), 0;
        isa_ok $type->( $JSON::PP::false ), 'JSON::PP::Boolean';
    };
};

describe "TestClass' true_or_false" => sub {

    it 'allows a JSON::PP::true' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( $JSON::PP::true );
        };

        is $obj->true_or_false, 1;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'allows a JSON::PP::false' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( $JSON::PP::false );
        };

        is $obj->true_or_false, 0;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'allows a 0' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( 0 );
        };

        is $obj->true_or_false, 0;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'allows a 1' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( 1 );
        };

        is $obj->true_or_false, 1;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'allows undef' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( undef );
        };

        is $obj->true_or_false, 0;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'allows empty string' => sub {
        my $obj = TestClass->new;

        lives_ok {
            $obj->true_or_false( "" );
        };

        is $obj->true_or_false, 0;
        isa_ok $obj->true_or_false, 'JSON::PP::Boolean';
    };

    it 'doesn\'t allow any references' => sub {
        my $obj = TestClass->new;

        dies_ok {
            $obj->true_or_false( [] );
        };
    };

    it 'doesn\'t allow strings other than ""' => sub {
        my $obj = TestClass->new;

        dies_ok {
            $obj->true_or_false( "true" );
        };
    };
};

runtests if !caller;