Exporting my Slack data to an Org mode file

;; -*- lexical-binding: t; -*-

(require 'json)
(require 'map)
(require 'seq)
(require 's)

;; Where I extracted the downloaded archive. For a script that isn't
;; written have reusability in mind, setting this is more convenient
;; than having to `defvar' and pass a path around.
;;
;; By the way, the current directory in Emacs is default-directory,
;; the current frame is (selected-frame), the current window (pane) is
;; (selected-window), and the current buffer is (current-buffer).
;; English and Emacs are both weird.
(setq default-directory "/tmp/slack-export/")

;; Used to break up long lines when trying to insert raw JSON objects
;; to see the data.
(defun my/fill-string (string)
  "Like `fill-paragraph', but on a STRING."
  (with-temp-buffer
    (insert string)
    (goto-char (point-min))
    (fill-paragraph)
    (buffer-string)))

(defun my/array-files->json (&rest files)
  "Like `my/file->json', except that top-level arrays are merged."
  (cl-reduce
   (lambda (json-a json-b)
     (cl-merge 'list json-a json-b
               (lambda (elem-a elem-b)
                 (< (string-to-number (alist-get 'ts elem-a))
                    (string-to-number (alist-get 'ts elem-b))))))
   (mapcar #'my/file->json files)))

(defun my/file->json (file)
  "Return contents of FILE read through `json-read'."
  (save-match-data
    (with-temp-buffer
      (insert-file-contents-literally file)
      (decode-coding-region (point-min) (point-max) 'utf-8)
      (goto-char (point-min))
      (json-read))))

(defun my/unix-time-to-iso8601-local (unix-timestamp)
  "Convert UNIX-TIMESTAMP into a ISO 8601 timestamp in local time.

Does not take leap seconds into account."
  (format-time-string "%FT%T%z" (seconds-to-time unix-timestamp)))

(defun my/get-user (user-id)
  "Get user JSON object from USER-ID."
  (seq-find
   (lambda (item)
     (equal (alist-get 'id item) user-id))
   (my/file->json "users.json")))

(defun my/get-channel (channel-id)
  "Get channel JSON object from CHANNEL-ID."
  (seq-find
   (lambda (item)
     (equal (alist-get 'id item) channel-id))
   (my/file->json "channels.json")))

(defun my/get-channel-events (channel)
  "Get events for CHANNEL.

CHANNEL can be either a string for its name, or an alist, in
which case the `name' property is used."
  (let ((name (cond ((stringp channel)
                     channel)
                    ((json-alist-p channel)
                     (alist-get 'name channel))
                    (t (error "CHANNEL must be a string or a `json-alist-p'")))))
    (apply #'my/array-files->json
           (directory-files name t "json$"))))

(defun my/insert-properties (alist)
  "Insert ALIST as an Org property drawer."
  (insert ":PROPERTIES:\n")
  (map-do
   (lambda (k v)
     (insert ":" (upcase (format "%s" k)) ":  " v "\n"))
   alist)
  (insert ":END:\n\n"))

(defun my/insert-text (text)
  "Insert TEXT with necessary newlines added amongst other processing."
  (save-match-data
    (insert
     (with-temp-buffer
       (insert text "\n\n")
       (goto-char (point-min))
       (while (re-search-forward "<\\(.*?\\)>" nil t)
         (let ((matched (match-string 1)))
           (cond ((string-prefix-p "@" matched)
                  (replace-match
                   (format "=@%s=" (alist-get 'name (my/get-user
                                                     (substring matched 1))))
                   t t))
                 ((string-prefix-p "http" matched)
                  (replace-match (format "[[%s]]" matched) t t))
                 ((string-prefix-p "#" matched)
                  (replace-match
                   (format "=#%s=" (alist-get 'name (my/get-channel
                                                     ;; Channel IDs are 9 digits
                                                     ;; + 1 for the #
                                                     (substring matched 1 10))))
                   t t)))))
       (buffer-string)))))

(defun my/insert-event (event)
  "Insert EVENT as Org format, handling some types."
  (let-alist event
    (insert "** " (my/unix-time-to-iso8601-local (string-to-number .ts)) "\n")
    (cond (.files
           (my/insert-properties '((type . "files")))
           (seq-doseq (file .files)
             (insert "=" (map-elt file 'name) "=\n")))
          ((equal "channel_join" .subtype)
           (my/insert-properties '((type . "event-join")))
           (my/insert-text .text))
          ((equal "channel_leave" .subtype)
           (my/insert-properties '((type . "event-leave")))
           (my/insert-text .text))
          ((equal "channel_purpose" .subtype)
           (my/insert-properties '((type . "event-set-purpose")))
           (my/insert-text .text))
          ((equal "channel_topic" .subtype)
           (my/insert-properties '((type . "event-set-topic")))
           (my/insert-text .text))
          ((equal "channel_name" .subtype)
           (my/insert-properties '((type . "event-set-name")))
           (my/insert-text .text))
          (t
           (my/insert-properties '((type . "message")))
           (my/insert-text .text)))))

(with-temp-file "slack.org"
  (insert "#+COLUMNS: %ITEM %CREATED %TOPIC %PURPOSE\n\n")
  (let ((channels (append (my/file->json "channels.json") nil)))
    (seq-doseq (channel channels)
      ;; Insert channel information
      (let-alist channel
        (insert "* =" .name "=\n")
        (my/insert-properties
         `((created . ,(my/unix-time-to-iso8601-local .created))
           ,@(unless (equal "" .topic.value) (list (cons 'topic .topic.value)))
           ,@(unless (equal "" .purpose.value) (list (cons 'purpose .purpose.value))))))
      ;; Insert events / messages
      (seq-doseq (event (my/get-channel-events channel))
        (my/insert-event event)))))