• Your recent searches
API-ISPManager
21 results

 view release on metacpan or  search on metacpan

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

    die "Cannot delete account";
 }


=cut

# Last raw answer from server 
our $last_answer = ''; 

# Public!
sub is_ok {
    my $answer = shift;

    return '' unless $answer && ref $answer eq 'HASH' && $answer->{success};
}


sub get_error {
    my $answer = shift;

    return '' if is_ok($answer); # ok == no error

    return Dumper( $answer->{error} );
}

# Get data from @_
sub get_params {
    my @params = @_;

    if (scalar @params == 1 && ref $params[0] eq 'HASH' ) {
        return { %{ $params[0] } };
    } else {
        return { @params };
    }
}

# Make query string
# STATIC(HASHREF: params)
sub mk_query_string {
    my $params = shift;

    return '' unless $params &&
        ref $params eq 'HASH' && %$params ;

    my $result = join '&', map { "$_=$params->{$_}" } sort keys %$params;
    warn $result if $DEBUG;

    return $result;
}

# Kill slashes at start / end string
# STATIC(STRING:input_string)
sub kill_start_end_slashes {
    my $str = shift;

    for ($str) {
        s/^\/+//sgi;
        s/\/+$//sgi;
    }
    
    return $str;
}

# Make full query string (with host, path and protocol)
# STATIC(HASHREF: params)
# params:
# host*
# path
# allow_http
# param1
# param2 
# ...
sub mk_full_query_string {
    my $params = shift;

    return '' unless
        $params               &&
        ref $params eq 'HASH' &&
        %$params              &&
        $params->{host};

    my $host       = delete $params->{host};
    my $path       = delete $params->{path}        || '';

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

    $host = kill_start_end_slashes($host);

    my $query_path = ( $allow_http ? 'http' : 'https' ) . "://$host/$path/ispmgr?";

    return %$params ? $query_path . mk_query_string($params) : '';
}


# Make request to server and get answer
# STATIC (STRING: query_string)
sub mk_query_to_server {
    my $query_string = shift;

    return '' unless $query_string;
    warn "Query string: $query_string\n" if $DEBUG;

    my $ua = LWP::UserAgent->new;
    $ua->agent("Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)");
    # Don`t working without this string!

    my $response = $ua->get($query_string);

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

    } else {
        return '';
    }
}

# Parse answer
# STATIC(HASHREF: params)
# params:
#  STRING: answer
#  HASHREF: xml_parser_params)
sub parse_answer {
    my %params = @_;

    my $answer_string =
        $params{answer};
    my $parser_params =
        $params{parser_params} || { };

    return '' unless $answer_string;

    my $deparsed = XMLin( $answer_string, %$parser_params );
    warn Dumper $deparsed if $DEBUG;
    
    return $deparsed ? $deparsed : '';
}

# Get + deparse
# STATIC(STRING: query_string)
sub process_query {
    my %params = @_;

    my $query_string      = $params{query_string};
    my $xml_parser_params = $params{parser_params} || '';
    my $fake_answer       = $params{fake_answer} || '';

    return '' unless $query_string;

    my $answer = $fake_answer ? $fake_answer : mk_query_to_server($query_string);
    warn $answer if $answer && $DEBUG;

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

    return $answer ?
        parse_answer(
            answer        => $answer,
            parser_params => $xml_parser_params
        ) : '';
}

