src/PMG/RuleDB/ModField.pm

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