Bubblegumdrop
/
cl-deck-builder2
1
1
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Activity
Yu-Gi-Oh! Deck Building and Card Inventory Management web interface written in Common Lisp, utilizing HTMX.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Haara
5.3MB
Puu: fc475a9eec
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'fc475a9eec'
${ noResults }
cl-deck-builder2/src/web/inventory.lisp

245 lines
9.7KB
Raaka Blame Historia 

  1. #|

  2. 

  3. src/web/inventory.lisp

  4. 

  5. Crystal Commerce-style Inventory Management User Interface and helpers.

  6. 

  7. TODO pass over the results of (make-search-query) such that

  8. :total-qty is the aggregate of:

  9. 

  10. (select 'ygo-cc-item (where (:= :item_id xxx)))

  11. 

  12. (reduce #'+

  13.  (mapcar (alexandria:compose #'read-from-string #'cc-sell-price-of)

  14.          (retrieve-dao 'ygo-cc-item :item-id 48883)))

  15. 

  16. (reduce #'+ (mapcar #'cc-qty-of (retrieve-dao 'ygo-cc-item :item-id 48883)))

  17. 

  18. 

  19. |#

  20. 

  21. (in-package #:cl-deck-builder2.web)

  22. 

  23. (defun render-results (&key (active "/inventory") (class 'cc-item) (params nil) (tpl #P"inventory/search-results.html"))

  24.   "Mega helper function. Render function for anything that currently queries the databse. We search both PRODUCT-NAME and NAME, as well as querying a list of VARIANTs, with a LIMIT on the number of results and an OFFSET into those search results. You may also specify a DIRECTION, and SORT-BY options.

  25. 

  26. TODO Major rewrite candidate right here.

  27. TODO Integrate new SEARCH-SESSION object after that's done."

  28.   (let ((direction (or (query-param "direction" params) "desc"))

  29.         (variant (or (query-param "variant" params)

  30.                      (find-dao 'variant-condition :name "Near Mint")))

  31.         (variants (select-variant-condition))

  32.         (limit (or (query-param "limit" params) "10"))

  33.         (name (or

  34.                (query-param "name" params)

  35.                (query-param "product-name" params)))

  36.         (offset (or (query-param "offset" params) "0"))

  37.         (sort-by (or (query-param "sort-by" params) "id")))

  38.     (handler-case

  39.         (ratify:with-parsed-forms

  40.             ((:integer limit)

  41.              (:integer offset)

  42.              (:string direction)

  43.              (:string sort-by))

  44.           ;; NAME can be blank, so...

  45.           (let* ((filtered-cards (make-search-query class params))

  46.                  (length (make-count-query class params))

  47.                  (pages (generate-pages length offset limit)))

  48.             (render-with-env tpl

  49.                              `(:active ,active

  50.                                :cards ,filtered-cards

  51.                                :direction ,direction

  52.                                :last-page ,(car (last pages))

  53.                                :length ,length

  54.                                :limit ,limit

  55.                                :name ,name

  56.                                :offset ,offset

  57.                                :opposite-direction ,(get-opposite-direction direction)

  58.                                :pages ,pages

  59.                                :search-params ,+search-params+

  60.                                :sort-by ,sort-by

  61.                                :total ,(count-dao class)

  62.                                :variant ,variant

  63.                                :variants ,variants))))

  64.       (ratify:combined-error (e)

  65.         (flash-error (format nil "~a/search.error => ~a~%" active e))))))

  66. 

  67. ;; USE REINITIALIZE-INSTANCE to update the existing YGO-SET-ITEM from _PARSED

  68. (defun patch-card (card _parsed)

  69.   (let ((set-id (query-param "set-id" card))

  70.         (variant-id (query-param "variant-id" card)))

  71.     (handler-case

  72.         (ratify-parsing:with-parsed-forms

  73.             ((:integer set-id)

  74.              (:integer variant-id))

  75.           (let ((found (find-or-create-instance 'ygo-set-item :item-id set-id :variant-id variant-id))

  76.                 (clean (filter-alist _parsed)))

  77.             (v:info :inventory "PATCH-CARD: ~a" found)

  78.             (if found

  79.                 ;; TODO redraw item based on context? Like patching from the inventory list vs patching from the editor?

  80.                 ;; (redirect (format nil "/inventory/~d/edit" (mito:object-id found)) 303)

  81.                 (progn

  82.                   (apply #'reinitialize-instance found (assoc-utils:alist-plist clean))

  83.                   (update-dao found)

  84.                   (_ "Save"))

  85.                 (progn

  86.                   (flash-error (format nil "Error udpating id ~d:~d" set-id variant-id))))))

  87.       (ratify:combined-error (e)

  88.         (flash-error e)))))

  89. 

  90. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  91. ;; Inventory Viewer

  92. (defroute ("/inventory" :method :GET) (&key _parsed)

  93.   "Inventory Viewer GET route. Will display index with search results."

  94.   (v:info :inventory "GET /inventory ~a" _parsed)

  95. 

  96.   ;; (with-logged-in-user

  97.   ;;   (render-results :params _parsed :tpl #P"inventory/index.html"))

  98.   (redirect "/cards"))

  99. 

  100. #|

  101. (defroute ("/inventory" :method :POST) (&key _parsed)

  102.   "Inventory Viewer search POST route. Will display index with search results."

  103.   (v:info :inventory "POST /inventory ~a" _parsed)

  104. 

  105.   (with-logged-in-user

  106.     (render-results :params _parsed :tpl #P"inventory/index.html")))

  107. 

  108. (defroute ("/inventory/search" :method :POST) (&key _parsed)

  109.   "Inventory Viewer search POST route. Will display index with search results."

  110.   (v:info :inventory "POST /inventory/search ~a" _parsed)

  111. 

  112.   (with-logged-in-user

  113.     (render-results :params _parsed)))

  114. 

  115. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  116. ;; Inventory Item Editor

  117. ;;

  118. ;; TODO PUT?? POST?? GET??

  119. 

  120. ;; New Item

  121. (defroute ("/inventory/new" :method :GET) ()

  122.   "Display the page for creation of a new inventory item"

  123.   (v:info :inventory "GET /inventory/new")

  124. 

  125.   (with-logged-in-user

  126.     (render-with-env #P"inventory/new.html"

  127.                      `(:active "/inventory"

  128.                        :card ,(make-instance 'cc-item)))))

  129. 

  130. (defroute ("/inventory/new" :method :POST) (&key _parsed)

  131.   "POST method for the processing the information from page for creation of a new inventory item."

  132.   (v:info :inventory "POST /inventory/new => ~a" _parsed)

  133. 

  134.   (with-logged-in-user

  135.     (let ((clean (filter-alist _parsed)))

  136.       (let ((new (apply #'cc-create (assoc-utils:alist-plist clean))))

  137.         (when (mito:object-id new)

  138.           (redirect (format nil "/inventory/~d/edit" (mito:object-id new))))))))

  139. 

  140. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  141. ;; Inventory Item Importer

  142. (defroute ("/inventory/import" :method :GET) ()

  143.   "Inventory Item Importer. TODO"

  144.   (v:info :inventory "GET /inventory/import")

  145. 

  146.   (with-logged-in-user

  147.     (render-with-env #P"inventory/import.html"

  148.                      `(:active "/inventory"))))

  149. 

  150. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  151. ;; Seems like this one needs to be last. It has something to do with

  152. ;; the wildcard :ID parameter. Maybe we ought to add the /edit back?

  153. 

  154. (defroute ("/inventory/:id/edit" :method :GET) (&key id)

  155.   "Edit Route for Inventory Item.

  156. 

  157. ARGUMENTS

  158. ID The ID of the CC-ITEM inventory item you wish to edit."

  159.   (v:info :inventory "GET /inventory/~d/edit" id)

  160. 

  161.   (with-logged-in-user

  162.     (handler-case

  163.         (ratify-parsing:with-parsed-forms

  164.             ((:integer id))

  165.           (render-with-env #P"inventory/edit.html"

  166.                            `(:active "/inventory"

  167.                              :errors ,(flash-gethash :errors)

  168.                              :messages ,(flash-gethash :messages)

  169.                              :card ,(cc-select-by-id id))))

  170.       (ratify:combined-error (e)

  171.         (flash-error e)))))

  172. 

  173. (defroute ("/inventory/:id/edit" :method :POST) (&key id _parsed)

  174.   "CC-ITEM Update POST route. If the item exists, update it using REINITIALIZE-INSTANCE, after filtering _PARSED through FILTER-ALIST.

  175. 

  176. TODO Differentiate between CC-ITEM and YGO-CC-ITEM?"

  177.   (v:info :inventory "POST /inventory/~d/edit => ~a" id _parsed)

  178. 

  179.   (with-logged-in-user

  180.     (handler-case

  181.         (ratify-parsing:with-parsed-forms

  182.             ((:integer id))

  183.           (with-connection (db)

  184.             (let ((found (mito:find-dao 'cc-item :id id))

  185.                   (clean (filter-alist _parsed)))

  186.               (when found

  187.                 (apply #'reinitialize-instance found (assoc-utils:alist-plist clean))

  188.                 (mito:save-dao found)

  189.                 (redirect (format nil "/inventory/~d/edit" (mito:object-id found)) 303)))))

  190.       (ratify:combined-error (e)

  191. (flash-error e)))))

  192. 

  193. (defroute ("/inventory/:id/delete" :method :DELETE) (&key id)

  194.   "DELETE an Inventory Item specified by ID."

  195.   (v:info :inventory "DELETE /inventory/~d/delete" id)

  196. 

  197.   (with-logged-in-user

  198.     (handler-case

  199.         (ratify-parsing:with-parsed-forms

  200.             ((:integer id))

  201.           (cc-delete-by-id id))

  202.       (ratify:combined-error (e)

  203.         (flash-error e)))))

  204. |#

  205. 

  206. (defroute ("/inventory/patch" :method :PATCH) (&key _parsed)

  207.   "YGO-CC-ITEM PATCH route. This appears to be functionally identical to EDIT route for ID, but this is using YGO-CC-ITEM as class. The POST route appears to be used for CC-ITEM object."

  208.   (v:info :inventory "PATCH /inventory/patch => ~a" _parsed)

  209. 

  210.   (with-logged-in-user

  211.     (alexandria:if-let ((cards (query-param "cards" _parsed)))

  212.       (dolist (card cards)

  213.         (patch-card card _parsed))

  214.       (patch-card _parsed _parsed))))

  215. 

  216. ;; Huh? It works??

  217. (defroute ("/inventory/variants/:id" :method :GET) (&key id)

  218.   "Display the VARIANTs for this inventory item using SELECT-YGO-CC-ITEM-VARIANTS."

  219.   (v:info :inventory "GET /inventory/variants/~d" id)

  220. 

  221.   (with-logged-in-user

  222.     (handler-case

  223.         (ratify-parsing:with-parsed-forms

  224.             ((:integer id))

  225.           (render-with-env #P"inventory/variant-results.html"

  226.                            (list :active "/inventory"

  227.                                  :id id

  228.                                  :cards (select-ygo-cc-item-variants id))))

  229.       ;; :cards ,filtered-cards

  230.       ;; :variant ,variant

  231.       ;; :variants ,variants

  232.       ;; :direction ,direction

  233.       ;; :length ,length

  234.       ;; :total ,(count-dao class)

  235.       ;; :limit ,limit

  236.       ;; :name ,name

  237.       ;; :offset ,offset

  238.       ;; :opposite-direction ,(get-opposite-direction direction)

  239.       ;; :pages ,(generate-pages length offset limit)

  240.       ;; :search-params ,+search-params+

  241.       ;; :sort-by ,sort-by)

  242.       

  243.       (ratify:combined-error (e)

  244.         (flash-error e)))))