chatikbot/vk.lisp

(in-package #:chatikbot)

(defparameter +vk-api-url+ "https://api.vk.com/method/~A?v=5.40" "VK.com API endpoint")

(defun %vk-api-call (method &optional args)
  (handler-case
      (bordeaux-threads:with-timeout (5)
        (let* ((params (loop for (k . v) in args
                          when v
                          collect (cons
                                   (princ-to-string k)
                                   (princ-to-string v))))
               (response (json-request (format nil +vk-api-url+ method)
                                       :method :post
                                       :parameters params)))
          (when (aget "error" response)
            (error (aget "error_msg" (aget "error" response))))
          (aget "response" response)))
    (bordeaux-threads:timeout (e)
      (declare (ignore e))
      (error "Timeout"))))

(defun vk-wall-get (&key owner-id domain offset count filter extended fields)
  (%vk-api-call "wall.get"
                `(("owner_id" . ,owner-id)
                  ("domain" . ,domain)
                  ("offset" . ,offset)
                  ("count" . ,count)
                  ("filter" . ,filter)
                  ("extended" . ,extended)
                  ("fields" . ,fields))))

(defun vk-get-user-name (id)
  (let ((r (first (%vk-api-call "users.get" `(("user_ids" . ,id))))))
    (format nil "~A ~A" (aget "first_name" r) (aget "last_name" r))))

(defun vk-get-group-name (id)
  (aget "name" (first (%vk-api-call "groups.getById"
                                    `(("group_id" . ,(if (numberp id)
                                                         (- id)
                                                         id)))))))

(defun vk-get-name (id)
  (if (and (numberp id) (> id 0))
      (vk-get-user-name id)
      (vk-get-group-name id)))

;; Cron
(defun process-walls ()
  (handler-case
      (loop for (domain last-id next-fetch period) in (db-vk-get-active-walls)
         when (or (null next-fetch)
                  (local-time:timestamp> (local-time:now) (local-time:unix-to-timestamp next-fetch)))
         do (progn
              (log:info "Fetching wall" domain)
              (handler-case
                  (let ((new-posts
                         (remove last-id (reverse (aget "items" (vk-wall-get :domain domain)))
                                 :test #'>= :key (lambda (p) (aget "id" p))))
                        name)
                    (setf period (adjust-period period (length new-posts)))
                    (when new-posts
                      (setf name (vk-get-name domain)))
                    (dolist (post new-posts)
                      (multiple-value-bind (text disable)
                          (%format-wall-post domain name post)
                        (dolist (chat-id (db-vk-get-domain-chats domain))
                          (ignore-errors
                            (telegram-send-message chat-id text
                                                   :parse-mode "Markdown"
                                                   :disable-web-preview disable))))
                      (setf last-id (max last-id (aget "id" post)))))
                (error (e) (log:error "~A" e)))
              (db-vk-update-wall domain last-id
                                 (local-time:timestamp-to-unix
                                  (local-time:timestamp+ (local-time:now) period :sec))
                                 period))) ;; Update last-id, next-fetch and period
    (error (e) (log:error "~A" e))))

;; Hooks
(defparameter +akb-vk-domain+ "baneks" "VK.com username of 'B-category anekdotes'")

(defun format-akb (post)
  (let* ((id (aget "id" post))
         (url (format nil "https://vk.com/~A?w=wall~A_~A"
                      +akb-vk-domain+ (aget "from_id" post) id)))
    (format nil "~A~%~A" (aget "text" post) url)))

(def-message-cmd-handler handler-akb (:akb)
  (let ((total-aneks
         (aget "count" (vk-wall-get :domain +akb-vk-domain+ :count 1 :offset 10000000))))
    (dolist (post (aget "items" (vk-wall-get :domain +akb-vk-domain+
                                             :count (or (ignore-errors (parse-integer (car args))) 1)
                                             :offset (random total-aneks))))
      (bot-send-message chat-id (format-akb post) :disable-web-preview 1))))

;; VK walls
(defun %send-domains (chat-id domains)
  (bot-send-message
   chat-id
   (if (null domains)
       "Пока ничего не постим"
       (format nil "Постим~%~{~A) https://vk.com/~A~^~%~}"
               (loop for d in domains for i from 1 append (list i d))))
   :disable-web-preview 1))

(defun %find-vk-domain (url)
  (let ((path (puri:uri-path (puri:parse-uri url))))
    (if (equal #\/ (elt path 0))
        (subseq path 1)
        path)))

(defun %ensure-domain (domain)
  (let* ((res (vk-wall-get :domain domain :count 1))
         (last-id (aget "id" (first (aget "items" res)))))
    (db-vk-ensure-domain domain last-id)
    domain))

(defun %vk-find-best-photo (attach)
  (when attach
    (let* ((photo (aget "photo" attach))
           (sizes (loop for (k . v) in photo
                    when (equal "photo_" (subseq k 0 (min 6 (length k))))
                    collect (cons (parse-integer (subseq k 6)) v))))
      (cdr (assoc (apply #'max (mapcar #'car sizes)) sizes)))))

(defun %vk-find-video (attach)
  (when attach
    (let ((video (aget "video" attach)))
      (format nil "https://vk.com/video~A_~A"
              (aget "owner_id" video)
              (aget "id" video)))))

(defun %vk-find-preview (attachments)
  (labels ((find-type (type)
             (find type attachments :key #'(lambda (a) (aget "type" a)) :test #'equal)))
    (or
     (%vk-find-best-photo (find-type "photo"))
     (%vk-find-video (find-type "video")))))

(defparameter +vk-link-scanner+ (cl-ppcre:create-scanner "\\[((id|club)\\d+)\\|([^\\]]*?)\\]") "vk linking regex")

(defun %vk-post-text (post)
  (let* ((history (aget "copy_history" post))
         (reposts (loop for p in history
                     collect (let* ((owner (aget "owner_id" p))
                                    (type (if (> owner 0) "id" "club"))
                                    (id (abs owner)))
                               (format nil "[~A](https://vk.com/~A~A)"
                                       (vk-get-name owner) type id)))))
    (when history
      (setf post (car (last history))))
    (values
     (cl-ppcre:regex-replace-all +vk-link-scanner+
                                 (aget "text" post)
                                 "[\\3](https://vk.com/\\1)")
     (%vk-find-preview (aget "attachments" post))
     reposts)))

(defun %format-wall-post (domain name post)
  (multiple-value-bind (text preview reposts) (%vk-post-text post)
    (values
     (format nil "~@[[✅](~A) ~][~A](https://vk.com/~A?w=wall~A_~A)~@[ ~{↩ ~A~}~]~@[ @ ~A~]~%~A"
             preview name domain (aget "from_id" post) (aget "id" post)
             reposts (format-ts (local-time:unix-to-timestamp (aget "date" post)))
             text)
     (if preview 0 1))))

(def-message-cmd-handler handler-cmd-wall (:wall)
  (let ((domains (db-vk-get-chat-domains chat-id)))
    (if (null args)
        (%send-domains chat-id domains)
        (progn
          (dolist (url args)
            (handler-case
                (let ((idx (parse-integer url)))
                  (db-vk-remove-chat-domain chat-id (nth (1- idx) domains)))
              (parse-error ()
                (let* ((domain (%ensure-domain (%find-vk-domain url)))
                       (existing (find domain domains :test #'equal)))
                  (if existing
                      (db-vk-remove-chat-domain chat-id domain)
                      (db-vk-add-chat-domain chat-id domain))))
              (error (e) (log:error "~A" e))))
          (%send-domains chat-id (db-vk-get-chat-domains chat-id))))))