mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-01-31 18:59:33 +00:00
3367 lines
111 KiB
Perl
3367 lines
111 KiB
Perl
# $Id$
|
|
##############################################################################
|
|
#
|
|
# 57_Calendar.pm
|
|
# Copyright by Dr. Boris Neubert
|
|
# e-mail: omega at online dot de
|
|
#
|
|
# This file is part of fhem.
|
|
#
|
|
# Fhem is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Fhem is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with fhem. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
|
|
use strict;
|
|
use warnings;
|
|
use HttpUtils;
|
|
|
|
|
|
##############################################
|
|
|
|
package main;
|
|
|
|
no if $] >= 5.017011, warnings => 'experimental::smartmatch';
|
|
|
|
#
|
|
# *** Potential isses:
|
|
#
|
|
# There might be issues when turning to daylight saving time and back that
|
|
# need further investigation. For counterpart please see
|
|
# http://forum.fhem.de/index.php?topic=18707
|
|
# http://forum.fhem.de/index.php?topic=15827
|
|
#
|
|
# *** Potential future extensions:
|
|
#
|
|
# sequence of events fired sorted by time
|
|
# http://forum.fhem.de/index.php?topic=29112
|
|
#
|
|
# document ownCloud ical use
|
|
# http://forum.fhem.de/index.php?topic=28667
|
|
#
|
|
# high load when parsing
|
|
# http://forum.fhem.de/index.php/topic,40783.0.html
|
|
|
|
|
|
=for comment
|
|
|
|
RFC
|
|
---
|
|
|
|
https://tools.ietf.org/html/rfc5545
|
|
|
|
|
|
Data structures
|
|
---------------
|
|
|
|
We call a set of calendar events (short: events) a series, even for sets
|
|
consisting only of a single event. A series may consist of only one single
|
|
event, a series of regularly reccuring events and reccuring events with
|
|
exceptions. A series is identified by a UID.
|
|
|
|
|
|
*** VEVENT record, class ICal::Entry
|
|
|
|
In the iCalendar, a series is represented by one or more VEVENT records.
|
|
|
|
The unique key for a VEVENT record is UID, RECURRENCE-ID (3.8.4.4, p. 112) and
|
|
SEQUENCE (3.8.7.4, p. 138).
|
|
|
|
The internal primary key for a VEVENT is ID.
|
|
|
|
FHEM keeps a set of VEVENT records (record set). When the calendar is updated,
|
|
a new record set is retrieved from the iCalendar and updates the old record set
|
|
to form the resultant record set.
|
|
|
|
A record in the resultant record set can be in exactly one of these states:
|
|
- deleted:
|
|
a record from the old record set for which no record with the same
|
|
(UID, RECURRENCE-ID) was in the new record set.
|
|
- new:
|
|
a record from the new record set for which no record with same
|
|
(UID, RECURRENCE-ID) was in the old record set.
|
|
- changed-old:
|
|
a record from the old record set for which a record with the same
|
|
(UID, RECURRENCE-ID) but different SEQUENCE was in the new record
|
|
set.
|
|
- changed-new:
|
|
a record from the new record set for which a record with the same
|
|
(UID, RECURRENCE-ID) but different SEQUENCE was in the old record
|
|
set.
|
|
- known:
|
|
a record with this (UID, RECURRENCE-ID, SEQUENCE) was both in the
|
|
old and in the new record set and both records have the same
|
|
LAST-MODIFIED. The record from the old record set was
|
|
kept and the record from the new record set was discarded.
|
|
- modified-new:
|
|
a record with this (UID, RECURRENCE-ID, SEQUENCE) was both in the
|
|
old and in the new record set and both records differ in
|
|
LAST-MODIFIED. This is the record from the new record set.
|
|
- modified-old:
|
|
a record with this (UID, RECURRENCE-ID, SEQUENCE) was both in the
|
|
old and in the new record set and both records differ in
|
|
LAST-MODIFIED. This is the record from the old record set.
|
|
|
|
Records in states modified-old and changed-old refer to the corresponding records
|
|
in states modified-new and change-new, and vice versa.
|
|
|
|
Records in state deleted, modified-old or changed-old are removed upon
|
|
the next update. They are said to be "obsolete".
|
|
|
|
A record is said to be "recurring" if it has a RRULE property.
|
|
|
|
A record is said to be an "exception" if it has a RECURRENCE-ID property.
|
|
|
|
Each records has a set of events attached.
|
|
|
|
|
|
|
|
*** calendar event, class Calendar::Event
|
|
|
|
Events are attached to single records (VEVENTs).
|
|
|
|
The uid of the event is the UID of the record with all non-alphanumerical
|
|
characters removed.
|
|
|
|
At a given point in time t, an event is in exactly one of these modes:
|
|
- upcoming:
|
|
the start time of the event is in the future
|
|
- alarm:
|
|
alarm time <= t < start time for any of the alarms for the event
|
|
- start:
|
|
start time <= t <= end time of the event
|
|
- end:
|
|
end time < t
|
|
|
|
An event is said to be "changed", when its mode has changed during the most
|
|
recent run of calendar event processing.
|
|
|
|
An event is said to be "hidden", when
|
|
- it was in mode end and end time of the event < t - horizonPast, or
|
|
- it was in mode upcoming and start time of the event > t + horizonFuture
|
|
at the most recent run of calendar event processing. horizonPast defaults to 0,
|
|
horizonFuture defaults to 366 days.
|
|
|
|
|
|
|
|
Processing of iCalender
|
|
-----------------------
|
|
|
|
*** Initial situation:
|
|
We have an old record set of VEVENTs. It is empty on a restart of FHEM or upon
|
|
issueing the "set ... reload" command.
|
|
|
|
*** Step 1: Retrieval of new record set (Calendar_GetUpdate)
|
|
1) The iCalendar is downloaded from its location into FHEM memory.
|
|
2) It is parsed into a new record set of VEVENTs.
|
|
|
|
*** Step 2: Update of internal record set (Calendar_UpdateCalendar)
|
|
1) All records in the old record set that are in state deleted or obsolete are
|
|
removed.
|
|
2) All states of all records in the old record set are set to blank.
|
|
3) The old and new record sets are merged to create a resultant record set
|
|
according to the following procedure:
|
|
|
|
If the new record set contains a record with the same (UID, RECURRENCE-ID,
|
|
SEQUENCE) as a record in the old record set:
|
|
- if the two records differ in LAST-MODIFIED, then both records
|
|
are kept. The state of the record from the old record set is set to
|
|
modified-old, the state of the record from the new record set is set to
|
|
modified-new.
|
|
- else the record from the old record set is kept, state set to known, and the
|
|
record from the new record set is discarded.
|
|
|
|
If the new record set contains a record with the same (UID, RECURRENCE-ID) but
|
|
different SEQUENCE as a record in the old record set, then both records are
|
|
kept. The state of the record from the new record set is set to changed-new,
|
|
and the state of record from the old record set is set to changed-old.
|
|
|
|
If the new record set contains a record that differs from any record in the old
|
|
record set by both UID and RECURRENCE-ID, the record from the new record set
|
|
id added to the resultant record set and its state is set to new.
|
|
|
|
4) The state of all records in the old record set that have not been touched
|
|
in 3) are set to deleted.
|
|
|
|
Notes:
|
|
- This procedure favors records from the new record set over records from the
|
|
old record set, even if the SEQUENCE is lower or LAST-MODIFIED is earlier.
|
|
- DTSTAMP is the time stamp of the creation of the iCalendar entry. For Google
|
|
Calendar it is the time stamp of the latest retrieval of the calendar.
|
|
|
|
|
|
*** Step 3: Update of calendar events (Calendar_UpdateCalendar)
|
|
We walk over all records and treat the corresponding events according to
|
|
the state of the record:
|
|
|
|
- deleted, changed-old, modified-old:
|
|
all events are removed
|
|
- new, changed-new, modified-new:
|
|
all events are removed and events are created anew
|
|
- known:
|
|
all events are left alone
|
|
|
|
No events older than 400 days or more than 400 days in the future will be
|
|
created.
|
|
|
|
Creation of events in a series works as follows:
|
|
|
|
If we have several events in a series, the main series has the RRULE tag and
|
|
the exceptions have RECURRENCE-IDs. The RECURRENCE-ID match the start
|
|
dates in the series created from the RRULE that need to be exempted. We
|
|
therefore collect all events from records with same UID and RECURRENCE-ID set
|
|
as they form the list of records with the exceptions for the UID.
|
|
|
|
Before the regular creation is done, events for RDATEs are added as long as
|
|
an RDATE is not superseded by an EXDATE. An RDATE takes precedence over a
|
|
regularly created recurring event.
|
|
|
|
Starting with the start date of the series, one event is created after the
|
|
other. Creation stops when the series ends or when an event more than 400 days
|
|
in the future has been created. If the event is in the list of exceptions
|
|
(either defined by other events with same UID and a RECURRENCE-ID or by the
|
|
EXDATE property), it is not added.
|
|
|
|
What attributes are recognized and which of these are honored or ignored?
|
|
|
|
The following frequencies (FREQ) are recognized and honored:
|
|
SECONDLY
|
|
MINUTELY
|
|
HOURLY
|
|
DAILY
|
|
WEEKLY
|
|
BYDAY: recognizes and honors one or several weekdays without prefix (e.g. -1SU, 2MO)
|
|
MONTHLY
|
|
BYDAY: recognizes and honors one or several weekdays with and without prefix (e.g. -1SU, 2MO)
|
|
BYMONTHDAY: recognized but ignored
|
|
BYMONTH: recognized but ignored
|
|
YEARLY
|
|
|
|
For all of the above:
|
|
INTERVAL: recognized and honored
|
|
UNTIL: recognized and honored
|
|
COUNT: recognized and honored
|
|
WKST: recognized but ignored
|
|
EXDATE: recognized and honored
|
|
RDATE: recognized and honored
|
|
|
|
*** Step 4: The device readings related to updates are set
|
|
|
|
- calname
|
|
- lastUpdate
|
|
- nextUpdate
|
|
- nextWakeup
|
|
- state
|
|
|
|
|
|
Note: the state... readings from the previous version of this module (2015 and
|
|
earlier) are not available any more.
|
|
|
|
|
|
|
|
Processing of calendar events
|
|
-----------------------------
|
|
Calendar_CheckTimes
|
|
|
|
In case of a series of calendar events, several calendar events may exist for
|
|
the same uid which may be in different modes. Therefore only the most
|
|
interesting mode is chosen over any other mode of any calendar event with
|
|
the same uid. The most interesting mode is the first applicable from the
|
|
following list:
|
|
- start
|
|
- alarm
|
|
- upcoming
|
|
- end
|
|
|
|
Apart from these actual modes, virtual modes apply:
|
|
- changed: the actual mode has changed during this call of Calendar_CheckTimes
|
|
- alarmed: modes are alarm and changed
|
|
- started: modes are start and changed
|
|
- ended: modes are end and changed
|
|
- alarm or start: mode is alarm or start
|
|
|
|
If the mode has changed to <mode>, the following FHEM events are created:
|
|
changed uid <mode>
|
|
<mode> uid
|
|
|
|
Note: there is no colon in these FHEM events.
|
|
|
|
|
|
Program flow
|
|
------------
|
|
|
|
Calendar_Initialize sets the Calendar_Notify to watch for notifications.
|
|
Calendar_Notify acts on the INITIALIZED and REREADCFG events by starting the
|
|
timer to call Calendar_Wakeup between 10 and 29 seconds after the
|
|
notification.
|
|
Calendar_Wakeup starts a processing run.
|
|
It sets the current time t as baseline for process.
|
|
If the time for the next update has been reached,
|
|
Calendar_GetUpdate is called
|
|
else
|
|
Calendar_CheckTimes
|
|
Calendar_RearmTimer
|
|
are called.
|
|
Calendar_GetUpdate retrieves the iCal file. If the source is url, this is
|
|
done asynchronously. Upon successfull retrieval of the iCal file, we
|
|
continue with Calendar_ProcessUpdate.
|
|
Calendar_ProcessUpdate calls
|
|
Calendar_UpdateCalendar
|
|
Calendar_CheckTimes
|
|
Calendar_RearmTimer
|
|
in sequence.
|
|
Calendar_UpdateCalendar updates the VEVENT records in the
|
|
$hash->{".fhem"}{vevents} hash and creates the associated calendar events.
|
|
Calendar_CheckTimes checks for a mode change of the calendar events and
|
|
creates the readings and FHEM events.
|
|
Calendar_RearmTimer sets the timer to call Calendar_Wakeup to time of the
|
|
next mode change or update, whatever comes earlier.
|
|
|
|
|
|
What's new?
|
|
-----------
|
|
This module version replaces the 2015 version that has been widely. Noteworthy
|
|
changes
|
|
- No more state... readings; "all" reading has been removed as well.
|
|
- The mode... readings (modeAlarm, modeAlarmOrStart, etc.) are deprecated
|
|
and will be removed in a future version. Use the mode=<regex> filter instead.
|
|
- Handles recurring calendar events with out-of-order events and exceptions
|
|
(EXDATE).
|
|
- Keeps ALL calendar events within plus/minus 400 days from the date of the
|
|
in FHEM: this means that you can have more than one calendar event with the
|
|
same UID.
|
|
- You can restrict visible calendar events with attributes hideLaterThan,
|
|
hideOlderThan.
|
|
- Nonblocking retrieval of calendar from URL.
|
|
- New get commands:
|
|
get <name> vevents
|
|
get <name> vcalendar
|
|
get <name> <format> <mode>
|
|
get <name> <format> mode=<regex>
|
|
get <name> <format> uid=<regex>
|
|
- The get commands
|
|
get <name> <format> ...
|
|
may not work as before since several calendar events may exist for a
|
|
single UID, particularly the get command
|
|
get <name> <format> all
|
|
show all calendar events from a series (past, current, and future); you
|
|
probably want to replace "all" by "next":
|
|
get <name> <format> next
|
|
to get only the first (not past but current or future) calendar event from
|
|
each series.
|
|
- Migration hints:
|
|
|
|
Replace
|
|
get <name> <format> all
|
|
by
|
|
get <name> <format> next
|
|
|
|
Replace
|
|
get <name> <format> <uid>
|
|
by
|
|
get <name> <format> uid=<uid> 1
|
|
|
|
Replace
|
|
get <name> <format> modeAlarmOrStart
|
|
by
|
|
get <name> <format> mode=alarm|start
|
|
|
|
- The FHEM events created for mode changes of single calendar events have been
|
|
amended:
|
|
changed: UID <mode>
|
|
<mode>: UID (this is new)
|
|
<mode> is the current mode of the calendar event after the change. It is
|
|
highly advisable to trigger actions based on these FHEM events instead of
|
|
notifications for changes of the mode... readings.
|
|
|
|
=cut
|
|
|
|
#####################################
|
|
#
|
|
# Event
|
|
#
|
|
#####################################
|
|
|
|
package Calendar::Event;
|
|
|
|
sub new {
|
|
my $class= shift;
|
|
my $self= {}; # I am a hash
|
|
bless $self, $class;
|
|
$self->{_previousMode}= "undefined";
|
|
$self->{_mode}= "undefined";
|
|
return($self);
|
|
}
|
|
|
|
sub uid {
|
|
my ($self)= @_;
|
|
return $self->{uid};
|
|
}
|
|
|
|
sub start {
|
|
my ($self)= @_;
|
|
return $self->{start};
|
|
}
|
|
|
|
sub end {
|
|
my ($self)= @_;
|
|
return $self->{end};
|
|
}
|
|
|
|
sub setNote($$) {
|
|
my ($self,$note)= @_;
|
|
$self->{_note}= $note;
|
|
return $note;
|
|
}
|
|
|
|
sub getNote($) {
|
|
my ($self)= @_;
|
|
return $self->{_note};
|
|
}
|
|
|
|
sub hasNote($) {
|
|
my ($self)= @_;
|
|
return defined($self->{_note}) ? 1 : 0;
|
|
}
|
|
|
|
|
|
sub setMode {
|
|
my ($self,$mode)= @_;
|
|
$self->{_previousMode}= $self->{_mode};
|
|
$self->{_mode}= $mode;
|
|
#main::Debug "After setMode $mode: Modes(" . $self->uid() . ") " . $self->{_previousMode} . " -> " . $self->{_mode};
|
|
return $mode;
|
|
}
|
|
|
|
sub setModeUnchanged {
|
|
my ($self)= @_;
|
|
$self->{_previousMode}= $self->{_mode};
|
|
}
|
|
|
|
sub getMode {
|
|
my ($self)= @_;
|
|
return $self->{_mode};
|
|
}
|
|
|
|
sub lastModified {
|
|
my ($self)= @_;
|
|
return $self->{lastModified};
|
|
}
|
|
|
|
sub modeChanged {
|
|
my ($self)= @_;
|
|
return (($self->{_mode} ne $self->{_previousMode}) and
|
|
($self->{_previousMode} ne "undefined")) ? 1 : 0;
|
|
}
|
|
|
|
|
|
sub summary {
|
|
my ($self)= @_;
|
|
return $self->{summary};
|
|
}
|
|
|
|
sub location {
|
|
my ($self)= @_;
|
|
return $self->{location};
|
|
}
|
|
|
|
sub description {
|
|
my ($self)= @_;
|
|
return $self->{description};
|
|
}
|
|
|
|
sub ts($$) {
|
|
my ($self,$tm)= @_;
|
|
return "" unless($tm);
|
|
my ($second,$minute,$hour,$day,$month,$year,$wday,$yday,$isdst)= localtime($tm);
|
|
return sprintf("%02d.%02d.%4d %02d:%02d:%02d", $day,$month+1,$year+1900,$hour,$minute,$second);
|
|
}
|
|
|
|
sub ts0($$) {
|
|
my ($self,$tm)= @_;
|
|
return "" unless($tm);
|
|
my ($second,$minute,$hour,$day,$month,$year,$wday,$yday,$isdst)= localtime($tm);
|
|
return sprintf("%02d.%02d.%2d %02d:%02d", $day,$month+1,$year-100,$hour,$minute);
|
|
}
|
|
|
|
sub asText {
|
|
my ($self)= @_;
|
|
return sprintf("%s %s",
|
|
$self->ts0($self->{start}),
|
|
$self->{summary}
|
|
);
|
|
}
|
|
|
|
sub asFull {
|
|
my ($self)= @_;
|
|
return sprintf("%s %9s %s %s-%s %s %s",
|
|
$self->uid(),
|
|
$self->getMode(),
|
|
$self->{alarm} ? $self->ts($self->{alarm}) : " ",
|
|
$self->ts($self->{start}),
|
|
$self->ts($self->{end}),
|
|
$self->{summary},
|
|
$self->{location}
|
|
);
|
|
}
|
|
|
|
sub asDebug {
|
|
my ($self)= @_;
|
|
return sprintf("%s %s %9s %s %s-%s %s %s %s",
|
|
$self->uid(),
|
|
$self->modeChanged() ? "*" : " ",
|
|
$self->getMode(),
|
|
$self->{alarm} ? $self->ts($self->{alarm}) : " ",
|
|
$self->ts($self->{start}),
|
|
$self->ts($self->{end}),
|
|
$self->{summary},
|
|
$self->{location},
|
|
$self->hasNote() ? $self->getNote() : ""
|
|
);
|
|
}
|
|
|
|
|
|
sub alarmTime {
|
|
my ($self)= @_;
|
|
return $self->ts($self->{alarm});
|
|
}
|
|
|
|
sub startTime {
|
|
my ($self)= @_;
|
|
return $self->ts($self->{start});
|
|
}
|
|
|
|
sub endTime {
|
|
my ($self)= @_;
|
|
return $self->ts($self->{end});
|
|
}
|
|
|
|
|
|
# returns 1 if time is before alarm time and before start time, else 0
|
|
sub isUpcoming {
|
|
my ($self,$t) = @_;
|
|
if($self->{alarm}) {
|
|
return $t< $self->{alarm} ? 1 : 0;
|
|
} else {
|
|
return $t< $self->{start} ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
# returns 1 if time is between alarm time and start time, else 0
|
|
sub isAlarmed {
|
|
my ($self,$t) = @_;
|
|
return $self->{alarm} ?
|
|
(($self->{alarm}<= $t && $t< $self->{start}) ? 1 : 0) : 0;
|
|
}
|
|
|
|
# return 1 if time is between start time and end time, else 0
|
|
sub isStarted {
|
|
my ($self,$t) = @_;
|
|
return 0 unless(defined($self->{start}));
|
|
return 0 if($t < $self->{start});
|
|
if(defined($self->{end})) {
|
|
return 0 if($t>= $self->{end});
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
sub isSeries {
|
|
my ($self)= @_;
|
|
#main::Debug " freq= " . $self->{freq};
|
|
return exists($self->{freq}) ? 1 : 0;
|
|
}
|
|
|
|
sub isAfterSeriesEnded {
|
|
my ($self,$t) = @_;
|
|
#main::Debug " isSeries? " . $self->isSeries();
|
|
return 0 unless($self->isSeries());
|
|
#main::Debug " until= " . $self->{until};
|
|
return 0 unless(exists($self->{until}));
|
|
#main::Debug " has until!";
|
|
return $self->{until}< $t ? 1 : 0;
|
|
}
|
|
|
|
sub isEnded {
|
|
my ($self,$t) = @_;
|
|
#main::Debug "isEnded for " . $self->asFull();
|
|
#main::Debug " isAfterSeriesEnded? " . $self->isAfterSeriesEnded($t);
|
|
#return 1 if($self->isAfterSeriesEnded($t));
|
|
#main::Debug " has end? " . (defined($self->{end}) ? 1 : 0);
|
|
return 0 unless(defined($self->{end}));
|
|
return $self->{end}<= $t ? 1 : 0;
|
|
}
|
|
|
|
sub nextTime {
|
|
my ($self,$t) = @_;
|
|
my @times= ( );
|
|
push @times, $self->{start} if(defined($self->{start}));
|
|
push @times, $self->{end} if(defined($self->{end}));
|
|
unshift @times, $self->{alarm} if($self->{alarm});
|
|
@times= sort grep { $_ > $t } @times;
|
|
|
|
# main::Debug "Calendar: " . $self->asFull();
|
|
# main::Debug "Calendar: Start " . main::FmtDateTime($self->{start});
|
|
# main::Debug "Calendar: End " . main::FmtDateTime($self->{end});
|
|
# main::Debug "Calendar: Alarm " . main::FmtDateTime($self->{alarm}) if($self->{alarm});
|
|
# main::Debug "Calendar: times[0] " . main::FmtDateTime($times[0]);
|
|
# main::Debug "Calendar: times[1] " . main::FmtDateTime($times[1]);
|
|
# main::Debug "Calendar: times[2] " . main::FmtDateTime($times[2]);
|
|
|
|
if(@times) {
|
|
return $times[0];
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
#####################################
|
|
#
|
|
# Events
|
|
#
|
|
#####################################
|
|
|
|
package Calendar::Events;
|
|
|
|
sub new {
|
|
my $class= shift;
|
|
my $self= []; # I am an array
|
|
bless $self, $class;
|
|
return($self);
|
|
}
|
|
|
|
sub addEvent($$) {
|
|
my ($self,$event)= @_;
|
|
return push @{$self}, $event;
|
|
}
|
|
|
|
sub clear($) {
|
|
my ($self)= @_;
|
|
return @{$self}= ();
|
|
}
|
|
|
|
#####################################
|
|
#
|
|
# ICal
|
|
# the ical format is governed by RFC2445 http://www.ietf.org/rfc/rfc2445.txt
|
|
#
|
|
#####################################
|
|
|
|
package ICal::Entry;
|
|
|
|
sub getNextMonthlyDateByDay($$$);
|
|
|
|
sub new($$) {
|
|
my $class= shift;
|
|
my ($type)= @_;
|
|
#main::Debug "new ICal::Entry $type";
|
|
my $self= {};
|
|
bless $self, $class;
|
|
$self->{type}= $type;
|
|
#$self->clearState(); set here:
|
|
$self->{state}= "<none>";
|
|
#$self->clearCounterpart(); unnecessary
|
|
#$self->clearReferences(); set here:
|
|
$self->{references}= [];
|
|
#$self->clearTags(); unnecessary
|
|
$self->{entries}= []; # array of subordinated ICal::Entry
|
|
$self->{events}= Calendar::Events->new();
|
|
$self->{skippedEvents}= Calendar::Events->new();
|
|
return($self);
|
|
}
|
|
|
|
#
|
|
# keys, properties, values
|
|
#
|
|
|
|
# is key a repeated property?
|
|
sub isMultiple($$) {
|
|
my ($self,$key)= @_;
|
|
return $self->{properties}{$key}{multiple};
|
|
}
|
|
|
|
# has a property named key?
|
|
sub hasKey($$) {
|
|
my ($self,$key)= @_;
|
|
return exists($self->{properties}{$key}) ? 1 : 0;
|
|
}
|
|
|
|
# value for single property key
|
|
sub value($$) {
|
|
my ($self,$key)= @_;
|
|
return undef if($self->isMultiple($key));
|
|
return $self->{properties}{$key}{VALUE};
|
|
}
|
|
|
|
# value for property key or default, if non-existant
|
|
sub valueOrDefault($$$) {
|
|
my ($self,$key,$default)= @_;
|
|
return $self->hasKey($key) ? $self->value($key) : $default;
|
|
}
|
|
|
|
# value for multiple property key (array counterpart)
|
|
sub values($$) {
|
|
my ($self,$key)= @_;
|
|
return undef unless($self->isMultiple($key));
|
|
return $self->{properties}{$key}{VALUES};
|
|
}
|
|
|
|
# true, if the property exists at both entries and have the same value
|
|
# or neither entry has this property
|
|
sub sameValue($$$) {
|
|
my ($self,$other,$key)= @_;
|
|
my $value1= $self->hasKey($key) ? $self->value($key) : "";
|
|
my $value2= $other->hasKey($key) ? $other->value($key) : "";
|
|
return $value1 eq $value2;
|
|
}
|
|
|
|
sub parts($$) {
|
|
my ($self,$key)= @_;
|
|
return split(";", $self->{properties}{$key}{PARTS});
|
|
}
|
|
|
|
#
|
|
# state
|
|
#
|
|
sub setState {
|
|
my ($self,$state)= @_;
|
|
$self->{state}= $state;
|
|
return $state;
|
|
}
|
|
|
|
sub clearState {
|
|
my ($self)= @_;
|
|
$self->{state}= "<none>";
|
|
}
|
|
|
|
sub state($) {
|
|
my($self)= @_;
|
|
return $self->{state};
|
|
}
|
|
|
|
sub inState($$) {
|
|
my($self, $state)= @_;
|
|
return ($self->{state} eq $state ? 1 : 0);
|
|
}
|
|
|
|
sub isObsolete($) {
|
|
my($self)= @_;
|
|
# VEVENT records in these states are obsolete
|
|
my @statesObsolete= qw/deleted changed-old modified-old/;
|
|
return $self->state() ~~ @statesObsolete ? 1 : 0;
|
|
}
|
|
|
|
sub hasChanged($) {
|
|
my($self)= @_;
|
|
# VEVENT records in these states have changed
|
|
my @statesChanged= qw/new changed-new modified-new/;
|
|
return $self->state() ~~ @statesChanged ? 1 : 0;
|
|
}
|
|
|
|
#
|
|
# type
|
|
#
|
|
sub type($) {
|
|
my($self)= @_;
|
|
return $self->{type};
|
|
}
|
|
|
|
#
|
|
# counterpart, for changed or modified records
|
|
#
|
|
sub counterpart($) {
|
|
my($self)= @_;
|
|
return $self->{counterpart};
|
|
}
|
|
|
|
sub setCounterpart($$) {
|
|
my ($self, $id)= @_;
|
|
$self->{counterpart}= $id;
|
|
return $id;
|
|
}
|
|
|
|
sub hasCounterpart($) {
|
|
my($self)= @_;
|
|
return (defined($self->{counterpart}) ? 1 : 0);
|
|
}
|
|
|
|
sub clearCounterpart($) {
|
|
my($self)= @_;
|
|
delete $self->{counterpart} if(defined($self->{counterpart}));
|
|
}
|
|
|
|
#
|
|
# series
|
|
#
|
|
sub isRecurring($) {
|
|
my($self)= @_;
|
|
return $self->hasKey("RRULE");
|
|
}
|
|
|
|
sub isException($) {
|
|
my($self)= @_;
|
|
return $self->hasKey("RECURRENCE-ID");
|
|
}
|
|
|
|
|
|
sub hasReferences($) {
|
|
my($self)= @_;
|
|
return scalar(@{$self->references()});
|
|
}
|
|
|
|
sub references($) {
|
|
my($self)= @_;
|
|
return $self->{references};
|
|
}
|
|
|
|
sub clearReferences($) {
|
|
my($self)= @_;
|
|
$self->{references}= [];
|
|
}
|
|
|
|
#
|
|
# tags
|
|
#
|
|
|
|
# sub tags($) {
|
|
# my($self)= @_;
|
|
# return $self->{tags};
|
|
# }
|
|
#
|
|
# sub clearTags($) {
|
|
# my($self)= @_;
|
|
# $self->{tags}= [];
|
|
# }
|
|
#
|
|
# sub tagAs($$) {
|
|
# my ($self, $tag)= @_;
|
|
# push @{$self->{tags}}, $tag unless($self->isTaggedAs($tag));
|
|
# }
|
|
#
|
|
# sub isTaggedAs($$) {
|
|
# my ($self, $tag)= @_;
|
|
# return grep { $_ eq $tag } @{$self->{tags}} ? 1 : 0;
|
|
# }
|
|
#
|
|
# sub numTags($) {
|
|
# my ($self)= @_;
|
|
# return scalar @{$self->{tags}};
|
|
# }
|
|
|
|
|
|
#
|
|
# parsing
|
|
#
|
|
|
|
sub addproperty($$) {
|
|
my ($self,$line)= @_;
|
|
# contentline = name *(";" param ) ":" value CRLF [Page 13]
|
|
# example:
|
|
# TRIGGER;VALUE=DATE-TIME:20120531T150000Z
|
|
#main::Debug "line=\'$line\'";
|
|
# for DTSTART, DTEND there are several variants:
|
|
# DTSTART;TZID=Europe/Berlin:20140205T183600
|
|
# * DTSTART;TZID="(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna":20140904T180000
|
|
# DTSTART:20140211T212000Z
|
|
# DTSTART;VALUE=DATE:20130619
|
|
my ($key,$parts,$parameter);
|
|
if($line =~ /^([\w\d\-]+)(;(.*))?:(.*)$/) {
|
|
$key= $1;
|
|
$parts= defined($3) ? $3 : "";
|
|
$parameter= defined($4) ? $4 : "";
|
|
} else {
|
|
return;
|
|
}
|
|
return unless($key);
|
|
|
|
# ignore some properties
|
|
my @ignores= qw(TRANSP STATUS ATTENDEE);
|
|
return if($key ~~ @ignores);
|
|
return if($key =~ /^X-/);
|
|
|
|
if(($key eq "EXDATE") or ($key eq "RDATE")) {
|
|
# handle multiple properties
|
|
my @values;
|
|
@values= @{$self->values($key)} if($self->hasKey($key));
|
|
push @values, $parameter;
|
|
$self->{properties}{$key}= {
|
|
multiple => 1,
|
|
VALUES => \@values,
|
|
}
|
|
} else {
|
|
# handle single properties
|
|
$self->{properties}{$key}= {
|
|
multiple => 0,
|
|
PARTS => "$parts",
|
|
VALUE => "$parameter",
|
|
}
|
|
};
|
|
}
|
|
|
|
sub parse($$) {
|
|
my ($self,@ical)= @_;
|
|
return $self->parseSub(0, @ical);
|
|
}
|
|
|
|
sub parseSub($$$) {
|
|
my ($self,$ln,@ical)= @_;
|
|
#main::Debug "ENTER @ $ln";
|
|
while($ln<$#ical) {
|
|
my $line= $ical[$ln];
|
|
chomp $line;
|
|
$line =~ s/[\x0D]$//; # chomp will not remove the CR
|
|
$ln++;
|
|
# check for and handle continuation lines (4.1 on page 12)
|
|
while($ln<$#ical) {
|
|
my $line1= $ical[$ln];
|
|
last unless($line1 =~ /^\s(.*)/);
|
|
$line.= $1;
|
|
chomp $line;
|
|
$line =~ s/[\x0D]$//; # chomp will not remove the CR
|
|
$ln++;
|
|
};
|
|
#main::Debug "$ln: $line";
|
|
next if($line eq ""); # ignore empty line
|
|
last if($line =~ m/^END:.*$/);
|
|
if($line =~ m/^BEGIN:(.*)$/) {
|
|
my $entry= ICal::Entry->new($1);
|
|
$entry->{ln}= $ln;
|
|
push @{$self->{entries}}, $entry;
|
|
$ln= $entry->parseSub($ln,@ical);
|
|
} else {
|
|
$self->addproperty($line);
|
|
}
|
|
}
|
|
#main::Debug "BACK";
|
|
return $ln;
|
|
}
|
|
|
|
#
|
|
# events
|
|
#
|
|
sub events($) {
|
|
my ($self)= @_;
|
|
return $self->{events};
|
|
}
|
|
|
|
sub clearEvents($) {
|
|
my ($self)= @_;
|
|
$self->{events}->clear();
|
|
}
|
|
|
|
sub numEvents($) {
|
|
my ($self)= @_;
|
|
return scalar(@{$self->{events}});
|
|
}
|
|
|
|
sub addEvent($$) {
|
|
my ($self, $event)= @_;
|
|
$self->{events}->addEvent($event);
|
|
}
|
|
|
|
sub skippedEvents($) {
|
|
my ($self)= @_;
|
|
return $self->{skippedEvents};
|
|
}
|
|
|
|
sub clearSkippedEvents($) {
|
|
my ($self)= @_;
|
|
$self->{skippedEvents}->clear();
|
|
}
|
|
|
|
sub numSkippedEvents($) {
|
|
my ($self)= @_;
|
|
return scalar(@{$self->{skippedEvents}});
|
|
}
|
|
|
|
sub addSkippedEvent($$) {
|
|
my ($self, $event)= @_;
|
|
$self->{skippedEvents}->addEvent($event);
|
|
}
|
|
|
|
|
|
|
|
sub createEvent($) {
|
|
my ($self)= @_;
|
|
|
|
my $event= Calendar::Event->new();
|
|
|
|
$event->{uid}= $self->value("UID");
|
|
$event->{uid}=~ s/\W//g; # remove all non-alphanumeric characters, this makes life easier for perl specials
|
|
|
|
return $event;
|
|
}
|
|
|
|
|
|
# converts a date/time string to the number of non-leap seconds since the epoch
|
|
# 20120520T185202Z: date/time string in ISO8601 format, time zone GMT
|
|
# 20121129T222200: date/time string in ISO8601 format, time zone local
|
|
# 20120520: a date string has no time zone associated
|
|
sub tm($$) {
|
|
my ($self, $t)= @_;
|
|
return undef if(!$t);
|
|
#main::Debug "convert >$t<";
|
|
my ($year,$month,$day)= (substr($t,0,4), substr($t,4,2),substr($t,6,2));
|
|
if(length($t)>8) {
|
|
my ($hour,$minute,$second)= (substr($t,9,2), substr($t,11,2),substr($t,13,2));
|
|
my $z;
|
|
$z= substr($t,15,1) if(length($t) == 16);
|
|
#main::Debug "$day.$month.$year $hour:$minute:$second $z";
|
|
if($z) {
|
|
return main::fhemTimeGm($second,$minute,$hour,$day,$month-1,$year-1900);
|
|
} else {
|
|
return main::fhemTimeLocal($second,$minute,$hour,$day,$month-1,$year-1900);
|
|
}
|
|
} else {
|
|
#main::Debug "$day.$month.$year";
|
|
return main::fhemTimeLocal(0,0,0,$day,$month-1,$year-1900);
|
|
}
|
|
}
|
|
|
|
# DURATION RFC2445
|
|
# dur-value = (["+"] / "-") "P" (dur-date / dur-time / dur-week)
|
|
#
|
|
# dur-date = dur-day [dur-time]
|
|
# dur-time = "T" (dur-hour / dur-minute / dur-second)
|
|
# dur-week = 1*DIGIT "W"
|
|
# dur-hour = 1*DIGIT "H" [dur-minute]
|
|
# dur-minute = 1*DIGIT "M" [dur-second]
|
|
# dur-second = 1*DIGIT "S"
|
|
# dur-day = 1*DIGIT "D"
|
|
#
|
|
# example: -P0DT0H30M0S
|
|
sub d($$) {
|
|
my ($self, $d)= @_;
|
|
|
|
#main::Debug "Duration $d";
|
|
|
|
my $sign= 1;
|
|
my $t= 0;
|
|
|
|
my @c= split("P", $d);
|
|
$sign= -1 if($c[0] eq "-");
|
|
my ($dw,$dt)= split("T", $c[1]);
|
|
$dt="" unless defined($dt);
|
|
if($dw =~ m/(\d+)D$/) {
|
|
$t+= 86400*$1; # days
|
|
} elsif($dw =~ m/(\d+)W$/) {
|
|
$t+= 604800*$1; # weeks
|
|
}
|
|
if($dt =~ m/(\d+)H/) {
|
|
$t+= $1*3600;
|
|
}
|
|
if($dt =~ m/(\d+)M/) {
|
|
$t+= $1*60;
|
|
}
|
|
if($dt =~ m/(\d+)S/) {
|
|
$t+= $1;
|
|
}
|
|
$t*= $sign;
|
|
#main::Debug "sign: $sign dw: $dw dt: $dt t= $t";
|
|
return $t;
|
|
}
|
|
|
|
sub dt($$$$) {
|
|
my ($self,$t0,$value,$parts)= @_;
|
|
#main::Debug "t0= $t0 parts= $parts value= $value";
|
|
if(defined($parts) && $parts =~ m/VALUE=DATE/) {
|
|
return $self->tm($value);
|
|
} else {
|
|
return $t0+$self->d($value);
|
|
}
|
|
}
|
|
|
|
|
|
sub makeEventDetails($$) {
|
|
my ($self, $event)= @_;
|
|
|
|
$event->{summary}= $self->valueOrDefault("SUMMARY", "");
|
|
$event->{location}= $self->valueOrDefault("LOCATION", "");
|
|
$event->{description}= $self->valueOrDefault("DESCRIPTION", "");
|
|
|
|
return $event;
|
|
}
|
|
|
|
sub makeEventAlarms($$) {
|
|
my ($self, $event)= @_;
|
|
|
|
# alarms
|
|
my @valarms= grep { $_->{type} eq "VALARM" } @{$self->{entries}};
|
|
my @alarmtimes= sort map { $self->dt($event->{start}, $_->value("TRIGGER"), $_->parts("TRIGGER")) } @valarms;
|
|
if(@alarmtimes) {
|
|
$event->{alarm}= $alarmtimes[0];
|
|
} else {
|
|
$event->{alarm}= undef;
|
|
}
|
|
|
|
return $event;
|
|
}
|
|
|
|
|
|
sub DSTOffset($$) {
|
|
my ($t1,$t2)= @_;
|
|
|
|
my @lt1 = localtime($t1);
|
|
my @lt2 = localtime($t2);
|
|
|
|
return 3600 *($lt1[8] - $lt2[8]);
|
|
}
|
|
|
|
# This function adds $n times $seconds to $t1 (seconds from the epoch).
|
|
# A correction of 3600 seconds (one hour) is applied if and only if
|
|
# one of $t1 and $t1+$n*$seconds falls into wintertime and the other
|
|
# into summertime. Thus, e.g., adding a multiple of 24*60*60 seconds
|
|
# to 5 o'clock always gives 5 o'clock and not 4 o'clock or 6 o'clock
|
|
# upon a change of summertime to wintertime or vice versa.
|
|
|
|
sub plusNSeconds($$$) {
|
|
my ($t1, $seconds, $n)= @_;
|
|
$n= 1 unless defined($n);
|
|
my $t2= $t1+$n*$seconds;
|
|
return $t2+DSTOffset($t1,$t2);
|
|
}
|
|
|
|
sub plusNMonths($$) {
|
|
my ($tm, $n)= @_;
|
|
my ($second,$minute,$hour,$day,$month,$year,$wday,$yday,$isdst)= localtime($tm);
|
|
#main::Debug "Adding $n months to $day.$month.$year $hour:$minute:$second= " . ts($tm);
|
|
$month+= $n;
|
|
$year+= int($month / 12);
|
|
$month %= 12;
|
|
#main::Debug " gives $day.$month.$year $hour:$minute:$second= " . ts(main::fhemTimeLocal($second,$minute,$hour,$day,$month,$year));
|
|
return main::fhemTimeLocal($second,$minute,$hour,$day,$month,$year);
|
|
}
|
|
|
|
# This function gets the next date according to interval and byDate
|
|
# Alex, 2016-11-24
|
|
# 1. parameter: startTime
|
|
# 2. parameter: interval (months)
|
|
# 3. parameter: byDay (string with byDay-value(s), e.g. "FR" or "4SA" or "-1SU" or "4SA,4SU" (not sure if this is possible, i just take the first byDay))
|
|
sub getNextMonthlyDateByDay($$$) {
|
|
my ( $ipTimeLocal, $ipByDays, $ipInterval )= @_;
|
|
|
|
my ($lSecond, $lMinute, $lHour, $lDay, $lMonth, $lYear, $lWday, $lYday, $lIsdst )= localtime( $ipTimeLocal );
|
|
|
|
#main::Debug "getNextMonthlyDateByDay($ipTimeLocal, $ipByDays, $ipInterval)";
|
|
|
|
my @lByDays = split(",", $ipByDays);
|
|
my $lByDay = $lByDays[0]; #only get first day element within string
|
|
my $lByDayLength = length( $lByDay );
|
|
|
|
my $lDayStr; # which day to set the date
|
|
my $lDayInterval; # e.g. 2 = 2nd $lDayStr of month or -1 = last $lDayStr of month
|
|
if ( $lByDayLength > 2 ) {
|
|
$lDayStr= substr( $lByDay, -2 );
|
|
$lDayInterval= int( substr( $lByDay, 0, $lByDayLength - 2 ) );
|
|
} else {
|
|
$lDayStr= $lByDay;
|
|
$lDayInterval= 1;
|
|
}
|
|
|
|
my @weekdays = qw(SU MO TU WE TH FR SA);
|
|
my ($lDayOfWeek)= grep { $weekdays[$_] eq $lDayStr } 0..$#weekdays;
|
|
|
|
# get next day from beginning of the month, e.g. "4FR" = 4th friday of the month
|
|
my $lNextMonth;
|
|
my $lNextYear;
|
|
my $lDayOfWeekNew;
|
|
my $lDaysToAddOrSub;
|
|
my $lNewTime;
|
|
if ( $lDayInterval > 0 ) {
|
|
#get next month and year according to $ipInterval
|
|
$lNextMonth= $lMonth + $ipInterval;
|
|
$lNextYear= $lYear;
|
|
$lNextYear += int( $lNextMonth / 12);
|
|
$lNextMonth %= 12;
|
|
|
|
my $lFirstOfNextMonth = main::fhemTimeLocal( $lSecond, $lMinute, $lHour, 1, $lNextMonth, $lNextYear );
|
|
($lSecond, $lMinute, $lHour, $lDay, $lMonth, $lYear, $lDayOfWeekNew, $lYday, $lIsdst )= localtime( $lFirstOfNextMonth );
|
|
|
|
if ( $lDayOfWeekNew <= $lDayOfWeek ) {
|
|
$lDaysToAddOrSub = $lDayOfWeek - $lDayOfWeekNew;
|
|
} else {
|
|
$lDaysToAddOrSub = 7 - $lDayOfWeekNew + $lDayOfWeek;
|
|
}
|
|
$lDaysToAddOrSub += ( 7 * ( $lDayInterval - 1 ) ); #add day interval, e.g. 4th friday...
|
|
|
|
$lNewTime = plusNSeconds( $lFirstOfNextMonth, 24*60*60*$lDaysToAddOrSub, 1);
|
|
($lSecond, $lMinute, $lHour, $lDay, $lMonth, $lYear, $lWday, $lYday, $lIsdst )= localtime( $lNewTime );
|
|
if ( $lMonth ne $lNextMonth ) { #skip this date and move on to the next interval...
|
|
$lNewTime = getNextMonthlyDateByDay( $lFirstOfNextMonth, $ipByDays, $ipInterval );
|
|
}
|
|
} else { #calculate date from end of month
|
|
#get next month and year according to ipInterval
|
|
$lNextMonth = $lMonth + $ipInterval + 1; #first get the month after the desired month
|
|
$lNextYear = $lYear;
|
|
$lNextYear += int( $lNextMonth / 12);
|
|
$lNextMonth %= 12;
|
|
|
|
my $lLastOfNextMonth = main::fhemTimeLocal( $lSecond, $lMinute, $lHour, 1, $lNextMonth, $lNextYear ); # get time
|
|
$lLastOfNextMonth = plusNSeconds( $lLastOfNextMonth, -24*60*60, 1 ); #subtract one day
|
|
|
|
($lSecond, $lMinute, $lHour, $lDay, $lMonth, $lYear, $lDayOfWeekNew, $lYday, $lIsdst )= localtime( $lLastOfNextMonth );
|
|
|
|
if ( $lDayOfWeekNew >= $lDayOfWeek )
|
|
{
|
|
$lDaysToAddOrSub = $lDayOfWeekNew - $lDayOfWeek;
|
|
}
|
|
else
|
|
{
|
|
$lDaysToAddOrSub = 7 - $lDayOfWeek + $lDayOfWeekNew;
|
|
}
|
|
$lDaysToAddOrSub += ( 7 * ( abs( $lDayInterval ) - 1 ) );
|
|
|
|
$lNewTime = plusNSeconds( $lLastOfNextMonth, -24*60*60*$lDaysToAddOrSub, 1);
|
|
}
|
|
#main::Debug "lByDay = $lByDay, lByDayLength = $lByDayLength, lDay = $lDay, lDayInterval = $lDayInterval, lDayOfWeek = $lDayOfWeek, lFirstOfNextMonth = $lFirstOfNextMonth, lNextYear = $lNextYear, lNextMonth = $lNextMonth";
|
|
#main::Debug main::FmtDateTime($lNewTime);
|
|
|
|
return $lNewTime;
|
|
}
|
|
|
|
use constant eventsLimitMinus => -34560000; # -400d
|
|
use constant eventsLimitPlus => 34560000; # +400d
|
|
|
|
sub addEventLimited($$$) {
|
|
my ($self, $t, $event)= @_;
|
|
|
|
return -1 if($event->start()< $t+eventsLimitMinus);
|
|
return 1 if($event->start()> $t+eventsLimitPlus);
|
|
#main::Debug " addEvent: " . $event->asFull();
|
|
$self->addEvent($event);
|
|
return 0;
|
|
|
|
}
|
|
|
|
sub createSingleEvent($$$) {
|
|
|
|
my ($self, $nextstart, $onCreateEvent)= @_;
|
|
|
|
my $event= $self->createEvent();
|
|
my $start= $self->tm($self->value("DTSTART"));
|
|
$nextstart= $start unless(defined($nextstart));
|
|
$event->{start}= $nextstart;
|
|
if($self->hasKey("DTEND")) {
|
|
my $end= $self->tm($self->value("DTEND"));
|
|
$event->{end}= $nextstart+($end-$start);
|
|
} elsif($self->hasKey("DURATION")) {
|
|
my $duration= $self->d($self->value("DURATION"));
|
|
$event->{end}= $nextstart + $duration;
|
|
}
|
|
$self->makeEventDetails($event);
|
|
$self->makeEventAlarms($event);
|
|
|
|
#main::Debug "createSingleEvent DTSTART=" . $self->value("DTSTART") . " DTEND=" . $self->value("DTEND");
|
|
#main::Debug "createSingleEvent Start " . main::FmtDateTime($event->{start});
|
|
#main::Debug "createSingleEvent End " . main::FmtDateTime($event->{end});
|
|
|
|
# plug-in
|
|
if(defined($onCreateEvent)) {
|
|
my $e= $event;
|
|
#main::Debug "Executing $onCreateEvent for " . $e->asDebug();
|
|
eval $onCreateEvent;
|
|
if($@) {
|
|
main::Log3 undef, 2, "Erroneous onCreateEvent $onCreateEvent: $@";
|
|
} else {
|
|
$event= $e;
|
|
}
|
|
}
|
|
|
|
return $event;
|
|
}
|
|
|
|
sub createEvents($$$%) {
|
|
my ($self, $t, $onCreateEvent, %vevents)= @_;
|
|
|
|
$self->clearEvents();
|
|
$self->clearSkippedEvents();
|
|
|
|
if($self->isRecurring()) {
|
|
#
|
|
# recurring event creates a series
|
|
#
|
|
my $rrule= $self->value("RRULE");
|
|
my @rrparts= split(";", $rrule);
|
|
my %r= map { split("=", $_); } @rrparts;
|
|
|
|
my @keywords= qw(FREQ INTERVAL UNTIL COUNT BYMONTHDAY BYDAY BYMONTH WKST);
|
|
foreach my $k (keys %r) {
|
|
if(not($k ~~ @keywords)) {
|
|
main::Log3 undef, 2, "Calendar: keyword $k in RRULE $rrule is not supported";
|
|
} else {
|
|
#main::Debug "keyword $k in RRULE $rrule has value $r{$k}";
|
|
}
|
|
}
|
|
|
|
# Valid values for freq: SECONDLY, MINUTELY, HOURLY, DAILY, WEEKLY, MONTHLY, YEARLY
|
|
my $freq = $r{"FREQ"};
|
|
#main::Debug "FREQ= $freq";
|
|
# According to RFC, interval defaults to 1
|
|
my $interval = exists($r{"INTERVAL"}) ? $r{"INTERVAL"} : 1;
|
|
my $until = exists($r{"UNTIL"}) ? $self->tm($r{"UNTIL"}) : 99999999999999999;
|
|
my $count = exists($r{"COUNT"}) ? $r{"COUNT"} : 999999;
|
|
my $bymonthday = $r{"BYMONTHDAY"} if(exists($r{"BYMONTHDAY"})); # stored but ignored
|
|
my $byday = exists($r{"BYDAY"}) ? $r{"BYDAY"} : "";
|
|
#main::Debug "byday is $byday";
|
|
my $bymonth = $r{"BYMONTH"} if(exists($r{"BYMONTH"})); # stored but ignored
|
|
my $wkst = $r{"WKST"} if(exists($r{"WKST"})); # stored but ignored
|
|
|
|
my @weekdays = qw(SU MO TU WE TH FR SA);
|
|
|
|
|
|
#main::Debug "createEvents: " . $self->asString();
|
|
|
|
#
|
|
# we first add all RDATEs
|
|
#
|
|
if($self->hasKey('RDATE')) {
|
|
foreach my $rdate (@{$self->values("RDATE")}) {
|
|
my $event= $self->createSingleEvent($self->tm($rdate), $onCreateEvent);
|
|
my $skip= 0;
|
|
if($self->hasKey('EXDATE')) {
|
|
foreach my $exdate (@{$self->values("EXDATE")}) {
|
|
if($self->tm($exdate) == $event->start()) {
|
|
$event->setNote("EXDATE: $exdate for RDATE: $rdate");
|
|
$self->addSkippedEvent($event);
|
|
$skip++;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
if(!$skip) {
|
|
# add event
|
|
# and return if we exceed storage limit
|
|
$event->setNote("RDATE: $rdate");
|
|
$self->addEventLimited($t, $event);
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# now we build the series
|
|
#
|
|
|
|
# first event in the series
|
|
my $event= $self->createSingleEvent(undef, $onCreateEvent);
|
|
my $n= 0;
|
|
|
|
|
|
while(1) {
|
|
my $skip= 0;
|
|
|
|
# check if superseded by out-of-series event
|
|
if($self->hasReferences()) {
|
|
foreach my $id (@{$self->references()}) {
|
|
my $vevent= $vevents{$id};
|
|
my $recurrenceid= $vevent->value("RECURRENCE-ID");
|
|
my $originalstart= $vevent->tm($recurrenceid);
|
|
if($originalstart == $event->start()) {
|
|
$event->setNote("RECURRENCE-ID: $recurrenceid");
|
|
$self->addSkippedEvent($event);
|
|
$skip++;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
# RFC 5545 p. 120
|
|
# The final recurrence set is generated by gathering all of the
|
|
# start DATE-TIME values generated by any of the specified "RRULE"
|
|
# and "RDATE" properties, and then excluding any start DATE-TIME
|
|
# values specified by "EXDATE" properties. This implies that start
|
|
# DATE-TIME values specified by "EXDATE" properties take precedence
|
|
# over those specified by inclusion properties (i.e., "RDATE" and
|
|
# "RRULE"). Where duplicate instances are generated by the "RRULE"
|
|
# and "RDATE" properties, only one recurrence is considered.
|
|
# Duplicate instances are ignored.
|
|
|
|
# check if excluded by EXDATE
|
|
if($self->hasKey('EXDATE')) {
|
|
foreach my $exdate (@{$self->values("EXDATE")}) {
|
|
if($self->tm($exdate) == $event->start()) {
|
|
$event->setNote("EXDATE: $exdate");
|
|
$self->addSkippedEvent($event);
|
|
$skip++;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
# check if excluded by a duplicate RDATE
|
|
# this is only to avoid duplicates from previously added RDATEs
|
|
if($self->hasKey('RDATE')) {
|
|
foreach my $rdate (@{$self->values("RDATE")}) {
|
|
if($self->tm($rdate) == $event->start()) {
|
|
$event->setNote("RDATE: $rdate");
|
|
$self->addSkippedEvent($event);
|
|
$skip++;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
return if($event->{start} > $until); # return if we are after end of series
|
|
if(!$skip) {
|
|
# add event
|
|
# and return if we exceed storage limit
|
|
return if($self->addEventLimited($t, $event) > 0);
|
|
}
|
|
$n++;
|
|
return if($n>= $count); # return if we exceeded occurances
|
|
|
|
# advance to next occurence
|
|
my $nextstart = $event->{start};
|
|
if($freq eq "SECONDLY") {
|
|
$nextstart = plusNSeconds($nextstart, 1, $interval);
|
|
} elsif($freq eq "MINUTELY") {
|
|
$nextstart = plusNSeconds($nextstart, 60, $interval);
|
|
} elsif($freq eq "HOURLY") {
|
|
$nextstart = plusNSeconds($nextstart, 60*60, $interval);
|
|
} elsif($freq eq "DAILY") {
|
|
$nextstart = plusNSeconds($nextstart, 24*60*60, $interval);
|
|
} elsif($freq eq "WEEKLY") {
|
|
# special handling for WEEKLY and BYDAY
|
|
#main::Debug "weekly event, BYDAY= $byday";
|
|
if($byday ne "") {
|
|
# BYDAY with prefix (e.g. -1SU or 2MO) is not recognized
|
|
my @bydays= split(',', $byday);
|
|
# we skip interval-1 weeks
|
|
$nextstart = plusNSeconds($nextstart, 7*24*60*60, $interval-1);
|
|
my ($msec, $mmin, $mhour, $mday, $mmon, $myear, $mwday, $yday, $isdat);
|
|
my $preventloop = 0;
|
|
do {
|
|
$nextstart = plusNSeconds($nextstart, 24*60*60, 1); # forward day by day
|
|
($msec, $mmin, $mhour, $mday, $mmon, $myear, $mwday, $yday, $isdat) =
|
|
localtime($nextstart);
|
|
#main::Debug "Skip to: start " . $event->ts($nextstart) . " = " . $weekdays[$mwday];
|
|
$preventloop++;
|
|
if($preventloop > 7) {
|
|
main::Log3 undef, 2,
|
|
"Calendar: something is wrong for RRULE $rrule in " .
|
|
$self->asString();
|
|
last;
|
|
}
|
|
#main::Debug "weekday= " . $weekdays[$mwday] . "($mwday), smartmatch " . join(" ",@bydays) ."= " . ($weekdays[$mwday] ~~ @bydays ? "yes" : "no");
|
|
} until($weekdays[$mwday] ~~ @bydays);
|
|
}
|
|
else {
|
|
# default WEEKLY handling
|
|
$nextstart = plusNSeconds($nextstart, 7*24*60*60, $interval);
|
|
}
|
|
} elsif($freq eq "MONTHLY") {
|
|
if ( $byday ne "" ) {
|
|
$nextstart = getNextMonthlyDateByDay( $nextstart, $byday, $interval );
|
|
}
|
|
else {
|
|
# here we ignore BYMONTHDAY as we consider the day of month of $self->{start}
|
|
# to be equal to BYMONTHDAY.
|
|
$nextstart= plusNMonths($nextstart, $interval);
|
|
}
|
|
} elsif($freq eq "YEARLY") {
|
|
$nextstart= plusNMonths($nextstart, 12*$interval);
|
|
} else {
|
|
main::Log3 undef, 2, "Calendar: event frequency '$freq' not implemented";
|
|
return;
|
|
}
|
|
# the next event
|
|
$event= $self->createSingleEvent($nextstart, $onCreateEvent);
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
#
|
|
# single event
|
|
#
|
|
my $event= $self->createSingleEvent(undef, $onCreateEvent);
|
|
$self->addEventLimited($t, $event);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#
|
|
# friendly string
|
|
#
|
|
sub asString($$) {
|
|
my ($self,$level)= @_;
|
|
$level= "" unless(defined($level));
|
|
my $s= $level . $self->{type};
|
|
$s.= " @" . $self->{ln} if(defined($self->{ln}));
|
|
$s.= " [";
|
|
$s.= "obsolete, " if($self->isObsolete());
|
|
$s.= $self->state();
|
|
$s.= ", refers to " . $self->counterpart() if($self->hasCounterpart());
|
|
$s.= ", in a series with " . join(",", sort @{$self->references()}) if($self->hasReferences());
|
|
$s.= "]";
|
|
#$s.= " (tags: " . join(",", @{$self->tags()}) . ")" if($self->numTags());
|
|
$s.= "\n";
|
|
$level .= " ";
|
|
for my $key (sort keys %{$self->{properties}}) {
|
|
$s.= $level . "$key: ";
|
|
if($self->{properties}{$key}{multiple}) {
|
|
$s.= "(" . join(" ", @{$self->values($key)}) . ")";
|
|
} else {
|
|
$s.= $self->value($key);
|
|
}
|
|
$s.= "\n";
|
|
}
|
|
if($self->{type} eq "VEVENT") {
|
|
if($self->isRecurring()) {
|
|
$s.= $level . ">>> is a series\n";
|
|
}
|
|
if($self->isException()) {
|
|
$s.= $level . ">>> is an exception\n";
|
|
}
|
|
$s.= $level . ">>> Events:\n";
|
|
foreach my $event (@{$self->{events}}) {
|
|
$s.= "$level " . $event->asDebug() . "\n";
|
|
}
|
|
$s.= $level . ">>> Skipped events:\n";
|
|
foreach my $event (@{$self->{skippedEvents}}) {
|
|
$s.= "$level " . $event->asDebug() . "\n";
|
|
}
|
|
}
|
|
my @entries= @{$self->{entries}};
|
|
for(my $i= 0; $i<=$#entries; $i++) {
|
|
$s.= $entries[$i]->asString($level);
|
|
}
|
|
|
|
return $s;
|
|
}
|
|
|
|
##########################################################################
|
|
#
|
|
# main
|
|
#
|
|
##########################################################################
|
|
|
|
package main;
|
|
|
|
#####################################
|
|
sub Calendar_Initialize($) {
|
|
|
|
my ($hash) = @_;
|
|
$hash->{DefFn} = "Calendar_Define";
|
|
$hash->{UndefFn} = "Calendar_Undef";
|
|
$hash->{GetFn} = "Calendar_Get";
|
|
$hash->{SetFn} = "Calendar_Set";
|
|
$hash->{AttrFn} = "Calendar_Attr";
|
|
$hash->{NotifyFn}= "Calendar_Notify";
|
|
$hash->{AttrList}= "hideOlderThan hideLaterThan onCreateEvent SSLVerify:0,1 $readingFnAttributes";
|
|
}
|
|
|
|
|
|
#####################################
|
|
sub Calendar_Define($$) {
|
|
|
|
my ($hash, $def) = @_;
|
|
|
|
# define <name> Calendar ical URL [interval]
|
|
|
|
my @a = split("[ \t][ \t]*", $def);
|
|
|
|
return "syntax: define <name> Calendar ical url <URL> [interval]\n".\
|
|
" define <name> Calendar ical file <FILENAME> [interval]"
|
|
if(($#a < 4 && $#a > 5) || ($a[2] ne 'ical') || (($a[3] ne 'url') && ($a[3] ne 'file')));
|
|
|
|
$hash->{NOTIFYDEV} = "global";
|
|
readingsSingleUpdate($hash, "state", "initialized", 1);
|
|
|
|
my $name = $a[0];
|
|
my $type = $a[3];
|
|
my $url = $a[4];
|
|
my $interval = 3600;
|
|
|
|
$interval= $a[5] if($#a==5);
|
|
|
|
$hash->{".fhem"}{type}= $type;
|
|
$hash->{".fhem"}{url}= $url;
|
|
$hash->{".fhem"}{interval}= $interval;
|
|
$hash->{".fhem"}{lastid}= 0;
|
|
$hash->{".fhem"}{vevents}= {};
|
|
$hash->{".fhem"}{nxtUpdtTs}= 0;
|
|
|
|
#$attr{$name}{"hideOlderThan"}= 0;
|
|
|
|
#main::Debug "Interval: ${interval}s";
|
|
# if initialization is not yet done, we do not wake up at this point already to
|
|
# avoid the following race condition:
|
|
# events are loaded from fhem.save and data are updated asynchronousy from
|
|
# non-blocking Http get
|
|
Calendar_Wakeup($hash, 0) if($init_done);
|
|
|
|
|
|
return undef;
|
|
}
|
|
|
|
#####################################
|
|
sub Calendar_Undef($$) {
|
|
|
|
my ($hash, $arg) = @_;
|
|
|
|
Calendar_DisarmTimer($hash);
|
|
return undef;
|
|
}
|
|
|
|
|
|
#####################################
|
|
sub Calendar_Attr(@) {
|
|
|
|
my ($cmd, $name, @a) = @_;
|
|
|
|
return undef unless($cmd eq "set");
|
|
|
|
my $hash= $defs{$name};
|
|
|
|
return "attr $name needs at least one argument." if(!@a);
|
|
|
|
my $arg= $a[1];
|
|
if($a[0] eq "onCreateEvent") {
|
|
if($arg !~ m/^{.*}$/s) {
|
|
return "$arg must be a perl command in curly brackets but you supplied $arg.";
|
|
}
|
|
}
|
|
|
|
return undef;
|
|
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_Notify($$)
|
|
{
|
|
my ($hash,$dev) = @_;
|
|
my $name = $hash->{NAME};
|
|
my $type = $hash->{TYPE};
|
|
|
|
return if($dev->{NAME} ne "global");
|
|
return if(!grep(m/^INITIALIZED|REREADCFG$/, @{$dev->{CHANGED}}));
|
|
|
|
return if($attr{$name} && $attr{$name}{disable});
|
|
|
|
# update calendar after initialization or change of configuration
|
|
# wait 10 to 29 seconds to avoid congestion due to concurrent activities
|
|
Calendar_DisarmTimer($hash);
|
|
my $delay= 10+int(rand(20));
|
|
|
|
# delay removed until further notice
|
|
$delay= 2;
|
|
|
|
Log3 $hash, 5, "Calendar $name: FHEM initialization or rereadcfg triggered update, delay $delay seconds.";
|
|
InternalTimer(time()+$delay, "Calendar_Wakeup", $hash, 0) ;
|
|
|
|
return undef;
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_Set($@) {
|
|
my ($hash, @a) = @_;
|
|
|
|
my $cmd= $a[1];
|
|
$cmd= "?" unless($cmd);
|
|
|
|
|
|
my $t= time();
|
|
# usage check
|
|
if((@a == 2) && ($a[1] eq "update")) {
|
|
Calendar_DisarmTimer($hash);
|
|
Calendar_GetUpdate($hash, $t, 0);
|
|
return undef;
|
|
} elsif((@a == 2) && ($a[1] eq "reload")) {
|
|
Calendar_DisarmTimer($hash);
|
|
Calendar_GetUpdate($hash, $t, 1); # remove all events before update
|
|
return undef;
|
|
} else {
|
|
return "Unknown argument $cmd, choose one of update:noArg reload:noArg";
|
|
}
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_Get($@) {
|
|
|
|
my ($hash, @a) = @_;
|
|
|
|
my $t= time();
|
|
|
|
my $eventsObj= $hash->{".fhem"}{events};
|
|
my @events;
|
|
|
|
my $cmd= $a[1];
|
|
$cmd= "?" unless($cmd);
|
|
|
|
|
|
if($cmd eq "update") {
|
|
# this is the same as set update for convenience
|
|
Calendar_DisarmTimer($hash);
|
|
Calendar_GetUpdate($hash, $t, 0);
|
|
return undef;
|
|
}
|
|
|
|
if($cmd eq "reload") {
|
|
# this is the same as set reload for convenience
|
|
Calendar_DisarmTimer($hash);
|
|
Calendar_GetUpdate($hash, $t, 1); # remove all events before update
|
|
return undef;
|
|
}
|
|
|
|
if($cmd eq "events") {
|
|
|
|
# see https://forum.fhem.de/index.php/topic,46608.msg397309.html#msg397309 for ideas
|
|
# get myCalendar events filter:mode=alarm|start|upcoming format=custom:{ sprintf("...") } select:series=next,max=8,from=-3d,to=10d
|
|
# attr myCalendar defaultFormat <format>
|
|
|
|
my @texts;
|
|
my @events= Calendar_GetEvents($hash, $t, undef, undef);
|
|
foreach my $event (@events) {
|
|
push @texts, $event->asFull();
|
|
}
|
|
return "" if($#texts<0);
|
|
return join("\n", @texts);
|
|
|
|
}
|
|
|
|
my @cmds2= qw/text full summary location description alarm start end uid debug/;
|
|
if($cmd ~~ @cmds2) {
|
|
|
|
return "argument is missing" if($#a < 2);
|
|
my $filter= $a[2];
|
|
|
|
|
|
# $reading is alarm, all, changed, start, end, upcoming
|
|
my $filterref;
|
|
my $param= undef;
|
|
my $keeppos= 3;
|
|
if($filter eq "changed") {
|
|
$filterref= \&filter_changed;
|
|
} elsif($filter eq "alarm") {
|
|
$filterref= \&filter_alarm;
|
|
} elsif($filter eq "start") {
|
|
$filterref= \&filter_start;
|
|
} elsif($filter eq "end") {
|
|
$filterref= \&filter_end;
|
|
} elsif($filter eq "upcoming") {
|
|
$filterref= \&filter_upcoming;
|
|
} elsif($filter =~ /^uid=(.+)$/) {
|
|
$filterref= \&filter_uids;
|
|
$param= $1;
|
|
} elsif($filter =~ /^mode=(.+)$/) {
|
|
$filterref= \&filter_modes;
|
|
$param= $1;
|
|
} elsif(($filter =~ /^mode\w+$/) and (defined($hash->{READINGS}{$filter}))) {
|
|
#main::Debug "apply filter_reading";
|
|
$filterref= \&filter_reading;
|
|
my @uids= split(";", $hash->{READINGS}{$filter}{VAL});
|
|
$param= \@uids;
|
|
} elsif($filter eq "all") {
|
|
$filterref= undef;
|
|
} elsif($filter eq "next") {
|
|
$filterref= \&filter_notend;
|
|
$param= { }; # reference to anonymous (unnamed) empty hash, thus $ in $param
|
|
} else { # everything else is interpreted as uid
|
|
$filterref= \&filter_uid;
|
|
$param= $a[2];
|
|
}
|
|
|
|
@events= Calendar_GetEvents($hash, $t, $filterref, $param);
|
|
|
|
# special treatment for next
|
|
if($filter eq "next") {
|
|
my %uids; # remember the UIDs
|
|
|
|
# the @events are ordered by start time ascending
|
|
# they do contain all events that have not ended
|
|
@events= grep {
|
|
my $seen= defined($uids{$_->uid()});
|
|
$uids{$_->uid()}= 1;
|
|
not $seen;
|
|
} @events;
|
|
|
|
}
|
|
|
|
my @texts;
|
|
|
|
if(@events) {
|
|
foreach my $event (sort { $a->start() <=> $b->start() } @events) {
|
|
push @texts, $event->uid() if $cmd eq "uid";
|
|
push @texts, $event->asText() if $cmd eq "text";
|
|
push @texts, $event->asFull() if $cmd eq "full";
|
|
push @texts, $event->asDebug() if $cmd eq "debug";
|
|
push @texts, $event->summary() if $cmd eq "summary";
|
|
push @texts, $event->location() if $cmd eq "location";
|
|
push @texts, $event->description() if $cmd eq "description";
|
|
push @texts, $event->alarmTime() if $cmd eq "alarm";
|
|
push @texts, $event->startTime() if $cmd eq "start";
|
|
push @texts, $event->endTime() if $cmd eq "end";
|
|
}
|
|
}
|
|
if(defined($a[$keeppos])) {
|
|
my $keep= $a[$keeppos];
|
|
return "Argument $keep is not a number." unless($keep =~ /\d+/);
|
|
$keep= $#texts+1 if($keep> $#texts);
|
|
splice @texts, $keep if($keep>= 0);
|
|
}
|
|
return "" if($#texts<0);
|
|
return join("\n", @texts);
|
|
|
|
} elsif($cmd eq "vevents") {
|
|
|
|
my %vevents= %{$hash->{".fhem"}{vevents}};
|
|
my $s= "";
|
|
foreach my $key (sort {$a<=>$b} keys %vevents) {
|
|
$s .= "$key: ";
|
|
$s .= $vevents{$key}->asString();
|
|
$s .= "\n";
|
|
}
|
|
return $s;
|
|
|
|
} elsif($cmd eq "vcalendar") {
|
|
|
|
return undef unless(defined($hash->{".fhem"}{iCalendar}));
|
|
return $hash->{".fhem"}{iCalendar}
|
|
|
|
} elsif($cmd eq "find") {
|
|
|
|
return "argument is missing" if($#a != 2);
|
|
my $regexp= $a[2];
|
|
|
|
my %vevents= %{$hash->{".fhem"}{vevents}};
|
|
my %uids;
|
|
foreach my $id (keys %vevents) {
|
|
my $v= $vevents{$id};
|
|
my @events= @{$v->{events}};
|
|
if(@events) {
|
|
eval {
|
|
if($events[0]->summary() =~ m/$regexp/) {
|
|
$uids{$events[0]->uid()}= 1; #
|
|
}
|
|
}
|
|
}
|
|
Log3($hash, 2, "Calendar " . $hash->{NAME} .
|
|
": The regular expression $regexp caused a problem: $@") if($@);
|
|
}
|
|
return join(";", keys %uids);
|
|
|
|
} else {
|
|
return "Unknown argument $cmd, choose one of update:noArg reload:noArg find text full summary location description alarm start end vcalendar:noArg vevents:noArg";
|
|
}
|
|
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_Wakeup($$) {
|
|
|
|
my ($hash, $removeall) = @_;
|
|
|
|
Log3 $hash, 4, "Calendar " . $hash->{NAME} . ": Wakeup";
|
|
|
|
my $t= time(); # baseline
|
|
# we could arrive here 1 second before nextWakeTs for unknown reasons
|
|
use constant delta => 5; # avoid waking up again in a few seconds
|
|
if($t>= $hash->{".fhem"}{nxtUpdtTs} - delta) {
|
|
# GetUpdate does CheckTimes and RearmTimer asynchronously
|
|
Calendar_GetUpdate($hash, $t, $removeall);
|
|
} else {
|
|
Calendar_CheckTimes($hash, $t);
|
|
Calendar_RearmTimer($hash, $t);
|
|
}
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_RearmTimer($$) {
|
|
|
|
my ($hash, $t) = @_;
|
|
|
|
#main::Debug "RearmTimer now " . FmtDateTime($t);
|
|
my $nt= $hash->{".fhem"}{nxtUpdtTs};
|
|
#main::Debug "RearmTimer next update " . FmtDateTime($nt);
|
|
# find next event
|
|
my %vevents= %{$hash->{".fhem"}{vevents}};
|
|
foreach my $uid (keys %vevents) {
|
|
my $v= $vevents{$uid};
|
|
foreach my $e (@{$v->{events}}) {
|
|
my $et= $e->nextTime($t);
|
|
# we only consider times in the future to avoid multiple
|
|
# invocations for calendar events with the event time
|
|
$nt= $et if(defined($et) && ($et< $nt) && ($et > $t));
|
|
}
|
|
}
|
|
|
|
$hash->{".fhem"}{nextWakeTs}= $nt;
|
|
$hash->{".fhem"}{nextWake}= FmtDateTime($nt);
|
|
#main::Debug "RearmTimer for " . $hash->{".fhem"}{nextWake};
|
|
readingsSingleUpdate($hash, "nextWakeup", $hash->{".fhem"}{nextWake}, 1);
|
|
|
|
if($nt< $t) { $nt= $t+1 }; # sanity check / do not wake-up at or before the same second
|
|
InternalTimer($nt, "Calendar_Wakeup", $hash, 0) ;
|
|
|
|
}
|
|
|
|
sub Calendar_DisarmTimer($) {
|
|
|
|
my ($hash)= @_;
|
|
RemoveInternalTimer($hash);
|
|
}
|
|
#
|
|
|
|
###################################
|
|
sub Calendar_GetSecondsFromTimeSpec($) {
|
|
|
|
my ($tspec) = @_;
|
|
|
|
# days
|
|
if($tspec =~ m/^([0-9]+)d$/) {
|
|
return ("", $1*86400);
|
|
}
|
|
|
|
# seconds
|
|
if($tspec =~ m/^[0-9]+s?$/) {
|
|
return ("", $tspec);
|
|
}
|
|
|
|
# D:HH:MM:SS
|
|
if($tspec =~ m/^([0-9]+):([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/) {
|
|
return ("", $4+60*($3+60*($2+24*$1)));
|
|
}
|
|
|
|
# HH:MM:SS
|
|
if($tspec =~ m/^([0-9]+):([0-5][0-9]):([0-5][0-9])$/) { # HH:MM:SS
|
|
return ("", $3+60*($2+(60*$1)));
|
|
}
|
|
|
|
# HH:MM
|
|
if($tspec =~ m/^([0-9]+):([0-5][0-9])$/) {
|
|
return ("", 60*($2+60*$1));
|
|
}
|
|
|
|
return ("Wrong time specification $tspec", undef);
|
|
|
|
}
|
|
|
|
###################################
|
|
# Filters
|
|
|
|
sub filter_modes($$) {
|
|
my ($event,$regex)= @_;
|
|
my $hit;
|
|
eval { $hit= ($event->getMode() =~ $regex); };
|
|
return 0 if($@);
|
|
return $hit ? 1 : 0;
|
|
}
|
|
|
|
sub filter_uids($$) {
|
|
my ($event,$regex)= @_;
|
|
my $hit;
|
|
eval { $hit= ($event->uid() =~ $regex); };
|
|
return 0 if($@);
|
|
return $hit ? 1 : 0;
|
|
}
|
|
|
|
sub filter_changed($) {
|
|
my ($event)= @_;
|
|
return $event->modeChanged();
|
|
}
|
|
|
|
sub filter_alarm($) {
|
|
my ($event)= @_;
|
|
return $event->getMode() eq "alarm" ? 1 : 0;
|
|
}
|
|
|
|
sub filter_start($) {
|
|
my ($event)= @_;
|
|
return $event->getMode() eq "start" ? 1 : 0;
|
|
}
|
|
|
|
sub filter_end($) {
|
|
my ($event)= @_;
|
|
return $event->getMode() eq "end" ? 1 : 0;
|
|
}
|
|
|
|
sub filter_notend($) {
|
|
my ($event)= @_;
|
|
return $event->getMode() eq "end" ? 0 : 1;
|
|
}
|
|
|
|
sub filter_upcoming($) {
|
|
my ($event)= @_;
|
|
return $event->getMode() eq "upcoming" ? 1 : 0;
|
|
}
|
|
|
|
sub filter_uid($$) {
|
|
my ($event, $param)= @_;
|
|
return $event->uid() eq "$param" ? 1 : 0;
|
|
}
|
|
|
|
sub filter_reading($$) {
|
|
my ($event, $param)= @_;
|
|
my @uids= @{$param};
|
|
#foreach my $u (@uids) { main::Debug "UID $u"; }
|
|
my $uid= $event->uid();
|
|
#main::Debug "SUCHE $uid";
|
|
#main::Debug "GREP: " . grep(/^$uid$/, @uids);
|
|
return grep(/^$uid$/, @uids);
|
|
}
|
|
|
|
|
|
|
|
|
|
###################################
|
|
sub Calendar_GetEvents($$$$) {
|
|
|
|
my ($hash, $t, $filterref, $param)= @_;
|
|
my $name= $hash->{NAME};
|
|
my @result= ();
|
|
|
|
# time window
|
|
my ($error, $t1, $t2)= (undef, undef, undef);
|
|
my $hideOlderThan= AttrVal($name, "hideOlderThan", undef);
|
|
my $hideLaterThan= AttrVal($name, "hideLaterThan", undef);
|
|
|
|
# start of time window
|
|
if(defined($hideOlderThan)) {
|
|
($error, $t1)= Calendar_GetSecondsFromTimeSpec($hideOlderThan);
|
|
if($error) {
|
|
Log3 $hash, 2, "$name: attribute hideOlderThan: $error";
|
|
} else {
|
|
$t1= $t- $t1;
|
|
}
|
|
}
|
|
|
|
# end of time window
|
|
if(defined($hideLaterThan)) {
|
|
($error, $t2)= Calendar_GetSecondsFromTimeSpec($hideLaterThan);
|
|
if($error) {
|
|
Log3 $hash, 2, "$name: attribute hideLaterThan: $error";
|
|
} else {
|
|
$t2= $t+ $t2;
|
|
}
|
|
}
|
|
|
|
# get and filter events
|
|
my %vevents= %{$hash->{".fhem"}{vevents}};
|
|
foreach my $id (keys %vevents) {
|
|
my $v= $vevents{$id};
|
|
my @events= @{$v->{events}};
|
|
foreach my $event (@events) {
|
|
if(defined($filterref)) {
|
|
next unless(&$filterref($event, $param));
|
|
}
|
|
if(defined($t1)) { next if(defined($event->end()) && $event->end() < $t1); }
|
|
if(defined($t2)) { next if(defined($event->start()) && $event->start() > $t2); }
|
|
push @result, $event;
|
|
}
|
|
}
|
|
return sort { $a->start() <=> $b->start() } @result;
|
|
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_GetUpdate($$$) {
|
|
|
|
my ($hash, $t, $removeall) = @_;
|
|
my $name= $hash->{NAME};
|
|
|
|
$hash->{".fhem"}{lstUpdtTs}= $t;
|
|
$hash->{".fhem"}{lastUpdate}= FmtDateTime($t);
|
|
|
|
my $nut= $t+ $hash->{".fhem"}{interval};
|
|
$hash->{".fhem"}{nxtUpdtTs}= $nut;
|
|
$hash->{".fhem"}{nextUpdate}= FmtDateTime($nut);
|
|
|
|
#main::Debug "Getting update now: " . $hash->{".fhem"}{lastUpdate};
|
|
#main::Debug "Next Update is at : " . $hash->{".fhem"}{nextUpdate};
|
|
|
|
Log3 $hash, 4, "Calendar $name: Updating...";
|
|
my $type = $hash->{".fhem"}{type};
|
|
my $url= $hash->{".fhem"}{url};
|
|
|
|
my $errmsg= "";
|
|
my $ics;
|
|
|
|
if($type eq "url") {
|
|
|
|
my $SSLVerify= AttrVal($name, "SSLVerify", undef);
|
|
my $SSLArgs= { };
|
|
if(defined($SSLVerify)) {
|
|
eval "use IO::Socket::SSL";
|
|
if($@) {
|
|
Log3 $hash, 2, $@;
|
|
} else {
|
|
my $SSLVerifyMode= eval("$SSLVerify ? SSL_VERIFY_PEER : SSL_VERIFY_NONE");
|
|
Log3 $hash, 5, "SSL verify mode set to $SSLVerifyMode";
|
|
$SSLArgs= { SSL_verify_mode => $SSLVerifyMode };
|
|
}
|
|
}
|
|
|
|
HttpUtils_NonblockingGet({
|
|
url => $url,
|
|
hideurl => 1,
|
|
noshutdown => 1,
|
|
hash => $hash,
|
|
timeout => 30,
|
|
type => 'caldata',
|
|
removeall => $removeall,
|
|
sslargs => $SSLArgs,
|
|
t => $t,
|
|
callback => \&Calendar_ProcessUpdate,
|
|
});
|
|
Log3 $hash, 4, "Calendar $name: Getting data from URL <hidden>"; # $url
|
|
|
|
} elsif($type eq "file") {
|
|
|
|
Log3 $hash, 4, "Calendar $name: Getting data from file $url";
|
|
if(open(ICSFILE, $url)) {
|
|
while(<ICSFILE>) {
|
|
$ics .= $_;
|
|
}
|
|
close(ICSFILE);
|
|
|
|
my $paramhash;
|
|
$paramhash->{hash} = $hash;
|
|
$paramhash->{removeall} = $removeall;
|
|
$paramhash->{t} = $t;
|
|
$paramhash->{type} = 'caldata';
|
|
Calendar_ProcessUpdate($paramhash, '', $ics);
|
|
return undef;
|
|
|
|
} else {
|
|
Log3 $hash, 1, "Calendar $name: Could not open file $url";
|
|
readingsSingleUpdate($hash, "state", "error (could not open file)", 1);
|
|
return 0;
|
|
}
|
|
} else {
|
|
# this case never happens by virtue of _Define, so just
|
|
die "Software Error";
|
|
}
|
|
|
|
}
|
|
|
|
|
|
###################################
|
|
sub Calendar_ProcessUpdate($$$) {
|
|
|
|
my ($param, $errmsg, $ics) = @_;
|
|
my $hash = $param->{hash};
|
|
my $name = $hash->{NAME};
|
|
my $removeall = $param->{removeall};
|
|
my $t= $param->{t};
|
|
|
|
delete($hash->{".fhem"}{iCalendar});
|
|
|
|
if($errmsg) {
|
|
Log3 $name, 1, "Calendar $name: retrieval failed with error message $errmsg";
|
|
readingsSingleUpdate($hash, "state", "error ($errmsg)", 1);
|
|
} else {
|
|
readingsSingleUpdate($hash, "state", "retrieved", 1);
|
|
}
|
|
|
|
if($errmsg or !defined($ics) or ("$ics" eq "") ) {
|
|
Log3 $hash, 1, "Calendar $name: retrieved no or empty data";
|
|
readingsSingleUpdate($hash, "state", "error (no or empty data)", 1);
|
|
} else {
|
|
Calendar_UpdateCalendar($hash, $t, $ics, $removeall);
|
|
}
|
|
|
|
#main::Debug "Calendar $name: iCalendar=\n$ics";
|
|
|
|
Calendar_CheckTimes($hash, $t);
|
|
Calendar_RearmTimer($hash, $t);
|
|
|
|
}
|
|
|
|
###################################
|
|
sub Calendar_UpdateCalendar($$$$) {
|
|
|
|
my ($hash, $t, $ics, $removeall) = @_;
|
|
|
|
|
|
# *********************
|
|
# *** Step 1 Parsing
|
|
# *********************
|
|
|
|
#
|
|
# 1
|
|
#
|
|
|
|
$hash->{".fhem"}{iCalendar}= $ics; # the plain text iCalendar
|
|
|
|
#
|
|
# 2 Parsing
|
|
#
|
|
|
|
my $name= $hash->{NAME};
|
|
Log3 $hash, 4, "Calendar $name: parsing data";
|
|
#main::Debug "Calendar $name: parsing data";
|
|
|
|
|
|
# we remove disturbing CRs from the file
|
|
$ics =~ s/[\r\n]+/\n/g;
|
|
|
|
# we parse the calendar into a recursive ICal::Entry structure
|
|
my $ical= ICal::Entry->new("root");
|
|
$ical->parse(split("\n",$ics));
|
|
|
|
#main::Debug "*** Result:";
|
|
#main::Debug $ical->asString();
|
|
|
|
my @entries= @{$ical->{entries}};
|
|
if($#entries<0) {
|
|
eval { require Compress::Zlib; };
|
|
if($@) {
|
|
readingsSingleUpdate($hash, "state",
|
|
"error (data not in ICal format or no Compress::Zlib)", 1);
|
|
Log3 $hash, 1, "Calendar $name: maybe gzip data, but cannot load Compress::Zlib";
|
|
}
|
|
else {
|
|
Log3 $hash, 4, "Calendar $name: unzipping data";
|
|
$ics = Compress::Zlib::memGunzip($ics);
|
|
$ical->parse(split("\n",$ics));
|
|
@entries= @{$ical->{entries}};
|
|
}
|
|
};
|
|
if($#entries<0) {
|
|
Log3 $hash, 1, "Calendar $name: data not in ICal format";
|
|
readingsSingleUpdate($hash, "state", "error (data not in ICal format)", 1);
|
|
return 0;
|
|
};
|
|
|
|
my $root= @{$ical->{entries}}[0];
|
|
my $calname= "?";
|
|
if($root->{type} ne "VCALENDAR") {
|
|
Log3 $hash, 1, "Calendar $name: root element is not VCALENDAR";
|
|
readingsSingleUpdate($hash, "state", "error (root element is not VCALENDAR)", 1);
|
|
return 0;
|
|
} else {
|
|
$calname= $root->value("X-WR-CALNAME");
|
|
}
|
|
|
|
|
|
# *********************
|
|
# *** Step 2 Merging
|
|
# *********************
|
|
|
|
Log3 $hash, 4, "Calendar $name: merging data";
|
|
#main::Debug "Calendar $name: merging data";
|
|
|
|
# this the hash of VEVENTs that have been created on the previous update
|
|
my %vevents;
|
|
%vevents= %{$hash->{".fhem"}{vevents}} if(!$removeall);
|
|
|
|
# the keys to the hash are numbers taken from a sequence
|
|
my $lastid= $hash->{".fhem"}{lastid};
|
|
|
|
#
|
|
# 1, 2, 4
|
|
#
|
|
|
|
# we first discard all VEVENTs that have been tagged as deleted in the previous run
|
|
# and untag the rest
|
|
foreach my $key (keys %vevents) {
|
|
#main::Debug "Preparing id $key...";
|
|
if($vevents{$key}->isObsolete() ) {
|
|
delete($vevents{$key});
|
|
} else {
|
|
$vevents{$key}->setState("deleted"); # will be changed if record is touched in the next step
|
|
$vevents{$key}->clearCounterpart();
|
|
$vevents{$key}->clearReferences();
|
|
}
|
|
}
|
|
|
|
#
|
|
# 3
|
|
#
|
|
|
|
# we now run through the list of freshly retrieved VEVENTs and merge them into
|
|
# the hash
|
|
my ($n, $nknown, $nmodified, $nnew, $nchanged)= (0,0,0,0,0,0);
|
|
|
|
# this code is O(n^2) and stalls FHEM for large numbers of VEVENTs
|
|
# to speed up the code we first build a reverse hash (UID,RECURRENCE-ID) -> id
|
|
sub kf($) { my ($v)= @_; return $v->value("UID").$v->valueOrDefault("RECURRENCE-ID","") }
|
|
|
|
my %lookup;
|
|
foreach my $id (keys %vevents) {
|
|
my $k= kf($vevents{$id});
|
|
Log3 $hash, 2, "Calendar $name: Duplicate VEVENT" if(defined($lookup{$k}));
|
|
$lookup{$k}= $id;
|
|
#main::Debug "Adding event $id with key $k to lookup hash.";
|
|
}
|
|
|
|
foreach my $v (grep { $_->{type} eq "VEVENT" } @{$root->{entries}}) {
|
|
#main::Debug "Merging " . $v->asString();
|
|
my $found= 0;
|
|
my $added= 0; # flag to prevent multiple additions
|
|
$n++;
|
|
# some braindead calendars provide no UID - add one:
|
|
$v->addproperty(sprintf("UID:synthetic-%06d", $v->{ln}))
|
|
unless($v->hasKey("UID") or !defined($v->{ln}));
|
|
# look for related records in the old record set
|
|
my $k= kf($v);
|
|
#main::Debug "Looking for event with key $k";
|
|
my $id= $lookup{$k};
|
|
if(defined($id)) {
|
|
my $v0= $vevents{$id};
|
|
#main::Debug "Found $id";
|
|
|
|
#
|
|
# same UID and RECURRENCE-ID
|
|
#
|
|
$found++;
|
|
if($v0->sameValue($v, "SEQUENCE")) {
|
|
#
|
|
# and same SEQUENCE
|
|
#
|
|
if($v0->sameValue($v, "LAST-MODIFIED")) {
|
|
#
|
|
# is not modified
|
|
#
|
|
# we only keep the record from the old record set
|
|
$v0->setState("known");
|
|
$nknown++;
|
|
} else {
|
|
#
|
|
# is modified
|
|
#
|
|
# we keep both records
|
|
next if($added);
|
|
$added++;
|
|
$vevents{++$lastid}= $v;
|
|
$v->setState("modified-new");
|
|
$v->setCounterpart($id);
|
|
$v0->setState("modified-old");
|
|
$v0->setCounterpart($lastid);
|
|
$nmodified++;
|
|
}
|
|
} else {
|
|
#
|
|
# and different SEQUENCE
|
|
#
|
|
# we keep both records
|
|
next if($added);
|
|
$added++;
|
|
$vevents{++$lastid}= $v;
|
|
$v->setState("changed-new");
|
|
$v->setCounterpart($id);
|
|
$v0->setState("changed-old");
|
|
$v0->setCounterpart($lastid);
|
|
$nchanged++;
|
|
}
|
|
}
|
|
|
|
if(!$found) {
|
|
$v->setState("new");
|
|
$vevents{++$lastid}= $v;
|
|
$added++;
|
|
$nnew++;
|
|
}
|
|
}
|
|
|
|
#
|
|
# Cross-referencing series
|
|
#
|
|
# this code is O(n^2) and stalls FHEM for large numbers of VEVENTs
|
|
# to speed up the code we build a hash of a hash UID => {id => VEVENT}
|
|
%lookup= ();
|
|
foreach my $id (keys %vevents) {
|
|
my $v= $vevents{$id};
|
|
$lookup{$v->value("UID")}{$id}= $v unless($v->isObsolete);
|
|
}
|
|
for my $idref (values %lookup) {
|
|
my %vs= %{$idref};
|
|
foreach my $v (values %vs) {
|
|
foreach my $id (keys %vs) {
|
|
push @{$v->references()}, $id unless($vs{$id} eq $v);
|
|
}
|
|
}
|
|
}
|
|
|
|
# foreach my $id (keys %vevents) {
|
|
# my $v= $vevents{$id};
|
|
# next if($v->isObsolete());
|
|
# foreach my $id0 (keys %vevents) {
|
|
# next if($id==$id0);
|
|
# my $v0= $vevents{$id0};
|
|
# next if($v0->isObsolete());
|
|
# push @{$v0->references()}, $id if($v->sameValue($v0, "UID"));
|
|
# }
|
|
# }
|
|
|
|
|
|
Log3 $hash, 4, "Calendar $name: $n records processed, $nnew new, ".
|
|
"$nknown known, $nmodified modified, $nchanged changed.";
|
|
|
|
# save the VEVENTs hash and lastid
|
|
$hash->{".fhem"}{vevents}= \%vevents;
|
|
$hash->{".fhem"}{lastid}= $lastid;
|
|
|
|
# *********************
|
|
# *** Step 3 Events
|
|
# *********************
|
|
|
|
|
|
#
|
|
# Recreating the events
|
|
#
|
|
Log3 $hash, 4, "Calendar $name: creating calendar events";
|
|
#main::Debug "Calendar $name: creating calendar events";
|
|
|
|
foreach my $id (keys %vevents) {
|
|
my $v= $vevents{$id};
|
|
if($v->isObsolete()) {
|
|
$v->clearEvents();
|
|
next;
|
|
}
|
|
|
|
my $onCreateEvent= AttrVal($name, "onCreateEvent", undef);
|
|
if($v->hasChanged() or !$v->numEvents()) {
|
|
#main::Debug "createEvents";
|
|
$v->createEvents($t, $onCreateEvent, %vevents);
|
|
}
|
|
|
|
}
|
|
|
|
#main::Debug "*** Result:";
|
|
#main::Debug $ical->asString();
|
|
|
|
|
|
# *********************
|
|
# *** Step 4 Readings
|
|
# *********************
|
|
|
|
readingsBeginUpdate($hash);
|
|
readingsBulkUpdate($hash, "calname", $calname);
|
|
readingsBulkUpdate($hash, "lastUpdate", $hash->{".fhem"}{lastUpdate});
|
|
readingsBulkUpdate($hash, "nextUpdate", $hash->{".fhem"}{nextUpdate});
|
|
readingsEndUpdate($hash, 1); # DoTrigger, because sub is called by a timer instead of dispatch
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
###################################
|
|
sub Calendar_CheckTimes($$) {
|
|
|
|
my ($hash, $t) = @_;
|
|
|
|
Log3 $hash, 4, "Calendar " . $hash->{NAME} . ": Checking times...";
|
|
|
|
#
|
|
# determine the uids of all events and their most interesting mode
|
|
#
|
|
my %priority= (
|
|
"none" => 0,
|
|
"end" => 1,
|
|
"upcoming" => 2,
|
|
"alarm" => 3,
|
|
"start" => 4,
|
|
);
|
|
my %mim; # most interesting mode per id
|
|
my %changed; # changed per id
|
|
my %vevents= %{$hash->{".fhem"}{vevents}};
|
|
foreach my $uid (keys %vevents) {
|
|
my $v= $vevents{$uid};
|
|
foreach my $e (@{$v->{events}}) {
|
|
my $uid= $e->uid();
|
|
my $mode= defined($mim{$uid}) ? $mim{$uid} : "none";
|
|
if($e->isEnded($t)) {
|
|
$e->setMode("end");
|
|
} elsif($e->isUpcoming($t)) {
|
|
$e->setMode("upcoming");
|
|
} elsif($e->isStarted($t)) {
|
|
$e->setMode("start");
|
|
} elsif($e->isAlarmed($t)) {
|
|
$e->setMode("alarm");
|
|
}
|
|
if($priority{$e->getMode()} > $priority{$mode}) {
|
|
$mim{$uid}= $e->getMode();
|
|
}
|
|
$changed{$uid}= 0 unless(defined($changed{$uid}));
|
|
# create the FHEM event
|
|
if($e->modeChanged()) {
|
|
$changed{$uid}= 1;
|
|
addEvent($hash, "changed: $uid " . $e->getMode());
|
|
addEvent($hash, $e->getMode() . ": $uid ");
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# determine the uids of events in certain modes
|
|
#
|
|
my @changed;
|
|
my @upcoming;
|
|
my @start;
|
|
my @started;
|
|
my @alarm;
|
|
my @alarmed;
|
|
my @end;
|
|
my @ended;
|
|
foreach my $uid (keys %mim) {
|
|
push @changed, $uid if($changed{$uid});
|
|
push @upcoming, $uid if($mim{$uid} eq "upcoming");
|
|
if($mim{$uid} eq "alarm") {
|
|
push @alarm, $uid;
|
|
push @alarmed, $uid if($changed{$uid});
|
|
}
|
|
if($mim{$uid} eq "start") {
|
|
push @start, $uid;
|
|
push @started, $uid if($changed{$uid});
|
|
}
|
|
if($mim{$uid} eq "end") {
|
|
push @end, $uid;
|
|
push @ended, $uid if($changed{$uid});
|
|
}
|
|
}
|
|
|
|
|
|
#sub uniq { my %uids; return grep {!$uids{$_->uid()}++} @_; }
|
|
|
|
|
|
#@allevents= sort { $a->start() <=> $b->start() } uniq(@allevents);
|
|
|
|
|
|
#foreach my $event (@allevents) {
|
|
# main::Debug $event->asFull();
|
|
#}
|
|
|
|
|
|
sub es(@) {
|
|
my (@events)= @_;
|
|
return join(";", @events);
|
|
}
|
|
|
|
sub rbu($$$) {
|
|
my ($hash, $reading, $value)= @_;
|
|
if(!defined($hash->{READINGS}{$reading}) or
|
|
($hash->{READINGS}{$reading}{VAL} ne $value)) {
|
|
readingsBulkUpdate($hash, $reading, $value);
|
|
}
|
|
}
|
|
|
|
# clears all events in CHANGED, thus must be called first
|
|
readingsBeginUpdate($hash);
|
|
# we update the readings
|
|
rbu($hash, "modeUpcoming", es(@upcoming));
|
|
rbu($hash, "modeAlarm", es(@alarm));
|
|
rbu($hash, "modeAlarmed", es(@alarmed));
|
|
rbu($hash, "modeAlarmOrStart", es(@alarm,@start));
|
|
rbu($hash, "modeChanged", es(@changed));
|
|
rbu($hash, "modeStart", es(@start));
|
|
rbu($hash, "modeStarted", es(@started));
|
|
rbu($hash, "modeEnd", es(@end));
|
|
rbu($hash, "modeEnded", es(@ended));
|
|
readingsBulkUpdate($hash, "state", "triggered");
|
|
# DoTrigger, because sub is called by a timer instead of dispatch
|
|
readingsEndUpdate($hash, 1);
|
|
|
|
}
|
|
|
|
|
|
#####################################
|
|
|
|
# filter:next count:3
|
|
sub CalendarAsHtml($;$) {
|
|
|
|
my ($d,$o) = @_;
|
|
$d = "<none>" if(!$d);
|
|
return "$d is not a Calendar instance<br>"
|
|
if(!$defs{$d} || $defs{$d}{TYPE} ne "Calendar");
|
|
|
|
my $l= Calendar_Get($defs{$d}, split("[ \t]+", "- text $o"));
|
|
my @lines= split("\n", $l);
|
|
|
|
my $ret = '<table class="calendar">';
|
|
|
|
foreach my $line (@lines) {
|
|
my @fields= split(" ", $line, 3);
|
|
$ret.= sprintf("<tr><td>%s</td><td>%s</td><td>%s</td></tr>", @fields);
|
|
}
|
|
$ret .= '</table>';
|
|
|
|
return $ret;
|
|
}
|
|
|
|
#####################################
|
|
|
|
|
|
1;
|
|
|
|
=pod
|
|
=item device
|
|
=item summary handles calendar events from iCal file or URL
|
|
=item summary_DE handhabt Kalendertermine aus iCal-Dateien und URLs
|
|
=begin html
|
|
|
|
<a name="Calendar"></a>
|
|
<h3>Calendar</h3>
|
|
<ul>
|
|
<br>
|
|
|
|
<a name="Calendardefine"></a>
|
|
<b>Define</b><br><br>
|
|
<ul>
|
|
<code>define <name> Calendar ical url <URL> [<interval>]</code><br>
|
|
<code>define <name> Calendar ical file <FILENAME> [<interval>]</code><br>
|
|
<br>
|
|
Defines a calendar device.<br><br>
|
|
|
|
A calendar device periodically gathers calendar events from the source calendar at the given URL or from a file.
|
|
The file must be in ICal format.<br><br>
|
|
|
|
If the URL
|
|
starts with <code>https://</code>, the perl module IO::Socket::SSL must be installed
|
|
(use <code>cpan -i IO::Socket::SSL</code>).<br><br>
|
|
|
|
Note for users of Google Calendar: You can literally use the private ICal URL from your Google Calendar.
|
|
If your Google Calendar
|
|
URL starts with <code>https://</code> and the perl module IO::Socket::SSL is not installed on your system, you can
|
|
replace it by <code>http://</code> if and only if there is no redirection to the <code>https://</code> URL.
|
|
Check with your browser first if unsure.<br><br>
|
|
|
|
The optional parameter <code>interval</code> is the time between subsequent updates
|
|
in seconds. It defaults to 3600 (1 hour).<br><br>
|
|
|
|
Examples:
|
|
<pre>
|
|
define MyCalendar Calendar ical url https://www.google.com­/calendar/ical/john.doe%40example.com­/private-foo4711/basic.ics
|
|
define YourCalendar Calendar ical url http://www.google.com­/calendar/ical/jane.doe%40example.com­/private-bar0815/basic.ics 86400
|
|
define SomeCalendar Calendar ical file /home/johndoe/calendar.ics
|
|
</pre>
|
|
</ul>
|
|
<br>
|
|
|
|
<a name="Calendarset"></a>
|
|
<b>Set </b><br><br>
|
|
<ul>
|
|
<code>set <name> update</code><br>
|
|
Forces the retrieval of the calendar from the URL. The next automatic retrieval is scheduled to occur <code>interval</code> seconds later.<br><br>
|
|
|
|
<code>set <name> reload</code><br>
|
|
Same as <code>update</code> but all calendar events are removed first.<br><br>
|
|
|
|
</ul>
|
|
<br>
|
|
|
|
|
|
<a name="Calendarget"></a>
|
|
<b>Get</b><br><br>
|
|
<ul>
|
|
<code>get <name> update</code><br>
|
|
Same as <code>set <name> update</code><br><br>
|
|
|
|
<code>get <name> reload</code><br>
|
|
Same as <code>set <name> update</code><br><br>
|
|
|
|
<code>get <name> <format> <filter> [<max>]</code><br>
|
|
Returns, line by line, information on the calendar events in the calendar <name>. The content depends on the
|
|
<format> specifier:<br><br>
|
|
|
|
<table>
|
|
<tr><th><format></th><th>content</th></tr>
|
|
<tr><td>uid</td><td>the UID of the event</td></tr>
|
|
<tr><td>text</td><td>a user-friendly textual representation, best suited for display</td></tr>
|
|
<tr><td>summary</td><td>the content of the summary field (subject, title)</td></tr>
|
|
<tr><td>location</td><td>the content of the location field</td></tr>
|
|
<tr><td>alarm</td><td>alarm time in human-readable format</td></tr>
|
|
<tr><td>start</td><td>start time in human-readable format</td></tr>
|
|
<tr><td>end</td><td>end time in human-readable format</td></tr>
|
|
<tr><td>full</td><td>the full state</td></tr>
|
|
<tr><td>debug</td><td>like full with additional information for debugging purposes</td></tr>
|
|
</table><br>
|
|
|
|
The <filter> specifier determines the selected subset of calendar events:<br><br>
|
|
|
|
<table>
|
|
<tr><th><filter></th><th>selection</th></tr>
|
|
<tr><td>mode=<regex></td><td>all calendar events with mode matching the regular expression <regex></td></tr>
|
|
<tr><td><mode></td><td>all calendar events in the mode <mode></td></tr>
|
|
<tr><td>uid=<regex></td><td>all calendar events identified by UIDs that match the regular expression <regex>.</td></tr>
|
|
<tr><td><uid></td><td>all calendar events identified by the UID <uid></td></tr>
|
|
<tr><td><reading></td><td>all calendar events listed in the reading <reading> (modeAlarm, modeAlarmed, modeStart, etc.) - this is deprecated and will be removed in a future version, use mode=<regex> instead.</td></tr>
|
|
<tr><td>all</td><td>all calendar events (past, current and future)</td></tr>
|
|
<tr><td>next</td><td>only calendar events that have not yet ended and among these only the first in a series, best suited for display</td></tr>
|
|
</table><br>
|
|
|
|
The <code>mode=<regex></code> and <code>uid=<regex></code> filters should be preferred over the
|
|
<code><mode></code> and <code><uid></code> filters.<br><br>
|
|
|
|
The optional parameter <code><max></code> limits
|
|
the number of returned lines.<br><br>
|
|
|
|
See attributes <code>hideOlderThan</code> and
|
|
<code>hideLaterThan</code> for how to return events within a certain time window.
|
|
Please remember that the global ±400 days limits apply.<br><br>
|
|
|
|
Examples:<br>
|
|
<code>get MyCalendar text next</code><br>
|
|
<code>get MyCalendar summary uid:435kjhk435googlecom 1</code><br>
|
|
<code>get MyCalendar summary 435kjhk435googlecom 1</code><br>
|
|
<code>get MyCalendar full all</code><br>
|
|
<code>get MyCalendar text mode=alarm|start</code><br>
|
|
<code>get MyCalendar text uid=.*6286.*</code><br>
|
|
<br>
|
|
|
|
<code>get <name> find <regexp></code><br>
|
|
Returns, line by line, the UIDs of all calendar events whose summary matches the regular expression
|
|
<regexp>.<br><br>
|
|
|
|
<code>get <name> vcalendar</code><br>
|
|
Returns the calendar in ICal format as retrieved from the source.<br><br>
|
|
|
|
<code>get <name> vevents</code><br>
|
|
Returns a list of all VEVENT entries in the calendar with additional information for
|
|
debugging. Only properties that have been kept during processing of the source
|
|
are shown. The list of calendar events created from each VEVENT entry is shown as well
|
|
as the list of calendar events that have been omitted.
|
|
|
|
</ul>
|
|
|
|
<br>
|
|
|
|
<a name="Calendarattr"></a>
|
|
<b>Attributes</b>
|
|
<br><br>
|
|
<ul>
|
|
<li><code>hideOlderThan <timespec></code><br>
|
|
<code>hideLaterThan <timespec></code><br><p>
|
|
|
|
These attributes limit the list of events shown by
|
|
<code>get <name> full|debug|text|summary|location|alarm|start|end ...</code>.<p>
|
|
|
|
The time is specified relative to the current time t. If hideOlderThan is set,
|
|
calendar events that ended before t-hideOlderThan are not shown. If hideLaterThan is
|
|
set, calendar events that will start after t+hideLaterThan are not shown.<p>
|
|
|
|
Please note that an action triggered by a change to mode "end" cannot access the calendar event
|
|
if you set hideOlderThan to 0 because the calendar event will already be hidden at that time. Better set
|
|
hideOlderThan to 10.<p>
|
|
|
|
<code><timespec></code> must have one of the following formats:<br>
|
|
<table>
|
|
<tr><th>format</th><th>description</th><th>example</th></tr>
|
|
<tr><td>SSS</td><td>seconds</td><td>3600</td></tr>
|
|
<tr><td>SSSs</td><td>seconds</td><td>3600s</td></tr>
|
|
<tr><td>HH:MM</td><td>hours:minutes</td><td>02:30</td></tr>
|
|
<tr><td>HH:MM:SS</td><td>hours:minutes:seconds</td><td>00:01:30</td></tr>
|
|
<tr><td>D:HH:MM:SS</td><td>days:hours:minutes:seconds</td><td>122:10:00:00</td></tr>
|
|
<tr><td>DDDd</td><td>days</td><td>100d</td></tr>
|
|
</table></li>
|
|
<p>
|
|
|
|
<li><code>onCreateEvent <perl-code></code><br>
|
|
|
|
This attribute allows to run the Perl code <perl-code> for every
|
|
calendar event that is created. See section <a href="#CalendarPlugIns">Plug-ins</a> below.
|
|
</li><p>
|
|
|
|
<li><code>SSLVerify</code><br>
|
|
|
|
This attribute sets the verification mode for the peer certificate for connections secured by
|
|
SSL. Set attribute either to 0 for SSL_VERIFY_NONE (no certificate verification) or
|
|
to 1 for SSL_VERIFY_PEER (certificate verification). Disabling verification is useful
|
|
for local calendar installations (e.g. OwnCloud, NextCloud) without valid SSL certificate.
|
|
</li><p>
|
|
|
|
<li><a href="#readingFnAttributes">readingFnAttributes</a></li>
|
|
</ul>
|
|
<br>
|
|
|
|
<b>Description</b>
|
|
<ul>
|
|
<br>
|
|
A calendar is a set of calendar events. The calendar events are
|
|
fetched from the source calendar at the given URL on a regular basis.<p>
|
|
|
|
A calendar event has a summary (usually the title shown in a visual
|
|
representation of the source calendar), a start time, an end time, and zero, one or more alarm times. In case of multiple alarm times for a calendar event, only the
|
|
earliest alarm time is kept.<p>
|
|
|
|
Recurring calendar events (series) are currently supported to an extent:
|
|
FREQ INTERVAL UNTIL COUNT are interpreted, BYMONTHDAY BYMONTH WKST
|
|
are recognized but not interpreted. BYDAY is correctly interpreted for weekly and monthly events.
|
|
The module will get it most likely wrong
|
|
if you have recurring calendar events with unrecognized or uninterpreted keywords.
|
|
Out-of-order events and events excluded from a series (EXDATE) are handled.
|
|
<p>
|
|
|
|
Calendar events are created when FHEM is started or when the respective entry in the source
|
|
calendar has changed and the calendar is updated or when the calendar is reloaded with
|
|
<code>get <name> reload</code>.
|
|
Only calendar events within ±400 days around the event creation time are created. Consider
|
|
reloading the calendar from time to time to avoid running out of upcoming events. You can use something like <code>define reloadCalendar at +*240:00:00 set MyCalendar reload</code> for that purpose.<p>
|
|
|
|
Some dumb calendars do not use LAST-MODIFIED. This may result in modifications in the source calendar
|
|
go unnoticed. Reload the calendar if you experience this issue.<p>
|
|
|
|
A calendar event is identified by its UID. The UID is taken from the source calendar.
|
|
All events in a series including out-of-order events habe the same UID.
|
|
All non-alphanumerical characters
|
|
are stripped off the original UID to make your life easier.<p>
|
|
|
|
A calendar event can be in one of the following modes:
|
|
<table>
|
|
<tr><td>upcoming</td><td>Neither the alarm time nor the start time of the calendar event is reached.</td></tr>
|
|
<tr><td>alarm</td><td>The alarm time has passed but the start time of the calendar event is not yet reached.</td></tr>
|
|
<tr><td>start</td><td>The start time has passed but the end time of the calendar event is not yet reached.</td></tr>
|
|
<tr><td>end</td><td>The end time of the calendar event has passed.</td></tr>
|
|
</table><br>
|
|
|
|
A calendar event transitions from one mode to another immediately when the time for the change has come. This is done by waiting
|
|
for the earliest future time among all alarm, start or end times of all calendar events.
|
|
<p>
|
|
|
|
A calendar device has several readings. Except for <code>calname</code>, each reading is a semicolon-separated list of UIDs of
|
|
calendar events that satisfy certain conditions:
|
|
<table>
|
|
<tr><td>calname</td><td>name of the calendar</td></tr>
|
|
<tr><td>modeAlarm</td><td>events in alarm mode</td></tr>
|
|
<tr><td>modeAlarmOrStart</td><td>events in alarm or start mode</td></tr>
|
|
<tr><td>modeAlarmed</td><td>events that have just transitioned from upcoming to alarm mode</td></tr>
|
|
<tr><td>modeChanged</td><td>events that have just changed their mode somehow</td></tr>
|
|
<tr><td>modeEnd</td><td>events in end mode</td></tr>
|
|
<tr><td>modeEnded</td><td>events that have just transitioned from start to end mode</td></tr>
|
|
<tr><td>modeStart</td><td>events in start mode</td></tr>
|
|
<tr><td>modeStarted</td><td>events that have just transitioned to start mode</td></tr>
|
|
<tr><td>modeUpcoming</td><td>events in upcoming mode</td></tr>
|
|
</table>
|
|
</ul>
|
|
<p>
|
|
|
|
For recurring events, usually several calendar events exists with the same UID. In such a case,
|
|
the UID is only shown in the mode reading for the most interesting mode. The most
|
|
interesting mode is the first applicable of start, alarm, upcoming, end.<p>
|
|
|
|
In particular, you will never see the UID of a series in modeEnd or modeEnded as long as the series
|
|
has not yet ended - the UID will be in one of the other mode... readings. This means that you better
|
|
do not trigger FHEM events for series based on mode... readings. See below for a recommendation.<p>
|
|
|
|
<b>Events</b>
|
|
<ul><br>
|
|
When the calendar was reloaded or updated or when an alarm, start or end time was reached, one
|
|
FHEM event is created:<p>
|
|
|
|
<code>triggered</code><br><br>
|
|
|
|
When you receive this event, you can rely on the calendar's readings being in a consistent and
|
|
most recent state.<p>
|
|
|
|
|
|
When a calendar event has changed, two FHEM events are created:<p>
|
|
|
|
<code>changed: UID <mode></code><br>
|
|
<code><mode>: UID</code><br><br>
|
|
|
|
<mode> is the current mode of the calendar event after the change. Note: there is a
|
|
colon followed by a single space in the FHEM event specification.<p>
|
|
|
|
The recommended way of reacting on mode changes of calendar events is to get notified
|
|
on the aforementioned FHEM events and do not check for the FHEM events triggered
|
|
by a change of a mode reading.
|
|
<p>
|
|
</ul>
|
|
|
|
<a name="CalendarPlugIns"></a>
|
|
<b>Plug-ins</b>
|
|
<ul>
|
|
<br>
|
|
This is experimental. Use with caution.<p>
|
|
|
|
A plug-in is a piece of Perl code that modifies a calendar event on the fly. The Perl code operates on the
|
|
hash reference <code>$e</code>. The most important elements are as follows:
|
|
|
|
<table>
|
|
<tr><th>code</th><th>description</th></tr>
|
|
<tr><td>$e->{start}</td><td>the start time of the calendar event, in seconds since the epoch</td></tr>
|
|
<tr><td>$e->{end}</td><td>the end time of the calendar event, in seconds since the epoch</td></tr>
|
|
<tr><td>$e->{alarm}</td><td>the alarm time of the calendar event, in seconds since the epoch</td></tr>
|
|
<tr><td>$e->{summary}</td><td>the summary (caption, title) of the calendar event</td></tr>
|
|
<tr><td>$e->{location}</td><td>the location of the calendar event</td></tr>
|
|
</table><br>
|
|
|
|
To add or change the alarm time of a calendar event for all events with the string "Tonne" in the
|
|
summary, the following plug-in can be used:<br><br>
|
|
<code>attr MyCalendar onCreateEvent { $e->{alarm}= $e->{start}-86400 if($e->{summary} =~ /Tonne/);; }</code><br>
|
|
<br>The double semicolon masks the semicolon. <a href="#perl">Perl specials</a> cannot be used.<br>
|
|
</ul>
|
|
<br><br>
|
|
|
|
<b>Usage scenarios</b>
|
|
<ul><br><br>
|
|
<i>Show all calendar events with details</i><br><br>
|
|
<ul>
|
|
<code>
|
|
get MyCalendar full all<br>
|
|
2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom alarm 31.05.2012 17:00:00 07.06.2012 16:30:00-07.06.2012 18:00:00 Erna for coffee<br>
|
|
992hydf4y44awer5466lhfdsr­gl7tin6b6mckf8glmhui4­googlecom upcoming 08.06.2012 00:00:00-09.06.2012 00:00:00 Vacation
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Show calendar events in your photo frame</i><br><br>
|
|
<ul>
|
|
Put a line in the <a href="#RSSlayout">layout description</a> to show calendar events in alarm or start mode:<br><br>
|
|
<code>text 20 60 { fhem("get MyCalendar text next 2") }</code><br><br>
|
|
This may look like:<br><br>
|
|
<code>
|
|
07.06.12 16:30 Erna for coffee<br>
|
|
08.06.12 00:00 Vacation
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Switch the light on when Erna comes</i><br><br>
|
|
<ul>
|
|
First find the UID of the calendar event:<br><br>
|
|
<code>
|
|
get MyCalendar find .*Erna.*<br>
|
|
2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom
|
|
</code><br><br>
|
|
Then define a notify (the dot after the second colon matches the space):<br><br>
|
|
<code>
|
|
define ErnaComes notify MyCalendar:start:.2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom set MyLight on
|
|
</code><br><br>
|
|
You can also do some logging:<br><br>
|
|
<code>
|
|
define LogErna notify MyCalendar:alarm:.2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom { Log3 $NAME, 1, "ALARM name=$NAME event=$EVENT part1=$EVTPART0 part2=$EVTPART1" }
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Switch actors on and off</i><br><br>
|
|
<ul>
|
|
Think about a calendar with calendar events whose summaries (subjects, titles) are the names of devices in your fhem installation.
|
|
You want the respective devices to switch on when the calendar event starts and to switch off when the calendar event ends.<br><br>
|
|
<code>
|
|
define SwitchActorOn notify MyCalendar:start:.* {
|
|
my $reading="$EVTPART0";;
|
|
my $uid= "$EVTPART1";;
|
|
my $actor= fhem("get MyCalendar summary $uid");;
|
|
if(defined $actor) {
|
|
fhem("set $actor on")
|
|
}
|
|
}<br><br>
|
|
define SwitchActorOff notify MyCalendar:end:.* {
|
|
my $reading="$EVTPART0";;
|
|
my $uid= "$EVTPART1";;
|
|
my $actor= fhem("get MyCalendar summary $uid");;
|
|
if(defined $actor) {
|
|
fhem("set $actor off")
|
|
}
|
|
}
|
|
</code><br><br>
|
|
You can also do some logging:<br><br>
|
|
<code>
|
|
define LogActors notify MyCalendar:(start|end):.* { my $reading= "$EVTPART0";; my $uid= "$EVTPART1";; my $actor= fhem("get MyCalendar summary $uid");; Log 3 $NAME, 1, "Actor: $actor, Reading $reading" }
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
|
|
</ul>
|
|
|
|
|
|
<b>Embedded HTML</b>
|
|
<ul><br>
|
|
The module provides an additional function <code>CalendarAsHtml(<name>,<options>)</code>. It
|
|
returns the HTML code for a list of calendar events. <code><name></code> is the name of the
|
|
Calendar device and <code><options></code> is what you would write after <code>get <name> text ...</code>.
|
|
<br><br>
|
|
Example: <code>define MyCalendarWeblink weblink htmlCode { CalendarAsHtml("MyCalendar","next 3") }</code>
|
|
<br><br>
|
|
This is a rudimentary function which might be extended in a future version.
|
|
<p>
|
|
</ul>
|
|
|
|
|
|
</ul>
|
|
|
|
|
|
=end html
|
|
=begin html_DE
|
|
|
|
<a name="Calendar"></a>
|
|
<h3>Calender</h3>
|
|
<ul>
|
|
<br>
|
|
|
|
<a name="Calendardefine"></a>
|
|
<b>Define</b>
|
|
<ul>
|
|
<code>define <name> Calendar ical url <URL> [<interval>]</code><br>
|
|
<code>define <name> Calendar ical file <FILENAME> [<interval>]</code><br>
|
|
<br>
|
|
Definiert ein Kalender-Device.<br><br>
|
|
|
|
Ein Kalender-Device ermittelt (Serien-) Termine aus einem Quell-Kalender. Dieser kann eine URL oder eine Datei sein.
|
|
Die Datei muss im iCal-Format vorliegen.<br><br>
|
|
|
|
Beginnt die URL mit <code>https://</code>, muss das Perl-Modul IO::Socket::SSL installiert sein
|
|
(use <code>cpan -i IO::Socket::SSL</code>).<br><br>
|
|
|
|
Hinweis für Nutzer des Google-Kalenders: Du kann direkt die private iCal-URL des Google Kalender nutzen.
|
|
|
|
Sollte Deine Google-Kalender-URL mit <code>https://</code> beginnen und das Perl-Modul IO::Socket::SSL ist nicht auf Deinem Systeme installiert,
|
|
kannst Du in der URL <code>https://</code> durch <code>http://</code> ersetzen, falls keine automatische Umleitung auf die <code>https://</code> URL erfolgt.
|
|
Solltest Du unsicher sein, ob dies der Fall ist, überprüfe es bitte zuerst mit Deinem Browser.<br><br>
|
|
|
|
Der optionale Parameter <code>interval</code> bestimmt die Zeit in Sekunden zwischen den Updates. Default-Wert ist 3600 (1 Stunde).<br><br>
|
|
|
|
Beispiele:
|
|
<pre>
|
|
define MeinKalender Calendar ical url https://www.google.com­/calendar/ical/john.doe%40example.com­/private-foo4711/basic.ics
|
|
define DeinKalender Calendar ical url http://www.google.com­/calendar/ical/jane.doe%40example.com­/private-bar0815/basic.ics 86400
|
|
define IrgendeinKalender Calendar ical file /home/johndoe/calendar.ics
|
|
</pre>
|
|
</ul>
|
|
<br>
|
|
|
|
<a name="Calendarset"></a>
|
|
<b>Set </b><br><br>
|
|
<ul>
|
|
<code>set <name> update</code><br>
|
|
|
|
Erzwingt das Einlesen des Kalenders von der definierten URL. Das nächste automatische Einlesen erfolgt in
|
|
<code>interval</code> Sekunden später.<br><br>
|
|
|
|
<code>set <name> reload</code><br>
|
|
Dasselbe wie <code>update</code>, jedoch werden zuerst alle Termine entfernt.<br><br>
|
|
|
|
</ul>
|
|
<br>
|
|
|
|
|
|
<a name="Calendarget"></a>
|
|
<b>Get</b><br><br>
|
|
<ul>
|
|
<code>get <name> update</code><br>
|
|
Entspricht <code>set <name> update</code><br><br>
|
|
|
|
<code>get <name> reload</code><br>
|
|
Entspricht <code>set <name> reload</code><br><br>
|
|
|
|
<code>get <name> <format> <filter> [<max>]</code><br>
|
|
Die Termine für den Kalender <name> werden Zeile für Zeile ausgegeben.<br><br>
|
|
|
|
Folgende Selektoren/Filter stehen zur Verfügung:<br><br>
|
|
|
|
Der Selektor <format> legt den zurückgegeben Inhalt fest:<br><br>
|
|
|
|
<table>
|
|
<tr><th><format></th><th>Inhalt</th></tr>
|
|
<tr><td>uid</td><td>UID des Termins</td></tr>
|
|
<tr><td>text</td><td>Benutzer-/Monitorfreundliche Textausgabe.</td></tr>
|
|
<tr><td>summary</td><td>Übersicht (Betreff, Titel)</td></tr>
|
|
<tr><td>location</td><td>Ort</td></tr>
|
|
<tr><td>alarm</td><td>Alarmzeit</td></tr>
|
|
<tr><td>start</td><td>Startzeit</td></tr>
|
|
<tr><td>end</td><td>Endezeit</td></tr>
|
|
<tr><td>full</td><td>Vollständiger Status</td></tr>
|
|
<tr><td>debug</td><td>wie <full> mit zusätzlichen Informationen zur Fehlersuche</td></tr>
|
|
</table><br>
|
|
|
|
Der Filter <filter> grenzt die Termine ein:<br><br>
|
|
|
|
<table>
|
|
<tr><th><filter></th><th>Inhalt</th></tr>
|
|
<tr><td>mode=<regex></td><td>alle Termine, deren Modus durch den regulären Ausdruck <regex> beschrieben werden.</td></tr>
|
|
<tr><td><mode></td><td>alle Termine mit Modus <mode>.</td></tr>
|
|
<tr><td>uid=<regex></td><td>Alle Termine, deren UIDs durch den regulären Ausdruck <regex> beschrieben werden.</td></tr>
|
|
<tr><td><uid></td><td>Alle Termine mit der UID <uid></td></tr>
|
|
<tr><td><reading></td><td>Alle Termine die im Reading <reading> aufgelistet werden (modeAlarm, modeAlarmed, modeStart, etc.)
|
|
- dieser Filter ist abgekündigt und steht in einer zukünftigen Version nicht mehr zur Verfügung, bitte mode=<regex> benutzen.</td></tr>
|
|
<tr><td>all</td><td>Alle Termine (vergangene, aktuelle und zukünftige)</td></tr>
|
|
<tr><td>next</td><td>Alle Termine, die noch nicht beendet sind. Bei Serienterminen der erste Termin. Benutzer-/Monitorfreundliche Textausgabe</td></tr>
|
|
</table><br>
|
|
|
|
Die Filter <code>mode=<regex></code> und <code>uid=<regex></code> sollten den Filtern
|
|
<code><mode></code> und <code><uid></code> vorgezogen werden.<br><br>
|
|
|
|
Der optionale Parameter <code><max></code> schränkt die Anzahl der zurückgegebenen Zeilen ein.<br><br>
|
|
|
|
Bitte beachte die Attribute <code>hideOlderThan</code> und
|
|
<code>hideLaterThan</code> für die Seletion von Terminen in einem bestimmten Zeitfenster.
|
|
Bitte berücksichtige, dass das globale ±400 Tageslimit gilt .<br><br>
|
|
|
|
Beispiele:<br>
|
|
<code>get MyCalendar text next</code><br>
|
|
<code>get MyCalendar summary uid:435kjhk435googlecom 1</code><br>
|
|
<code>get MyCalendar summary 435kjhk435googlecom 1</code><br>
|
|
<code>get MyCalendar full all</code><br>
|
|
<code>get MyCalendar text mode=alarm|start</code><br>
|
|
<code>get MyCalendar text uid=.*6286.*</code><br>
|
|
<br>
|
|
|
|
<code>get <name> find <regexp></code><br>
|
|
Gibt Zeile für Zeile die UIDs aller Termine deren Zusammenfassungen durch den regulären Ausdruck <regex> beschrieben werden.
|
|
<regexp>.<br><br>
|
|
|
|
<code>get <name> vcalendar</code><br>
|
|
Gibt den Kalender ICal-Format, so wie er von der Quelle gelesen wurde, zurück.<br><br>
|
|
|
|
<code>get <name> vevents</code><br>
|
|
Gibt eine Liste aller VEVENT-Einträge des Kalenders <name>, angereichert um Ausgaben für die Fehlersuche, zurück.
|
|
Es werden nur Eigenschaften angezeigt, die während der Programmausführung beibehalten wurden. Es wird sowohl die Liste
|
|
der Termine, die von jedem VEVENT-Eintrag erzeugt wurden, als auch die Liste der ausgelassenen Termine angezeigt.
|
|
|
|
</ul>
|
|
|
|
<br>
|
|
|
|
<a name="Calendarattr"></a>
|
|
<b>Attributes</b>
|
|
<br><br>
|
|
<ul>
|
|
<li><code>hideOlderThan <timespec></code><br>
|
|
<code>hideLaterThan <timespec></code><br><p>
|
|
|
|
Dieses Attribut grenzt die Liste der durch <code>get <name> full|debug|text|summary|location|alarm|start|end ...</code> gezeigten Termine ein.
|
|
|
|
Die Zeit wird relativ zur aktuellen Zeit t angegeben.<br>
|
|
Wenn <hideOlderThan> gesetzt ist, werden Termine, die vor <t-hideOlderThan> enden, ingnoriert.<br>
|
|
Wenn <hideLaterThan> gesetzt ist, werden Termine, die nach <t+hideLaterThan> anfangen, ignoriert.<p>
|
|
|
|
Bitte beachten, dass eine Aktion, die durch einen Wechsel in den Modus "end" ausgelöst wird, nicht auf den Termin
|
|
zugreifen kann, wenn hideOlderThan 0 ist, weil der Termin dann schon versteckt ist. Besser hideOlderThan auf 10 setzen.<p>
|
|
|
|
|
|
<code><timespec></code> muss einem der folgenden Formate entsprechen:<br>
|
|
<table>
|
|
<tr><th>Format</th><th>Beschreibung</th><th>Beispiel</th></tr>
|
|
<tr><td>SSS</td><td>Sekunden</td><td>3600</td></tr>
|
|
<tr><td>SSSs</td><td>Sekunden</td><td>3600s</td></tr>
|
|
<tr><td>HH:MM</td><td>Stunden:Minuten</td><td>02:30</td></tr>
|
|
<tr><td>HH:MM:SS</td><td>Stunden:Minuten:Sekunden</td><td>00:01:30</td></tr>
|
|
<tr><td>D:HH:MM:SS</td><td>Tage:Stunden:Minuten:Sekunden</td><td>122:10:00:00</td></tr>
|
|
<tr><td>DDDd</td><td>Tage</td><td>100d</td></tr>
|
|
</table></li>
|
|
<p>
|
|
|
|
<li><code>onCreateEvent <perl-code></code><br>
|
|
|
|
Dieses Attribut führt ein Perlprogramm <perl-code> für jeden erzeugten Termin aus.
|
|
Weitere Informationen unter <a href="#CalendarPlugIns">Plug-ins</a> im Text.
|
|
</li><p>
|
|
|
|
<li><code>SSLVerify</code><br>
|
|
|
|
Dieses Attribut setzt die Art der Überpruuml;fung des Zertifikats des Partners
|
|
bei mit SSL gesicherten Verbindungen. Entweder auf 0 setzen für
|
|
SSL_VERIFY_NONE (keine Überprüfung des Zertifikats) oder auf 1 für
|
|
SSL_VERIFY_PEER (Überprüfung des Zertifikats). Die Überprüfung auszuschalten
|
|
ist nützlich für lokale Kalenderinstallationen(e.g. OwnCloud, NextCloud)
|
|
ohne gütiges SSL-Zertifikat.
|
|
</li><p>
|
|
|
|
<li><a href="#readingFnAttributes">readingFnAttributes</a></li>
|
|
</ul>
|
|
<br>
|
|
|
|
<b>Beschreibung</b>
|
|
<ul><br>
|
|
|
|
Ein Kalender ist eine Menge von Terminen. Ein Termin hat eine Zusammenfassung (normalerweise der Titel, welcher im Quell-Kalender angezeigt wird), eine Startzeit, eine Endzeit und keine, eine oder mehrere Alarmzeiten. Die Termine werden
|
|
aus dem Quellkalender ermittelt, welcher über die URL angegeben wird. Sollten mehrere Alarmzeiten für einen Termin existieren, wird nur der früheste Alarmzeitpunkt beibehalten. Wiederkehrende Kalendereinträge werden in einem gewissen Umfang unterstützt:
|
|
FREQ INTERVAL UNTIL COUNT werden ausgewertet, BYMONTHDAY BYMONTH WKST
|
|
werden erkannt aber nicht ausgewertet. BYDAY wird für wöchentliche und monatliche Termine
|
|
korrekt behandelt. Das Modul wird es sehr wahrscheinlich falsch machen, wenn Du wiederkehrende Termine mit unerkannten oder nicht ausgewerteten Schlüsselwörtern hast.<p>
|
|
|
|
Termine werden erzeugt, wenn FHEM gestartet wird oder der betreffende Eintrag im Quell-Kalender verändert
|
|
wurde oder der Kalender mit <code>get <name> reload</code> neu geladen wird. Es werden nur Termine
|
|
innerhalb ±400 Tage um die Erzeugungs des Termins herum erzeugt. Ziehe in Betracht, den Kalender von Zeit zu Zeit
|
|
neu zu laden, um zu vermeiden, dass die künftigen Termine ausgehen. Du kann so etwas wie <code>define reloadCalendar at +*240:00:00 set MyCalendar reload</code> dafür verwenden.<p>
|
|
|
|
Manche dummen Kalender benutzen LAST-MODIFIED nicht. Das kann dazu führen, dass Veränderungen im
|
|
Quell-Kalender unbemerkt bleiben. Lade den Kalender neu, wenn Du dieses Problem hast.<p>
|
|
|
|
Ein Termin wird durch seine UID identifiziert. Die UID wird vom Quellkalender bezogen. Um das Leben leichter zu machen, werden alle nicht-alphanumerischen Zeichen automatisch aus der UID entfernt.<p>
|
|
|
|
Ein Termin kann sich in einem der folgenden Modi befinden:
|
|
<table>
|
|
<tr><td>upcoming</td><td>Weder die Alarmzeit noch die Startzeit des Kalendereintrags ist erreicht.</td></tr>
|
|
<tr><td>alarm</td><td>Die Alarmzeit ist überschritten, aber die Startzeit des Kalender-Ereignisses ist noch nicht erreicht.</td></tr>
|
|
<tr><td>start</td><td>Die Startzeit ist überschritten, aber die Ende-Zeit des Kalender-Ereignisses ist noch nicht erreicht.</td></tr>
|
|
<tr><td>end</td><td>Die Ende-Zeit des Kalender-Ereignisses wurde überschritten.</td></tr>
|
|
</table><br>
|
|
Ein Kalender-Ereignis wechselt umgehend von einem Modus zum Anderen, wenn die Zeit für eine Änderung erreicht wurde. Dies wird dadurch erreicht, dass auf die früheste zukünftige Zeit aller Alarme, Start- oder Endezeiten aller Kalender-Ereignisse gewartet wird.
|
|
<p>
|
|
|
|
Ein Kalender-Device hat verschiedene Readings. Mit Ausnahme von <code>calname</code> stellt jedes Reading eine Semikolon-getrennte Liste von UIDs von Kalender-Ereignisse dar, welche bestimmte Zustände haben:
|
|
<table>
|
|
<tr><td>calname</td><td>Name des Kalenders</td></tr>
|
|
<tr><td>modeAlarm</td><td>Ereignisse im Alarm-Modus</td></tr>
|
|
<tr><td>modeAlarmOrStart</td><td>Ereignisse im Alarm- oder Startmodus</td></tr>
|
|
<tr><td>modeAlarmed</td><td>Ereignisse, welche gerade in den Alarmmodus gewechselt haben</td></tr>
|
|
<tr><td>modeChanged</td><td>Ereignisse, welche gerade in irgendeiner Form ihren Modus gewechselt haben</td></tr>
|
|
<tr><td>modeEnd</td><td>Ereignisse im Endemodus</td></tr>
|
|
<tr><td>modeEnded</td><td>Ereignisse, welche gerade vom Start- in den Endemodus gewechselt haben</td></tr>
|
|
<tr><td>modeStart</td><td>Ereignisse im Startmodus</td></tr>
|
|
<tr><td>modeStarted</td><td>Ereignisse, welche gerade in den Startmodus gewechselt haben</td></tr>
|
|
<tr><td>modeUpcoming</td><td>Ereignisse im zukünftigen Modus</td></tr>
|
|
</table>
|
|
<p>
|
|
|
|
Für Serientermine werden mehrere Termine mit der selben UID erzeugt. In diesem Fall
|
|
wird die UID nur im interessantesten gelesenen Modus-Reading angezeigt.
|
|
Der interessanteste Modus ist der erste zutreffende Modus aus der Liste der Modi start, alarm, upcoming, end.<p>
|
|
|
|
Die UID eines Serientermins wird nicht angezeigt, solange sich der Termin im Modus: modeEnd oder modeEnded befindet
|
|
und die Serie nicht beendet ist. Die UID befindet sich in einem der anderen mode... Readings.
|
|
Hieraus ergibts sich, das FHEM-Events nicht auf einem mode... Reading basieren sollten.
|
|
Weiter unten im Text gibt es hierzu eine Empfehlung.<p>
|
|
</ul>
|
|
|
|
<b>Events</b>
|
|
<ul><br>
|
|
Wenn der Kalendar neu geladen oder aktualisiert oder eine Alarm-, Start- oder Endezeit
|
|
erreicht wurde, wird ein FHEM-Event erzeugt:<p>
|
|
|
|
<code>triggered</code><br><br>
|
|
|
|
Man kann sich darauf verlassen, dass alle Readings des Kalenders in einem konsistenten und aktuellen
|
|
Zustand befinden, wenn dieses Event empfangen wird.<p>
|
|
|
|
Wenn ein Termin geändert wurde, werden zwei FHEM-Events erzeugt:<p>
|
|
|
|
<code>changed: UID <mode></code><br>
|
|
<code><mode>: UID</code><br><br>
|
|
|
|
<mode> ist der aktuelle Modus des Termins nach der änderung. Bitte beachten: Im FHEM-Event befindet sich ein Doppelpunkt gefolgt von einem Leerzeichen.<p>
|
|
|
|
FHEM-Events sollten nur auf den vorgenannten Events basieren und nicht auf FHEM-Events, die durch ändern eines mode... Readings ausgelöst werden.
|
|
<p>
|
|
</ul>
|
|
|
|
<a name="CalendarPlugIns"></a>
|
|
<b>Plug-ins</b>
|
|
<ul>
|
|
<br>
|
|
Experimentell, bitte mit Vorsicht nutzen.<p>
|
|
|
|
Ein Plug-In ist ein kleines Perl-Programm, dass Termine nebenher verändern kann.
|
|
Das Perl-Programm arbeitet mit der Hash-Referenz <code>$e</code>.<br>
|
|
Die wichtigsten Elemente sind:
|
|
|
|
<table>
|
|
<tr><th>code</th><th>description</th></tr>
|
|
<tr><td>$e->{start}</td><td>Startzeit des Termins, in Sekunden seit 1.1.1970</td></tr>
|
|
<tr><td>$e->{end}</td><td>Endezeit des Termins, in Sekunden seit 1.1.1970</td></tr>
|
|
<tr><td>$e->{alarm}</td><td>Alarmzeit des Termins, in Sekunden seit 1.1.1970</td></tr>
|
|
<tr><td>$e->{summary}</td><td>die Zusammenfassung (Betreff, Titel) des Termins</td></tr>
|
|
<tr><td>$e->{location}</td><td>Der Ort des Termins</td></tr>
|
|
</table><br>
|
|
|
|
Um für alle Termine mit dem Text "Tonne" in der Zusammenfassung die Alarmzeit zu ergänzen / zu ändern,
|
|
kann folgendes Plug-In benutzt werden:<br><br>
|
|
<code>attr MyCalendar onCreateEvent { $e->{alarm}= $e->{start}-86400 if($e->{summary} =~ /Tonne/);; }</code><br>
|
|
<br>Das doppelte Semikolon maskiert das Semikolon. <a href="#perl">Perl specials</a> können nicht genutzt werden.<br>
|
|
</ul>
|
|
<br><br>
|
|
|
|
<b>Anwendungsbeispiele</b>
|
|
<ul><br>
|
|
<i>Alle Termine inkl. Details anzeigen</i><br><br>
|
|
<ul>
|
|
<code>
|
|
get MyCalendar full all<br>
|
|
2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom known alarm 31.05.2012 17:00:00 07.06.2012 16:30:00-07.06.2012 18:00:00 Erna for coffee<br>
|
|
992hydf4y44awer5466lhfdsr­gl7tin6b6mckf8glmhui4­googlecom known upcoming 08.06.2012 00:00:00-09.06.2012 00:00:00 Vacation
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Zeige Termine in Deinem Bilderrahmen</i><br><br>
|
|
<ul>
|
|
Füge eine Zeile in die <a href="#RSSlayout">layout description</a> ein, um Termine im Alarm- oder Startmodus anzuzeigen:<br><br>
|
|
<code>text 20 60 { fhem("get MyCalendar text next 2") }</code><br><br>
|
|
Dies kann dann z.B. so aussehen:<br><br>
|
|
<code>
|
|
07.06.12 16:30 Erna zum Kaffee<br>
|
|
08.06.12 00:00 Urlaub
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Schalte das Licht ein, wenn Erna kommt</i><br><br>
|
|
<ul>
|
|
Finde zuerst die UID des Termins:<br><br>
|
|
<code>
|
|
get MyCalendar find .*Erna.*<br>
|
|
2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom
|
|
</code><br><br>
|
|
Definiere dann ein notify: (Der Punkt nach dem zweiten Doppelpunkt steht für ein Leerzeichen)<br><br>
|
|
<code>
|
|
define ErnaComes notify MyCalendar:start:.2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom.* set MyLight on
|
|
</code><br><br>
|
|
Du kannst auch ein Logging aufsetzen:<br><br>
|
|
<code>
|
|
define LogErna notify MyCalendar:alarm:.2767324dsfretfvds7dsfn3e4­dsa234r234sdfds6bh874­googlecom.* { Log3 $NAME, 1, "ALARM name=$NAME event=$EVENT part1=$EVTPART0 part2=$EVTPART1" }
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
<i>Schalte die Aktoren an und aus</i><br><br>
|
|
<ul>
|
|
Stell Dir einen Kalender vor, dessen Zusammenfassungen (Betreff, Titel) die Namen von Devices in Deiner fhem-Installation sind.
|
|
Du willst nun die entsprechenden Devices an- und ausschalten, wenn das Kalender-Ereignis beginnt bzw. endet.<br><br>
|
|
<code>
|
|
define SwitchActorOn notify MyCalendar:start:.* {}<br>
|
|
</code>
|
|
Dann auf DEF klicken und im DEF-Editor folgendes zwischen die beiden geschweiften Klammern {} eingeben:
|
|
<code>
|
|
my $reading="$EVTPART0";
|
|
my $uid= "$EVTPART1";
|
|
my $actor= fhem("get MyCalendar summary $uid");
|
|
if(defined $actor) {
|
|
fhem("set $actor on")
|
|
}
|
|
<br><br>
|
|
define SwitchActorOff notify MyCalendar:end:.* {}<br>
|
|
</code>
|
|
Dann auf DEF klicken und im DEF-Editor folgendes zwischen die beiden geschweiften Klammern {} eingeben:
|
|
<code>
|
|
my $reading="$EVTPART0";
|
|
my $uid= "$EVTPART1";
|
|
my $actor= fhem("get MyCalendar summary $uid");
|
|
if(defined $actor) {
|
|
fhem("set $actor off")
|
|
}
|
|
</code><br><br>
|
|
Auch hier kann ein Logging aufgesetzt werden:<br><br>
|
|
<code>
|
|
define LogActors notify MyCalendar:(start|end).* {}<br>
|
|
</code>
|
|
Dann auf DEF klicken und im DEF-Editor folgendes zwischen die beiden geschweiften Klammern {} eingeben:
|
|
<code>
|
|
my $reading= "$EVTPART0";
|
|
my $uid= "$EVTPART1";
|
|
my $actor= fhem("get MyCalendar summary $uid");
|
|
Log 3 $NAME, 1, "Actor: $actor, Reading $reading";
|
|
</code><br><br>
|
|
</ul>
|
|
|
|
</ul>
|
|
|
|
<b>Eingebettetes HTML</b>
|
|
<ul><br>
|
|
Das Modul stellt eine zusätzliche Funktion <code>CalendarAsHtml(<name>,<options>)</code> bereit.
|
|
Diese gibt den HTML-Kode für eine Liste von Terminen zurück. <code><name></code> ist der Name des
|
|
Kalendar-Device und <code><options></code> ist das, was Du hinter <code>get <name> text ...</code>
|
|
schreiben würdest.
|
|
<br><br>
|
|
Beispiel: <code>define MyCalendarWeblink weblink htmlCode { CalendarAsHtml("MyCalendar","next 3") }</code>
|
|
<br><br>
|
|
Dies ist eine rudimentäre Funktion, die vielleicht in künftigen Versionen erweitert wird.
|
|
<p>
|
|
</ul>
|
|
|
|
|
|
</ul>
|
|
|
|
=end html_DE
|
|
=cut
|
|
|