1111 lines
43 KiB
EmacsLisp
1111 lines
43 KiB
EmacsLisp
;;; gnus-icalendar.el --- reply to iCalendar meeting requests -*- lexical-binding:t -*-
|
|
|
|
;; Copyright (C) 2013-2024 Free Software Foundation, Inc.
|
|
|
|
;; Author: Jan Tatarik <Jan.Tatarik@gmail.com>
|
|
;; Keywords: mail, icalendar, org
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs 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 3 of the License, or
|
|
;; (at your option) any later version.
|
|
|
|
;; GNU Emacs 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 GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; To install:
|
|
;; (require 'gnus-icalendar)
|
|
;; (gnus-icalendar-setup)
|
|
|
|
;; to enable optional iCalendar->Org sync functionality
|
|
;; NOTE: both the capture file and the headline(s) inside must already exist
|
|
;; (setq gnus-icalendar-org-capture-file "~/org/notes.org")
|
|
;; (setq gnus-icalendar-org-capture-headline '("Calendar"))
|
|
;; (gnus-icalendar-org-setup)
|
|
|
|
|
|
;;; Code:
|
|
|
|
(require 'icalendar)
|
|
(require 'eieio)
|
|
(require 'gmm-utils)
|
|
(require 'mm-decode)
|
|
(require 'gnus-sum)
|
|
(require 'gnus-art)
|
|
|
|
(eval-when-compile (require 'cl-lib))
|
|
|
|
(defun gnus-icalendar-find-if (pred seq)
|
|
(catch 'found
|
|
(while seq
|
|
(when (funcall pred (car seq))
|
|
(throw 'found (car seq)))
|
|
(pop seq))))
|
|
|
|
;;;
|
|
;;; ical-event
|
|
;;;
|
|
|
|
(defclass gnus-icalendar-event ()
|
|
((organizer :initarg :organizer
|
|
:accessor gnus-icalendar-event:organizer
|
|
:initform ""
|
|
:type (or null string))
|
|
(summary :initarg :summary
|
|
:accessor gnus-icalendar-event:summary
|
|
:initform ""
|
|
:type (or null string))
|
|
(description :initarg :description
|
|
:accessor gnus-icalendar-event:description
|
|
:initform ""
|
|
:type (or null string))
|
|
(location :initarg :location
|
|
:accessor gnus-icalendar-event:location
|
|
:initform ""
|
|
:type (or null string))
|
|
(start-time :initarg :start-time
|
|
:accessor gnus-icalendar-event:start-time
|
|
:initform ""
|
|
:type (or null t))
|
|
(end-time :initarg :end-time
|
|
:accessor gnus-icalendar-event:end-time
|
|
:initform ""
|
|
:type (or null t))
|
|
(recur :initarg :recur
|
|
:accessor gnus-icalendar-event:recur
|
|
:initform ""
|
|
:type (or null string))
|
|
(uid :initarg :uid
|
|
:accessor gnus-icalendar-event:uid
|
|
:type string)
|
|
(method :initarg :method
|
|
:accessor gnus-icalendar-event:method
|
|
:initform "PUBLISH"
|
|
:type (or null string))
|
|
(rsvp :initarg :rsvp
|
|
:accessor gnus-icalendar-event:rsvp
|
|
:initform nil
|
|
:type (or null boolean))
|
|
(participation-type :initarg :participation-type
|
|
:accessor gnus-icalendar-event:participation-type
|
|
:initform 'non-participant
|
|
:type (or null t))
|
|
(req-participants :initarg :req-participants
|
|
:accessor gnus-icalendar-event:req-participants
|
|
:initform nil
|
|
:type (or null t))
|
|
(opt-participants :initarg :opt-participants
|
|
:accessor gnus-icalendar-event:opt-participants
|
|
:initform nil
|
|
:type (or null t)))
|
|
"Generic iCalendar Event class.")
|
|
|
|
(defclass gnus-icalendar-event-request (gnus-icalendar-event)
|
|
nil
|
|
"iCalendar class for REQUEST events.")
|
|
|
|
(defclass gnus-icalendar-event-cancel (gnus-icalendar-event)
|
|
nil
|
|
"iCalendar class for CANCEL events.")
|
|
|
|
(defclass gnus-icalendar-event-reply (gnus-icalendar-event)
|
|
nil
|
|
"iCalendar class for REPLY events.")
|
|
|
|
(cl-defmethod gnus-icalendar-event:recurring-p ((event gnus-icalendar-event))
|
|
"Return t if EVENT is recurring."
|
|
(not (null (gnus-icalendar-event:recur event))))
|
|
|
|
(cl-defmethod gnus-icalendar-event:recurring-freq ((event gnus-icalendar-event))
|
|
"Return recurring frequency of EVENT."
|
|
(let ((rrule (gnus-icalendar-event:recur event)))
|
|
(string-match "FREQ=\\([[:alpha:]]+\\)" rrule)
|
|
(match-string 1 rrule)))
|
|
|
|
(cl-defmethod gnus-icalendar-event:recurring-interval ((event gnus-icalendar-event))
|
|
"Return recurring interval of EVENT."
|
|
(let ((rrule (gnus-icalendar-event:recur event))
|
|
(default-interval "1"))
|
|
|
|
(if (string-match "INTERVAL=\\([[:digit:]]+\\)" rrule)
|
|
(match-string 1 rrule)
|
|
default-interval)))
|
|
|
|
(cl-defmethod gnus-icalendar-event:recurring-days ((event gnus-icalendar-event))
|
|
"Return, when available, the week day numbers on which the EVENT recurs."
|
|
(let ((rrule (gnus-icalendar-event:recur event))
|
|
(weekday-map '(("SU" . 0)
|
|
("MO" . 1)
|
|
("TU" . 2)
|
|
("WE" . 3)
|
|
("TH" . 4)
|
|
("FR" . 5)
|
|
("SA" . 6))))
|
|
(when (and rrule (string-match "BYDAY=\\([^;]+\\)" rrule))
|
|
(let ((bydays (split-string (match-string 1 rrule) ",")))
|
|
(seq-map
|
|
(lambda (x) (cdr (assoc x weekday-map)))
|
|
(seq-filter (lambda (x) (string-match "^[A-Z]\\{2\\}$" x)) bydays))))))
|
|
|
|
(cl-defmethod gnus-icalendar-event:start ((event gnus-icalendar-event))
|
|
(format-time-string "%Y-%m-%d %H:%M" (gnus-icalendar-event:start-time event)))
|
|
|
|
(defun gnus-icalendar-event--decode-datefield (event field zone-map)
|
|
(let* ((dtdate (icalendar--get-event-property event field))
|
|
(dtdate-zone (icalendar--find-time-zone
|
|
(icalendar--get-event-property-attributes
|
|
event field) zone-map))
|
|
(dtdate-dec (icalendar--decode-isodatetime dtdate nil dtdate-zone)))
|
|
(when dtdate-dec (encode-time dtdate-dec))))
|
|
|
|
(defun gnus-icalendar-event--find-attendee (ical name-or-email)
|
|
(let* ((event (car (icalendar--all-events ical)))
|
|
(event-props (caddr event)))
|
|
(cl-labels ((attendee-name (att) (plist-get (cadr att) 'CN))
|
|
(attendee-email
|
|
(att)
|
|
(replace-regexp-in-string "^.*MAILTO:" "" (caddr att)))
|
|
(attendee-prop-matches-p
|
|
(prop)
|
|
(and (eq (car prop) 'ATTENDEE)
|
|
(or (member (attendee-name prop) name-or-email)
|
|
(let ((att-email (attendee-email prop)))
|
|
(gnus-icalendar-find-if
|
|
(lambda (str-or-fun)
|
|
(if (functionp str-or-fun)
|
|
(funcall str-or-fun att-email)
|
|
(string-match str-or-fun att-email)))
|
|
name-or-email))))))
|
|
(gnus-icalendar-find-if #'attendee-prop-matches-p event-props))))
|
|
|
|
(defun gnus-icalendar-event--get-attendee-names (ical)
|
|
(let* ((event (car (icalendar--all-events ical)))
|
|
(attendee-props (seq-filter
|
|
(lambda (p) (eq (car p) 'ATTENDEE))
|
|
(caddr event))))
|
|
|
|
(cl-labels
|
|
((attendee-role (prop)
|
|
;; RFC5546: default ROLE is REQ-PARTICIPANT
|
|
(and prop
|
|
(or (plist-get (cadr prop) 'ROLE)
|
|
"REQ-PARTICIPANT")))
|
|
(attendee-name
|
|
(prop)
|
|
(or (plist-get (cadr prop) 'CN)
|
|
(replace-regexp-in-string "^.*MAILTO:" "" (caddr prop))))
|
|
(attendees-by-type (type)
|
|
(seq-filter
|
|
(lambda (p) (string= (attendee-role p) type))
|
|
attendee-props))
|
|
(attendee-names-by-type
|
|
(type)
|
|
(mapcar #'attendee-name (attendees-by-type type))))
|
|
(list
|
|
(attendee-names-by-type "REQ-PARTICIPANT")
|
|
(attendee-names-by-type "OPT-PARTICIPANT")))))
|
|
|
|
(defun gnus-icalendar-event-from-ical (ical &optional attendee-name-or-email)
|
|
(let* ((event (car (icalendar--all-events ical)))
|
|
(organizer (replace-regexp-in-string
|
|
"^.*MAILTO:" ""
|
|
(or (icalendar--get-event-property event 'ORGANIZER) "")))
|
|
(prop-map '((summary . SUMMARY)
|
|
(description . DESCRIPTION)
|
|
(location . LOCATION)
|
|
(recur . RRULE)
|
|
(uid . UID)))
|
|
(method (caddr (assoc 'METHOD (caddr (car (nreverse ical))))))
|
|
(attendee (when attendee-name-or-email
|
|
(gnus-icalendar-event--find-attendee
|
|
ical attendee-name-or-email)))
|
|
(attendee-names (gnus-icalendar-event--get-attendee-names ical))
|
|
;; RFC5546: default ROLE is REQ-PARTICIPANT
|
|
(role (and attendee
|
|
(or (plist-get (cadr attendee) 'ROLE)
|
|
"REQ-PARTICIPANT")))
|
|
(participation-type (pcase role
|
|
("REQ-PARTICIPANT" 'required)
|
|
("OPT-PARTICIPANT" 'optional)
|
|
(_ 'non-participant)))
|
|
(zone-map (icalendar--convert-all-timezones ical))
|
|
(args
|
|
(list :method method
|
|
:organizer organizer
|
|
:start-time (gnus-icalendar-event--decode-datefield
|
|
event 'DTSTART zone-map)
|
|
:end-time (gnus-icalendar-event--decode-datefield
|
|
event 'DTEND zone-map)
|
|
:rsvp (string= (plist-get (cadr attendee) 'RSVP) "TRUE")
|
|
:participation-type participation-type
|
|
:req-participants (car attendee-names)
|
|
:opt-participants (cadr attendee-names)))
|
|
(event-class
|
|
(cond
|
|
((string= method "REQUEST") 'gnus-icalendar-event-request)
|
|
((string= method "CANCEL") 'gnus-icalendar-event-cancel)
|
|
((string= method "REPLY") 'gnus-icalendar-event-reply)
|
|
(t 'gnus-icalendar-event))))
|
|
(cl-labels
|
|
((map-property
|
|
(prop)
|
|
(let ((value (icalendar--get-event-property event prop)))
|
|
(when value
|
|
;; ugly, but cannot get
|
|
;;replace-regexp-in-string work with "\\" as
|
|
;;REP, plus we should also handle "\\;"
|
|
(string-replace
|
|
"\\," ","
|
|
(string-replace
|
|
"\\n" "\n" (substring-no-properties value))))))
|
|
(accumulate-args
|
|
(mapping)
|
|
(cl-destructuring-bind (slot . ical-property) mapping
|
|
(setq args (append (list
|
|
(intern (concat ":" (symbol-name slot)))
|
|
(map-property ical-property))
|
|
args)))))
|
|
(mapc #'accumulate-args prop-map)
|
|
(apply
|
|
#'make-instance
|
|
event-class
|
|
(cl-loop for slot in (eieio-class-slots event-class)
|
|
for keyword = (intern
|
|
(format ":%s" (eieio-slot-descriptor-name slot)))
|
|
when (plist-member args keyword)
|
|
append (list keyword
|
|
(if (eq keyword :uid)
|
|
;; The UID has to be a string.
|
|
(or (plist-get args keyword) "")
|
|
(plist-get args keyword))))))))
|
|
|
|
(defun gnus-icalendar-event-from-buffer (buf &optional attendee-name-or-email)
|
|
"Parse RFC5545 iCalendar in buffer BUF and return an event object.
|
|
|
|
Return a gnus-icalendar-event object representing the first event
|
|
contained in the invitation. Return nil for calendars without an
|
|
event entry.
|
|
|
|
ATTENDEE-NAME-OR-EMAIL is a list of strings that will be matched
|
|
against the event's attendee names and emails. Invitation rsvp
|
|
status will be retrieved from the first matching attendee record."
|
|
(let ((ical (with-current-buffer (icalendar--get-unfolded-buffer (get-buffer buf))
|
|
(goto-char (point-min))
|
|
(icalendar--read-element nil nil))))
|
|
|
|
(when ical
|
|
(gnus-icalendar-event-from-ical ical attendee-name-or-email))))
|
|
|
|
;;;
|
|
;;; gnus-icalendar-event-reply
|
|
;;;
|
|
|
|
(defun gnus-icalendar-event--build-reply-event-body (ical-request status identities &optional comment)
|
|
(let ((summary-status (capitalize (symbol-name status)))
|
|
(attendee-status (upcase (symbol-name status)))
|
|
reply-event-lines)
|
|
(cl-labels
|
|
((update-summary
|
|
(line)
|
|
(if (string-match "^[^:]+:" line)
|
|
(replace-match (format "\\&%s: " summary-status) t nil line)
|
|
line))
|
|
(update-comment
|
|
(line)
|
|
(if comment (format "COMMENT:%s" comment)
|
|
line))
|
|
(update-dtstamp ()
|
|
(format-time-string "DTSTAMP:%Y%m%dT%H%M%SZ" nil t))
|
|
(attendee-matches-identity
|
|
(line)
|
|
(gnus-icalendar-find-if (lambda (name) (string-match-p name line))
|
|
identities))
|
|
(update-attendee-status
|
|
(line)
|
|
(when (and (attendee-matches-identity line)
|
|
(string-match "\\(PARTSTAT=\\)[^;]+" line))
|
|
(replace-match (format "\\1%s" attendee-status) t nil line)))
|
|
(process-event-line
|
|
(line)
|
|
(when (string-match "^\\([^;:]+\\)" line)
|
|
(let* ((key (match-string 0 line))
|
|
;; NOTE: not all of the below fields are mandatory,
|
|
;; but they are often present in other clients'
|
|
;; replies. Can be helpful for debugging, too.
|
|
(new-line
|
|
(cond
|
|
((string= key "ATTENDEE") (update-attendee-status line))
|
|
((string= key "SUMMARY") (update-summary line))
|
|
((string= key "COMMENT") (update-comment line))
|
|
((string= key "DTSTAMP") (update-dtstamp))
|
|
((member key '("ORGANIZER" "DTSTART" "DTEND"
|
|
"LOCATION" "DURATION" "SEQUENCE"
|
|
"RECURRENCE-ID" "UID"))
|
|
line)
|
|
(t nil))))
|
|
(when new-line
|
|
(push new-line reply-event-lines))))))
|
|
|
|
(mapc #'process-event-line (split-string ical-request "\n"))
|
|
|
|
;; RFC5546 refers to uninvited attendees as "party crashers".
|
|
;; This situation is common if the invitation is sent to a group
|
|
;; of people via a mailing list.
|
|
(unless (gnus-icalendar-find-if (lambda (x) (string-match "^ATTENDEE" x))
|
|
reply-event-lines)
|
|
(lwarn 'gnus-icalendar :warning
|
|
"Could not find an event attendee matching given identity")
|
|
(push (format "ATTENDEE;RSVP=TRUE;PARTSTAT=%s;CN=%s:MAILTO:%s"
|
|
attendee-status user-full-name user-mail-address)
|
|
reply-event-lines))
|
|
|
|
;; add comment line if not existing
|
|
(when (and comment
|
|
(not (gnus-icalendar-find-if
|
|
(lambda (x)
|
|
(string-match "^COMMENT" x))
|
|
reply-event-lines)))
|
|
(push (format "COMMENT:%s" comment) reply-event-lines))
|
|
|
|
(mapconcat #'identity `("BEGIN:VEVENT"
|
|
,@(nreverse reply-event-lines)
|
|
"END:VEVENT")
|
|
"\n"))))
|
|
|
|
(defun gnus-icalendar-event-reply-from-buffer (buf status identities &optional comment)
|
|
"Build a calendar event reply for request contained in BUF.
|
|
The reply will have STATUS (`accepted', `tentative' or `declined').
|
|
The reply will be composed for attendees matching any entry
|
|
on the IDENTITIES list.
|
|
Optional argument COMMENT will be placed in the comment field of the
|
|
reply.
|
|
"
|
|
(cl-labels
|
|
((extract-block
|
|
(blockname)
|
|
(save-excursion
|
|
(let ((block-start-re (format "^BEGIN:%s" blockname))
|
|
(block-end-re (format "^END:%s" blockname))
|
|
start)
|
|
(when (re-search-forward block-start-re nil t)
|
|
(setq start (line-beginning-position))
|
|
(re-search-forward block-end-re)
|
|
(buffer-substring-no-properties start (line-end-position)))))))
|
|
(let (zone event)
|
|
(with-current-buffer (icalendar--get-unfolded-buffer (get-buffer buf))
|
|
(goto-char (point-min))
|
|
(setq zone (extract-block "VTIMEZONE")
|
|
event (extract-block "VEVENT")))
|
|
|
|
(when event
|
|
(let ((contents (list "BEGIN:VCALENDAR"
|
|
"METHOD:REPLY"
|
|
"PRODID:Gnus"
|
|
"VERSION:2.0"
|
|
zone
|
|
(gnus-icalendar-event--build-reply-event-body event status identities comment)
|
|
"END:VCALENDAR")))
|
|
|
|
(mapconcat #'identity (delq nil contents) "\n"))))))
|
|
|
|
;;;
|
|
;;; gnus-icalendar-org
|
|
;;
|
|
;; TODO: this is an optional feature, and it's only available with org-mode
|
|
;; 7+, so will need to properly handle emacsen with no/outdated org-mode
|
|
|
|
(require 'org)
|
|
(require 'org-capture)
|
|
|
|
(defgroup gnus-icalendar-org nil
|
|
"Settings for Calendar Event gnus/org integration."
|
|
:version "24.4"
|
|
:group 'gnus-icalendar
|
|
:prefix "gnus-icalendar-org-")
|
|
|
|
(defcustom gnus-icalendar-org-capture-file nil
|
|
"Target Org file for storing captured calendar events."
|
|
:type '(choice (const nil) file))
|
|
|
|
(defcustom gnus-icalendar-org-capture-headline nil
|
|
"Target outline in `gnus-icalendar-org-capture-file' for storing captured events."
|
|
:type '(repeat string))
|
|
|
|
(defcustom gnus-icalendar-org-template-name "used by gnus-icalendar-org"
|
|
"Org-mode template name."
|
|
:type '(string))
|
|
|
|
(defcustom gnus-icalendar-org-template-key "#"
|
|
"Org-mode template hotkey."
|
|
:type '(string))
|
|
|
|
(defvar gnus-icalendar-org-enabled-p nil)
|
|
|
|
|
|
(cl-defmethod gnus-icalendar-event:org-repeat ((event gnus-icalendar-event))
|
|
"Return `org-mode' timestamp repeater string for recurring EVENT.
|
|
Return nil for non-recurring EVENT."
|
|
(when (gnus-icalendar-event:recurring-p event)
|
|
(let* ((freq-map '(("HOURLY" . "h")
|
|
("DAILY" . "d")
|
|
("WEEKLY" . "w")
|
|
("MONTHLY" . "m")
|
|
("YEARLY" . "y")))
|
|
(org-freq (cdr (assoc (gnus-icalendar-event:recurring-freq event) freq-map))))
|
|
|
|
(when org-freq
|
|
(format "+%s%s" (gnus-icalendar-event:recurring-interval event) org-freq)))))
|
|
|
|
(defun gnus-icalendar--find-day (start-date end-date day)
|
|
(let ((time-1-day 86400))
|
|
(if (= (decoded-time-weekday (decode-time start-date))
|
|
day)
|
|
(list start-date end-date)
|
|
(gnus-icalendar--find-day (time-add start-date time-1-day)
|
|
(time-add end-date time-1-day)
|
|
day))))
|
|
|
|
(defun gnus-icalendar-event--org-timestamp (start end org-repeat)
|
|
(let* ((start-date (format-time-string "%Y-%m-%d" start))
|
|
(start-time (format-time-string "%H:%M" start))
|
|
(start-at-midnight (string= start-time "00:00"))
|
|
(end-date (format-time-string "%Y-%m-%d" end))
|
|
(end-time (format-time-string "%H:%M" end))
|
|
(end-at-midnight (string= end-time "00:00"))
|
|
(start-end-date-diff
|
|
(time-to-number-of-days
|
|
(time-subtract (org-time-string-to-time end-date)
|
|
(org-time-string-to-time start-date))))
|
|
(repeat (if org-repeat (concat " " org-repeat) ""))
|
|
(time-1-day 86400))
|
|
|
|
;; NOTE: special care is needed with appointments ending at midnight
|
|
;; (typically all-day events): the end time has to be changed to 23:59 to
|
|
;; prevent org agenda showing the event on one additional day
|
|
(cond
|
|
;; start/end midnight
|
|
;; A 0:0 - A+1 0:0 -> A
|
|
;; A 0:0 - A+n 0:0 -> A - A+n-1
|
|
((and start-at-midnight end-at-midnight) (if (> start-end-date-diff 1)
|
|
(let ((end-ts (format-time-string "%Y-%m-%d" (time-subtract end time-1-day))))
|
|
(format "<%s>--<%s>" start-date end-ts))
|
|
(format "<%s%s>" start-date repeat)))
|
|
;; end midnight
|
|
;; A .:. - A+1 0:0 -> A .:.-23:59
|
|
;; A .:. - A+n 0:0 -> A .:. - A_n-1
|
|
(end-at-midnight (if (= start-end-date-diff 1)
|
|
(format "<%s %s-23:59%s>" start-date start-time repeat)
|
|
(let ((end-ts (format-time-string "%Y-%m-%d" (time-subtract end time-1-day))))
|
|
(format "<%s %s>--<%s>" start-date start-time end-ts))))
|
|
;; start midnight
|
|
;; A 0:0 - A .:. -> A 0:0-.:. (default 1)
|
|
;; A 0:0 - A+n .:. -> A - A+n .:.
|
|
((and start-at-midnight
|
|
(cl-plusp start-end-date-diff)) (format "<%s>--<%s %s>" start-date end-date end-time))
|
|
;; default
|
|
;; A .:. - A .:. -> A .:.-.:.
|
|
;; A .:. - B .:.
|
|
((zerop start-end-date-diff) (format "<%s %s-%s%s>" start-date start-time end-time repeat))
|
|
(t (format "<%s %s>--<%s %s>" start-date start-time end-date end-time))))
|
|
)
|
|
|
|
(cl-defmethod gnus-icalendar-event:org-timestamp ((event gnus-icalendar-event))
|
|
"Build `org-mode' timestamp from EVENT start/end dates and recurrence info."
|
|
;; if org-repeat +1d or +1w and byday: generate one timestamp per
|
|
;; byday, starting at start-date. Change +1d to +7d.
|
|
(let ((start (gnus-icalendar-event:start-time event))
|
|
(end (gnus-icalendar-event:end-time event))
|
|
(org-repeat (gnus-icalendar-event:org-repeat event))
|
|
(recurring-days (gnus-icalendar-event:recurring-days event)))
|
|
(if (and (or (string= org-repeat "+1d")
|
|
(string= org-repeat "+1w"))
|
|
recurring-days)
|
|
(let ((repeat "+1w")
|
|
(dates (seq-sort-by
|
|
'car
|
|
'time-less-p
|
|
(seq-map (lambda (x)
|
|
(gnus-icalendar--find-day start end x))
|
|
recurring-days))))
|
|
(mapconcat (lambda (x)
|
|
(gnus-icalendar-event--org-timestamp (car x) (cadr x)
|
|
repeat)) dates "\n"))
|
|
(gnus-icalendar-event--org-timestamp start end org-repeat))))
|
|
|
|
(defun gnus-icalendar--format-summary-line (summary &optional location)
|
|
(if location
|
|
(format "%s (%s)" summary location)
|
|
(format "%s" summary)))
|
|
|
|
|
|
(defun gnus-icalendar--format-participant-list (participants)
|
|
(mapconcat #'identity participants ", "))
|
|
|
|
;; TODO: make the template customizable
|
|
(cl-defmethod gnus-icalendar-event->org-entry ((event gnus-icalendar-event) reply-status)
|
|
"Return string with new `org-mode' entry describing EVENT."
|
|
(with-temp-buffer
|
|
(org-mode)
|
|
(with-slots (organizer summary description location
|
|
recur uid) event
|
|
(let* ((reply (if reply-status (capitalize (symbol-name reply-status))
|
|
"Not replied yet"))
|
|
(props `(("ICAL_EVENT" . "t")
|
|
("ID" . ,uid)
|
|
("ORGANIZER" . ,(gnus-icalendar-event:organizer event))
|
|
("LOCATION" . ,(gnus-icalendar-event:location event))
|
|
("PARTICIPATION_TYPE" . ,(symbol-name (gnus-icalendar-event:participation-type event)))
|
|
("REQ_PARTICIPANTS" . ,(gnus-icalendar--format-participant-list (gnus-icalendar-event:req-participants event)))
|
|
("OPT_PARTICIPANTS" . ,(gnus-icalendar--format-participant-list (gnus-icalendar-event:opt-participants event)))
|
|
("RRULE" . ,(gnus-icalendar-event:recur event))
|
|
("REPLY" . ,reply))))
|
|
|
|
(insert (format "* %s\n\n"
|
|
(gnus-icalendar--format-summary-line summary location)))
|
|
(mapc (lambda (prop)
|
|
(org-entry-put (point) (car prop) (cdr prop)))
|
|
props))
|
|
|
|
(save-restriction
|
|
(narrow-to-region (point) (point))
|
|
(insert (gnus-icalendar-event:org-timestamp event)
|
|
"\n\n"
|
|
(or description "No description"))
|
|
(indent-region (point-min) (point-max) 2)
|
|
(fill-region (point-min) (point-max)))
|
|
|
|
(buffer-string))))
|
|
|
|
(defun gnus-icalendar--deactivate-org-timestamp (ts)
|
|
(replace-regexp-in-string "[<>]"
|
|
(lambda (m) (cond ((string= m "<") "[")
|
|
((string= m ">") "]")))
|
|
ts))
|
|
|
|
(defun gnus-icalendar-find-org-event-file (event &optional org-file)
|
|
"Return the name of the file containing EVENT org entry.
|
|
Return nil when not found.
|
|
|
|
All org agenda files are searched for the EVENT entry. When
|
|
the optional ORG-FILE argument is specified, only that one file
|
|
is searched."
|
|
(let ((uid (gnus-icalendar-event:uid event))
|
|
(files (or org-file (org-agenda-files t 'ifmode))))
|
|
(cl-labels
|
|
((find-event-in
|
|
(file)
|
|
(org-check-agenda-file file)
|
|
(with-current-buffer (find-file-noselect file)
|
|
(let ((event-pos (org-find-entry-with-id uid)))
|
|
(when (and event-pos
|
|
(string= (cdr (assoc "ICAL_EVENT"
|
|
(org-entry-properties event-pos)))
|
|
"t"))
|
|
(throw 'found file))))))
|
|
(gnus-icalendar-find-if #'find-event-in files))))
|
|
|
|
|
|
(defun gnus-icalendar--show-org-event (event &optional org-file)
|
|
(let ((file (gnus-icalendar-find-org-event-file event org-file)))
|
|
(when file
|
|
(switch-to-buffer (find-file file))
|
|
(goto-char (org-find-entry-with-id (gnus-icalendar-event:uid event)))
|
|
(org-fold-show-entry))))
|
|
|
|
|
|
(defun gnus-icalendar--update-org-event (event reply-status &optional org-file)
|
|
(let ((file (gnus-icalendar-find-org-event-file event org-file)))
|
|
(when file
|
|
(with-current-buffer (find-file-noselect file)
|
|
(with-slots (uid summary description organizer location recur
|
|
participation-type req-participants opt-participants) event
|
|
(let ((event-pos (org-find-entry-with-id uid)))
|
|
(when event-pos
|
|
(goto-char event-pos)
|
|
|
|
;; update the headline, keep todo, priority and tags, if any
|
|
(save-excursion
|
|
(let* ((priority (org-entry-get (point) "PRIORITY"))
|
|
(headline (delq nil (list
|
|
(org-entry-get (point) "TODO")
|
|
(when priority (format "[#%s]" priority))
|
|
(gnus-icalendar--format-summary-line summary location)
|
|
(org-entry-get (point) "TAGS")))))
|
|
|
|
(re-search-forward "^\\*+ " (line-end-position))
|
|
(delete-region (point) (line-end-position))
|
|
(insert (mapconcat #'identity headline " "))))
|
|
|
|
;; update props and description
|
|
(let ((entry-end (org-entry-end-position))
|
|
(entry-outline-level (org-outline-level)))
|
|
|
|
;; delete body of the entry, leave org drawers intact
|
|
(save-restriction
|
|
(org-narrow-to-element)
|
|
(goto-char entry-end)
|
|
(re-search-backward "^[\t ]*:END:")
|
|
(forward-line)
|
|
(delete-region (point) entry-end))
|
|
|
|
;; put new event description in the entry body
|
|
(save-restriction
|
|
(narrow-to-region (point) (point))
|
|
(insert "\n"
|
|
(gnus-icalendar-event:org-timestamp event)
|
|
"\n\n"
|
|
(replace-regexp-in-string "[\n]+$" "\n"
|
|
(or description "No description"))
|
|
"\n")
|
|
(indent-region (point-min) (point-max) (1+ entry-outline-level))
|
|
(fill-region (point-min) (point-max)))
|
|
|
|
;; update entry properties
|
|
(cl-labels
|
|
((update-org-entry
|
|
(position property value)
|
|
(if (or (null value)
|
|
(string= value ""))
|
|
(org-entry-delete position property)
|
|
(org-entry-put position property value))))
|
|
|
|
(update-org-entry event-pos "ORGANIZER" organizer)
|
|
(update-org-entry event-pos "LOCATION" location)
|
|
(update-org-entry event-pos "PARTICIPATION_TYPE"
|
|
(symbol-name participation-type))
|
|
(update-org-entry event-pos "REQ_PARTICIPANTS"
|
|
(gnus-icalendar--format-participant-list
|
|
req-participants))
|
|
(update-org-entry event-pos "OPT_PARTICIPANTS"
|
|
(gnus-icalendar--format-participant-list
|
|
opt-participants))
|
|
(update-org-entry event-pos "RRULE" recur)
|
|
(update-org-entry
|
|
event-pos "REPLY"
|
|
(if reply-status (capitalize (symbol-name reply-status))
|
|
"Not replied yet")))
|
|
(save-buffer)))))))))
|
|
|
|
|
|
(defun gnus-icalendar--cancel-org-event (event &optional org-file)
|
|
(let ((file (gnus-icalendar-find-org-event-file event org-file)))
|
|
(when file
|
|
(with-current-buffer (find-file-noselect file)
|
|
(let ((event-pos (org-find-entry-with-id (gnus-icalendar-event:uid event))))
|
|
(when event-pos
|
|
(let ((ts (org-entry-get event-pos "DT")))
|
|
(when ts
|
|
(org-entry-put event-pos "DT" (gnus-icalendar--deactivate-org-timestamp ts))
|
|
(save-buffer)))))))))
|
|
|
|
|
|
(defun gnus-icalendar--get-org-event-reply-status (event &optional org-file)
|
|
(let ((file (gnus-icalendar-find-org-event-file event org-file)))
|
|
(when file
|
|
(save-excursion
|
|
(with-current-buffer (find-file-noselect file)
|
|
(let ((event-pos (org-find-entry-with-id (gnus-icalendar-event:uid event))))
|
|
(org-entry-get event-pos "REPLY")))))))
|
|
|
|
|
|
(defun gnus-icalendar-insinuate-org-templates ()
|
|
(unless (gnus-icalendar-find-if (lambda (x) (string= (cadr x) gnus-icalendar-org-template-name))
|
|
org-capture-templates)
|
|
(setq org-capture-templates
|
|
(append `((,gnus-icalendar-org-template-key
|
|
,gnus-icalendar-org-template-name
|
|
entry
|
|
(file+olp ,gnus-icalendar-org-capture-file ,@gnus-icalendar-org-capture-headline)
|
|
"%i"
|
|
:immediate-finish t))
|
|
org-capture-templates))
|
|
|
|
;; hide the template from interactive template selection list
|
|
;; (org-capture)
|
|
;; NOTE: doesn't work when capturing from string
|
|
;; (when (boundp 'org-capture-templates-contexts)
|
|
;; (push `(,gnus-icalendar-org-template-key "" ((in-mode . "gnus-article-mode")))
|
|
;; org-capture-templates-contexts))
|
|
))
|
|
|
|
(defun gnus-icalendar:org-event-save (event reply-status)
|
|
(with-temp-buffer
|
|
(org-capture-string (gnus-icalendar-event->org-entry event reply-status)
|
|
gnus-icalendar-org-template-key)))
|
|
|
|
(defun gnus-icalendar-show-org-agenda (event)
|
|
(let* ((time-delta (time-subtract (gnus-icalendar-event:end-time event)
|
|
(gnus-icalendar-event:start-time event)))
|
|
(duration-days (1+ (floor (time-convert time-delta 'integer) 86400))))
|
|
(org-agenda-list nil (gnus-icalendar-event:start event) duration-days)))
|
|
|
|
(cl-defmethod gnus-icalendar-event:sync-to-org ((event gnus-icalendar-event-request) reply-status)
|
|
(if (gnus-icalendar-find-org-event-file event)
|
|
(gnus-icalendar--update-org-event event reply-status)
|
|
(gnus-icalendar:org-event-save event reply-status)))
|
|
|
|
(cl-defmethod gnus-icalendar-event:sync-to-org ((event gnus-icalendar-event-cancel) _reply-status)
|
|
(when (gnus-icalendar-find-org-event-file event)
|
|
(gnus-icalendar--cancel-org-event event)))
|
|
|
|
(defun gnus-icalendar-org-setup ()
|
|
(if (and gnus-icalendar-org-capture-file gnus-icalendar-org-capture-headline)
|
|
(progn
|
|
(gnus-icalendar-insinuate-org-templates)
|
|
(setq gnus-icalendar-org-enabled-p t))
|
|
(message "Cannot enable Calendar->Org: missing capture file, headline")))
|
|
|
|
;;;
|
|
;;; gnus-icalendar
|
|
;;;
|
|
|
|
(defgroup gnus-icalendar nil
|
|
"Settings for inline display of iCalendar invitations."
|
|
:version "24.4"
|
|
:group 'gnus-article
|
|
:prefix "gnus-icalendar-")
|
|
|
|
(defcustom gnus-icalendar-reply-bufname "*CAL*"
|
|
"Buffer used for building iCalendar invitation reply."
|
|
:type '(string))
|
|
|
|
(defcustom gnus-icalendar-additional-identities nil
|
|
"We need to know your identity to make replies to calendar requests work.
|
|
|
|
Gnus will only offer you the Accept/Tentative/Decline buttons for
|
|
calendar events if any of your identities matches at least one
|
|
RSVP participant.
|
|
|
|
Your identity is guessed automatically from the variables
|
|
`user-full-name', `user-mail-address',
|
|
`gnus-ignored-from-addresses' and `message-alternative-emails'.
|
|
|
|
If you need even more aliases you can define them here. It really
|
|
only makes sense to define names or email addresses."
|
|
|
|
:type '(repeat string))
|
|
|
|
(defvar-local gnus-icalendar-reply-status nil)
|
|
|
|
(defvar-local gnus-icalendar-event nil)
|
|
|
|
(defvar-local gnus-icalendar-handle nil)
|
|
|
|
(defun gnus-icalendar-identities ()
|
|
"Return list of regexp-quoted names and email addresses belonging to the user.
|
|
|
|
These will be used to retrieve the RSVP information from ical events."
|
|
(apply #'append
|
|
(mapcar
|
|
(lambda (x) (if (listp x) x (list x)))
|
|
(list user-full-name (regexp-quote user-mail-address)
|
|
;; NOTE: these can be lists
|
|
gnus-ignored-from-addresses ; String or function.
|
|
message-alternative-emails ; String or function.
|
|
(mapcar #'regexp-quote gnus-icalendar-additional-identities)))))
|
|
|
|
;; TODO: make the template customizable
|
|
(cl-defmethod gnus-icalendar-event->gnus-calendar ((event gnus-icalendar-event) &optional reply-status)
|
|
"Format an overview of EVENT details."
|
|
(cl-labels
|
|
((format-header (x)
|
|
(format "%-12s%s"
|
|
(propertize (concat (car x) ":") 'face 'bold)
|
|
(cadr x))))
|
|
|
|
(with-slots (organizer summary description location recur uid
|
|
method rsvp participation-type)
|
|
event
|
|
(let ((headers `(("Summary" ,summary)
|
|
("Location" ,(or location ""))
|
|
("Time" ,(gnus-icalendar-event:org-timestamp event))
|
|
("Organizer" ,organizer)
|
|
("Attendance" ,(if (eq participation-type 'non-participant)
|
|
"You are not listed as an attendee"
|
|
(capitalize (symbol-name participation-type))))
|
|
("Method" ,method))))
|
|
|
|
(when (and (not (gnus-icalendar-event-reply-p event)) rsvp)
|
|
(setq headers (append headers
|
|
`(("Status" ,(or reply-status "Not replied yet"))))))
|
|
|
|
(concat
|
|
(mapconcat #'format-header headers "\n")
|
|
"\n\n"
|
|
description)))))
|
|
|
|
(defmacro gnus-icalendar-with-decoded-handle (handle &rest body)
|
|
"Execute BODY in buffer containing the decoded contents of HANDLE."
|
|
(let ((charset (make-symbol "charset")))
|
|
`(let ((,charset (downcase
|
|
(or (cdr (assoc 'charset (mm-handle-type ,handle)))
|
|
"utf-8"))))
|
|
(with-temp-buffer
|
|
(mm-insert-part ,handle)
|
|
(decode-coding-region (point-min) (point-max) (intern ,charset))
|
|
,@body))))
|
|
|
|
|
|
(defun gnus-icalendar-event-from-handle (handle &optional attendee-name-or-email)
|
|
(gnus-icalendar-with-decoded-handle handle
|
|
(gnus-icalendar-event-from-buffer (current-buffer) attendee-name-or-email)))
|
|
|
|
(defun gnus-icalendar-insert-button (text callback data)
|
|
;; FIXME: the gnus-mime-button-map keymap does not make sense for this kind
|
|
;; of button.
|
|
(let ((start (point)))
|
|
(add-text-properties
|
|
start
|
|
(progn
|
|
(insert "[ " text " ]")
|
|
(point))
|
|
`(gnus-callback
|
|
,callback
|
|
keymap ,gnus-mime-button-map
|
|
face ,gnus-article-button-face
|
|
follow-link t
|
|
category t
|
|
button t
|
|
gnus-data ,data))))
|
|
|
|
(defun gnus-icalendar-send-buffer-by-mail (buffer-name subject organizer)
|
|
(let ((message-signature nil))
|
|
(with-current-buffer gnus-summary-buffer
|
|
(gnus-summary-reply)
|
|
;; Reply to the organizer, not to whoever sent the invitation. person
|
|
;; Some calendar systems use specific email address as organizer to
|
|
;; receive these responses.
|
|
(message-replace-header "To" organizer)
|
|
(message-goto-body)
|
|
(mml-insert-multipart "alternative")
|
|
(mml-insert-empty-tag 'part 'type "text/plain")
|
|
(mml-attach-buffer buffer-name "text/calendar; method=REPLY; charset=UTF-8")
|
|
(message-goto-subject)
|
|
(delete-region (line-beginning-position) (line-end-position))
|
|
(insert "Subject: " subject)
|
|
(message-send-and-exit))))
|
|
|
|
(defun gnus-icalendar-reply (data &optional comment)
|
|
(let* ((handle (car data))
|
|
(status (cadr data))
|
|
(event (caddr data))
|
|
(reply (gnus-icalendar-with-decoded-handle handle
|
|
(gnus-icalendar-event-reply-from-buffer
|
|
(current-buffer) status (gnus-icalendar-identities) comment)))
|
|
(organizer (gnus-icalendar-event:organizer event)))
|
|
|
|
(when reply
|
|
(cl-labels
|
|
((fold-icalendar-buffer
|
|
()
|
|
(goto-char (point-min))
|
|
(while (re-search-forward "^\\(.\\{72\\}\\)\\(.+\\)$" nil t)
|
|
(replace-match "\\1\n \\2")
|
|
(goto-char (line-beginning-position)))))
|
|
(let ((subject (concat (capitalize (symbol-name status))
|
|
": " (gnus-icalendar-event:summary event))))
|
|
|
|
(with-current-buffer (gnus-get-buffer-create gnus-icalendar-reply-bufname)
|
|
(delete-region (point-min) (point-max))
|
|
(insert reply)
|
|
(fold-icalendar-buffer)
|
|
(gnus-icalendar-send-buffer-by-mail (buffer-name) subject organizer))
|
|
|
|
;; Back in article buffer
|
|
(setq-local gnus-icalendar-reply-status status)
|
|
(when gnus-icalendar-org-enabled-p
|
|
(gnus-icalendar--update-org-event event status)
|
|
;; refresh article buffer to update the reply status
|
|
(with-current-buffer gnus-summary-buffer
|
|
(gnus-summary-show-article))))))))
|
|
|
|
(defun gnus-icalendar-sync-event-to-org (event)
|
|
(gnus-icalendar-event:sync-to-org event gnus-icalendar-reply-status))
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-reply-buttons ((event gnus-icalendar-event) handle)
|
|
(let ((accept-btn "Accept")
|
|
(tentative-btn "Tentative")
|
|
(decline-btn "Decline"))
|
|
(unless (gnus-icalendar-event:rsvp event)
|
|
(setq accept-btn "Uninvited Accept"
|
|
tentative-btn "Uninvited Tentative"
|
|
decline-btn "Uninvited Decline"))
|
|
`((,accept-btn gnus-icalendar-reply (,handle accepted ,event))
|
|
(,tentative-btn gnus-icalendar-reply (,handle tentative ,event))
|
|
(,decline-btn gnus-icalendar-reply (,handle declined ,event)))))
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-reply-buttons ((_event gnus-icalendar-event-reply) _handle)
|
|
"No buttons for REPLY events."
|
|
nil)
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-reply-status ((event gnus-icalendar-event))
|
|
(or (when gnus-icalendar-org-enabled-p
|
|
(gnus-icalendar--get-org-event-reply-status event))
|
|
"Not replied yet"))
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-reply-status ((_event gnus-icalendar-event-reply))
|
|
"No reply status for REPLY events."
|
|
nil)
|
|
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-org-buttons ((event gnus-icalendar-event))
|
|
(let* ((org-entry-exists-p (gnus-icalendar-find-org-event-file event))
|
|
(export-button-text (if org-entry-exists-p "Update Org Entry" "Export to Org")))
|
|
|
|
(delq nil (list
|
|
`("Show Agenda" gnus-icalendar-show-org-agenda ,event)
|
|
(when (gnus-icalendar-event-request-p event)
|
|
`(,export-button-text gnus-icalendar-sync-event-to-org ,event))
|
|
(when org-entry-exists-p
|
|
`("Show Org Entry" gnus-icalendar--show-org-event ,event))))))
|
|
|
|
|
|
(cl-defmethod gnus-icalendar-event:inline-org-buttons ((event gnus-icalendar-event-cancel))
|
|
(let ((org-entry-exists-p (gnus-icalendar-find-org-event-file event)))
|
|
|
|
(delq nil (list
|
|
`("Show Agenda" gnus-icalendar-show-org-agenda ,event)
|
|
(when org-entry-exists-p
|
|
`("Update Org Entry" gnus-icalendar-sync-event-to-org ,event))
|
|
(when org-entry-exists-p
|
|
`("Show Org Entry" gnus-icalendar--show-org-event ,event))))))
|
|
|
|
;;;###autoload
|
|
(defun gnus-icalendar-mm-inline (handle)
|
|
(let ((event (gnus-icalendar-event-from-handle handle (gnus-icalendar-identities))))
|
|
|
|
(setq gnus-icalendar-reply-status nil)
|
|
|
|
(when event
|
|
(cl-labels
|
|
((insert-button-group
|
|
(buttons)
|
|
(when buttons
|
|
(mapc (lambda (x)
|
|
(apply #'gnus-icalendar-insert-button x)
|
|
(insert " "))
|
|
buttons)
|
|
(insert "\n\n"))))
|
|
|
|
(insert-button-group
|
|
(gnus-icalendar-event:inline-reply-buttons event handle))
|
|
|
|
(when gnus-icalendar-org-enabled-p
|
|
(insert-button-group (gnus-icalendar-event:inline-org-buttons event)))
|
|
|
|
(setq gnus-icalendar-event event
|
|
gnus-icalendar-handle handle)
|
|
|
|
(insert (gnus-icalendar-event->gnus-calendar
|
|
event
|
|
(gnus-icalendar-event:inline-reply-status event)))))))
|
|
|
|
(defun gnus-icalendar-save-part (handle)
|
|
(let (event)
|
|
(when (and (equal (car (mm-handle-type handle)) "text/calendar")
|
|
(setq event (gnus-icalendar-event-from-handle handle (gnus-icalendar-identities))))
|
|
|
|
(gnus-icalendar-event:sync-to-org event))))
|
|
|
|
|
|
(defun gnus-icalendar-save-event ()
|
|
"Save the Calendar event in the text/calendar part under point."
|
|
(interactive nil gnus-article-mode gnus-summary-mode)
|
|
(gnus-article-check-buffer)
|
|
(let ((data (get-text-property (point) 'gnus-data)))
|
|
(when data
|
|
(gnus-icalendar-save-part data))))
|
|
|
|
(defun gnus-icalendar-reply-accept (&optional comment-p)
|
|
"Accept invitation in the current article.
|
|
|
|
Optional argument COMMENT-P non-nil (interactively `\\[universal-argument]')
|
|
means prompt for a comment to include in the reply."
|
|
(interactive "P" gnus-article-mode gnus-summary-mode)
|
|
(with-current-buffer gnus-article-buffer
|
|
(gnus-icalendar-reply (list gnus-icalendar-handle 'accepted gnus-icalendar-event)
|
|
(when comment-p (read-string "Comment: ")))
|
|
(setq-local gnus-icalendar-reply-status 'accepted)))
|
|
|
|
(defun gnus-icalendar-reply-tentative (&optional comment-p)
|
|
"Send tentative response to invitation in the current article.
|
|
|
|
Optional argument COMMENT-P non-nil (interactively `\\[universal-argument]')
|
|
means prompt for a comment to include in the reply."
|
|
(interactive "P" gnus-article-mode gnus-summary-mode)
|
|
(with-current-buffer gnus-article-buffer
|
|
(gnus-icalendar-reply (list gnus-icalendar-handle 'tentative gnus-icalendar-event)
|
|
(when comment-p (read-string "Comment: ")))
|
|
(setq-local gnus-icalendar-reply-status 'tentative)))
|
|
|
|
(defun gnus-icalendar-reply-decline (&optional comment-p)
|
|
"Decline invitation in the current article.
|
|
|
|
Optional argument COMMENT-P non-nil (interactively `\\[universal-argument]')
|
|
means prompt for a comment to include in the reply."
|
|
(interactive "P" gnus-article-mode gnus-summary-mode)
|
|
(with-current-buffer gnus-article-buffer
|
|
(gnus-icalendar-reply (list gnus-icalendar-handle 'declined gnus-icalendar-event)
|
|
(when comment-p (read-string "Comment: ")))
|
|
(setq-local gnus-icalendar-reply-status 'declined)))
|
|
|
|
(defun gnus-icalendar-event-export ()
|
|
"Export calendar event to `org-mode', or update existing agenda entry."
|
|
(interactive nil gnus-article-mode gnus-summary-mode)
|
|
(with-current-buffer gnus-article-buffer
|
|
(gnus-icalendar-sync-event-to-org gnus-icalendar-event))
|
|
;; refresh article buffer in case the reply had been sent before initial org
|
|
;; export
|
|
(with-current-buffer gnus-summary-buffer
|
|
(gnus-summary-show-article)))
|
|
|
|
(defun gnus-icalendar-event-show ()
|
|
"Display `org-mode' agenda entry related to the calendar event."
|
|
(interactive nil gnus-article-mode gnus-summary-mode)
|
|
(gnus-icalendar--show-org-event
|
|
(with-current-buffer gnus-article-buffer
|
|
gnus-icalendar-event)))
|
|
|
|
(defun gnus-icalendar-event-check-agenda ()
|
|
"Display `org-mode' agenda for days between event start and end dates."
|
|
(interactive nil gnus-article-mode gnus-summary-mode)
|
|
(gnus-icalendar-show-org-agenda
|
|
(with-current-buffer gnus-article-buffer gnus-icalendar-event)))
|
|
|
|
(defvar gnus-mime-action-alist) ; gnus-art
|
|
|
|
(defun gnus-icalendar-setup ()
|
|
;; FIXME: Get rid of this!
|
|
;; The three add-to-list are now redundant (good), but I think the rest
|
|
;; is still not automatically setup.
|
|
(add-to-list 'mm-inlined-types "text/calendar")
|
|
(add-to-list 'mm-automatic-display "text/calendar")
|
|
(add-to-list 'mm-inline-media-tests '("text/calendar" gnus-icalendar-mm-inline identity))
|
|
|
|
(define-key gnus-summary-mode-map "i"
|
|
(define-keymap :prefix 'gnus-summary-calendar-map
|
|
"a" #'gnus-icalendar-reply-accept
|
|
"t" #'gnus-icalendar-reply-tentative
|
|
"d" #'gnus-icalendar-reply-decline
|
|
"c" #'gnus-icalendar-event-check-agenda
|
|
"e" #'gnus-icalendar-event-export
|
|
"s" #'gnus-icalendar-event-show))
|
|
|
|
(require 'gnus-art)
|
|
(add-to-list 'gnus-mime-action-alist
|
|
(cons "save calendar event" #'gnus-icalendar-save-event)
|
|
t))
|
|
|
|
(provide 'gnus-icalendar)
|
|
|
|
;;; gnus-icalendar.el ends here
|