# Filter hash
# STATIC(HASHREF: hash, ARRREF: allowed_keys)
# RETURN: hashref only with allowed keys
sub filter_hash {
    my ($hash, $allowed_keys) = @_;

    return unless ref $hash eq 'HASH' &&
        ref $allowed_keys eq 'ARRAY';
    
    my $new_hash = { };

    foreach my $allowed_key (@$allowed_keys) {
        if (exists $hash->{$allowed_key}) {
            $new_hash->{$allowed_key} = $hash->{$allowed_key};

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


    return $new_hash;
}

# Get access key, time to live -- 30 minutes
# STATIC(HASHREF: params_hash)
# params_hash:
# - all elements from mk_full_query_string +
# - username*
# - password*
sub get_auth_id {
    my %params_raw = @_;

    warn 'get_auth_id params: ' . Dumper(\%params_raw)  if $DEBUG;

    my $params = filter_hash(
        \%params_raw,
        [ 'host', 'path', 'allow_http', 'username', 'password' ]
    );

    # Check this sub params
    unless ($params->{username} && $params->{password}) {
        return '';
    }

    
    my $query_string = mk_full_query_string( {
        %$params, 
        func     => 'auth',
        out      => 'xml',
    } );

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

        my $error_node = exists $xml->{authfail};
        return '' if $error_node;

        return $xml->{auth}->{id};
    } else {
        return '';
    }
}

# Wrapper for "ref" on undef value, without warnings :)
# Possible very stupid sub :)
# STATIC(REF: our_ref)
sub refs {
    my $ref = shift;

    return '' unless $ref;

    return ref $ref;
}

# INTERNAL!!! Check server answer result
# STATIC(data_block)
sub is_success {
    my $data_block = shift;

    if ( ref $data_block eq 'HASH' && ! $data_block->{error} && $data_block->{data} ) {
        return 1;
    } else {
        return '';
    }
}

# Get data from server answer
# STATIC(data_block)
sub get_data {
    my $data_block = shift;

    unless ( is_success($data_block) ) {
        return '';
    }

    return $data_block->{data};
}

# list all users
# all params derived from get_auth_id
sub query_abstract {
    my %params = @_;

    my $params_raw  = $params{params};
    my $func_name   = $params{func};
    my $fake_answer = $params{fake_answer} || '';

    warn 'query_abstract ' . Dumper( \%params ) if $DEBUG;

    return '' unless $params_raw && $func_name;

lib/API/ISPManager/db.pm  view on Meta::CPAN 

package API::ISPManager::db;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'db',
        fake_answer => shift,
    );

    if ( $server_answer         &&
         $server_answer->{elem} &&
         ref $server_answer->{elem} eq 'HASH' ) {

        return { data =>  $server_answer->{elem} };

    }

    return $server_answer;
}


sub create {
   my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params          => { %$params, sok => 'yes' },
        func            => 'db.edit',
        allowed_fields  => [ qw( host path allow_http  sok name dbtype owner dbencoding dbuser dbusername dbpassword dbconfirm dbuserhost ) ],
    );

    $API::ISPManager::last_answer = $result;

lib/API/ISPManager/db.pm  view on Meta::CPAN 

    } else {
        return '';
    }
}


package API::ISPManager::db_user;

use API::ISPManager;

sub list {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'db.users',
        allowed_fields => [ 'host', 'path', 'allow_http', 'elid' ],
        fake_answer => shift,
    );

    if ( $server_answer         &&

lib/API/ISPManager/diskpreset.pm  view on Meta::CPAN 

package API::ISPManager::diskpreset;

use API::ISPManager;

sub create {


}


sub edit {

}

sub get {

}


sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'disktempl',
        allowed_fields => [ qw( host path allow_http ) ],
    );

    my $disk_templ = $result->{elem};
    
    return $disk_templ;
}


sub delete {


}



1;

lib/API/ISPManager/dns.pm  view on Meta::CPAN 

package API::ISPManager::dns;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'domain',
        fake_answer => shift,
    );

    #if ( $server_answer && $server_answer->{elem} && ref $server_answer->{elem} eq 'HASH' ) {
    #    return { data =>  $server_answer->{elem} };
    #}

    return $server_answer;
}

sub get {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'domain.edit',
        fake_answer => shift,
    );
    return $server_answer;
   
}

sub edit {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => { %$params, sok => 'yes' },
        func        => 'domain.edit',
        allowed_fields => [qw(host path allow_http sok   owner elid mx ns ip)], 
        fake_answer => shift,
    );
    return $server_answer;
   
}

sub sublist {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'domain.sublist',
        fake_answer => shift,
    );
    return $server_answer;
   
}

sub sublist_get {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'domain.sublist.edit',
        fake_answer => shift,
    );
    return $server_answer;
   
}

sub sublist_edit {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => { %$params, sok => 'yes' },
        func        => 'domain.sublist.edit',
        fake_answer => shift,
    );
    return $server_answer;
   
}

