├── version.lisp-expr
├── package.lisp
├── README.md
├── weblocks-cms-import-export-data.asd
├── weblocks-cms-import-export-data.lisp
├── serialization-testing.lisp
├── serialization.lisp
├── import-export-data-ui.lisp
└── license.txt


/version.lisp-expr:
--------------------------------------------------------------------------------
1 | "0.3.3"
2 | 


--------------------------------------------------------------------------------
/package.lisp:
--------------------------------------------------------------------------------
1 | ;;;; package.lisp
2 | 
3 | (defpackage #:weblocks-cms-import-export-data
4 |   (:use #:cl)
5 |   (:export #:import-export-data-ui)
6 |   (:import-from :weblocks #:lambda/cc)
7 |   (:import-from :weblocks-utils #:all-of #:first-by-values))
8 | 
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Weblocks CMS Import/Export Data plugin
 2 | 
 3 | Contains import/export functionality for Weblocks CMS. 
 4 | You can import/export any separate model data and all models data at once.
 5 | Include package and new button should appear in standard Weblocks CMS admin interface.
 6 | 
 7 | ## Compatibility
 8 | 
 9 | Currently Weblocks CMS Import/Export Data plugin should work ok with latest Weblocks and Weblocks CMS, though it was tested using weblocks-routes branch of https://github.com/html/weblocks repository 
10 | 


--------------------------------------------------------------------------------
/weblocks-cms-import-export-data.asd:
--------------------------------------------------------------------------------
 1 | ;;;; weblocks-cms-import-export-data.asd
 2 | 
 3 | (asdf:defsystem #:weblocks-cms-import-export-data
 4 |   :serial t
 5 |   :description "Import/export separate model data, all models data"
 6 |   :author "Olexiy Zamkoviy <olexiy.z@gmail.com>"
 7 |   :version (:read-from-file "version.lisp-expr")
 8 |   :license "LLGPL"
 9 |   :depends-on (#:weblocks
10 |                #:weblocks-cms 
11 |                #:weblocks-prevalence 
12 |                #:weblocks-stores 
13 |                #:weblocks-utils 
14 |                #:closer-mop 
15 |                #:cl-json 
16 |                #:clos-diff)
17 |   :components 
18 |   ((:file "package")
19 |    (:file "serialization")
20 |    (:file "serialization-testing")
21 |    (:file "weblocks-cms-import-export-data")
22 |    (:file "import-export-data-ui")))
23 | 
24 | 


--------------------------------------------------------------------------------
/weblocks-cms-import-export-data.lisp:
--------------------------------------------------------------------------------
 1 | ;;;; weblocks-cms-import-export-data.lisp
 2 | 
 3 | (in-package #:weblocks-cms-import-export-data)
 4 | 
 5 | ;;; "weblocks-cms-import-export-data" goes here. Hacks and glory await!
 6 | 
 7 | (defmacro with-yaclml (&body body)
 8 |   "A wrapper around cl-yaclml with-yaclml-stream macro."
 9 |   `(yaclml:with-yaclml-stream weblocks:*weblocks-output-stream*
10 |      ,@body))
11 | 
12 | (defun get-store-type (store)
13 |   (if (equal "HU.DWIM.PEREC" (package-name (symbol-package (type-of store))) )
14 |     (return-from get-store-type :perec))
15 | 
16 |   (loop for i in (weblocks-stores:list-store-types) do
17 |         (when (find-symbol (string-upcase (type-of store))
18 |                            (find-package (alexandria:make-keyword (format nil "WEBLOCKS-~A" (string-upcase i)))))
19 |           (return-from get-store-type i))))
20 | 
21 | (defun write-model-export-data (model s)
22 |   (write-string (weblocks-stores:serialize (all-of model) :format :json) s))
23 | 
24 | (defun get-model-export-data (model)
25 |   (with-output-to-string (s)
26 |     (write-model-export-data model s)))
27 | 
28 | (defun get-models-export-data (model-classes)
29 |   (with-output-to-string (s)
30 |     (json:with-object (s)
31 |       (loop for i in model-classes do 
32 |             (json:as-object-member (i s)
33 |               (write-model-export-data i s))))))
34 | 
35 | (defvar *update-meta-deferred* nil)
36 | (defvar *update-meta-callbacks* nil)
37 | 
38 | (defun update-model-id-counter (store model)
39 |   (let ((max (apply #'max (list* -1 (mapcar #'weblocks-stores:object-id (all-of model :store store))))))
40 |     (ignore-errors (setf (slot-value (weblocks-prevalence::get-root-object store model) 'weblocks-prevalence::next-id) max))))
41 | 
42 | (defun import-model-data (store model json-string &key (update-meta t) (testp nil))
43 |   (unless testp 
44 |     (weblocks-utils:delete-all model :store store))
45 | 
46 |   (let* ((data (json:decode-json-from-string json-string))
47 |          (result-records (loop for i in data collect
48 |                                (weblocks-stores:unserialize (json:encode-json-alist-to-string i) :format :json))))
49 |     (unless testp 
50 |       (loop for i in result-records do 
51 |             (weblocks-stores:persist-object store i)))
52 | 
53 |     (update-model-id-counter store model)
54 | 
55 |     result-records))
56 | 
57 | (defun run-update-meta-callbacks ()
58 |   (declare (special *update-meta-callbacks*))
59 |   (mapcar #'funcall (reverse *update-meta-callbacks*)))
60 | 
61 | (defun import-model-data-with-meta-deferred (store model data &key (testp nil))
62 |   (let ((*update-meta-callbacks* nil)
63 |         (*update-meta-deferred* t))
64 |     (declare (special *update-meta-callbacks*))
65 |     (import-model-data store model data :update-meta nil :testp testp)
66 |     (run-update-meta-callbacks)))
67 | 
68 | (defun import-models-data (store data &optional data-package)
69 |   "Imports all data specified for store."
70 |   (unless data-package 
71 |     (setf data-package (get-store-data-package store)))
72 |   (let ((*update-meta-callbacks* nil))
73 |     (declare (special *update-meta-callbacks*))
74 | 
75 |     (loop for (key . value) in data do 
76 |           (import-model-data store (intern (string key) data-package)
77 |                              value
78 |                              :update-meta nil))
79 | 
80 |     (run-update-meta-callbacks)))
81 | 
82 | (defun get-store-data-package (store)
83 |   (let ((packages (remove-duplicates (mapcar #'symbol-package (weblocks-stores:list-model-classes store)))))
84 |     (when (second packages)
85 |       (error "There are several packages possible for store ~A" store))
86 |     (intern (package-name (first packages)))))
87 | 
88 | 


--------------------------------------------------------------------------------
/serialization-testing.lisp:
--------------------------------------------------------------------------------
 1 | (in-package :weblocks-cms-import-export-data)
 2 | 
 3 | (defun reserialized-copy (object)
 4 |   "Serializes object and than unserializes it"
 5 |   (ignore-errors 
 6 |     (weblocks-stores:unserialize 
 7 |       (weblocks-stores:serialize object :format :json)
 8 |       :format :json)))
 9 | 
10 | (defun equalp-improved (obj1 obj2)
11 |   (cond 
12 |     ((typep obj1 'standard-object)
13 |      (equal (weblocks-stores:object-id obj1) (weblocks-stores:object-id obj2)))
14 |     ((consp obj1)
15 |      (progn 
16 |        (and 
17 |          (equalp-improved (car obj1) (car obj2))
18 |          (equalp-improved (cdr obj1) (cdr obj2)))))
19 |     ((hash-table-p obj1)
20 |      (equalp-improved 
21 |        (sort (alexandria:hash-table-alist obj1) #'string>
22 |              :key #'car)
23 |        (sort (alexandria:hash-table-alist obj2) #'string> 
24 |              :key #'car)))
25 |     (t (equal obj1 obj2))))
26 | 
27 | 
28 | (defun serialization-error-p (object)
29 |   "T if reserialized copy is not equal to original"
30 |   (flet ((objects-differ-p (obj1 obj2)
31 |            (cdr (clos-diff:diff obj1 obj2 :test #'equalp-improved))))
32 |     (objects-differ-p 
33 |       (reserialized-copy object)
34 |       object)))
35 | 
36 | (defun smart-describe-to-string (obj)
37 |   (with-output-to-string (s) 
38 |     (cond 
39 |       ((hash-table-p obj) 
40 |        (format s "~A" (sort (alexandria:hash-table-alist obj) #'string> :key #'car)))
41 |       (t (describe obj  s)))))
42 | 
43 | (defun print-objects-diff (obj1 obj2)
44 |   (if (equal (type-of obj1) (type-of obj2))
45 |     (let ((difference (cdr (clos-diff:diff obj1 obj2 :test #'equalp-improved))))
46 |       (when difference 
47 |         (loop for (dummy slot value) in difference do 
48 |               (format t "Slot ~A is different~%~%Object 1 value - ~%~%~A~%Object 2 value - ~%~%~A~%~%" 
49 |                       (prin1-to-string slot)
50 |                       (smart-describe-to-string (slot-value obj1 slot))
51 |                       (smart-describe-to-string (slot-value obj2 slot))))))
52 |     (format t "Objects types not equal - ~A ~A~%" (type-of obj1) (type-of obj2))))
53 | 
54 | (defun print-records-serialized-with-errors (model)
55 |   "Reserializes all records for specific `model`, if any reserialized record is different from original, shows a message"
56 |   (loop for i in (all-of model)
57 |         if (serialization-error-p i)
58 |         do 
59 |         (describe i)
60 |         (print-objects-diff i (reserialized-copy i))))
61 | 
62 | (defun model-reserialization-ok-p (model)
63 |   "Reserializes all records for specific `model`, returns true if all records reserialized correctly, nil in other case"
64 |   
65 |   (loop for i in (all-of model)
66 |         if (serialization-error-p i)
67 |         do
68 |         (return-from model-reserialization-ok-p nil))
69 | 
70 |   t)
71 | 
72 | (defun store-reserialization-ok-p (store)
73 |   "Reserializes all records for all models of store. If all records reserialized correctly, returns true, nil in other case"
74 |   (loop for model in (weblocks-stores:list-model-classes store)
75 |         if (not (model-reserialization-ok-p model))
76 |         do (return-from store-reserialization-ok-p nil))
77 |   t)
78 | 
79 | (defun all-stores-reserialization-ok-p ()
80 |   "Reserializes all records in all models of all stores. If all records reserialized correctly, returns true, nil in other case"
81 |   (loop for i in weblocks-stores:*store-names* 
82 |         if (not (store-reserialization-ok-p  (symbol-value i)))
83 |         do 
84 |         (return-from all-stores-reserialization-ok-p nil))
85 |   t)
86 | 
87 | (defun records-with-reserialization-errors (model)
88 |   "Reserializes all records for specific `model`, if any reserialized record is different from original, shows a message"
89 |   (loop for i in (all-of model)
90 |         if (serialization-error-p i)
91 |         collect i))
92 | 


--------------------------------------------------------------------------------
/serialization.lisp:
--------------------------------------------------------------------------------
  1 | (in-package :weblocks-cms-import-export-data)
  2 | 
  3 | (defgeneric serialization-link-to-data-object (object)
  4 |   (:method ((obj standard-object))
  5 |    `(:eval 
  6 |       (first-by-id ',(type-of obj)
  7 |                    ,(weblocks-stores:object-id obj)))))
  8 | 
  9 | (defmethod weblocks-stores::serialize-impl (obj &key (format (eql :json)))
 10 |   (labels ((lisp-code (value inside-lisp-code-p)
 11 |              (if inside-lisp-code-p 
 12 |                value 
 13 |                (format nil "#+lisp~A" (prin1-to-string value))))
 14 |            (serialize-value (value &optional inside-lisp-code-p)
 15 |              (cond 
 16 |                ((null value)
 17 |                 nil)
 18 |                ((typep value 'standard-object)
 19 |                 (lisp-code 
 20 |                   (serialization-link-to-data-object value)
 21 |                   inside-lisp-code-p))
 22 |                ((typep value 'hash-table)
 23 |                 (lisp-code 
 24 |                   `(:eval 
 25 |                      (alexandria:alist-hash-table 
 26 |                        ',(loop for (key . val) in (alexandria:hash-table-alist value)
 27 |                                collect
 28 |                                (cons (serialize-value key t) (serialize-value val t)))))
 29 |                   inside-lisp-code-p))
 30 |                ((consp value)
 31 |                 (lisp-code
 32 |                   (cons 
 33 |                     (serialize-value (car value) t)
 34 |                     (serialize-value (cdr value) t))
 35 |                   inside-lisp-code-p))
 36 |                ((stringp value)
 37 |                 value)
 38 |                (t (lisp-code value inside-lisp-code-p)))))
 39 |     (let ((model (type-of obj)))
 40 |       (json:with-object ()
 41 |         (json:encode-object-member :cl-type (prin1-to-string model))
 42 |         (loop for j in (weblocks-stores:class-visible-slots model) 
 43 |               ;if (equal (c2mop:slot-definition-name j) 'weblocks-cms::social-networks)
 44 |               do 
 45 |               (let ((value (slot-value obj (c2mop:slot-definition-name j))))
 46 |                 (json:encode-object-member 
 47 |                   (alexandria:make-keyword (c2mop:slot-definition-name j))
 48 |                   (serialize-value value))))))))
 49 | 
 50 | (defmethod weblocks-stores:serialize ((obj standard-object) &key (format (eql :json)))
 51 |   (with-output-to-string (json:*json-output*)
 52 |     (weblocks-stores::serialize-impl obj :format format)))
 53 | 
 54 | (defmethod weblocks-stores:serialize ((list list) &key (format (eql :json)))
 55 |   (with-output-to-string (json:*json-output*)
 56 |     (json:with-array 
 57 |       (json:*json-output*)
 58 |       (loop for i in list
 59 |             do 
 60 |             (json:as-array-member (json:*json-output*)
 61 |               (format json:*json-output* "~A" (weblocks-stores:serialize i :format :json)))))))
 62 | 
 63 | (defun first-by-id (model id)
 64 |   (first-by-values model :id id))
 65 | 
 66 | (defmethod weblocks-stores:unserialize (obj &key (format (eql :json)))
 67 |   (let* ((item-data (json:decode-json-from-string obj))
 68 |          (model (read-from-string (cdr (assoc :cl-type item-data))))
 69 |          (item (make-instance model))
 70 |          (slot-name))
 71 | 
 72 |     (loop for i in (weblocks-stores:class-visible-slots model) 
 73 |           do 
 74 |           (setf slot-name (c2mop:slot-definition-name i))
 75 |           (setf (slot-value item slot-name)
 76 |                 (cdr (assoc (alexandria:make-keyword slot-name) item-data))))
 77 | 
 78 |     (labels ((unserialize-value (item slot-name slot-value)
 79 |                (cond 
 80 |                  ((and (stringp slot-value) (string= "f" slot-value))
 81 |                   t)
 82 |                  ((stringp slot-value)
 83 |                   (ppcre:register-groups-bind 
 84 |                     (data )
 85 |                     ((ppcre:create-scanner "#\\+lisp(.*)$" :single-line-mode t) slot-value)
 86 |                     (setf data (read-from-string data)) 
 87 |                     (when (and (consp data) (equal :eval (car data)))
 88 |                       (if *update-meta-deferred*
 89 |                         (progn 
 90 |                           (push 
 91 |                             (lambda ()
 92 |                               (setf (slot-value item slot-name)
 93 |                                     (eval (second data))))
 94 |                             *update-meta-callbacks*)
 95 |                           (return-from unserialize-value :deferred-value))
 96 |                         (setf data (eval (second data)))))
 97 |                     
 98 |                     (return-from unserialize-value data))
 99 |                   slot-value)
100 |                  (t slot-value))))
101 |       (flet ((update-meta ()
102 |                (loop for i in (weblocks-stores:class-visible-slots model) 
103 |                      do 
104 |                      (let* ((slot-name (c2mop:slot-definition-name i))
105 |                             (slot-value (slot-value item slot-name)))
106 |                        (setf (slot-value item slot-name)
107 |                              (unserialize-value item slot-name slot-value))))))
108 |         
109 |         (update-meta)))
110 | 
111 |     item))
112 | 
113 | 


--------------------------------------------------------------------------------
/import-export-data-ui.lisp:
--------------------------------------------------------------------------------
  1 | (in-package :weblocks-cms-import-export-data)
  2 | 
  3 | (defun import-callback (test-callback callback caption)
  4 |   (ps:ps-inline* 
  5 |     `(initiate-action 
  6 |        ,(weblocks:make-action 
  7 |           (lambda (&rest args)
  8 |             (weblocks:do-page 
  9 |               (weblocks:make-quickform 
 10 |                 (weblocks:defview nil (:type weblocks:form :persistp nil :caption caption)
 11 |                                   (data :requiredp t 
 12 |                                         :present-as textarea))
 13 |                 :satisfies (lambda (form data)
 14 |                              (let ((ret (handler-case 
 15 |                                           (progn 
 16 |                                             (funcall test-callback (slot-value data 'data))
 17 |                                             t)
 18 |                                           (t (var) (with-output-to-string (s)
 19 |                                                      (let ((*print-escape* nil))
 20 |                                                        (print-object var s)))))))
 21 |                                (if (equal ret t)
 22 |                                  t
 23 |                                  (values  nil `((data . ,(format nil "Importing data failed - ~A" ret)))))))
 24 |                 :on-success (lambda/cc (form data)
 25 |                               (progn 
 26 |                                 (funcall callback (slot-value data 'data))
 27 |                                 (weblocks:do-information "Import finished")
 28 |                                 (weblocks:answer form t)))
 29 |                 :on-cancel (lambda (form)
 30 |                              (weblocks:answer form t))
 31 |                 :answerp nil))))
 32 |        ,(weblocks:session-name-string-pair))))
 33 | 
 34 | (defun stores-check-html(continuation)
 35 |   (with-yaclml 
 36 |     (if (all-stores-reserialization-ok-p)
 37 |       (<:as-is "All stores are ok !")
 38 |       (<ul 
 39 |         (loop for i in weblocks-stores:*store-names* do 
 40 |               (<li 
 41 |                 (if (store-reserialization-ok-p (symbol-value i))
 42 |                   (progn 
 43 |                     (<:format "~A " (prin1-to-string i))
 44 |                     (<i :class "icon-ok"))
 45 |                   (progn 
 46 |                     (<:format "~A " (prin1-to-string i))
 47 |                     (<i :class "icon-ban-circle")
 48 |                     (<br)
 49 |                     (<ul 
 50 |                       (loop for j in (weblocks-stores:list-model-classes (symbol-value i)) do 
 51 |                             (<li
 52 |                               (if (model-reserialization-ok-p j)
 53 |                                 (progn 
 54 |                                   (<:format "~A " (prin1-to-string j))
 55 |                                   (<i :class "icon-ok"))
 56 |                                 (progn 
 57 |                                   (<:format "~A " (prin1-to-string j))
 58 |                                   (<i :class "icon-ban-circle")
 59 |                                   (<br)
 60 |                                   (<b (<:format 
 61 |                                         "Problem records are: " )
 62 |                                       (<ul 
 63 |                                         (loop for record in (records-with-reserialization-errors j) 
 64 |                                               do
 65 |                                               (<li 
 66 |                                                 (<a :href (format nil "javascript:~A"
 67 |                                                                   (ps:ps 
 68 |                                                                     (alert 
 69 |                                                                       (ps:LISP (with-output-to-string (*standard-output*)
 70 |                                                                                  (print-objects-diff record (reserialized-copy record)))))))
 71 |                                                     (<:as-html record)))))))))))))))))
 72 |     (<div :style "text-align:center"
 73 |           (<a :href (weblocks:make-action-url 
 74 |                       (weblocks:make-action 
 75 |                         (lambda (&rest args)
 76 |                           (weblocks:answer continuation)
 77 |                           ;(weblocks:answer (first (weblocks:widget-children (weblocks:root-widget))))
 78 |                           ;(error "~A ~A" (first (weblocks:widget-children (weblocks:root-widget))) (weblocks:widget-continuation (first (weblocks:widget-children (weblocks:root-widget)))))
 79 |                           #+l(weblocks:answer (weblocks:current-dialog)))))
 80 |               :class "btn btn-primary"
 81 |               "Ok")
 82 |           (<br)
 83 |           (<br)
 84 |           )))
 85 | 
 86 | (defun import-export-data-ui (&rest args)
 87 |   (with-yaclml 
 88 |     (<a :href (weblocks:make-action-url 
 89 |                 (weblocks:make-action 
 90 |                   (lambda/cc (&rest args)
 91 |                     (weblocks:do-dialog 
 92 |                       "Checking reserialization results"
 93 |                       #'stores-check-html))))
 94 |         "Check data reserialization for all stores")
 95 |     (<ul
 96 |       (loop for i in weblocks-stores:*store-names* do 
 97 |             (let ((i-copy i)
 98 |                   (store-name (string-downcase (format nil "~a::~a" (package-name (symbol-package i)) i))))
 99 |               (<li 
100 |                 (<i (<:as-html store-name))
101 |                 (if (symbol-value i)
102 |                   (<:as-is (format nil "&nbsp;of type ~A" (write-to-string (get-store-type (symbol-value i)))))
103 |                   (<:as-is "&nbsp;(closed)"))
104 |                 (<:as-is " ")
105 |                 (<a :href (weblocks:add-get-param-to-url 
106 |                             (weblocks:make-action-url 
107 |                               (weblocks:make-action 
108 |                                 (lambda (&rest args)
109 |                                   (setf (hunchentoot:header-out :content-type) "text/x-json")
110 |                                   (get-models-export-data (weblocks-stores:list-model-classes (symbol-value i))))))
111 |                             "pure"
112 |                             "true")
113 |                     :target "_blank" "export data")
114 |                 (<:as-is " | ")
115 |                 (<a :href "javascript:;"
116 |                     :onclick (import-callback 
117 |                                (lambda (data)
118 |                                  (import-models-data (symbol-value i-copy) data :testp t))
119 |                                (lambda (data)
120 |                                  (import-models-data (symbol-value i-copy) data))
121 |                                (format nil "Importing data for all models of store ~A" store-name))
122 |                     "import data")
123 |                 (<:as-is " | ")
124 |                 (<a :href "javascript:;"
125 |                     :onclick (ps:ps-inline* 
126 |                                `(initiate-action 
127 |                                   ,(weblocks:make-action 
128 |                                      (lambda/cc (&rest args)
129 |                                                 (if (equal :ok 
130 |                                                            (weblocks:do-confirmation 
131 |                                                              (format nil "Are you sure you want to delete all data for ~A store ?" (write-to-string i-copy))))
132 |                                                   (progn 
133 |                                                     (weblocks-stores:clean-store (symbol-value i-copy))
134 |                                                     (weblocks:do-information (format nil "All data deleted for ~A" (write-to-string i-copy)))))))
135 |                                   ,(weblocks:session-name-string-pair)))
136 |                     "delete all data")
137 |                 (<ul 
138 |                   (loop for j in (weblocks-stores:list-model-classes (symbol-value i)) do 
139 |                         (let ((j-copy j))
140 |                           (<li (<:as-html (string-downcase (write-to-string j)))
141 |                            (<:format " (records count - ~A)" (weblocks-utils:count-of j :store (symbol-value i)))
142 |                                " - "
143 |                                (<a :target "_blank"
144 |                                    :href (weblocks:add-get-param-to-url 
145 |                                            (weblocks:make-action-url 
146 |                                              (weblocks:make-action 
147 |                                                (lambda (&rest args)
148 |                                                  (setf (hunchentoot:header-out :content-type) "text/x-json")
149 | 
150 |                                                  (get-model-export-data j-copy))))
151 |                                            "pure"
152 |                                            "true") "export data")
153 |                                (<:as-is " | ")
154 |                                (<a :href "javascript:;"
155 |                                    :onclick (import-callback 
156 |                                               (lambda (data)
157 |                                                 (import-model-data-with-meta-deferred (symbol-value i-copy) j-copy data :testp t))
158 |                                               (lambda (data)
159 |                                                 (import-model-data-with-meta-deferred (symbol-value i-copy) j-copy data))
160 |                                               (format nil "Importing data for model ~A, store ~A" j-copy store-name))
161 |                                    "import data")
162 |                                (<:as-is " | ")
163 |                                (<a :href "javascript:;"
164 |                                    :onclick (ps:ps-inline* 
165 |                                               `(initiate-action 
166 |                                                  ,(weblocks:make-action 
167 |                                                     (lambda/cc (&rest args)
168 |                                                                (if (equal :ok 
169 |                                                                           (weblocks:do-confirmation 
170 |                                                                             (format nil "Are you sure you want to delete all data for ~A model ?" (write-to-string j-copy))))
171 |                                                                  (progn 
172 |                                                                    (weblocks-stores:delete-model-class (symbol-value i) j-copy)
173 |                                                                    (weblocks:do-information (format nil "All data deleted for ~A" (write-to-string j-copy)))))))
174 |                                                  ,(weblocks:session-name-string-pair)))
175 |                                    "delete all data")))))))))))
176 | 
177 | (push (lambda () 
178 |         (list (weblocks::translate "Import/Export Data")
179 |               #'weblocks-cms-import-export-data:import-export-data-ui
180 |               "import-export-data"))
181 |       weblocks-cms:*admin-menu-widgets*)
182 | 


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
  1 | 	Preamble to the Gnu Lesser General Public License 	 
  2 | 
  3 |  Copyright (c) 2000 Franz Incorporated, Berkeley, CA 94704
  4 | 
  5 | The concept of the GNU Lesser General Public License version 2.1
  6 | ("LGPL") has been adopted to govern the use and distribution of
  7 | above-mentioned application. However, the LGPL uses terminology that
  8 | is more appropriate for a program written in C than one written in
  9 | Lisp. Nevertheless, the LGPL can still be applied to a Lisp program if
 10 | certain clarifications are made. This document details those
 11 | clarifications. Accordingly, the license for the open-source Lisp
 12 | applications consists of this document plus the LGPL. Wherever there
 13 | is a conflict between this document and the LGPL, this document takes
 14 | precedence over the LGPL.
 15 | 
 16 | A "Library" in Lisp is a collection of Lisp functions, data and
 17 | foreign modules. The form of the Library can be Lisp source code (for
 18 | processing by an interpreter) or object code (usually the result of
 19 | compilation of source code or built with some other
 20 | mechanisms). Foreign modules are object code in a form that can be
 21 | linked into a Lisp executable. When we speak of functions we do so in
 22 | the most general way to include, in addition, methods and unnamed
 23 | functions. Lisp "data" is also a general term that includes the data
 24 | structures resulting from defining Lisp classes. A Lisp application
 25 | may include the same set of Lisp objects as does a Library, but this
 26 | does not mean that the application is necessarily a "work based on the
 27 | Library" it contains.
 28 | 
 29 | The Library consists of everything in the distribution file set before
 30 | any modifications are made to the files. If any of the functions or
 31 | classes in the Library are redefined in other files, then those
 32 | redefinitions ARE considered a work based on the Library. If
 33 | additional methods are added to generic functions in the Library,
 34 | those additional methods are NOT considered a work based on the
 35 | Library. If Library classes are subclassed, these subclasses are NOT
 36 | considered a work based on the Library. If the Library is modified to
 37 | explicitly call other functions that are neither part of Lisp itself
 38 | nor an available add-on module to Lisp, then the functions called by
 39 | the modified Library ARE considered a work based on the Library. The
 40 | goal is to ensure that the Library will compile and run without
 41 | getting undefined function errors.
 42 | 
 43 | It is permitted to add proprietary source code to the Library, but it
 44 | must be done in a way such that the Library will still run without
 45 | that proprietary code present. Section 5 of the LGPL distinguishes
 46 | between the case of a library being dynamically linked at runtime and
 47 | one being statically linked at build time. Section 5 of the LGPL
 48 | states that the former results in an executable that is a "work that
 49 | uses the Library." Section 5 of the LGPL states that the latter
 50 | results in one that is a "derivative of the Library", which is
 51 | therefore covered by the LGPL. Since Lisp only offers one choice,
 52 | which is to link the Library into an executable at build time, we
 53 | declare that, for the purpose applying the LGPL to the Library, an
 54 | executable that results from linking a "work that uses the Library"
 55 | with the Library is considered a "work that uses the Library" and is
 56 | therefore NOT covered by the LGPL.
 57 | 
 58 | Because of this declaration, section 6 of LGPL is not applicable to
 59 | the Library. However, in connection with each distribution of this
 60 | executable, you must also deliver, in accordance with the terms and
 61 | conditions of the LGPL, the source code of Library (or your derivative
 62 | thereof) that is incorporated into this executable.
 63 | 
 64 | 	   	   GNU LESSER GENERAL PUBLIC LICENSE
 65 |                        Version 3, 29 June 2007
 66 | 
 67 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 68 |  Everyone is permitted to copy and distribute verbatim copies
 69 |  of this license document, but changing it is not allowed.
 70 | 
 71 | 
 72 |   This version of the GNU Lesser General Public License incorporates
 73 | the terms and conditions of version 3 of the GNU General Public
 74 | License, supplemented by the additional permissions listed below.
 75 | 
 76 |   0. Additional Definitions. 
 77 | 
 78 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 79 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 80 | General Public License.
 81 | 
 82 |   "The Library" refers to a covered work governed by this License,
 83 | other than an Application or a Combined Work as defined below.
 84 | 
 85 |   An "Application" is any work that makes use of an interface provided
 86 | by the Library, but which is not otherwise based on the Library.
 87 | Defining a subclass of a class defined by the Library is deemed a mode
 88 | of using an interface provided by the Library.
 89 | 
 90 |   A "Combined Work" is a work produced by combining or linking an
 91 | Application with the Library.  The particular version of the Library
 92 | with which the Combined Work was made is also called the "Linked
 93 | Version".
 94 | 
 95 |   The "Minimal Corresponding Source" for a Combined Work means the
 96 | Corresponding Source for the Combined Work, excluding any source code
 97 | for portions of the Combined Work that, considered in isolation, are
 98 | based on the Application, and not on the Linked Version.
 99 | 
100 |   The "Corresponding Application Code" for a Combined Work means the
101 | object code and/or source code for the Application, including any data
102 | and utility programs needed for reproducing the Combined Work from the
103 | Application, but excluding the System Libraries of the Combined Work.
104 | 
105 |   1. Exception to Section 3 of the GNU GPL.
106 | 
107 |   You may convey a covered work under sections 3 and 4 of this License
108 | without being bound by section 3 of the GNU GPL.
109 | 
110 |   2. Conveying Modified Versions.
111 | 
112 |   If you modify a copy of the Library, and, in your modifications, a
113 | facility refers to a function or data to be supplied by an Application
114 | that uses the facility (other than as an argument passed when the
115 | facility is invoked), then you may convey a copy of the modified
116 | version:
117 | 
118 |    a) under this License, provided that you make a good faith effort to
119 |    ensure that, in the event an Application does not supply the
120 |    function or data, the facility still operates, and performs
121 |    whatever part of its purpose remains meaningful, or
122 | 
123 |    b) under the GNU GPL, with none of the additional permissions of
124 |    this License applicable to that copy.
125 | 
126 |   3. Object Code Incorporating Material from Library Header Files.
127 | 
128 |   The object code form of an Application may incorporate material from
129 | a header file that is part of the Library.  You may convey such object
130 | code under terms of your choice, provided that, if the incorporated
131 | material is not limited to numerical parameters, data structure
132 | layouts and accessors, or small macros, inline functions and templates
133 | (ten or fewer lines in length), you do both of the following:
134 | 
135 |    a) Give prominent notice with each copy of the object code that the
136 |    Library is used in it and that the Library and its use are
137 |    covered by this License.
138 | 
139 |    b) Accompany the object code with a copy of the GNU GPL and this license
140 |    document.
141 | 
142 |   4. Combined Works.
143 | 
144 |   You may convey a Combined Work under terms of your choice that,
145 | taken together, effectively do not restrict modification of the
146 | portions of the Library contained in the Combined Work and reverse
147 | engineering for debugging such modifications, if you also do each of
148 | the following:
149 | 
150 |    a) Give prominent notice with each copy of the Combined Work that
151 |    the Library is used in it and that the Library and its use are
152 |    covered by this License.
153 | 
154 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
155 |    document.
156 | 
157 |    c) For a Combined Work that displays copyright notices during
158 |    execution, include the copyright notice for the Library among
159 |    these notices, as well as a reference directing the user to the
160 |    copies of the GNU GPL and this license document.
161 | 
162 |    d) Do one of the following:
163 | 
164 |        0) Convey the Minimal Corresponding Source under the terms of this
165 |        License, and the Corresponding Application Code in a form
166 |        suitable for, and under terms that permit, the user to
167 |        recombine or relink the Application with a modified version of
168 |        the Linked Version to produce a modified Combined Work, in the
169 |        manner specified by section 6 of the GNU GPL for conveying
170 |        Corresponding Source.
171 | 
172 |        1) Use a suitable shared library mechanism for linking with the
173 |        Library.  A suitable mechanism is one that (a) uses at run time
174 |        a copy of the Library already present on the user's computer
175 |        system, and (b) will operate properly with a modified version
176 |        of the Library that is interface-compatible with the Linked
177 |        Version. 
178 | 
179 |    e) Provide Installation Information, but only if you would otherwise
180 |    be required to provide such information under section 6 of the
181 |    GNU GPL, and only to the extent that such information is
182 |    necessary to install and execute a modified version of the
183 |    Combined Work produced by recombining or relinking the
184 |    Application with a modified version of the Linked Version. (If
185 |    you use option 4d0, the Installation Information must accompany
186 |    the Minimal Corresponding Source and Corresponding Application
187 |    Code. If you use option 4d1, you must provide the Installation
188 |    Information in the manner specified by section 6 of the GNU GPL
189 |    for conveying Corresponding Source.)
190 | 
191 |   5. Combined Libraries.
192 | 
193 |   You may place library facilities that are a work based on the
194 | Library side by side in a single library together with other library
195 | facilities that are not Applications and are not covered by this
196 | License, and convey such a combined library under terms of your
197 | choice, if you do both of the following:
198 | 
199 |    a) Accompany the combined library with a copy of the same work based
200 |    on the Library, uncombined with any other library facilities,
201 |    conveyed under the terms of this License.
202 | 
203 |    b) Give prominent notice with the combined library that part of it
204 |    is a work based on the Library, and explaining where to find the
205 |    accompanying uncombined form of the same work.
206 | 
207 |   6. Revised Versions of the GNU Lesser General Public License.
208 | 
209 |   The Free Software Foundation may publish revised and/or new versions
210 | of the GNU Lesser General Public License from time to time. Such new
211 | versions will be similar in spirit to the present version, but may
212 | differ in detail to address new problems or concerns.
213 | 
214 |   Each version is given a distinguishing version number. If the
215 | Library as you received it specifies that a certain numbered version
216 | of the GNU Lesser General Public License "or any later version"
217 | applies to it, you have the option of following the terms and
218 | conditions either of that published version or of any later version
219 | published by the Free Software Foundation. If the Library as you
220 | received it does not specify a version number of the GNU Lesser
221 | General Public License, you may choose any version of the GNU Lesser
222 | General Public License ever published by the Free Software Foundation.
223 | 
224 |   If the Library as you received it specifies that a proxy can decide
225 | whether future versions of the GNU Lesser General Public License shall
226 | apply, that proxy's public statement of acceptance of any version is
227 | permanent authorization for you to choose that version for the
228 | Library.
229 | 


--------------------------------------------------------------------------------