(cl:in-package :hhgbot-augmented-assistant)
;; Special Variables
(defparameter *zxcv* *standard-output*)
(defvar *client*)
(defvar *queue-pair* nil)
;; Macros
(defun start-in-repl (&optional (start-bot t) (team-id :atomampd))
(ubiquitous:restore :hhgbot-augmented-assistant)
(setf slacker::*api-token* (ubiquitous:value :api-token :atomampd))
(if start-bot
(start-with-apitoken team-id)
slacker::*api-token*))
(defun start-with-apitoken (&optional (team-id :atomampd))
(unless *queue-pair*
(setf *queue-pair* (make-instance 'slacker::queue-pair)))
(ubiquitous:restore :hhgbot-augmented-assistant)
(let ((slacker::*api-token* (ubiquitous:value :api-token team-id)))
(unless slacker::*api-token*
(format *terminal-io* "~&API Token? ")
(finish-output *terminal-io*)
(setf slacker::*api-token* (read-line)))
(values (slacker:coordinate-threads *queue-pair*)
slacker::*api-token*)))
(defmacro if-let* ((&rest bindings) &body (then-form &optional else-form))
"Like if-let, but sets bindings sequentially. Doesn't short-circuit."
`(let* ,bindings
(if (and ,@(mapcar #'car bindings))
,then-form
,else-form)))
;; Utility functions
(define-command "myip" (event-pump ts channel)
(in-wq (event-pump)
(blackbird:alet ((ip (carrier:request "http://api.ipify.org/" :return-body t)))
(format *zxcv* "~&IP: ~a~%TS: ~a~%CHANNEL: ~a~%CLIENT: ~A~%" (babel:octets-to-string ip) ts channel event-pump)
(edit-message ts channel
(concat "My ip is: "
(babel:octets-to-string ip))))))
(define-command "jira" (event-pump ts channel project &optional issue-number &rest rest)
(let ((drakma:*drakma-default-external-format* :utf-8))
(apply #'edit-message ts channel
(fw.lu:ensure-list
(cond (rest
"I don't understand . . .")
(issue-number
(format nil "https://atomampd.atlassian.net/browse/~A-~A"
project issue-number))
(t
(format nil "https://atomampd.atlassian.net/browse/ATOMOS-~a"
project)))))))
(define-command "pr" (event-pump ts channel num)
(let ((num (parse-integer num)))
(edit-message ts channel (format nil "https://bitbucket.org/atomampd/atomos/pull-requests/~d?w=1" num))))
(define-command "js>" (event-pump ts channel &rest args)
(declare (ignorable ts))
(let ((*js-executor* (gethash :js-executor (modules event-pump))))
(blackbird:alet ((result (submit-js *js-executor*
(string-join args " "))))
(let ((result (cl-js:to-string result)))
(queue-message event-pump channel
(subseq result 0
(min 1000
(length result)))
:quote t)))))
(define-command "my-rsa-key" (event-pump ts channel &optional (cipher "rsa"))
(with-output-to-message (s event-pump channel :quote t)
(with-open-file (f (truename (concat "~/.ssh/id_" cipher ".pub")))
(let ((seq (make-string (file-length f))))
(read-sequence seq f)
(format s seq)))))
(define-command "paste" (event-pump ts channel)
(with-simple-restart (abort "Stop command")
(ubiquitous:restore :atomampd-slack)
(format t "foo")
(let ((drakma:*drakma-default-external-format* :utf-8))
(edit-message ts channel
(format nil "```~%~a~%```"
(pop (ubiquitous:value :clip)))))))
(define-command "id" (event-pump ts channel &optional (for "channel"))
(edit-message ts channel
(string-case for
("channel" channel)
(t (concat "don't know the id for " for)))))
(defmacro with ((var val) &body body)
`(let ((,var ,val))
,@body))
(ql:quickload '(:vecto :ironclad))
(defun hash-of-vector (vec)
(ironclad:byte-array-to-hex-string (ironclad:digest-sequence :sha256 vec)))
(defpackage #:vecto-example
(:use :cl :alexandria :serapeum :slacker :vecto)
(:shadowing-import-from :alexandria :rotate))
(defparameter *zxcv* *standard-output*)
(define-command "lss" (event-pump ts channel)
(fw.lu:let-each (:be *)
#p"~/public_html/Screenshots/"
(uiop:directory-files *)
(sort * #'> :key #'file-write-date)
(car *)
(uiop/common-lisp:enough-namestring * #p"~/public_html/")
(concat "https://srv2.elangley.org/~edwlan/" *)
(slacker.api:chat.post-message channel * :as_user t :icon_emoji "camera_with_flash")))
(in-package :vecto-example)
(defmacro with ((var val) &body body)
`(let ((,var ,val))
,@body))
(defun octets-to-36string (octets)
(string-join (map 'list (lambda (it)
(format nil "~2,1,0,'0@a"
(with (*print-base* 36)
(write-to-string it ))))
octets)))
(defmacro with-digested-output ((stream (data-sym digest-sym)) data-form &body body)
(with-gensyms (digest-stream data-stream)
`(let* ((,digest-stream (ironclad:make-digesting-stream :sha256))
(,data-stream (ironclad:make-octet-output-stream))
(,stream (make-broadcast-stream ,data-stream ,digest-stream)))
,data-form
(let ((,data-sym (ironclad:get-output-stream-octets ,data-stream))
(,digest-sym (ironclad:produce-digest ,digest-stream)))
,@body))))
(define-command "ring-word" (event-pump ts channel &optional (content #(#x3BB)))
(bt:make-thread
(lambda ()
(declare (optimize (debug 3)))
(let ((*default-pathname-defaults* #p"/home/edwlan/github_repos/hhgbot/"))
(with-canvas (:width 90 :height 90)
(let ((font (get-font "times.ttf"))
(step (/ pi 7)))
(set-font font 40)
(translate 45 45)
(format hhgbot-augmented-assistant::*zxcv* "~&content: ~s~%" content)
(draw-centered-string 0 -10 (map 'vector #'char-code content))
(set-rgb-stroke 1 0 0)
(centered-circle-path 0 0 35)
(stroke)
(set-rgba-stroke 0 0 1.0 0.5)
(set-line-width 4)
(dotimes (i 14)
(with-graphics-state
(vecto:rotate (* i step))
(move-to 30 0)
(line-to 40 0)
(stroke))))
(let* ((image-directory (ensure-directories-exist "/home/edwlan/public_html/slack_images/"))
(image-basename (concat channel "-" ts ".png"))
(image-filename (merge-pathnames image-basename image-directory))
(payload
(concat "token=" *api-token*
"&channel=" channel
"&text=..."
"&as_user=true"
"&attachments="
(quri:url-encode
(concat
"[{\"fallback\": \"foo\", \"ts\":" ts ",\"image_url\": \"https://srv2.elangley.org/~edwlan/slack_images/"
image-basename "\"}]")))))
(vecto:save-png image-filename)
(babel:octets-to-string
(drakma:http-request "https://slack.com/api/chat.postMessage"
:method :post
:content payload))))))
:name "Image Maker"))