ICal::QuickAdd - ICal::QuickAdd documentation

  $iqa = ICal::QuickAdd->new('tomorrow at noon. Lunch with Bob') ;

  # Default to expecting a email message with the SMS in body, On STDIN
  $iqa = ICal::QuickAdd->new();

   $iqa->parse_date_and_summary($msg);

 tomorrow at noon. Lunch with Bob

    $iqa->inject_into_ics($filename);

 my $desc = $iqa->parsed_string;

 my $vevent = $iqa->as_vevent;

 my $data_ical = $iqa->as_ical;

 my $email_simple_obj = $iqa->as_ical_email(
        To    => $your_regular_email,
        From  => $from_email, # Defaults to $iqa->from_email
  );

 Return the event name found in the SMS message.

 darcs get http://mark.stosberg.com/darcs_hive/ICal-QuickAdd
 cd ICal-QuickAdd
 # hack...
 darcs record
 darcs send

package ICal::QuickAdd;
use Params::Validate ':all';
use strict;
use warnings;
use Fcntl qw(SEEK_END O_RDONLY);
use Carp;
use vars '$VERSION';
$VERSION = '1.00';

sub new {
    my $class = shift;
    my $str = shift;

    my $self  = {};
    unless ($str) {
        require Mail::Audit;
        my $m = Mail::Audit->new(
                emergency=>"~/mail_audit_emergency_mbox",
                #   log =>'~/mail_audit_log',
                #  loglevel => 3,
                            );
        # Look on the first line of the message.
        $str = $m->body->[0];
        $self->{from_email} = $m->from;
        $self->{from_email_obj} = $m;
    }
    bless($self,$class);

    die "no quick-add message found in arg or email" unless $str;

    ($self->{dt},$self->{msg}) = $self->parse_date_and_summary($str);

    return $self;

}

sub _is_ical_file {
    my $filename = shift;
    my $handle;
    sysopen( $handle, $filename, O_RDONLY ) || croak "failed to open $filename: $!";
    binmode $handle ;

   my $file_length = (stat($filename))[7];

   # "END:VCALENDAR" + \n or CRLF == 15 chars/bytes
   my $end_vcal_len = 15;

   # A valid ics file would be much bigger
   croak "not valid ICS file" unless ($file_length > $end_vcal_len);

    # seek to the end of the file and get its size
    my $seek_pos = seek( $handle, -$end_vcal_len, SEEK_END ) or croak "failed to seek: $!";
    my $last_chars;
    read($handle, $last_chars, $end_vcal_len);
    # The spec says we must end in CRLF, not just unix "\n"
    my $is_ical_file = ($last_chars =~ m/END:VCALENDAR(\r?\n)$/s) ;
    my $line_ending = $1;
    # $is_ical_file || warn "last chars were: $last_chars";
    return ($is_ical_file, $line_ending);
}

sub parse_date_and_summary {
    my $self = shift;
    my $in = shift;

    require DateTime::Format::Natural;
    my ($date,$msg) = split '\.',  $in;
    $date ||= '';
    $msg ||= '';
    chomp $date;
    chomp $msg;

    # trim leading and trailing whitespace
    $msg =~ s/^\s+|\s+$//g;

    my $dt;
    eval { $dt = DateTime::Format::Natural->new->parse_datetime(string => $date) };
    croak "error parsing date ($date). error was: $@" if $@;

    return ($dt, $msg);
}

sub inject_into_ics {
    my $self     = shift;
    my $filename = shift;

    my ($is_ical,$line_ending) = _is_ical_file($filename);
    croak "$filename doesn't look like a valid ICS file" unless $is_ical;

    my $entry =  $self->as_vevent->as_string;

    open( my $fh, "+<$filename") || croak "couldn't open $filename: $!";

    # END:VCALENDAR has 13 chars
    my $perfect_length = 13 + length $line_ending;

    # seek to exactly the right spot to inject our file.
    my $seek_pos = seek( $fh, -$perfect_length, SEEK_END ) or croak "failed to seek: $!";

    print $fh $entry || croak "couldn't print to fh: $!";

    print $fh "END:VCALENDAR".$line_ending;

    close ($fh) || croak "couldn't close fh: $!";

    return 1;

}

sub parsed_string {
    my $self = shift;
    my $dt = $self->get_dt;
    return sprintf("Event: %s on %s %d, %d at %02d:%02d",
            $self->get_msg, $dt->month_abbr, $dt->day, $dt->year, $dt->hour, $dt->minute);

}

sub as_vevent {
    my $self = shift;

    # XXX Could add caching here.

    require Data::ICal::Entry::Event;
    require DateTime::Format::ICal;
    my $vevent = Data::ICal::Entry::Event->new;
       $vevent->add_properties(
           summary => $self->get_msg,
           dtstart => DateTime::Format::ICal->format_datetime($self->get_dt),
           dtend   => DateTime::Format::ICal->format_datetime( $self->get_dt->add( hours => 1 ) ),
       );
    return $vevent;

}

sub as_ical {
    my $self = shift;

    require Data::ICal;

     my $calendar = Data::ICal->new;
     $calendar->add_entry( $self->as_vevent );
     $calendar->add_properties( method => 'PUBLISH');

     return $calendar;
}

sub as_ical_email {
    my $self = shift;
    my %in = validate(@_, {
        To    => { type => SCALAR },
        From  => { type => SCALAR, default => $self->from_email },
    });

     require Email::Simple;
     my $email = Email::Simple->new('');
     $email->header_set("Content-Type", "text/calendar; name=calendar.ics; charset=utf-8; METHOD=PUBLISH");
     $email->header_set(From => $in{From} );
     $email->header_set(To => $in{To} );

     $email->header_set("Subject", $self->parsed_string );
     $email->body_set( $self->as_ical->as_string );

     use Email::Date;
     $email->header_set( Date => format_date );

     return $email;
}

sub from_email {
    my $self = shift;
    return $self->{from_email};
}

sub from_email_obj {
    my $self = shift;
    return $self->{from_email_obj}

}

sub get_msg {
    my $self = shift;
    return $self->{msg};
}

sub get_dt {
    my $self = shift;
    return $self->{dt};
}