PMG/RuleDB/ModField.pm

   1 package PMG::RuleDB::ModField;
   2
   3 use strict;
   4 use warnings;
   5 use DBI;
   6 use Digest::SHA;
   7
   8 use PMG::Utils;
   9 use PMG::ModGroup;
  10 use PMG::RuleDB::Object;
  11
  12 use base qw(PMG::RuleDB::Object);
  13
  14 sub otype {
  15     return 4003;
  16 }
  17
  18 sub oclass {
  19     return 'action';
  20 }
  21
  22 sub otype_text {
  23     return 'Header Attribute';
  24 }
  25
  26 sub final {
  27     return 0;
  28 }
  29
  30 sub priority {
  31     return 10;
  32 }
  33
  34 sub new {
  35     my ($type, $field, $field_value, $ogroup) = @_;
  36
  37     my $class = ref($type) || $type;
  38
  39     my $self = $class->SUPER::new($class->otype(), $ogroup);
  40
  41     $self->{field} = $field;
  42     $self->{field_value} = $field_value;
  43
  44     return $self;
  45 }
  46
  47 sub load_attr {
  48     my ($type, $ruledb, $id, $ogroup, $value) = @_;
  49
  50     my $class = ref($type) || $type;
  51
  52     defined($value) || return undef;
  53
  54     my ($field, $field_value) = $value =~ m/^([^\:]*)\:(.*)$/;
  55
  56     (defined($field) && defined($field_value)) || return undef;
  57
  58     my $obj = $class->new($field, $field_value, $ogroup);
  59     $obj->{id} = $id;
  60
  61     $obj->{digest} = Digest::SHA::sha1_hex($id, $field, $field_value, $ogroup);
  62
  63     return $obj;
  64 }
  65
  66 sub save {
  67     my ($self, $ruledb) = @_;
  68
  69     defined($self->{ogroup}) || return undef;
  70
  71     my $new_value = "$self->{field}:$self->{field_value}";
  72
  73     if (defined ($self->{id})) {
  74         # update
  75
  76         $ruledb->{dbh}->do(
  77             "UPDATE Object SET Value = ? WHERE ID = ?",
  78             undef, $new_value, $self->{id});
  79
  80     } else {
  81         # insert
  82
  83         my $sth = $ruledb->{dbh}->prepare(
  84             "INSERT INTO Object (Objectgroup_ID, ObjectType, Value) " .
  85             "VALUES (?, ?, ?);");
  86
  87         $sth->execute($self->ogroup, $self->otype, $new_value);
  88
  89         $self->{id} = PMG::Utils::lastid($ruledb->{dbh}, 'object_id_seq');
  90     }
  91
  92     return $self->{id};
  93 }
  94
  95 sub execute {
  96     my ($self, $queue, $ruledb, $mod_group, $targets,
  97         $msginfo, $vars, $marks) = @_;
  98
  99     my $fvalue = PMG::Utils::subst_values ($self->{field_value}, $vars);
 100
 101     # support for multiline values (i.e. __SPAM_INFO__)
 102     $fvalue =~ s/\r?\n/\n\t/sg; # indent content
 103     $fvalue =~ s/\n\s*\n//sg;   # remove empty line
 104     $fvalue =~ s/\n?\s*$//s;    # remove trailing spaces
 105
 106     my $subgroups = $mod_group->subgroups($targets);
 107
 108     foreach my $ta (@$subgroups) {
 109         my ($tg, $e) = (@$ta[0], @$ta[1]);
 110         $e->head->replace($self->{field}, $fvalue);
 111     }
 112 }
 113
 114 sub short_desc {
 115     my $self = shift;
 116
 117     return "modify field: $self->{field}:$self->{field_value}";
 118 }
 119
 120 sub properties {
 121     my ($class) = @_;
 122
 123     return {
 124         field => {
 125             description => "The Field",
 126             type => 'string',
 127             pattern => '[0-9a-zA-Z\/\\\[\]\+\-\.\*\_]+',
 128             maxLength => 1024,
 129         },
 130         value => {
 131             description => "The Value",
 132             type => 'string',
 133             pattern => '[0-9a-zA-Z\/\\\[\]\+\-\.\*\_]+',
 134             maxLength => 1024,
 135         },
 136     };
 137 }
 138
 139 sub get {
 140     my ($self) = @_;
 141
 142     return {
 143         field => $self->{field},
 144         value => $self->{field_value},
 145     };
 146 }
 147
 148 sub update {
 149     my ($self, $param) = @_;
 150
 151     $self->{field_value} = $param->{value};
 152     $self->{field} = $param->{field};
 153 }
 154
 155 1;
 156
 157 __END__
 158
 159 =head1 PMG::RuleDB::ModField
 160
 161 Modify fields of a message.