lib/API/ISPManager/domain.pm  view on Meta::CPAN 

package API::ISPManager::domain;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'wwwdomain'
    );
}

# Create domain
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'wwwdomain.edit', 
        allowed_fields => [  qw( host path allow_http     domain alias sok name owner ip docroot cgi php ssi ror ssl sslport admin ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit domain data
sub edit {

}

# Delete domain from panel
sub delete {

}

package API::ISPManager::email_domain;

use API::ISPManager;

sub list {
    my $params = shift;

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'emaildomain'
    );
}

# Create domain
sub create {

}

# Edit domain data
sub edit {

}

# Delete domain from panel
sub delete {

}

1;

lib/API/ISPManager/file.pm  view on Meta::CPAN 

use API::ISPManager;
use WWW::Mechanize;
use HTTP::Cookies;
use Data::Dumper;

# NB! plid âåçäå áåç ëèäèðóþùåãî /, ò.å. www/..., à íå /www/...

# List of files and directories
# IN: plid - parent directory (optional, equal to docroot when empty)
# IN: elid - directory for listing
sub list {
    my $params = shift;

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'file',
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );
}

# Create file or directory
# IN: filetype (0 - file, 1 - directory, zip ......)
# IN: plid - parent directory (optional, equal to docroot when empty)
# IN: name - parent directory for created file
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' },
        func   => 'file.new',
        elid   => '',
        allowed_fields => [  qw( host path allow_http sok filetype name elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

lib/API/ISPManager/file.pm  view on Meta::CPAN 

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Delete file or directory
# IN: plid - parent directory (optional, equal to docroot when empty)
# IN: elid - parent directory for created file
sub delete {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.delete', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Copy file or directory
# IN: plid - destination
# IN: elid - file/direcory to be copied
sub copy {
    my $params = shift;
    $params->{elid} = '//c/' . $params->{elid};
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.paste', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Move file or directory
# IN: plid - destination
# IN: elid - file/direcory to be moved
sub move {
    my $params = shift;
    $params->{elid} = '//x/' . $params->{elid};
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.paste', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Move file or directory
# IN: plid - parent directory
# IN: elid - archive to be extracted
sub extract {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.extract', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit file or directory
sub edit {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' },
        func   => 'file.attr', 
        allowed_fields => [  qw( host path allow_http elid plid sok name uid gid recursive mode pur puw pux pgr pgx por pox) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Upload file
sub upload {
    my $params = shift;
    
    my $allowed_fields = [  qw( host path allow_http plid ) ];
    my $func_name = 'file.upload';
    
    my $auth_id = API::ISPManager::get_auth_id( %$params );
    if ($auth_id) {
        
        my $params_raw = API::ISPManager::filter_hash( $params, $allowed_fields );

lib/API/ISPManager/ftp.pm  view on Meta::CPAN 

package API::ISPManager::ftp;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'ftp',
        allowed_fields => [ qw( host path allow_http     su authinfo) ], # TODO: hack with authinfo!!!
    );

    return $result;
}


sub create  {


}

sub edit {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'ftp.edit',
        allowed_fields => [  qw( host path allow_http     sok elid su passwd name) ],
    );

    return $result;

}


sub delete {


}

1;

lib/API/ISPManager/ip.pm  view on Meta::CPAN 

package API::ISPManager::ip;

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params => $params,
        func   => 'iplist',
        parser_params =>  { ForceArray => qr/^elem$/ } 
    );

    ###warn Dumper($server_answer);

lib/API/ISPManager/mailbox.pm  view on Meta::CPAN 

package API::ISPManager::mailbox;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'email'
    );
}

# Create domain
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'email.edit', 
        allowed_fields => [  qw( host path allow_http  sok name domain aliases passwd confirm quota forward rmlocal greylist spamassassin note ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit email data
sub edit {

}

# Delete email from panel
sub delete {

}

1;

lib/API/ISPManager/misc.pm  view on Meta::CPAN 

package API::ISPManager::misc;

use strict;
use warnings;

use API::ISPManager;

sub reload {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'restart',
    );

    if ( $server_answer && $server_answer->{elem} && ref $server_answer->{elem} eq 'HASH' ) {
        return { data =>  $server_answer->{elem} };
    }

    return $server_answer;
}

sub usrparam {
    my $params = shift;
    
     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'usrparam',
     );

    return $server_answer;
}

# Only for BillManager
sub accountinfo {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'accountinfo',
     );

    return $server_answer;
}

# Only for BillManager
sub discountinfo {
    my $params = shift;

     my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'discountinfo',
     );

    if ($server_answer && ref $server_answer eq 'HASH' && $server_answer->{elem}) {
        return $server_answer->{elem};
    }

lib/API/ISPManager/order.pm  view on Meta::CPAN 

package API::ISPManager::order;

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'order',
    );

    if ($result && ref $result eq 'HASH' && $result->{elem}) {
        return $result->{elem};
    } 

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;

lib/API/ISPManager/preset.pm  view on Meta::CPAN 

package API::ISPManager::preset;

use API::ISPManager;

sub create {


}


sub edit {


}

sub get {
    my $params = shift;
   
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'preset.edit',  
        allowed_fields => [  qw( host path allow_http  elid) ],
    );
  
    if (ref $result->{php} eq 'HASH' ) {
        $result->{php} = 'on';

lib/API/ISPManager/preset.pm  view on Meta::CPAN 

    if (ref $result->{phpmod} eq 'HASH' ) {
        $result->{phpmod} = 'on';
    }

    return '' if $result->{error};

    return $result;
}


sub list {
    my $params = shift;
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'preset',
        allowed_fields => [  qw( host path allow_http ) ],
    );

    my $plans = $result->{elem};
    
    for (keys %$plans) {

lib/API/ISPManager/preset.pm  view on Meta::CPAN 

            if ( $val && ref $val eq 'HASH' ) {
                $plans->{$_}->{$param} = 'on';
            }
        } 
    }

    return $plans;
}


