]>
Commit | Line | Data |
---|---|---|
72d8bf49 DM |
1 | package PMG::RuleDB; |
2 | ||
3 | use strict; | |
4 | use warnings; | |
72d8bf49 DM |
5 | use DBI; |
6 | use HTML::Entities; | |
7 | ||
8 | use PVE::SafeSyslog; | |
9 | ||
10 | use PMG::Utils; | |
11 | use PMG::DBTools; | |
12 | ||
13 | use PMG::RuleDB::Group; | |
14 | ||
15 | #use Proxmox::Statistic; | |
16 | use PMG::RuleDB::Object; | |
17 | use PMG::RuleDB::WhoRegex; | |
18 | use PMG::RuleDB::ReceiverRegex; | |
19 | use PMG::RuleDB::EMail; | |
20 | use PMG::RuleDB::Receiver; | |
21 | use PMG::RuleDB::IPAddress; | |
22 | use PMG::RuleDB::IPNet; | |
23 | use PMG::RuleDB::Domain; | |
24 | use PMG::RuleDB::ReceiverDomain; | |
25 | # fixme: | |
26 | #use Proxmox::RuleDB::LDAP; | |
27 | #use Proxmox::RuleDB::LDAPUser; | |
28 | use PMG::RuleDB::TimeFrame; | |
29 | use PMG::RuleDB::Spam; | |
30 | use PMG::RuleDB::ReportSpam; | |
31 | use PMG::RuleDB::Virus; | |
32 | use PMG::RuleDB::Accept; | |
33 | use PMG::RuleDB::Remove; | |
34 | use PMG::RuleDB::ModField; | |
35 | use PMG::RuleDB::MatchField; | |
36 | use PMG::RuleDB::MatchFilename; | |
37 | use PMG::RuleDB::Attach; | |
38 | use PMG::RuleDB::Disclaimer; | |
39 | use PMG::RuleDB::BCC; | |
40 | use PMG::RuleDB::Quarantine; | |
41 | use PMG::RuleDB::Block; | |
42 | use PMG::RuleDB::Counter; | |
43 | use PMG::RuleDB::Notify; | |
44 | use PMG::RuleDB::Rule; | |
45 | use PMG::RuleDB::ContentTypeFilter; | |
c4741113 | 46 | use PMG::RuleDB::ArchiveFilter; |
72d8bf49 DM |
47 | |
48 | sub new { | |
49 | my ($type, $dbh) = @_; | |
9ef3f143 | 50 | |
72d8bf49 DM |
51 | $dbh = PMG::DBTools::open_ruledb("Proxmox_ruledb") if !defined ($dbh); |
52 | ||
53 | my $self = bless { dbh => $dbh }, $type; | |
54 | ||
55 | return $self; | |
56 | } | |
57 | ||
58 | sub close { | |
59 | my ($self) = @_; | |
60 | ||
61 | $self->{dbh}->disconnect(); | |
62 | } | |
63 | ||
9973fc66 | 64 | sub create_group_with_obj { |
bdf383f3 | 65 | my ($self, $obj, $name, $info) = @_; |
744483ce DM |
66 | |
67 | my $og; | |
68 | my $id; | |
69 | ||
70 | defined($obj) || die "proxmox: undefined object"; | |
71 | ||
bdf383f3 DM |
72 | $name //= ''; |
73 | $info //= ''; | |
74 | ||
744483ce DM |
75 | eval { |
76 | ||
77 | $self->{dbh}->begin_work; | |
78 | ||
bdf383f3 DM |
79 | $self->{dbh}->do("INSERT INTO Objectgroup (Name, Info, Class) " . |
80 | "VALUES (?, ?, ?)", undef, | |
81 | $name, $info, $obj->oclass()); | |
744483ce DM |
82 | |
83 | my $lid = PMG::Utils::lastid($self->{dbh}, 'objectgroup_id_seq'); | |
84 | ||
4a574ae2 | 85 | $og = PMG::RuleDB::Group->new($name, $info, $obj->oclass()); |
744483ce DM |
86 | $og->{id} = $lid; |
87 | ||
88 | $obj->{ogroup} = $lid; | |
89 | $id = $obj->save($self, 1); | |
90 | $obj->{id} = $id; # just to be sure | |
91 | ||
92 | $self->{dbh}->commit; | |
93 | }; | |
94 | if (my $err = $@) { | |
95 | $self->{dbh}->rollback; | |
96 | die $err; | |
97 | } | |
98 | return $og; | |
99 | } | |
100 | ||
72d8bf49 DM |
101 | sub load_groups { |
102 | my ($self, $rule) = @_; | |
103 | ||
9ef3f143 | 104 | defined($rule->{id}) || die "undefined rule id: ERROR"; |
72d8bf49 DM |
105 | |
106 | my $sth = $self->{dbh}->prepare( | |
107 | "SELECT RuleGroup.Grouptype, Objectgroup.ID, " . | |
9ef3f143 | 108 | "Objectgroup.Name, Objectgroup.Info " . |
72d8bf49 DM |
109 | "FROM Rulegroup, Objectgroup " . |
110 | "WHERE Rulegroup.Rule_ID = ? and " . | |
111 | "Rulegroup.Objectgroup_ID = Objectgroup.ID " . | |
112 | "ORDER BY RuleGroup.Grouptype"); | |
113 | ||
114 | my $groups = (); | |
115 | ||
116 | $sth->execute($rule->{id}); | |
117 | ||
118 | my ($from, $to, $when, $what, $action) = ((), (), (), (), ()); | |
119 | ||
120 | while (my $ref = $sth->fetchrow_hashref()) { | |
121 | my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info}); | |
122 | $og->{id} = $ref->{id}; | |
123 | ||
124 | if ($ref->{'grouptype'} == 0) { #from | |
125 | push @$from, $og; | |
126 | } elsif ($ref->{'grouptype'} == 1) { # to | |
127 | push @$to, $og; | |
128 | } elsif ($ref->{'grouptype'} == 2) { # when | |
129 | push @$when, $og; | |
130 | } elsif ($ref->{'grouptype'} == 3) { # what | |
131 | push @$what, $og; | |
132 | } elsif ($ref->{'grouptype'} == 4) { # action | |
133 | my $objects = $self->load_group_objects($og->{id}); | |
134 | my $obj = @$objects[0]; | |
9ef3f143 | 135 | defined($obj) || die "undefined action object: ERROR"; |
72d8bf49 DM |
136 | $og->{action} = $obj; |
137 | push @$action, $og; | |
138 | } | |
139 | } | |
140 | ||
141 | $sth->finish(); | |
142 | ||
143 | return ($from, $to, $when, $what, $action); | |
144 | } | |
145 | ||
146 | sub save_group { | |
147 | my ($self, $og) = @_; | |
148 | ||
9ef3f143 DM |
149 | defined($og->{name}) || |
150 | die "undefined group attribute - name: ERROR"; | |
151 | defined($og->{info}) || | |
152 | die "undefined group attribute - info: ERROR"; | |
153 | defined($og->{class}) || | |
154 | die "undefined group attribute - class: ERROR"; | |
72d8bf49 DM |
155 | |
156 | if (defined($og->{id})) { | |
157 | ||
9ef3f143 | 158 | $self->{dbh}->do("UPDATE Objectgroup " . |
72d8bf49 | 159 | "SET Name = ?, Info = ? " . |
9ef3f143 | 160 | "WHERE ID = ?", undef, |
72d8bf49 | 161 | $og->{name}, $og->{info}, $og->{id}); |
9ef3f143 | 162 | |
72d8bf49 DM |
163 | return $og->{id}; |
164 | ||
165 | } else { | |
166 | my $sth = $self->{dbh}->prepare( | |
167 | "INSERT INTO Objectgroup (Name, Info, Class) " . | |
168 | "VALUES (?, ?, ?);"); | |
169 | ||
170 | $sth->execute($og->name, $og->info, $og->class); | |
171 | ||
172 | return $og->{id} = PMG::Utils::lastid($self->{dbh}, 'objectgroup_id_seq'); | |
173 | } | |
174 | ||
175 | return undef; | |
176 | } | |
177 | ||
72d8bf49 DM |
178 | sub delete_group { |
179 | my ($self, $groupid) = @_; | |
180 | ||
9ef3f143 | 181 | defined($groupid) || die "undefined group id: ERROR"; |
72d8bf49 DM |
182 | |
183 | eval { | |
184 | ||
185 | $self->{dbh}->begin_work; | |
186 | ||
187 | # test if group is used in rules | |
188 | $self->{dbh}->do("LOCK TABLE RuleGroup IN EXCLUSIVE MODE"); | |
189 | ||
190 | my $sth = $self->{dbh}->prepare( | |
191 | "SELECT Rule.Name as rulename, ObjectGroup.Name as groupname " . | |
192 | "FROM RuleGroup, Rule, ObjectGroup WHERE " . | |
193 | "ObjectGroup.ID = ? AND Objectgroup_ID = ObjectGroup.ID AND " . | |
194 | "Rule_ID = Rule.ID"); | |
195 | ||
196 | $sth->execute($groupid); | |
197 | ||
198 | if (my $ref = $sth->fetchrow_hashref()) { | |
9ef3f143 | 199 | die "Group '$ref->{groupname}' is used by rule '$ref->{rulename}' - unable to delete\n"; |
72d8bf49 DM |
200 | } |
201 | ||
202 | $sth->finish(); | |
203 | ||
9ef3f143 | 204 | $self->{dbh}->do("DELETE FROM ObjectGroup " . |
72d8bf49 DM |
205 | "WHERE ID = ?", undef, $groupid); |
206 | ||
9ef3f143 | 207 | $self->{dbh}->do("DELETE FROM RuleGroup " . |
72d8bf49 DM |
208 | "WHERE Objectgroup_ID = ?", undef, $groupid); |
209 | ||
210 | $sth = $self->{dbh}->prepare("SELECT * FROM Object " . | |
211 | "where Objectgroup_ID = ?"); | |
212 | $sth->execute($groupid); | |
9ef3f143 | 213 | |
72d8bf49 | 214 | while (my $ref = $sth->fetchrow_hashref()) { |
9ef3f143 | 215 | $self->{dbh}->do("DELETE FROM Attribut " . |
72d8bf49 DM |
216 | "WHERE Object_ID = ?", undef, $ref->{id}); |
217 | } | |
9ef3f143 | 218 | |
72d8bf49 DM |
219 | $sth->finish(); |
220 | ||
9ef3f143 | 221 | $self->{dbh}->do("DELETE FROM Object " . |
72d8bf49 | 222 | "WHERE Objectgroup_ID = ?", undef, $groupid); |
9ef3f143 | 223 | |
72d8bf49 DM |
224 | $self->{dbh}->commit; |
225 | }; | |
226 | if (my $err = $@) { | |
227 | $self->{dbh}->rollback; | |
9ef3f143 | 228 | die $err; |
72d8bf49 DM |
229 | } |
230 | ||
231 | return undef; | |
232 | } | |
233 | ||
234 | sub load_objectgroups { | |
235 | my ($self, $class, $id) = @_; | |
9ef3f143 | 236 | |
72d8bf49 | 237 | my $sth; |
9ef3f143 DM |
238 | |
239 | defined($class) || die "undefined object class"; | |
240 | ||
72d8bf49 DM |
241 | if (!(defined($id))) { |
242 | $sth = $self->{dbh}->prepare( | |
243 | "SELECT * FROM Objectgroup where Class = ? ORDER BY name"); | |
244 | $sth->execute($class); | |
9ef3f143 | 245 | |
72d8bf49 DM |
246 | } else { |
247 | $sth = $self->{dbh}->prepare( | |
248 | "SELECT * FROM Objectgroup where Class like ? and id = ? " . | |
249 | "order by name"); | |
250 | $sth->execute($class,$id); | |
251 | } | |
9ef3f143 | 252 | |
72d8bf49 DM |
253 | my $arr_og = (); |
254 | while (my $ref = $sth->fetchrow_hashref()) { | |
255 | my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info}, | |
256 | $ref->{class}); | |
257 | $og->{id} = $ref->{id}; | |
258 | ||
259 | if ($class eq 'action') { | |
260 | my $objects = $self->load_group_objects($og->{id}); | |
261 | my $obj = @$objects[0]; | |
9ef3f143 | 262 | defined($obj) || die "undefined action object: ERROR"; |
72d8bf49 DM |
263 | $og->{action} = $obj; |
264 | } | |
265 | push @$arr_og, $og; | |
266 | } | |
9ef3f143 | 267 | |
72d8bf49 DM |
268 | $sth->finish(); |
269 | ||
270 | return $arr_og; | |
271 | } | |
272 | ||
273 | sub get_object { | |
274 | my ($self, $otype) = @_; | |
275 | ||
276 | my $obj; | |
9ef3f143 | 277 | |
72d8bf49 DM |
278 | # WHO OBJECTS |
279 | if ($otype == PMG::RuleDB::Domain::otype()) { | |
280 | $obj = PMG::RuleDB::Domain->new(); | |
9ef3f143 | 281 | } |
72d8bf49 DM |
282 | elsif ($otype == PMG::RuleDB::ReceiverDomain::otype) { |
283 | $obj = PMG::RuleDB::ReceiverDomain->new(); | |
9ef3f143 | 284 | } |
72d8bf49 DM |
285 | elsif ($otype == PMG::RuleDB::WhoRegex::otype) { |
286 | $obj = PMG::RuleDB::WhoRegex->new(); | |
9ef3f143 | 287 | } |
72d8bf49 DM |
288 | elsif ($otype == PMG::RuleDB::ReceiverRegex::otype) { |
289 | $obj = PMG::RuleDB::ReceiverRegex->new(); | |
9ef3f143 | 290 | } |
72d8bf49 DM |
291 | elsif ($otype == PMG::RuleDB::EMail::otype) { |
292 | $obj = PMG::RuleDB::EMail->new(); | |
9ef3f143 | 293 | } |
72d8bf49 DM |
294 | elsif ($otype == PMG::RuleDB::Receiver::otype) { |
295 | $obj = PMG::RuleDB::Receiver->new(); | |
9ef3f143 | 296 | } |
72d8bf49 DM |
297 | elsif ($otype == PMG::RuleDB::IPAddress::otype) { |
298 | $obj = PMG::RuleDB::IPAddress->new(); | |
9ef3f143 | 299 | } |
72d8bf49 DM |
300 | elsif ($otype == PMG::RuleDB::IPNet::otype) { |
301 | $obj = PMG::RuleDB::IPNet->new(); | |
9ef3f143 | 302 | } |
72d8bf49 DM |
303 | # fixme |
304 | # elsif ($otype == Proxmox::RuleDB::LDAP::otype) { | |
305 | # $obj = Proxmox::RuleDB::LDAP->new(); | |
9ef3f143 | 306 | # } |
72d8bf49 DM |
307 | # elsif ($otype == Proxmox::RuleDB::LDAPUser::otype) { |
308 | # $obj = Proxmox::RuleDB::LDAPUser->new(); | |
9ef3f143 | 309 | # } |
72d8bf49 DM |
310 | # WHEN OBJECTS |
311 | elsif ($otype == PMG::RuleDB::TimeFrame::otype) { | |
312 | $obj = PMG::RuleDB::TimeFrame->new(); | |
9ef3f143 | 313 | } |
72d8bf49 DM |
314 | # WHAT OBJECTS |
315 | elsif ($otype == PMG::RuleDB::Spam::otype) { | |
316 | $obj = PMG::RuleDB::Spam->new(); | |
317 | } | |
318 | elsif ($otype == PMG::RuleDB::Virus::otype) { | |
319 | $obj = PMG::RuleDB::Virus->new(); | |
320 | } | |
321 | elsif ($otype == PMG::RuleDB::MatchField::otype) { | |
322 | $obj = PMG::RuleDB::MatchField->new(); | |
323 | } | |
324 | elsif ($otype == PMG::RuleDB::MatchFilename::otype) { | |
325 | $obj = PMG::RuleDB::MatchFilename->new(); | |
326 | } | |
327 | elsif ($otype == PMG::RuleDB::ContentTypeFilter::otype) { | |
328 | $obj = PMG::RuleDB::ContentTypeFilter->new(); | |
329 | } | |
c4741113 DM |
330 | elsif ($otype == PMG::RuleDB::ArchiveFilter::otype) { |
331 | $obj = PMG::RuleDB::ArchiveFilter->new(); | |
332 | } | |
72d8bf49 DM |
333 | # ACTION OBJECTS |
334 | elsif ($otype == PMG::RuleDB::ModField::otype) { | |
335 | $obj = PMG::RuleDB::ModField->new(); | |
336 | } | |
337 | elsif ($otype == PMG::RuleDB::Accept::otype()) { | |
338 | $obj = PMG::RuleDB::Accept->new(); | |
339 | } | |
340 | elsif ($otype == PMG::RuleDB::ReportSpam::otype()) { | |
341 | $obj = PMG::RuleDB::ReportSpam->new(); | |
342 | } | |
343 | elsif ($otype == PMG::RuleDB::Attach::otype) { | |
344 | $obj = PMG::RuleDB::Attach->new(); | |
345 | } | |
346 | elsif ($otype == PMG::RuleDB::Disclaimer::otype) { | |
347 | $obj = PMG::RuleDB::Disclaimer->new(); | |
348 | } | |
349 | elsif ($otype == PMG::RuleDB::BCC::otype) { | |
350 | $obj = PMG::RuleDB::BCC->new(); | |
351 | } | |
352 | elsif ($otype == PMG::RuleDB::Quarantine::otype) { | |
353 | $obj = PMG::RuleDB::Quarantine->new(); | |
354 | } | |
355 | elsif ($otype == PMG::RuleDB::Block::otype) { | |
356 | $obj = PMG::RuleDB::Block->new(); | |
357 | } | |
358 | elsif ($otype == PMG::RuleDB::Counter::otype) { | |
359 | $obj = PMG::RuleDB::Counter->new(); | |
360 | } | |
361 | elsif ($otype == PMG::RuleDB::Remove::otype) { | |
362 | $obj = PMG::RuleDB::Remove->new(); | |
363 | } | |
364 | elsif ($otype == PMG::RuleDB::Notify::otype) { | |
365 | $obj = PMG::RuleDB::Notify->new(); | |
366 | } | |
367 | else { | |
9ef3f143 | 368 | die "proxmox: unknown object type: ERROR"; |
72d8bf49 | 369 | } |
9ef3f143 | 370 | |
72d8bf49 DM |
371 | return $obj; |
372 | } | |
373 | ||
374 | sub load_counters_data { | |
375 | my ($self) = @_; | |
9ef3f143 | 376 | |
72d8bf49 DM |
377 | my $sth = $self->{dbh}->prepare( |
378 | "SELECT Object.id, Objectgroup.name, Object.Value, Objectgroup.info " . | |
9ef3f143 | 379 | "FROM Object, Objectgroup " . |
72d8bf49 DM |
380 | "WHERE objectgroup.id = object.objectgroup_id and ObjectType = ? " . |
381 | "order by Objectgroup.name, Value"); | |
382 | ||
383 | my @data; | |
384 | ||
385 | $sth->execute(PMG::RuleDB::Counter->otype()); | |
386 | ||
9ef3f143 | 387 | while (my $ref = $sth->fetchrow_hashref()) { |
72d8bf49 DM |
388 | my $tmp = [$ref->{id},$ref->{name},$ref->{value},$ref->{info}]; |
389 | push (@data, $tmp); | |
390 | } | |
9ef3f143 | 391 | |
72d8bf49 | 392 | $sth->finish(); |
9ef3f143 DM |
393 | |
394 | return @data; | |
72d8bf49 DM |
395 | } |
396 | ||
397 | sub load_object { | |
398 | my ($self, $objid) = @_; | |
9ef3f143 | 399 | |
72d8bf49 DM |
400 | my $value = ''; |
401 | ||
9ef3f143 | 402 | defined($objid) || die "undefined object id"; |
72d8bf49 DM |
403 | |
404 | my $sth = $self->{dbh}->prepare("SELECT * FROM Object where ID = ?"); | |
405 | $sth->execute($objid); | |
9ef3f143 | 406 | |
72d8bf49 DM |
407 | my $ref = $sth->fetchrow_hashref(); |
408 | ||
409 | $sth->finish(); | |
410 | ||
9ef3f143 DM |
411 | if (defined($ref->{'value'})) { |
412 | $value = $ref->{'value'}; | |
72d8bf49 DM |
413 | } |
414 | ||
9ef3f143 | 415 | if (!(defined($ref->{'objecttype'}) && |
72d8bf49 DM |
416 | defined($ref->{'objectgroup_id'}))) { |
417 | return undef; | |
418 | } | |
419 | ||
420 | my $ogroup = $ref->{'objectgroup_id'}; | |
9ef3f143 | 421 | |
72d8bf49 DM |
422 | my $otype = $ref->{'objecttype'}; |
423 | my $obj = $self->get_object($otype); | |
424 | ||
425 | $obj->load_attr($self, $objid, $ogroup, $value); | |
426 | } | |
427 | ||
744483ce DM |
428 | sub load_object_full { |
429 | my ($self, $id, $gid, $exp_otype) = @_; | |
430 | ||
431 | my $obj = $self->load_object($id); | |
432 | die "object '$id' does not exists\n" if !defined($obj); | |
433 | ||
434 | my $otype = $obj->otype(); | |
435 | die "wrong object type ($otype != $exp_otype)\n" | |
436 | if defined($exp_otype) && $otype != $exp_otype; | |
437 | ||
438 | die "wrong object group ($obj->{ogroup} != $gid)\n" | |
439 | if $obj->{ogroup} != $gid; | |
440 | ||
441 | return $obj; | |
442 | } | |
443 | ||
72d8bf49 DM |
444 | sub load_group_by_name { |
445 | my ($self, $name) = @_; | |
446 | ||
9ef3f143 | 447 | my $sth = $self->{dbh}->prepare("SELECT * FROM Objectgroup " . |
72d8bf49 DM |
448 | "WHERE name = ?"); |
449 | ||
450 | $sth->execute($name); | |
9ef3f143 | 451 | |
72d8bf49 DM |
452 | while (my $ref = $sth->fetchrow_hashref()) { |
453 | my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info}, | |
454 | $ref->{class}); | |
455 | $og->{id} = $ref->{id}; | |
456 | ||
457 | $sth->finish(); | |
458 | ||
459 | if ($ref->{'class'} eq 'action') { | |
460 | my $objects = $self->load_group_objects($og->{id}); | |
461 | my $obj = @$objects[0]; | |
9ef3f143 | 462 | defined($obj) || die "undefined action object: ERROR"; |
72d8bf49 DM |
463 | $og->{action} = $obj; |
464 | } | |
9ef3f143 | 465 | |
72d8bf49 DM |
466 | return $og; |
467 | } | |
468 | ||
469 | $sth->finish(); | |
470 | ||
471 | return undef; | |
472 | } | |
473 | ||
474 | sub greylistexclusion_groupid { | |
475 | my ($self) = @_; | |
9ef3f143 | 476 | |
72d8bf49 | 477 | my $sth = $self->{dbh}->prepare( |
9ef3f143 DM |
478 | "select id from objectgroup where class='greylist' limit 1;"); |
479 | ||
72d8bf49 | 480 | $sth->execute(); |
9ef3f143 | 481 | |
72d8bf49 | 482 | my $ref = $sth->fetchrow_hashref(); |
9ef3f143 | 483 | |
72d8bf49 DM |
484 | return $ref->{id}; |
485 | } | |
486 | ||
487 | sub load_group_objects { | |
488 | my ($self, $ogid) = @_; | |
489 | ||
9ef3f143 | 490 | defined($ogid) || die "undefined group id: ERROR"; |
72d8bf49 | 491 | |
9ef3f143 DM |
492 | my $sth = $self->{dbh}->prepare( |
493 | "SELECT * FROM Object " . | |
72d8bf49 DM |
494 | "WHERE Objectgroup_ID = ? order by ObjectType,Value"); |
495 | ||
496 | my $objects = (); | |
497 | ||
498 | $sth->execute($ogid); | |
499 | ||
500 | while (my $ref = $sth->fetchrow_hashref()) { | |
501 | my $obj = $self->load_object($ref->{id}); | |
502 | push @$objects, $obj; | |
503 | } | |
504 | ||
505 | $sth->finish(); | |
506 | ||
507 | return $objects; | |
508 | } | |
509 | ||
510 | ||
511 | sub save_object { | |
512 | my ($self, $obj) = @_; | |
9ef3f143 | 513 | |
72d8bf49 DM |
514 | $obj->save($self); |
515 | ||
516 | return $obj->{id}; | |
517 | } | |
518 | ||
519 | sub group_add_object { | |
520 | my ($self, $group, $obj) = @_; | |
9ef3f143 | 521 | |
72d8bf49 | 522 | ($obj->oclass() eq $group->{class}) || |
9ef3f143 | 523 | die "wrong object class: ERROR"; |
72d8bf49 DM |
524 | |
525 | $obj->{ogroup} = $group->{id}; | |
9ef3f143 | 526 | |
72d8bf49 DM |
527 | $self->save_object($obj); |
528 | } | |
529 | ||
530 | sub delete_object { | |
531 | my ($self, $obj) = @_; | |
532 | ||
9ef3f143 | 533 | defined($obj->{id}) || die "undefined object id"; |
72d8bf49 DM |
534 | |
535 | eval { | |
536 | ||
537 | $self->{dbh}->begin_work; | |
538 | ||
9ef3f143 | 539 | $self->{dbh}->do("DELETE FROM Attribut " . |
72d8bf49 | 540 | "WHERE Object_ID = ?", undef, $obj->{id}); |
9ef3f143 DM |
541 | |
542 | $self->{dbh}->do("DELETE FROM Object " . | |
72d8bf49 DM |
543 | "WHERE ID = ?", |
544 | undef, $obj->{id}); | |
545 | ||
546 | $self->{dbh}->commit; | |
547 | }; | |
548 | if (my $err = $@) { | |
549 | $self->{dbh}->rollback; | |
550 | syslog('err', $err); | |
551 | return undef; | |
552 | } | |
553 | ||
554 | $obj->{id} = undef; | |
555 | ||
556 | return 1; | |
557 | } | |
558 | ||
559 | sub save_rule { | |
560 | my ($self, $rule) = @_; | |
561 | ||
9ef3f143 DM |
562 | defined($rule->{name}) || |
563 | die "undefined rule attribute - name: ERROR"; | |
564 | defined($rule->{priority}) || | |
565 | die "undefined rule attribute - priority: ERROR"; | |
566 | defined($rule->{active}) || | |
567 | die "undefined rule attribute - active: ERROR"; | |
568 | defined($rule->{direction}) || | |
569 | die "undefined rule attribute - direction: ERROR"; | |
72d8bf49 DM |
570 | |
571 | if (defined($rule->{id})) { | |
572 | ||
573 | $self->{dbh}->do( | |
9ef3f143 | 574 | "UPDATE Rule " . |
72d8bf49 | 575 | "SET Name = ?, Priority = ?, Active = ?, Direction = ? " . |
9ef3f143 DM |
576 | "WHERE ID = ?", undef, |
577 | $rule->{name}, $rule->{priority}, $rule->{active}, | |
72d8bf49 DM |
578 | $rule->{direction}, $rule->{id}); |
579 | ||
580 | return $rule->{id}; | |
581 | ||
582 | } else { | |
583 | my $sth = $self->{dbh}->prepare( | |
584 | "INSERT INTO Rule (Name, Priority, Active, Direction) " . | |
585 | "VALUES (?, ?, ?, ?);"); | |
586 | ||
9ef3f143 DM |
587 | $sth->execute($rule->name, $rule->priority, $rule->active, |
588 | $rule->direction); | |
72d8bf49 DM |
589 | |
590 | return $rule->{id} = PMG::Utils::lastid($self->{dbh}, 'rule_id_seq'); | |
591 | } | |
592 | ||
593 | return undef; | |
594 | } | |
595 | ||
596 | sub delete_rule { | |
597 | my ($self, $ruleid) = @_; | |
598 | ||
9ef3f143 | 599 | defined($ruleid) || die "undefined rule id: ERROR"; |
72d8bf49 DM |
600 | |
601 | eval { | |
602 | $self->{dbh}->begin_work; | |
603 | ||
9ef3f143 | 604 | $self->{dbh}->do("DELETE FROM Rule " . |
72d8bf49 | 605 | "WHERE ID = ?", undef, $ruleid); |
9ef3f143 | 606 | $self->{dbh}->do("DELETE FROM RuleGroup " . |
72d8bf49 DM |
607 | "WHERE Rule_ID = ?", undef, $ruleid); |
608 | ||
609 | $self->{dbh}->commit; | |
610 | }; | |
611 | if (my $err = $@) { | |
612 | $self->{dbh}->rollback; | |
613 | syslog('err', $err); | |
614 | return undef; | |
615 | } | |
616 | ||
617 | return 1; | |
618 | } | |
619 | ||
620 | sub delete_testrules { | |
621 | my ($self) = @_; | |
622 | ||
623 | eval { | |
624 | $self->{dbh}->begin_work; | |
625 | ||
626 | my $sth = $self->{dbh}->prepare("Select id FROM Rule " . | |
627 | "WHERE name = 'testrule'"); | |
628 | $sth->execute(); | |
629 | ||
630 | while(my $ref = $sth->fetchrow_hashref()) { | |
9ef3f143 | 631 | $self->{dbh}->do("DELETE FROM Rule " . |
72d8bf49 | 632 | "WHERE ID = ?", undef, $ref->{id}); |
9ef3f143 | 633 | $self->{dbh}->do("DELETE FROM RuleGroup " . |
72d8bf49 DM |
634 | "WHERE Rule_ID = ?", undef, $ref->{id}); |
635 | } | |
636 | $sth->finish(); | |
637 | ||
638 | $self->{dbh}->commit; | |
639 | }; | |
640 | if (my $err = $@) { | |
641 | $self->{dbh}->rollback; | |
9ef3f143 | 642 | die $err; |
72d8bf49 DM |
643 | } |
644 | ||
9ef3f143 | 645 | return 1; |
72d8bf49 DM |
646 | } |
647 | ||
72d8bf49 DM |
648 | sub rule_add_group { |
649 | my ($self, $ruleid, $groupid, $gtype) = @_; | |
650 | ||
9ef3f143 DM |
651 | defined($ruleid) || die "undefined rule id: ERROR"; |
652 | defined($groupid) || die "undefined group id: ERROR"; | |
653 | defined($gtype) || die "undefined group type: ERROR"; | |
654 | ||
655 | $self->{dbh}->do("INSERT INTO RuleGroup " . | |
72d8bf49 | 656 | "(Objectgroup_ID, Rule_ID, Grouptype) " . |
9ef3f143 | 657 | "VALUES (?, ?, ?)", undef, |
72d8bf49 DM |
658 | $groupid, $ruleid, $gtype); |
659 | return 1; | |
660 | } | |
661 | ||
662 | sub rule_add_from_group { | |
663 | my ($self, $rule, $group) = @_; | |
9ef3f143 | 664 | |
72d8bf49 DM |
665 | $self->rule_add_group($rule->{id}, $group->{id}, 0); |
666 | } | |
667 | ||
668 | sub rule_add_to_group { | |
669 | my ($self, $rule, $group) = @_; | |
9ef3f143 | 670 | |
72d8bf49 DM |
671 | $self->rule_add_group($rule->{id}, $group->{id}, 1); |
672 | } | |
673 | ||
674 | sub rule_add_when_group { | |
675 | my ($self, $rule, $group) = @_; | |
9ef3f143 | 676 | |
72d8bf49 DM |
677 | $self->rule_add_group($rule->{id}, $group->{id}, 2); |
678 | } | |
679 | ||
680 | sub rule_add_what_group { | |
681 | my ($self, $rule, $group) = @_; | |
9ef3f143 | 682 | |
72d8bf49 DM |
683 | $self->rule_add_group($rule->{id}, $group->{id}, 3); |
684 | } | |
685 | ||
686 | sub rule_add_action { | |
687 | my ($self, $rule, $group) = @_; | |
9ef3f143 | 688 | |
72d8bf49 DM |
689 | $self->rule_add_group($rule->{id}, $group->{id}, 4); |
690 | } | |
691 | ||
692 | sub rule_remove_group { | |
693 | my ($self, $ruleid, $groupid, $gtype) = @_; | |
694 | ||
9ef3f143 DM |
695 | defined($ruleid) || die "undefined rule id: ERROR"; |
696 | defined($groupid) || die "undefined group id: ERROR"; | |
697 | defined($gtype) || die "undefined group type: ERROR"; | |
72d8bf49 | 698 | |
9ef3f143 | 699 | $self->{dbh}->do("DELETE FROM RuleGroup WHERE " . |
72d8bf49 DM |
700 | "Objectgroup_ID = ? and Rule_ID = ? and Grouptype = ?", |
701 | undef, $groupid, $ruleid, $gtype); | |
702 | return 1; | |
703 | } | |
704 | ||
705 | sub load_rule { | |
706 | my ($self, $id) = @_; | |
9ef3f143 DM |
707 | |
708 | defined($id) || die "undefined id: ERROR"; | |
709 | ||
72d8bf49 DM |
710 | my $sth = $self->{dbh}->prepare( |
711 | "SELECT * FROM Rule where id = ? ORDER BY Priority DESC"); | |
712 | ||
713 | my $rules = (); | |
714 | ||
715 | $sth->execute($id); | |
716 | ||
717 | my $ref = $sth->fetchrow_hashref(); | |
9ef3f143 | 718 | |
72d8bf49 DM |
719 | my $rule = PMG::RuleDB::Rule->new($ref->{name}, $ref->{priority}, |
720 | $ref->{active}, $ref->{direction}); | |
721 | $rule->{id} = $ref->{id}; | |
9ef3f143 DM |
722 | |
723 | return $rule; | |
72d8bf49 DM |
724 | } |
725 | ||
726 | sub load_rules { | |
727 | my ($self) = @_; | |
728 | ||
729 | my $sth = $self->{dbh}->prepare( | |
730 | "SELECT * FROM Rule ORDER BY Priority DESC"); | |
731 | ||
732 | my $rules = (); | |
733 | ||
734 | $sth->execute(); | |
9ef3f143 | 735 | |
72d8bf49 DM |
736 | while (my $ref = $sth->fetchrow_hashref()) { |
737 | my $rule = PMG::RuleDB::Rule->new($ref->{name}, $ref->{priority}, | |
738 | $ref->{active}, $ref->{direction}); | |
739 | $rule->{id} = $ref->{id}; | |
740 | push @$rules, $rule; | |
741 | } | |
742 | ||
743 | $sth->finish(); | |
744 | ||
745 | return $rules; | |
746 | } | |
747 | ||
748 | ||
749 | ||
750 | 1; | |
751 | ||
752 | __END__ | |
753 | ||
754 | =head1 PMG::RuleDB | |
755 | ||
756 | The RuleDB Object manages the database connection and provides an interface to manipulate the database without SQL. A typical application first create a RuleDB object: | |
757 | ||
758 | use PMG::RuleDB; | |
759 | ||
760 | $ruledb = PMG::RuleDB->new(); | |
761 | ||
762 | =head2 Database Overview | |
763 | ||
764 | =head3 Rules | |
765 | ||
766 | Rules contains sets of Groups, grouped by classes (FROM, TO, WHEN, WHAT and ACTION). Each rule has an associated priority and and active/inactive marker. | |
767 | ||
768 | =head3 Groups | |
769 | ||
770 | A Group is a set of Objects. | |
771 | ||
772 | =head3 Objects | |
773 | ||
774 | Objects contains the filter data. | |
775 | ||
776 | =head3 Rule Semantics | |
777 | ||
778 | The classes have 'and' semantics. A rule matches if the checks in FROM, TO, WHEN and WHAT classes returns TRUE. | |
779 | ||
780 | Within a class the objects are or'ed together. | |
781 | ||
782 | =head2 Managing Rules | |
783 | ||
784 | =head3 $ruledb->load_rules() | |
785 | ||
786 | Returns an array of Rules containing all rules in the database. | |
787 | ||
788 | =head3 $ruledb->save_rule ($rule) | |
789 | ||
790 | One can use the following code to add a new rule to the database: | |
791 | ||
792 | my $rule = PMG::RuleDB::Rule->new ($name, $priority, $active); | |
793 | $ruledb->save_rule ($rule); | |
794 | ||
9ef3f143 | 795 | You can also use save_rule() to commit changes back to the database. |
72d8bf49 DM |
796 | |
797 | =head3 $ruledb->delete_rule ($ruleid) | |
798 | ||
799 | Removes the rule from the database. | |
800 | ||
801 | =head3 $ruledb->rule_add_group ($rule, $og, $gtype) | |
802 | ||
803 | Add an object group to the rule. | |
804 | ||
805 | Possible values for $gtype are: | |
806 | ||
807 | 0 = FROM, 1 = TO, 2 = WHEN, 3 = WHAT, 4 = ACTION | |
808 | ||
809 | =head3 $ruledb->rule_remove_group ($rule, $og, $gtype) | |
810 | ||
811 | Removes an object group from the rule. | |
812 | ||
813 | =head2 Managing Objects and Groups | |
814 | ||
815 | =head3 $ruledb->load_groups ($rule) | |
816 | ||
817 | Return all object groups belonging to a rule. Data is divided into separate arrays: | |
818 | ||
9ef3f143 | 819 | my ($from, $to, $when, $what, $action) = |
72d8bf49 DM |
820 | $ruledb->load_groups($rule); |
821 | ||
822 | =head3 $ruledb->save_group ($og) | |
823 | ||
824 | This can be used to add or modify an Group. This code segemnt creates | |
825 | a new object group: | |
826 | ||
827 | $og = PMG::RuleDB::Group->new ($name, $desc); | |
828 | $ruledb->save_group ($og); | |
829 | ||
830 | ||
831 | =head3 $ruledb->delete_group ($groupid) | |
832 | ||
9ef3f143 DM |
833 | Deletes the object group, all reference to the group and all objects |
834 | belonging to this group from the Database. | |
72d8bf49 DM |
835 | |
836 | =head3 $ruledb->group_add_object ($og, $obj) | |
837 | ||
838 | Attach an object to an object group. | |
839 | ||
840 | =head3 $ruledb->save_object ($obj) | |
841 | ||
9ef3f143 | 842 | Save or update an object. This can be used to add new objects |
72d8bf49 DM |
843 | to the database (although group_add_object() is the prefered way): |
844 | ||
845 | $obj = PMG::RuleDB::EMail->new ('.*@mydomain.com'); | |
846 | # we need to set the object group manually | |
847 | $obj->ogroup ($group->id); | |
848 | $ruledb->save_object ($obj); | |
9ef3f143 | 849 | |
72d8bf49 DM |
850 | |
851 | =head3 $ruledb->delete_object ($obj) | |
852 | ||
9ef3f143 | 853 | Deletes the object, all references to the object and all object |
72d8bf49 | 854 | attributes from the database. |