src/PMG/API2/Rules.pm

   1 package PMG::API2::Rules;
   2
   3 use strict;
   4 use warnings;
   5 use Data::Dumper;
   6
   7 use PVE::SafeSyslog;
   8 use PVE::Tools qw(extract_param);
   9 use HTTP::Status qw(:constants);
  10 use PVE::JSONSchema qw(get_standard_option);
  11 use PVE::RESTHandler;
  12 use PVE::INotify;
  13
  14 use PMG::Config;
  15
  16 use PMG::RuleDB;
  17 use PMG::DBTools;
  18 use PMG::API2::ObjectGroupHelpers;
  19
  20 use base qw(PVE::RESTHandler);
  21
  22 __PACKAGE__->register_method ({
  23     name => 'index',
  24     path => '',
  25     method => 'GET',
  26     description => "Directory index.",
  27     permissions => { check => [ 'admin', 'audit' ] },
  28     parameters => {
  29         additionalProperties => 0,
  30         properties => {
  31             id => {
  32                 description => "Rule ID.",
  33                 type => 'integer',
  34             },
  35         },
  36     },
  37     returns => {
  38         type => 'array',
  39         items => {
  40             type => "object",
  41             properties => {
  42                 subdir => { type => 'string'},
  43             },
  44         },
  45         links => [ { rel => 'child', href => "{subdir}" } ],
  46     },
  47     code => sub {
  48         my ($param) = @_;
  49
  50         my $rdb = PMG::RuleDB->new();
  51
  52         $rdb->load_rule($param->{id}); # test if rule exist
  53
  54         return [
  55             { subdir => 'config' },
  56             { subdir => 'from' },
  57             { subdir => 'to' },
  58             { subdir => 'when' },
  59             { subdir => 'what' },
  60             { subdir => 'actions' },
  61         ];
  62
  63     }});
  64
  65 __PACKAGE__->register_method ({
  66     name => 'delete_rule',
  67     path => '',
  68     method => 'DELETE',
  69     description => "Delete rule.",
  70     proxyto => 'master',
  71     protected => 1,
  72     permissions => { check => [ 'admin' ] },
  73     parameters => {
  74         additionalProperties => 0,
  75         properties => {
  76             id => {
  77                 description => "Rule ID.",
  78                 type => 'integer',
  79             },
  80         },
  81     },
  82     returns => { type => 'null' },
  83     code => sub {
  84         my ($param) = @_;
  85
  86         my $rdb = PMG::RuleDB->new();
  87
  88         $rdb->load_rule($param->{id}); # test if rule exist
  89
  90         $rdb->delete_rule($param->{id});
  91
  92         PMG::DBTools::reload_ruledb();
  93
  94         return undef;
  95     }});
  96
  97 __PACKAGE__->register_method ({
  98     name => 'config',
  99     path => 'config',
 100     method => 'GET',
 101     description => "Get common rule properties.",
 102     proxyto => 'master',
 103     permissions => { check => [ 'admin', 'audit' ] },
 104     parameters => {
 105         additionalProperties => 0,
 106         properties => {
 107             id => {
 108                 description => "Rule ID.",
 109                 type => 'integer',
 110             },
 111         },
 112     },
 113     returns => {
 114         type => "object",
 115         properties => {
 116             id => { type => 'integer'},
 117             name => { type => 'string' },
 118             active => { type => 'boolean' },
 119             direction => { type => 'integer' },
 120             priority => { type => 'integer' },
 121         },
 122     },
 123     code => sub {
 124         my ($param) = @_;
 125
 126         my $rdb = PMG::RuleDB->new();
 127
 128         my $rule = $rdb->load_rule($param->{id});
 129
 130         my ($from, $to, $when, $what, $action) =
 131             $rdb->load_groups($rule);
 132
 133         my $data = PMG::API2::ObjectGroupHelpers::format_rule(
 134             $rule, $from, $to, $when, $what, $action);
 135
 136         return $data;
 137    }});
 138
 139 __PACKAGE__->register_method ({
 140     name => 'update_config',
 141     path => 'config',
 142     method => 'PUT',
 143     description => "Set rule properties.",
 144     proxyto => 'master',
 145     protected => 1,
 146     permissions => { check => [ 'admin' ] },
 147     parameters => {
 148         additionalProperties => 0,
 149         properties => {
 150             id => {
 151                 description => "Rule ID.",
 152                 type => 'integer',
 153             },
 154             name => {
 155                 description => "Rule name",
 156                 type => 'string',
 157                 optional => 1,
 158             },
 159             active => {
 160                 description => "Flag to activate rule.",
 161                 type => 'boolean',
 162                 optional => 1,
 163             },
 164             direction => {
 165                 description => "Rule direction. Value `0` matches incomming mails, value `1` matches outgoing mails, and value `2` matches both directions.",
 166                 type => 'integer',
 167                 minimum => 0,
 168                 maximum => 2,
 169                 optional => 1,
 170             },
 171             priority => {
 172                 description => "Rule priotity.",
 173                 type => 'integer',
 174                 minimum => 0,
 175                 maximum => 100,
 176                 optional => 1,
 177             },
 178         },
 179     },
 180     returns => { type => "null" },
 181     code => sub {
 182         my ($param) = @_;
 183
 184         my $id = extract_param($param, 'id');
 185
 186         die "no options specified\n"
 187             if !scalar(keys %$param);
 188
 189         my $rdb = PMG::RuleDB->new();
 190
 191         my $rule = $rdb->load_rule($id);
 192
 193         for my $key (qw(name active direction priority)) {
 194             $rule->{$key} = $param->{$key} if defined($param->{$key});
 195         }
 196
 197         $rdb->save_rule($rule);
 198
 199         PMG::DBTools::reload_ruledb();
 200
 201         return undef;
 202    }});
 203
 204 my $register_rule_group_api = sub {
 205     my ($name) = @_;
 206
 207     __PACKAGE__->register_method ({
 208         name => $name,
 209         path => $name,
 210         method => 'GET',
 211         description => "Get '$name' group list.",
 212         proxyto => 'master',
 213         permissions => { check => [ 'admin', 'audit' ] },
 214         parameters => {
 215             additionalProperties => 0,
 216             properties => {
 217                 id => {
 218                     description => "Rule ID.",
 219                     type => 'integer',
 220                 },
 221             },
 222         },
 223         returns => {
 224             type => 'array',
 225             items => {
 226                 type => "object",
 227                 properties => {
 228                     id => { type => 'integer' },
 229                 },
 230             },
 231         },
 232         code => sub {
 233             my ($param) = @_;
 234
 235             my $rdb = PMG::RuleDB->new();
 236
 237             my $rule = $rdb->load_rule($param->{id});
 238
 239             my $group_hash = $rdb->load_groups_by_name($rule);
 240
 241             return PMG::API2::ObjectGroupHelpers::format_object_group(
 242                 $group_hash->{$name});
 243         }});
 244
 245     __PACKAGE__->register_method ({
 246         name => "add_${name}_group",
 247         path => $name,
 248         method => 'POST',
 249         description => "Add  group to '$name' list.",
 250         proxyto => 'master',
 251         protected => 1,
 252         permissions => { check => [ 'admin' ] },
 253         parameters => {
 254             additionalProperties => 0,
 255             properties => {
 256                 id => {
 257                     description => "Rule ID.",
 258                     type => 'integer',
 259                 },
 260                 ogroup => {
 261                     description => "Groups ID.",
 262                     type => 'integer',
 263                 },
 264             },
 265         },
 266         returns => { type => 'null' },
 267         code => sub {
 268             my ($param) = @_;
 269
 270             my $rdb = PMG::RuleDB->new();
 271
 272             my $rule = $rdb->load_rule($param->{id});
 273
 274             $rdb->rule_add_group($param->{id}, $param->{ogroup}, $name);
 275
 276             PMG::DBTools::reload_ruledb();
 277
 278             return undef;
 279         }});
 280
 281     __PACKAGE__->register_method ({
 282         name => "delete_${name}_group",
 283         path => "$name/{ogroup}",
 284         method => 'DELETE',
 285         description => "Delete group from '$name' list.",
 286         proxyto => 'master',
 287         protected => 1,
 288         permissions => { check => [ 'admin' ] },
 289         parameters => {
 290             additionalProperties => 0,
 291             properties => {
 292                 id => {
 293                     description => "Rule ID.",
 294                     type => 'integer',
 295                 },
 296                 ogroup => {
 297                     description => "Groups ID.",
 298                     type => 'integer',
 299                 },
 300             },
 301         },
 302         returns => { type => 'null' },
 303         code => sub {
 304             my ($param) = @_;
 305
 306             my $rdb = PMG::RuleDB->new();
 307
 308             my $rule = $rdb->load_rule($param->{id});
 309
 310             $rdb->rule_remove_group($param->{id}, $param->{ogroup}, $name);
 311
 312             PMG::DBTools::reload_ruledb();
 313
 314             return undef;
 315         }});
 316
 317 };
 318
 319 $register_rule_group_api->('from');
 320 $register_rule_group_api->('to');
 321 $register_rule_group_api->('when');
 322 $register_rule_group_api->('what');
 323 $register_rule_group_api->('action');
 324
 325 1;