sub delete {


}



1;

lib/API/ISPManager/services.pm  view on Meta::CPAN 

package API::ISPManager::services;

use strict;
use warnings;

use API::ISPManager;

sub get {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'services',
        fake_answer => shift,
    );

    if ( $server_answer && $server_answer->{elem} && ref $server_answer->{elem} eq 'HASH' ) {
        return { data =>  $server_answer->{elem} };

lib/API/ISPManager/software.pm  view on Meta::CPAN 

package API::ISPManager::software;

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'software',
    );

    if ($result && ref $result eq 'HASH' && $result->{elem}) { 
       return $result->{elem};
    }

    return $result;
}

sub get {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params, # чтобы создание разрешить
        func   => 'software.edit',
        allowed_fields => [  qw( host path allow_http    elid ) ],
    );

    return $result;
}

sub renew {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params, # чтобы создание разрешить
        func   => 'software.period',
        allowed_fields => [  qw( host path allow_http    elid ) ],
    );

=head

lib/API/ISPManager/software.pm  view on Meta::CPAN 

period	16
pricename	ISPmanager Pro (without support)
sok	ok

=cut

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;

lib/API/ISPManager/stat.pm  view on Meta::CPAN 

package API::ISPManager::stat;

use strict;
use warnings;

use API::ISPManager;

sub sysinfo {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        fake_answer => shift,
        func        => shift || 'sysinfo', # TODO: stupid hack!
    );

    if ( $server_answer && $server_answer->{elem} && ref $server_answer->{elem} eq 'HASH' ) {
        my $stat_data = { };

lib/API/ISPManager/stat.pm  view on Meta::CPAN 

        for (keys %{ $server_answer->{elem} } ) {
            $stat_data->{$_} = $server_answer->{elem}->{$_}->{value};
        }
    
        return { data => $stat_data  };
    }

    return $server_answer;
}

sub usagestat {
    my $params = shift;


    return sysinfo($params, shift || '', 'usagestat');
}



1;

lib/API/ISPManager/user.pm  view on Meta::CPAN 

package API::ISPManager::user;

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'user',
    );
}

