EmailReminder/Event.pm

   1 # This file is part of Email-Reminder.
   2 #
   3 # Email-Reminder is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU General Public License as
   5 # published by the Free Software Foundation; either version 3 of the
   6 # License, or (at your option) any later version.
   7 #
   8 # Email-Reminder is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with Email-Reminder; if not, write to the Free Software
  15 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16 # 02110-1301, USA.
  17
  18 package EmailReminder::Event;
  19
  20 # Base class for all other events.
  21 #
  22 # This class should never be used directly, use a derived class instead.
  23
  24 use strict;
  25 use warnings;
  26
  27 use Date::Manip;
  28 use XML::DOM;
  29
  30 use EmailReminder::Utils;
  31
  32 # XML tags
  33 __PACKAGE__->mk_accessors(qw(name));
  34
  35 sub mk_accessors {
  36     my ($self, @field_names) = @_;
  37
  38     # get the classname since it might be a derived class calling this
  39     my $class = ref $self || $self;
  40
  41     foreach my $field_name ( @field_names ) {
  42         my $get_method = sub {
  43             my ($self) = @_;
  44             my $valid_sub = "valid_$field_name";
  45             my $value = EmailReminder::Utils::get_node_value($self->{XML_NODE}, $field_name);
  46             return $self->$valid_sub( $value );
  47         };
  48
  49         my $set_method = sub {
  50             my ($self, $new_value) = @_;
  51             return EmailReminder::Utils::set_node_value($self->{XML_NODE}, $field_name, $new_value);
  52         };
  53
  54         {
  55             no strict 'refs';
  56             *{"${class}::get_$field_name"} = $get_method;
  57             *{"${class}::set_$field_name"} = $set_method;
  58         }
  59     }
  60 }
  61
  62 # other XML tags, attributes and values
  63 my $REMINDER_TAG = 'reminder';
  64 my $REMINDERS_TAG = 'reminders';
  65 my $RECIPIENT_TAG = 'recipient';
  66 my $RECIPIENTS_TAG = 'recipients';
  67
  68 my $EMAIL_ATTR = 'email';
  69 my $NAME_ATTR = 'name';
  70 my $TYPE_ATTR = 'type';
  71
  72 my $DAYS_BEFORE_VAL = 'days before';
  73 my $SAME_DAY_VAL = 'same day';
  74
  75 # Hard-coded value for this event's type (class method)
  76 sub get_type
  77 {
  78     return;
  79 }
  80
  81 # Number of fields this event adds to its parent (class method)
  82 sub get_nb_fields
  83 {
  84     return 1;
  85 }
  86
  87 sub valid_name {
  88     my ($class, $new_value) = @_;
  89     return $new_value;
  90 }
  91
  92 sub new
  93 {
  94     my $class = shift;
  95     my $event_node = shift;
  96     my $id = shift;
  97
  98     my $self = { "OCCURRING" => 0,
  99                  "XML_NODE" => $event_node,
 100                  "ID" => $id,
 101                  "DATA" => [$id],
 102             };
 103
 104     bless $self, $class;
 105
 106     # Create empty data array
 107     my $count = $self->get_nb_fields() - 1;
 108     for (my $i = 0; $i < $count; $i++) {
 109         push(@{$self->{DATA}}, undef);
 110     }
 111
 112     # Where to send this reminder email
 113     my $recipients = $self->{XML_NODE}->getElementsByTagName($RECIPIENTS_TAG)->item(0);
 114     if (defined($recipients)) {
 115         $self->{RECIPIENTS_NODE} = $recipients;
 116         $self->{RECIPIENTS_CACHE} = $self->get_recipients();
 117     }
 118
 119     # Process reminders
 120     my $reminders = $self->{XML_NODE}->getElementsByTagName($REMINDERS_TAG)->item(0);
 121     if (defined($reminders)) {
 122         $self->{REMINDERS_NODE} = $reminders;
 123         $self->{REMINDERS_CACHE} = $self->get_reminders();
 124     }
 125
 126     return $self;
 127 }
 128
 129 sub unlink
 130 {
 131     my $self = shift;
 132     my $node = $self->{XML_NODE};
 133     $node->getParentNode()->removeChild($node);
 134     $node->dispose();
 135 }
 136
 137 sub get_recipients
 138 {
 139     my $self = shift;
 140
 141     if (!defined($self->{RECIPIENTS_CACHE})) {
 142         my @recipients = ();
 143
 144         if (defined($self->{RECIPIENTS_NODE})) {
 145             foreach my $recipient ($self->{RECIPIENTS_NODE}->getElementsByTagName($RECIPIENT_TAG)) {
 146                 my $email = $recipient->getAttribute($EMAIL_ATTR);
 147                 if (defined($email)) {
 148                     my $fname = undef;
 149                     my $lname = undef;
 150                     my $fullname = $recipient->getAttribute($NAME_ATTR);
 151
 152                     my @name_parts = split(/ /, $fullname);
 153                     $fname = $name_parts[0];
 154                     $lname = $name_parts[-1] if @name_parts > 1;
 155
 156                     push(@recipients, [$email, $fname, $lname]);
 157                 }
 158             }
 159         }
 160
 161         $self->{RECIPIENTS_CACHE} = \@recipients;
 162     }
 163     return $self->{RECIPIENTS_CACHE};
 164 }
 165
 166 sub get_reminders
 167 {
 168     my $self = shift;
 169
 170     if (!defined($self->{REMINDERS_CACHE})) {
 171         my @reminders = ();
 172
 173         if (defined($self->{REMINDERS_NODE}))
 174         {
 175             foreach my $reminder ($self->{REMINDERS_NODE}->getElementsByTagName($REMINDER_TAG)){
 176                 my $type = $reminder->getAttribute($TYPE_ATTR);
 177
 178                 if ($type eq $SAME_DAY_VAL) {
 179                     push(@reminders, 0);
 180
 181                     if ($self->will_occur("")) {
 182                         $self->{WHEN} = "today";
 183                         $self->{OCCURRING}++;
 184                     }
 185                 }
 186                 elsif (($type eq $DAYS_BEFORE_VAL) &&
 187                        ($reminder->getFirstChild()))
 188                 {
 189                     my $days = $reminder->getFirstChild()->getNodeValue();
 190                     push(@reminders, $days);
 191
 192                     if ($self->will_occur($days)) {
 193                         if ($days > 1) {
 194                             my $upcoming_date = DateCalc("today", "+${days}days");
 195                             $self->{WHEN} = "in $days days (" . UnixDate($upcoming_date, "%A %b %e") . ")";
 196                         }
 197                         elsif ($days == 1) {
 198                             $self->{WHEN} = "tomorrow";
 199                         }
 200                         elsif ($days == 0) {
 201                             $self->{WHEN} = "today";
 202                         }
 203                         else {
 204                             next; # Negative days are ignored
 205                         }
 206
 207                         $self->{OCCURRING}++;
 208                     }
 209                 }
 210             }
 211         }
 212
 213         $self->{REMINDERS_CACHE} = \@reminders;
 214     }
 215
 216     return $self->{REMINDERS_CACHE};
 217 }
 218
 219 sub set_reminders
 220 {
 221     my ($self, $new_reminders) = @_;
 222
 223     my $event = $self->{XML_NODE};
 224     my $doc = $event->getOwnerDocument();
 225     my $reminders = $self->{REMINDERS_NODE};
 226
 227     if (!defined($reminders)) {
 228         # Create a blank <reminders> tag
 229         $reminders = $doc->createElement($REMINDERS_TAG);
 230         $event->appendChild($reminders);
 231
 232         $self->{REMINDERS_NODE} = $reminders;
 233     }
 234     else {
 235         # TODO: preserve extra reminders in the XML but not in the UI
 236
 237         # Delete all current reminders
 238         foreach my $child ($reminders->getChildNodes()) {
 239             $reminders->removeChild($child);
 240         }
 241     }
 242
 243     # Add all reminders to the <reminders> node
 244     foreach my $nb_days (@$new_reminders)
 245     {
 246         my $new_node = $doc->createElement($REMINDER_TAG);
 247
 248         if ($nb_days == 0)
 249         {
 250             $new_node->setAttribute($TYPE_ATTR, $SAME_DAY_VAL);
 251         }
 252         elsif ($nb_days > 0)
 253         {
 254             $new_node->setAttribute($TYPE_ATTR, $DAYS_BEFORE_VAL);
 255             $new_node->addText($nb_days);
 256         }
 257         else
 258         {
 259             # Invalid number, ignore
 260                 next;
 261             }
 262
 263         $reminders->appendChild($new_node);
 264     }
 265
 266     # Clear the cache
 267     undef $self->{REMINDERS_CACHE};
 268 }
 269
 270 sub is_occurring
 271 {
 272     my $self = shift;
 273     return $self->{OCCURRING};
 274 }
 275
 276 sub get_message
 277 {
 278     my $self = shift;
 279
 280     # destination user
 281     my $first_name = shift || 'there';
 282
 283     my $body = $self->get_message_body(@_);
 284
 285     my $message = "";
 286     $message = <<"MESSAGEEND" if $body;
 287 Hi $first_name,
 288
 289 $body
 290 Have a good day!
 291
 292 --
 293 Sent by Email-Reminder $EmailReminder::Utils::VERSION
 294 http://www.email-reminder.org.nz/
 295 MESSAGEEND
 296
 297     return $message;
 298 }
 299
 300 sub data
 301 {
 302     my $self = shift;
 303     return $self->{DATA};
 304 }
 305
 306 sub get_id
 307 {
 308     my $self = shift;
 309     return $self->{ID};
 310 }
 311
 312 1;