(in-package :oneliners.api) ;;; DATA DEFINITIONS (defclass invite (db:store-object) ((code :reader invite-code :initform (uuid) :index-type bknr.indices:string-unique-index :index-reader invite-by-code :documentation "An invite code.") (from :reader invite-from :initarg :from :initform nil :index-type bknr.indices:hash-index :index-reader invites-by-contributor :documentation "Who created this invite.") (created-at :reader created-at :initform (get-universal-time) :documentation "When the invite was created. Used to determine invite expiration.")) (:documentation "An invitation to create a new contributor on this server.") (:metaclass db:persistent-class)) (defun invite-expiration (invite) "Returns a string representation of the expiration of an invite" (multiple-value-bind (sec min hour date month year) (decode-universal-time (+ +invite-lifetime+ (created-at invite))) (format nil "~2,'0d-~2,'0d-~2,'0d ~2,'0d:~2,'0d" year month date hour min))) (defmethod json:%to-json ((invite invite)) (json:with-object (json:write-key-value :code (invite-code invite)) (when (invite-from invite) (json:write-key-value :from (contributor-handle (invite-from invite)))) (json:write-key-value :expires (invite-expiration invite)))) (defclass contributor (db:store-object) ((handle :accessor contributor-handle :initarg :handle :initform (error "Contributors must have a name.") :index-type bknr.indices:string-unique-index :index-reader contributor-by-handle :documentation "The contributor's name. Must be unique among all other contributor names.") (signature :accessor contributor-signature :initarg :signature :initform nil :documentation "A short piece of contributor flair. May contain a url.") (salt :reader contributor-salt :initform (uuid) :type string :documentation "Per contributor salt for password hashing.") (hashed-pw :accessor hashed-pw :initform nil :type string :documentation "Hashed password for this contributor. Note, this value is hashed with the server salt and the contributor-salt.") (invites :accessor contributor-invites :initform (list :made 0 :redeemed 0 :limit 1) :documentation "A pair of integers (Invites Made . Invites Redeemed)") (adminp :accessor adminp :initform nil :documentation "indicates whether or not this contributor has admin privileges.") (lockedp :accessor contributor-lockedp :initform nil :documentation "indicates that this contributor is currently banned from editing.")) (:metaclass db:persistent-class)) (defun can-invite-p (contributor) "Returns T if the contributor is currently allowed to make more invites." (or (adminp contributor) (with-plist (limit made) (contributor-invites contributor) (< made limit)))) (defmethod json:%to-json ((obj contributor)) (json:with-object (json:write-key-value "HANDLE" (contributor-handle obj)) (json:write-key-value "SIGNATURE" (contributor-signature obj)))) (defclass api-access (db:store-object) ((token :reader api-token :initform (uuid) :index-type bknr.indices:string-unique-index :index-reader access-by-token) (contributor :reader api-contributor :initarg :contributor :index-type bknr.indices:unique-index :index-reader access-by-contributor)) (:metaclass db:persistent-class)) (deftype runstyle () `(member :auto :manual)) (defparameter +oneliner-brief-max-length+ 72) (defclass oneliner (db:store-object) ((oneliner :accessor oneliner :initarg :oneliner :initform (error "Oneliner required")) (runstyle :accessor oneliner-runstyle :initarg :runstyle :initform :auto :type runstyle :documentation "If :manual, indicates that this oneliner is not suitable for running from within another process, and should be run directly. Hence, clients should copy the text of this oneliner to the clipboard if possible. Examples include ncurses applications, applications making use of readline, or those require extensive contributor interaction.") (tags :accessor oneliner-tags :initarg :tags :initform nil :index-type bknr.indices:hash-list-index :index-initargs (:test 'equal) :index-reader oneliners-by-tag :documentation "The commands that this oneliner principally involves.") (brief :accessor oneliner-brief :initarg :brief :initform (error "Oneliners need a brief title") :documentation "A short description of the oneliner.") (explanation :accessor oneliner-explanation :initarg :explanation :initform "") (created-by :reader created-by :initform (error "oneliners must be made by a contributor") :initarg :created-by) (created-at :reader created-at :initform (get-universal-time)) (edited-at :accessor edited-at :initform nil :documentation "A universal time recording the last time of edit") (last-edited-by :accessor last-edited-by :initform nil :documentation "a contributor instance, the last person to edit thiscommand.") (flagged-by :accessor flagged-by :initform nil :documentation "NIL or a CONTRIBUTOR object.") (lockedp :accessor lockedp :initform nil :documentation "Prevents editing until unliked. Only contributors with admin priviliges can lock/unlock.")) (:metaclass db:persistent-class)) (defmethod json:%to-json ((instance oneliner)) (with-slots (db::id oneliner tags brief explanation created-at edited-at last-edited-by created-by flagged-by audited-by lockedp runstyle) instance (json:with-object (json:write-key-value :id db::id) (json:write-key-value :oneliner oneliner) (json:write-key-value :tags tags) (json:write-key-value :brief brief) (json:write-key-value :explanation explanation) (json:write-key-value :runstyle runstyle) (json:write-key-value :createdAt created-at) (json:write-key-value :editedAt (if edited-at edited-at :null)) (json:write-key-value :createdBy (contributor-handle created-by)) (json:write-key-value :isFlagged (if (not (null flagged-by)) t :false)) (json:write-key-value :isLocked (if lockedp t :false))))) ;;; SERVICE CONTROL (defvar *server* nil) (defvar *server-domain* "localhost") (defvar *cleaning-thread* nil) (defvar *runningp* nil) (defvar *instance-salt* "change me" "This is salt used for password hashing and login recovery") (defparameter +default-config-file+ #+linux "/etc/oneliners/oneliners-conf.lisp") (defparameter +data-store-directory-name+ "oneliners-api-datastore") (defun data-store-path (store-dir) (let ((store-dir (pathname-directory (if store-dir store-dir (user-homedir-pathname))))) (make-pathname :directory (append store-dir (list +data-store-directory-name+))))) (defun initialize-datastore (store-dir) (ensure-directories-exist (data-store-path store-dir)) (make-instance 'db:mp-store :directory (data-store-path store-dir) :subsystems (list (make-instance 'db:store-object-subsystem)))) (defun ensure-datastore (store-dir) (unless (boundp 'db:*store*) (initialize-datastore store-dir))) (defun ensure-server (port address) (unless *server* (setf *server* (lzb:create-server :port port :address address)) (set-canned-responses))) (defun set-canned-responses () (lzb:set-canned-response *server* 400 "Bad Request" "text/plain") (lzb:set-canned-response *server* 401 "Unauthorized" "text/plain") (lzb:set-canned-response *server* 403 "Forbidden" "text/plain") (lzb:set-canned-response *server* 404 "Not Found" "text/plain") (lzb:set-canned-response *server* 500 "Server Error" "text/plain")) (defun salt-from-file (path) "Get server salt from a file, making one if not already extant. It is recommended to keep this file somewhere other than the host where you are running this instance.. You will need it to allow people to obtain new tokens or to change their passwords for their contributor accounts. So keep it secret, keep it safe." (unless (uiop:file-exists-p path) (a:write-string-into-file (uuid) path)) (a:read-file-into-string path)) (defun make-admins-from-file (path) (if (uiop:file-exists-p path) (let ((admins (with-open-file (input path) (read input)))) (assert (every #$(and (= 2 (length $admin)) (every 'stringp $admin)) admins) () "Admins file formatted incorrectly. It should be a list of pairs of strings ((name pw) (name pw) ...)") (loop for (name pass) in admins unless (contributor-by-handle name) do (make-new-admin-contributor name pass) else do (format *error-output* "Did not make admin ~a." name))) (format *error-output* "Though an admins file ~s was specified, it was not found on disk.~%" path))) (defun start-from-config (&optional (config-file +default-config-file+)) "A config file should contain a single PLIST, specifying several options: :PORT :ADDRESS :DOMAIN :STORE-DIR are all passed to START as-is. :SALT-FILE should be a path to a location on disk both readible and writable by the current process. This file contains the server salt, used to generate password hashes (along with contributor-salt). If a file at this location does not exist, it will be created. You should store this file somewhere besides the server after starting up, or you should ensure that this process, and only this process, has read/write access to it. :INIT-ADMINS-FILE should be a file that contains a list of pairs of strings. This list is interpeted to be ((HANDLE1 PW1) (HANDLE2 PW2) ...) for admin contributors for this server. This file will be read and the contributors will be made. You should destroy this file after the initial boot up, subsequent boots will not need it, even if it remains mentioned in th config file. " (handler-case (progn (assert (uiop:file-exists-p config-file)) (let ((config (with-open-file (input config-file) (read input)))) (with-plist (port address salt-file domain store-dir init-admins-file) config ;; start the server with options in the config. (apply 'start (nconc (when port (list :port port)) (when salt-file (list :salt (salt-from-file salt-file))) (when address (list :address address)) (when domain (list :domain domain)) (when store-dir (list :store-dir store-dir)))) ;; make any admins listed. (when init-admins-file (make-admins-from-file init-admins-file))))) (error (err) (format t "Caught error ~a~%" err)))) (defun start (&key (port 8888) (address "127.0.0.1") salt (domain "localhost") store-dir) (assert salt) (setf *instance-salt* salt *server-domain* domain) (ensure-datastore store-dir) (ensure-server port address) (lzb:install-app *server* (lzb:app 'oneliners.api::oneliners.api)) (lzb:start-server *server*) (setf *runningp* t) (start-cleaning-thread) (format t "STARTED~%")) (defun start-cleaning-thread (&key (run-period 3600)) ;; when the thread was stopped properly. (when (and *cleaning-thread* (bt:thread-alive-p *cleaning-thread*)) (bt:destroy-thread *cleaning-thread*)) (setf *cleaning-thread* (bt:make-thread (lambda () (loop while *runningp* do (sleep run-period) (handler-case (routine-cleaning) (error (e) (print e)))))))) (defun stop () (setf *runningp* nil) (when *server* (lzb:stop-server *server*))) (defparameter +invite-lifetime+ (* 60 60 24) "Invites expire after 24 hours") (defun expired-invite-p (invite &optional (current-time (get-universal-time))) (> (- current-time (created-at invite)) +invite-lifetime+)) (defun routine-cleaning () (let ((now (get-universal-time))) (a:when-let (expired-invites (remove-if-not #$(expired-invite-p $invite now) (db:store-objects-with-class 'invite))) (db:with-transaction () (mapc #'db:delete-object expired-invites))))) ;;; EXTERNAL CACHES (defparameter +newest-queue-size+ 10) (defvar *newest-queue-lock* (bt:make-lock "newest-queue-lock")) (defvar *newest-queue* (make-qb +newest-queue-size+)) ;;; API DEFINITION AND PROVISIONING (defparameter +oneliners-description+ "TBD") (lzb:provision-app () :title "Oneliners Wiki API" :version "0.2.0" :prefix "/api" :desc +oneliners-description+ :content-type "application/json" :auth 'api-token-authorization) (defun api-token-authorization () "This request must be made with an API access token." (a:when-let (contributor (request-contributor)) (or (not (contributor-lockedp contributor)) (adminp contributor)))) ;;; DATABASE TRANSACTIONS (defun delete-oneliner (oneliner) (db:with-transaction () (db:delete-object oneliner))) (defun update-password (contributor new-password) (db:with-transaction () (with-slots (salt hashed-pw) contributor (setf hashed-pw (pw-hash new-password salt))))) (defun set-contributor-locked (contributor value) "Lock / unlock a contributor account" (db:with-transaction () (setf (contributor-lockedp contributor) value))) (defun set-signature (contributor signature) "Set signature" (db:with-transaction () (setf (contributor-signature contributor) signature))) (defun make-new-invite (&optional contributor) "Make and return a new invite object. " (db:with-transaction () (if contributor (let ((invites (contributor-invites contributor))) (incf (getf invites :made)) (setf (contributor-invites contributor) invites) (make-instance 'invite :from contributor)) (make-instance 'invite)))) (defun redeem-invite (invite handle password &optional sig) (db:with-transaction () ;; make new contributor (with-slots (salt hashed-pw signature) (make-instance 'contributor :handle handle) (setf hashed-pw (pw-hash password salt)) (when sig (setf signature sig))) ;; increment the redeemed invite count on the contributor who made ;; it, if exists. (a:when-let (contributor (invite-from invite)) ;; doing it this way b/c i'm not sure if the transaction log ;; would see (incf (getf (contributor-invites contributor) :redeemed)) (let ((invites (contributor-invites contributor))) (incf (getf invites :redeemed)) (setf (contributor-invites contributor) invites))) ;; finally, delete the invite. (db:delete-object invite))) (defun make-new-admin-contributor (handle password) (db:with-transaction () (with-slots (salt hashed-pw adminp) (make-instance 'contributor :handle handle) (setf hashed-pw (pw-hash password salt) adminp t)))) (defun make-api-access (contributor) (db:with-transaction () (make-instance 'api-access :contributor contributor))) (defgeneric revoke-access (what) (:documentation "Effectively deletes an api-access instance.") (:method ((access api-access)) (db:with-transaction () (db:delete-object access))) (:method ((token string)) (a:when-let ((access (access-by-token token))) (revoke-access access))) (:method ((contributor contributor)) (a:when-let ((access (access-by-contributor contributor))) (revoke-access access)))) (defun make-new-oneliner (contributor &key oneliner tags brief explanation runstyle) (a:when-let ((ol (db:with-transaction () (make-instance 'oneliner :created-by contributor :explanation (or explanation "") :tags tags :oneliner oneliner :brief brief :runstyle (if runstyle (a:make-keyword runstyle) :auto))))) (bt:with-lock-held (*newest-queue-lock*) (enqueue-qb *newest-queue* ol)))) (defun unflag-oneliner (oneliner) (db:with-transaction () (setf (flagged-by oneliner) nil))) (defun flag-oneliner (oneliner contributor) (db:with-transaction () (setf (flagged-by oneliner) contributor))) (defun lock-oneliner (oneliner contributor) "Locks a oneliner. Only admins can lock and unlock." (when (adminp contributor) (db:with-transaction () (setf (lockedp oneliner) t)))) (defun unlock-oneliner (oneliner contributor) "Unlocks a oneliner. Only admins can lock and unlock." (when (adminp contributor) (db:with-transaction () (setf (lockedp oneliner) nil)))) (defun edit-oneliner (ol contributor &key oneliner tags brief explanation runstyle) "Assumes each param, where given, has been validated." (db:with-transaction () (setf (last-edited-by ol) contributor) (when oneliner (setf (oneliner ol) oneliner)) (when tags (setf (oneliner-tags ol) tags)) (when brief (setf (oneliner-brief ol) brief)) (when explanation (setf (oneliner-explanation ol) explanation)) (when runstyle (setf (oneliner-runstyle ol) (a:make-keyword runstyle))))) ;;; NONTRANSACTIONAL DATABASE QUERIES (defun newest-oneliners (&optional limit) (bt:with-lock-held (*newest-queue-lock*) (qb-look *newest-queue* :limit limit :reversep t))) (defun flagged-oneliners (&optional limit) (loop for idx from 0 for ol in (db:store-objects-with-class 'oneliner) while (or (not limit) (< idx limit)) when (flagged-by ol) collect ol)) (defun oneliners-with-all-tags (tags) (reduce #'intersection (mapcar #'oneliners-by-tag tags))) (defun query-oneliners (&key tags notflagged (limit 10)) ;; inefficient but easy to express (let ((ols (oneliners-with-all-tags tags))) (a:subseq* (if notflagged (remove-if #'flagged-by ols) ols) 0 limit))) ;;; ROUTE VARIABLE AND PARAMATER PARSERS (defun an-int (string) "An Integer" (parse-integer string)) (defun a-string (string) "A String" string) (defun a-csl (s) "A list of strings separated by commas. e.g. \"foo,bar,goo\"" (mapcar #'str:trim (str:split "," s))) (defun a-boolean (s) "Either \"true\" or \"false\"/" (cond ((string-equal s "true") t) ((string-equal s "false") nil) (t (error "String ~s is neither 'true' nor 'false'" s)))) (defun an-invite-code (code) "An invite code." (a:if-let (invite (invite-by-code code)) invite (http-err 404))) (defun a-contributor-by-handle (handle) "A Contributor's Handle" (a:if-let (contributor (contributor-by-handle handle)) contributor (http-err 404))) (defun a-short-string (string) "A string at most 50 characters in length" (when (< 50 (length string)) (http-err 400 "String Too Long")) string) (defun a-oneliner-id (string) "An id of a oneliner entry " (a:if-let (oneliner (db:store-object-with-id (parse-integer string))) oneliner (http-err 404))) (defun an-api-token (token) "An api token" (a:if-let (access (access-by-token token)) access (http-err 404))) ;;; SOME PREDICATES (defparameter +compiled-tag-and-handle-re+ (ppcre:create-scanner "^[a-z0-9_\-]+$" :single-line-mode t :case-insensitive-mode t)) (defun valid-tag-p (tag) (and (stringp tag) (<= (length tag) 20) (ppcre:scan +compiled-tag-and-handle-re+ tag))) (defun valid-contributor-handle-p (handle) (and (stringp handle) (<= 3 (length handle) 15) (ppcre:scan +compiled-tag-and-handle-re+ handle))) (defun valid-signature-p (signature) (and (stringp signature) (<= (length signature) +oneliner-brief-max-length+))) (defun is-current-password-p (contributor pw) (with-slots (salt hashed-pw) contributor (equal hashed-pw (pw-hash pw salt)))) ;;; ENDPOINT DEFINITIONS (defendpoint* :get "/contributor/:who a-contributor-by-handle:" () () "Return a [contributor](#contributor) data object." (to-json who)) (defendpoint* :put "/contributor/:who a-contributor-by-handle:/locked" ((value a-boolean) (token an-api-token)) (:auth 'admin-only) "Admin users may lock a particular contributor, preventing that contributor for making edits or adding new oneliners." (set-contributor-locked who value) "true") (defendpoint* :put "/contributor/:who a-contributor-by-handle:/password" ((value a-string) (repeated a-string) (current a-string) (token an-api-token)) (:auth t) "Change a contributor's password. CURRENT is the current password. VALUE is the new password. REPEATED must match VALUE. TOKEN is an API Access token." (unless (or (eq who (api-contributor token)) (adminp (api-contributor token))) (http-err 403 "Cannot change that password.")) (unless (is-current-password-p who current) (http-err 400 "The old password is incorrect.")) (unless (equalp value repeated) (http-err 400 "The two passwords do not match.")) (update-password who value) "true") (defendpoint* :put "/contributor/:who a-contributor-by-handle:/signature" ((token an-api-token)) (:auth t) "Update a [contributor's](#contributor) signature." (unless (or (eq who (api-contributor token)) (adminp (api-contributor token))) (http-err 403)) (with-plist (signature) (lzb:request-body) (unless (valid-signature-p signature) (http-err 400 "Bad signature")) (set-signature who signature) "true")) (defendpoint* :post "/invite/redeem/:code an-invite-code:" () () "Redeem an [invite code](#invite-code) and create a new [contributor](#new-contributor-post-body)" (with-plist (password1 password2 handle signature) (lzb:request-body) (unless (equal password1 password2) (http-err 400 "Passwords dont match")) (unless (valid-contributor-handle-p handle) (http-err 400 (format nil "~a is not a valid contributor handle." handle))) (when (contributor-by-handle handle) (http-err 403 (format nil "The name ~a is already taken." handle))) (redeem-invite code handle password1 signature) "true")) (defendpoint* :post "/access" () () "Authenticate a contributor and reply with an [API token](#access-token)" (with-plist (password handle) (lzb:request-body) (a:if-let ((contributor (contributor-by-handle handle))) (if (equal (pw-hash password (contributor-salt contributor)) (hashed-pw contributor)) (let ((token (a:if-let (access (access-by-contributor contributor)) (api-token access) (api-token (make-api-access contributor))))) (to-json (list :token token))) (http-err 401))))) (defun can-revoke-contributor (requesting-contributor target-contributor) "A contributor can revoke their own access, or an admin can revoke anybody's." (or (eq requesting-contributor target-contributor) (adminp requesting-contributor))) ;TODO: Might rewrite this to be by user-name (defendpoint* :delete "/access/:access an-api-token:" ((token an-api-token)) (:auth t) "Revoke access of CONTRIBUTOR" (unless (can-revoke-contributor (request-contributor) (api-contributor access)) (http-err 403)) (revoke-access access) "true") (defun authorized-to-invite () "To make a new invite, a contributor must be authorized and must not have exceeded the invite limit." (a:when-let (contributor (and (api-token-authorization) (request-contributor))) (or (adminp contributor) (can-invite-p contributor)))) (defendpoint* :post "/invite" ((token an-api-token)) (:auth 'authorized-to-invite) "On success, return an object containing a new [invite token](#invite-token)." (to-json (make-new-invite (api-contributor token)))) (defparameter +explanation-wordcount-limit+ 549) (defun validate-new-oneliner-plist (plist) (with-plist (oneliner tags brief runstyle explanation) plist (unless tags (http-err 400 "A oneliner requires tags")) (unless (every 'valid-tag-p tags) (http-err 400 "Some tags are malformed.")) (unless brief (http-err 400 "Oneliner requires a brief explanation")) (unless (<= (length brief) +oneliner-brief-max-length+) (http-err 400 "Brief description is too long. Limit to 75 characters")) (unless oneliner (http-err 400 "Oneliner cannot be blank")) (when explanation (unless (<= (count #\space explanation) +explanation-wordcount-limit+) (http-err 400 "Explanation is too long. Limit to around 550 words."))) (when runstyle (setf runstyle (a:make-keyword runstyle)) (unless (typep runstyle 'runstyle) (http-err 400 "Invalid runstyle. Must be AUTO or MANUAL"))))) (defendpoint* :delete "/oneliner/:oneliner a-oneliner-id:" ((token an-api-token)) (:auth t) "Delete a oneliner." (delete-oneliner oneliner) "true") (defendpoint* :post "/oneliner" ((token an-api-token)) (:auth t) "Make a new [oneliner](#oneliner)." (validate-new-oneliner-plist (lzb:request-body)) (apply 'make-new-oneliner (api-contributor token) (lzb:request-body)) "true") (defun admin-only () "The request requires an API access token. Only contributors with admin privileges are allowed to perform this action." (a:when-let (contributor (request-contributor)) (adminp contributor))) (defendpoint* :put "/oneliner/:oneliner a-oneliner-id:/locked" ((token an-api-token) (value a-boolean)) (:auth 'admin-only) "Sets the locked value of the specified oneliner" (if value (lock-oneliner oneliner (api-contributor token)) (unlock-oneliner oneliner (api-contributor token))) "true") (defun validate-oneliner-edit-plist (plist) (with-plist (brief runstyle) plist (when brief (unless (<= (length brief) +oneliner-brief-max-length+) (http-err 400 (format nil "Brief too long. Must be under ~a" +oneliner-brief-max-length+)))) (when runstyle (unless (typep (a:make-keyword runstyle) 'runstyle) (http-err 400 (format nil "Invalid runstyle. Must be AUTO or MANUAL")))))) (defendpoint* :patch "/oneliner/:entry a-oneliner-id:/edit" ((token an-api-token)) (:auth t) "Edit the fields of a oneliner." (when (and (lockedp entry) (not (adminp (api-contributor token)))) (http-err 403)) (validate-oneliner-edit-plist (lzb:request-body)) (apply 'edit-oneliner entry (api-contributor token) (lzb:request-body)) "true") (defendpoint* :get "/oneliner/:entry a-oneliner-id:" () () "Gets a oneliner by id." (to-json entry)) (defendpoint* :put "/oneliner/:entry a-oneliner-id:/flag" ((token an-api-token) (value a-boolean)) (:auth t) "Flag / Unflag the oneliner for review." (when (and (lockedp entry) (not (adminp (api-contributor token)))) (http-err 403)) (if value (flag-oneliner entry (api-contributor token)) (if (adminp (api-contributor token)) (unflag-oneliner entry) (http-err 403))) "true") (defendpoint* :get "/oneliners/newest" ((limit an-int)) () "A search endpoint returning the LIMIT newest oneliners." (to-json (list :oneliners (newest-oneliners limit)))) (defendpoint* :get "/oneliners/all-flagged" ((limit an-int)) () "A search endpoint returning all of the flagged oneliners. If LIMIT is present, only that many are returned." (to-json (list :oneliners (flagged-oneliners limit)))) (defendpoint* :get "/oneliners" ((tags a-csl) (limit an-int) (notflagged a-boolean)) () "A search endpoint returning a JSON encoded array of Oneliner Entries. TAGS cannot be empty. Returns a [Search Result](#search-result) object." (if tags (to-json (list :oneliners (query-oneliners :tags tags :notflagged notflagged :limit limit))) (http-err 400))) ;;; HELPERS (defun pw-hash (plaintext salt) "Hash plaintext using SALT and the value of *INSTANCE-SALT*" (flexi-streams:octets-to-string (ironclad:digest-sequence :sha3 (flexi-streams:string-to-octets (concatenate 'string *instance-salt* salt plaintext) :external-format :utf-8)) :external-format :latin1)) (defun uuid () (format nil "~a" (uuid:make-v1-uuid))) (defun oneliner-mentions-any (ol keywords) "A case insensitive search for the presence of any of KEYWORDS in the oneliner OL." (with-slots (text breif explanation) ol (loop for word in keywords thereis (search word text :test #'char-equal) thereis (search word breif :test #'char-equal) thereis (search word explanation :test #'char-equal)))) (defun to-json (thing) (let ((jonathan:*false-value* :false) (jonathan:*null-value* :null)) (jonathan:to-json thing))) (defun request-contributor () (a:when-let (access (access-by-token (lzb:request-parameter "TOKEN"))) (api-contributor access)))