# Âîçâðàùàåò ÷èñëî àêòèâíûõ ïîëüçîâàòåëåé
sub active_user_count {
    my $params = shift;
    my $ans = API::ISPManager::user::list($params);
    
    my $result = 0;
    foreach my $key (keys %{$ans->{elem}}) {
        $result++ unless exists $ans->{elem}->{$key}->{disabled};
    }

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;
    #warn Dumper($API::ISPManager::last_answer);

lib/API/ISPManager/user.pm  view on Meta::CPAN 

    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

# Edit user data
sub edit {
    my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'user.edit',
        allowed_fields => [  qw( host path allow_http     sok elid name domain email preset ip passwd ftplimit disklimit ssl ssi phpmod safemode  maillimit domainlimit webdomainlimit maildomainlimit baselimit baseuserlimit bandwidthlimit phpfcgi) ],
    );

    return $result;
}

# Delete user from panel
sub delete {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.delete');
 
    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Abstract sub for bool ( on | off ) methods
sub abstract_bool_manipulate {
    my ($params, $type) = @_;

    return '' unless $params && $type;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => $type, 
        allowed_fields => [  qw( host path allow_http    elid) ],
    );

    return $result;
}

# Switch-on user account
# elid -- user name =)
sub enable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.enable');

    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Switch off user account
# elid -- user name =)
sub disable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.disable');

    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';

lib/API/ISPManager/vds.pm  view on Meta::CPAN 

package API::ISPManager::vds;

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vds',
    );

    return $result->{elem};
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'vds.edit', 
        allowed_fields => [  qw( host path allow_http     
            sok name id ip passwd confirm owner vdspreset disktempl pvtdisk extns ispmgr
            disk mem  cpu proc desc traf note 
        ) ],
    );

lib/API/ISPManager/vds.pm  view on Meta::CPAN 

    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

# Edit user data
sub edit {
    my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vds.edit',
        allowed_fields => [  qw( host path allow_http     sok elid name domain email preset ip passwd ftplimit disklimit ssl ssi phpmod safemode  maillimit domainlimit webdomainlimit maildomainlimit baselimit baseuserlimit bandwidthlimit) ],
    );

    return $result;
}

# Delete user from panel
sub delete {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.delete');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Abstract sub for bool ( on | off ) methods
sub abstract_bool_manipulate {
    my ($params, $type) = @_;

    return '' unless $params && $type;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => $type, 
        allowed_fields => [  qw( host path allow_http    elid) ],
    );

    return $result;
}

# Switch-on user account
# elid -- user name =)
sub enable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'vds.enable');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Switch off user account
# elid -- user name =)
sub disable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'vds.disable');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

lib/API/ISPManager/vdspreset.pm  view on Meta::CPAN 

package API::ISPManager::vdspreset;

use API::ISPManager;

sub create {


}


sub edit {


}

sub get {
    my $params = shift;
   
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vdspreset.edit',  
        allowed_fields => [  qw( host path allow_http  elid) ],
    );
  
    return $result;
}


sub list {
    my $params = shift;
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vdspreset',
        allowed_fields => [  qw( host path allow_http ) ],
    );

    my $plans = $result->{elem};
    
    return $plans;
}


sub delete {


}



1;

t/01-test.t  view on Meta::CPAN 

my $test_host = $ENV{host} || 'ultrasam.ru';

ok(1, 'Test OK');
use_ok('API::ISPManager');

$a = 'refs';

is( refs( undef ),   '',       $a);
is( refs( {} ),      'HASH',   $a );
is( refs( [] ),      'ARRAY',  $a );
is( refs( sub {} ),  'CODE',   $a );
is( refs( \$a ),     'SCALAR', $a );

$a = 'is_success';

ok(! is_success(), $a);
ok(! is_success( { error => {}, data => {} } ), $a);
ok(  is_success( { data  => {} } ), $a);
ok(! is_success( { } ), $a);

$a = 'get_data';

t/02-files.t  view on Meta::CPAN 

API::ISPManager::file::delete( {
    %connection_params,
    elid => "$now.tar.gz",  
    plid => '',    
} );

unlink $now;
unlink "$now.tar.gz";

# Ïîëó÷åíèå ñïèñêà ôàéëîâ â âèäå ìàññèâà
sub get_file_list {
    my ($plid, $elid) = @_;
    my $answer = API::ISPManager::file::list( { 
        %connection_params, 
        plid => $plid, 
        elid => $elid,
    } );
    my @result;
    if (ref($answer->{elem}) eq 'ARRAY') {
        foreach my $elem (@{$answer->{elem}}) {
            push @result, $elem->{name}->{content};
        }
    }
    else {
        push @result, $answer->{elem}->{name}->{content};
    }
    return @result;
}

# Ñðàâíåíèå äâóõ ìàññèâîâ êàê ìíîæåñòâ - ò.å. áåç ó÷åòà ïîðÿäêà ÷èñëà
# ýëåìåíòîâ è ÷èñëà èõ ïîâòîðåíèé
sub union_equal {
    my ($a, $b) = @_;
    return union_part_of($a, $b) && union_part_of($b, $a);
}

sub union_part_of {
    my ($a, $b) = @_;
    my $result = 1;
    for (my $i = 0; $i < scalar @{$a} && $result; $i++) {
        my $sub_result = 0;
        for (my $j = 0; $j < scalar @{$b} && !$sub_result; $j++) {
            $sub_result = $sub_result || ${$b}[$j] eq ${$a}[$i];
        }
        $result = $result && $sub_result;
    }

vdsmanager.pl  view on Meta::CPAN 


if ( $create_result && $create_result->{ok} && $create_result->{ip} && $create_result->{veid} ) {
    print "$create_result->{ip}|$create_result->{veid}\n";
    exit 0; # всё окей!
} else {
    print "error\n";
    exit 1;
}

# Проверка существования дискового шаблона
sub check_disk_preset {
    my $disk_preset_name = shift;
    return '' unless $disk_preset_name;

    my $disk_templates =
        API::ISPManager::diskpreset::list( $connection_params );

    return '' unless $disk_templates && ref $disk_templates eq 'HASH';

    # List all disk templates
    my @list = keys %$disk_templates;

vdsmanager.pl  view on Meta::CPAN 

            $disk_templates->{$_}->{state} eq 'ok';

        return 1 if $preset_ok;
    }

    return '';
}


# Проверяем корректность переданного шаблона ВПС
sub check_vps_preset {
    my $disk_preset_name = shift;
    return '' unless $disk_preset_name;

    my $disk_templates =
        API::ISPManager::vdspreset::list( $connection_params );

    return '' unless $disk_templates && ref $disk_templates eq 'HASH';

    # List all VPS templates
    my @list = keys %$disk_templates;

vdsmanager.pl  view on Meta::CPAN 

            $disk_templates->{$_};

        return 1 if $preset_ok;
    }

    return '';
}


# Получаем детализацию тарифа ВПС
sub get_vps_preset_details {
    my $preset_name = shift;
    return '' unless $preset_name;

    my $vds_template_details = API::ISPManager::vdspreset::get( {
        %$connection_params ,
        elid => $preset_name
    } );

    # Фильтруем только нужные параметры тарифа
    my $clean_plan_details = { };

vdsmanager.pl  view on Meta::CPAN 

        }

        $clean_plan_details->{$_} = $vds_template_details->{$_};
    }
    
    return $clean_plan_details;
}


# Получаем ID следующей впски
sub get_next_veid {
    my $node_id = shift;
    return '' unless $node_id;

    my $vds_list = API::ISPManager::vds::list( { %$connection_params } );
    return unless $vds_list && ref $vds_list eq 'HASH';

    my @id_list =
        sort { $a <=> $b }
        grep { /^$node_id\d{3}$/ }
        map  { $vds_list->{$_}->{id} }
        keys %$vds_list;

    if (@id_list) {
        return ++$id_list[-1];  # продолжаем имеющуюся нумерацию
    } else {
        return "${node_id}001"; # это первый впс
    }
}

# Создаем ВПС
sub create_vps {
    my %params = @_;

    my $all_params_ok =
        $params{password} &&
        $params{os}       &&
        $params{owner}    &&
        $params{preset}   &&
        $params{node_id};
    
    unless ($all_params_ok)  {



( run in 1.195 second using v1.01-cache-2.11-cpan-a5abf4f5562 )