path: root/lisp/service/resume-service.lisp

;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10 -*-
(declaim (optimize (speed 0) (safety 3) (debug 3)))

(in-package :resume)

;; shared

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun state-options (states)
    (mapcar (lambda (state)
              `(:label ,(format nil "~a ~a" (abbr state) (state state)) :value ,(id state)))
            states))

  (defun visastatus-options (visastatuses)
    (mapcar (lambda (visastatus)
              `(:label ,(status visastatus) :value ,(id visastatus)))
            visastatuses))

  (defun language-options ()
    (mapcar (lambda (level)
              `(:label ,level :value ,level))
            '("A1" "A2" "B1" "B2" "C1" "C2")))

  (defclass resume-service (auth-service)
    ((title :initarg :title
            :initform nil
            :accessor title))
    (:documentation ""))

  ;; resume

  (defun resume-json ()
    (with-auth (instance resume-service "resume-view")
      (setf (title instance) "Resumes")))

  (defclass resume/view-service (resume-service resume)
    ((resumes :initarg :resumes
              :initform nil
              :accessor resumes)
     (location-p :initform nil))
    (:documentation ""))

  (defun resume-view-json ()
    (with-auth (instance resume/view-service "resume-view")
      (with-resume-database
        (let ((resume-pkg (make-instance 'resume-pkg))
              (user (get-user)))
          (setf (resumes instance) (get-records resume-pkg (make-instance 'resume :user_id (id user)) "name asc"))))
      (sanitize-rest-json instance)
      (loop for resume in (resumes instance)
            do (sanitize-json resume))))

  (defclass resume/add-service (resume/view-service)
    ((form :initarg :form
           :initform nil
           :accessor form))
    (:documentation ""))

  (defun resume-add-json ()
    (with-auth (instance resume/add-service "resume-modify")
      (setf (title instance) "Resume - Add")
      (setf (form instance) (make-form "resume-add-form"
                                       nil
                                       t
                                       `((:name "name" :label "Name" :field-type "text" :required "required")
                                         (:label "Add Resume" :field-type "button" :onclick "on_resume_add_submit_clicked()"))))))

  (defun resume-add-submit-json (name)
    (declare (special name))
    (with-auth (instance resume/add-service "resume-modify")
      (with-resume-database
        (handler-case
            (let* ((resume-pkg (make-instance 'resume-pkg))
                   (user (get-user))
                   (resume (make-instance 'resume :user_id (id user))))
              (loop for param in (remove-if (lambda (x)
                                              (intersection `(,x) '(id)))
                                            (sb-introspect:function-lambda-list #'resume-add-submit-json))
                    do (setf (slot-value resume param) (symbol-value param)))
              (insert-record resume-pkg resume)
              (setf (session-value :message) (format nil "Resume \"~a\" created successfully." (name resume))))
          (error (e)
            (setf (session-value :errormsg) (format nil "Error creating resume \"~a\". ~a" name e)))))))

  (defclass resume/modify-service (resume/add-service)
    ()
    (:documentation ""))

  (defun resume-modify-json (id)
    (with-auth (instance resume/modify-service "resume-modify")
      (setf (title instance) "Resume - Modify")
      (with-resume-database
        (let* ((resume-pkg (make-instance 'resume-pkg))
               (user (get-user))
               (resume (get-record resume-pkg (make-instance 'resume :id id :user_id (id user)))))
          (if resume
              (setf (form instance) (make-form "resume-modify-form"
                                               nil
                                               t
                                               `((:name "id" :field-type "hidden" :value ,(id resume) :required "required")
                                                 (:name "name" :label "Name" :field-type "text" :value ,(name resume) :required "required")
                                                 (:label "Modify Resume" :field-type "button" :onclick "on_resume_modify_submit_clicked()"))))
              (setf (session-value :errormsg) "Error: could not modify resume. Not found."))))))

  (defun resume-modify-submit-json (id name)
    (declare (special id name))
    (with-auth (instance resume/modify-service "resume-modify")
      (setf (title instance) "Resume - Modify")
      (with-resume-database
        (handler-case
            (let* ((resume-pkg (make-instance 'resume-pkg))
                   (user (get-user))
                   (resume (get-record resume-pkg (make-instance 'resume :id id :user_id (id user)))))
              (loop for param in (remove-if (lambda (x)
                                              (intersection `(,x) '(id)))
                                            (sb-introspect:function-lambda-list #'resume-modify-submit-json))
                    do (setf (slot-value resume param) (symbol-value param)))
              (update-record resume-pkg resume)
              (setf (session-value :message) (format nil "Resume \"~a\" modified successfully." (name resume))))
          (error (e)
            (setf (session-value :errormsg) (format nil "Error modifying resume \"~a\". ~a" name e)))))))

  (defclass resume/delete-service (resume/add-service)
    ()
    (:documentation ""))

  (defun resume-delete-json (id)
    (with-auth (instance resume/delete-service "resume-modify")
      (with-resume-database
        (let* ((resume-pkg (make-instance 'resume-pkg))
               (user (get-user))
               (resume (get-record resume-pkg (make-instance 'resume :id id :user_id (id user)))))
          (if resume
              (progn
                (delete-resume resume-pkg resume)
                (setf (session-value :message) (format nil "Resume \"~a\" deleted successfully." (name resume))))
              (setf (session-value :errormsg) "Error: could not delete resume: not found."))))))

  ;; ;; contactinfo

  ;; (defun contactinfo-json ()
  ;;   (with-auth (instance resume-service "resume-view")
  ;;     (setf (title instance) "Contact Information")))

  ;; (defclass contactinfo/view-service (resume-service contactinfo)
  ;;   ((contactinfos :initarg :contactinfos
  ;;                  :initform nil
  ;;                  :accessor contactinfos)
  ;;    (location-p :initform nil))
  ;;   (:documentation ""))

  ;; (defun contactinfo-view-json ()
  ;;   (with-auth (instance contactinfo/view-service "resume-view")
  ;;     (with-resume-database
  ;;       (let ((resume-pkg (make-instance 'resume-pkg))
  ;;             (user (get-user)))
  ;;         (setf (contactinfos instance) (get-records resume-pkg (make-instance 'contactinfo-v :user_id (id user)) "state_name asc, city asc, address asc, email asc, phone asc, visastatus asc"))))
  ;;     (sanitize-rest-json instance)
  ;;     (loop for contactinfo-v in (contactinfos instance)
  ;;           do (sanitize-json contactinfo-v))))

  ;; (defclass contactinfo/add-service (contactinfo/view-service)
  ;;   ((form :initarg :form
  ;;          :initform nil
  ;;          :accessor form))
  ;;   (:documentation ""))

  ;; (defun contactinfo-add-json ()
  ;;   (with-auth (instance contactinfo/add-service "resume-modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (states (get-records resume-pkg (make-instance 'states) "abbr asc"))
  ;;              (visastatuses (get-records resume-pkg (make-instance 'visastatus) "visastatus asc")))
  ;;         (setf (title instance) "Contact Info - Add")
  ;;         (setf (form instance) (make-form "contactinfo-add-form"
  ;;                                          nil
  ;;                                          t
  ;;                                          `((:name "address" :label "Address" :field-type "text" :required "required")
  ;;                                            (:name "city" :label "City" :field-type "text" :required "required")
  ;;                                            (:name "state_id" :label "State" :field-type "select" :options ,(state-options states) :required "required")
  ;;                                            (:name "phone" :label "Phone" :field-type "text" :required "required")
  ;;                                            (:name "email" :label "Email" :field-type "text" :required "required")
  ;;                                            (:name "visastatus_id" :label "VISA Status" :field-type "select" :options ,(visastatus-options visastatuses) :required "required")
  ;;                                            (:label "Add Contact Info" :field-type "button" :onclick "on_contactinfo_add_submit_clicked()"))))))))

  ;; (defun contactinfo-add-submit-json (address city state_id phone email visastatus_id)
  ;;   (declare (special address city state_id phone email visastatus_id))
  ;;   (with-auth (instance contactinfo/add-service "resume-modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (contactinfo (make-instance 'contactinfo :user_id (id user))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'contactinfo-add-submit-json))
  ;;                   do (setf (slot-value contactinfo param) (symbol-value param)))
  ;;             (insert-contactinfo resume-pkg contactinfo)
  ;;             (setf (session-value :message) (format nil "Contact Info \"~a, ~a\" created successfully." address city)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error creating Contact Info \"~a, ~a\". ~a" address city e)))))))

  ;; (defclass contactinfo/modify-service (contactinfo/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun contactinfo-modify-json (id)
  ;;   (with-auth (instance contactinfo/modify-service "resume-modify")
  ;;     (setf (title instance) "Contact Info - Modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (states (get-records resume-pkg (make-instance 'states) "abbr asc"))
  ;;              (visastatuses (get-records resume-pkg (make-instance 'visastatus) "status asc"))
  ;;              (contactinfo-v (get-record resume-pkg (make-instance 'contactinfo-v :id id :user_id (id user)))))
  ;;         (if contactinfo-v
  ;;             (setf (form instance) (make-form "contactinfo-modify-form"
  ;;                                              nil
  ;;                                              t
  ;;                                              `((:name "id" :field-type "hidden" :value ,(id contactinfo-v) :required "required")
  ;;                                                (:name "address" :label "Address" :field-type "text" :value ,(address contactinfo-v) :required "required")
  ;;                                                (:name "city" :label "City" :field-type "text" :value ,(city contactinfo-v) :required "required")
  ;;                                                (:name "state_id" :label "State" :field-type "select" :value ,(state_id contactinfo-v) :options ,(state-options states) :required "required")
  ;;                                                (:name "phone" :label "Phone" :field-type "text" :value ,(phone contactinfo-v) :required "required")
  ;;                                                (:name "email" :label "Email" :field-type "text" :value ,(email contactinfo-v) :required "required")
  ;;                                                (:name "visastatus_id" :label "VISA Status" :field-type "select" :value ,(visastatus_id contactinfo-v) :options ,(visastatus-options visastatuses) :required "required")
  ;;                                                (:label "Modify Contact Info" :field-type "button" :onclick "on_contactinfo_modify_submit_clicked()"))))
  ;;             (setf (session-value :errormsg) "Error: could not modify Contact Info. Not found."))))))

  ;; (defun contactinfo-modify-submit-json (id address city state_id phone email visastatus_id)
  ;;   (declare (special id address city state_id phone email visastatus_id))
  ;;   (with-auth (instance contactinfo/modify-service "resume-modify")
  ;;     (setf (title instance) "Contact Info - Modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (contactinfo (get-record resume-pkg (make-instance 'contactinfo :id id :user_id (id user)))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'contactinfo-modify-submit-json))
  ;;                   do (setf (slot-value contactinfo param) (symbol-value param)))
  ;;             (update-record resume-pkg contactinfo)
  ;;             (setf (session-value :message) (format nil "Contact Info \"~a, ~a\" modified successfully." address city)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error modifying Contact Info \"~a, ~a\". ~a" address city e)))))))

  ;; (defclass contactinfo/delete-service (contactinfo/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun contactinfo-delete-json (id)
  ;;   (with-auth (instance contactinfo/delete-service "resume-modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (contactinfo (get-record resume-pkg (make-instance 'contactinfo :id id :user_id (id user)))))
  ;;         (if contactinfo
  ;;             (progn
  ;;               (delete-record resume-pkg contactinfo)
  ;;               (setf (session-value :message) (format nil "Contact Info \"~a, ~a\" deleted successfully." (address contactinfo) (city contactinfo))))
  ;;             (setf (session-value :errormsg) "Error: could not delete Contact Info: not found."))))))

  ;; ;; education

  ;; (defun education-json ()
  ;;   (with-auth (instance resume-service "resume-view")
  ;;     (setf (title instance) "Education")))

  ;; (defclass education/view-service (resume-service education)
  ;;   ((educations :initarg :educations
  ;;                :initform nil
  ;;                :accessor educations)
  ;;    (location-p :initform nil))
  ;;   (:documentation ""))

  ;; (defun education-view-json ()
  ;;   (with-auth (instance education/view-service "resume-view")
  ;;     (with-resume-database
  ;;       (let ((resume-pkg (make-instance 'resume-pkg))
  ;;             (user (get-user)))
  ;;         (setf (educations instance) (get-records resume-pkg (make-instance 'education :user_id (id user))))))
  ;;     (sanitize-rest-json instance)
  ;;     (loop for education in (educations instance)
  ;;           do (sanitize-json education))))

  ;; (defclass education/add-service (education/view-service)
  ;;   ((form :initarg :form
  ;;          :initform nil
  ;;          :accessor form))
  ;;   (:documentation ""))

  ;; (defun education-add-json ()
  ;;   (with-auth (instance education/add-service "resume-modify")
  ;;     (setf (form instance) (make-form "education-add-form"
  ;;                                      nil
  ;;                                      t
  ;;                                      `((:name "school" :label "School" :field-type "text" :required "required")
  ;;                                        (:name "major" :label "Major" :field-type "text" :required "required")
  ;;                                        (:name "minor" :label "Minor" :field-type "text")
  ;;                                        (:name "degree" :label "Degree" :field-type "text" :required "required")
  ;;                                        (:name "progress" :label "Progress" :field-type "text" :required "required")
  ;;                                        (:name "start_date" :label "Start Date" :field-type "text" :required "required")
  ;;                                        (:name "end_date" :label "End Date" :field-type "text" :required "required")
  ;;                                        (:label "Add Education" :field-type "button" :onclick "on_education_add_submit_clicked()"))))))

  ;; (defun education-add-submit-json (school major minor degree progress start_date end_date)
  ;;   (declare (special school major minor degree progress start_date end_date))
  ;;   (with-auth (instance education/add-service "resume-modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (education (make-instance 'education :user_id (id user))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'education-add-submit-json))
  ;;                   do (setf (slot-value education param) (symbol-value param)))
  ;;             (insert-education resume-pkg education)
  ;;             (setf (session-value :message) (format nil "Education \"~a, ~a\" created successfully." school major)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error creating Education \"~a, ~a\". ~a" school major e)))))))

  ;; (defclass education/modify-service (education/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun education-modify-json (id)
  ;;   (with-auth (instance education/modify-service "resume-modify")
  ;;     (setf (title instance) "Education - Modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (education (get-record resume-pkg (make-instance 'education :id id :user_id (id user)))))
  ;;         (if education
  ;;             (setf (form instance) (make-form "education-modify-form"
  ;;                                              nil
  ;;                                              t
  ;;                                              `((:name "id" :field-type "hidden" :value ,(id education) :required "required")
  ;;                                                (:name "school" :label "School" :field-type "text" :value ,(school education) :required "required")
  ;;                                                (:name "major" :label "Major" :field-type "text" :value ,(major education) :required "required")
  ;;                                                (:name "minor" :label "Minor" :field-type "text" :value ,(minor education))
  ;;                                                (:name "degree" :label "Degree" :field-type "text" :value ,(degree education) :required "required")
  ;;                                                (:name "progress" :label "Progress" :field-type "text" :value ,(progress education) :required "required")
  ;;                                                (:name "start_date" :label "Start Date" :field-type "text" :value ,(start_date education) :required "required")
  ;;                                                (:name "end_date" :label "End Date" :field-type "text" :value ,(end_date education) :required "required")
  ;;                                                (:label "Modify Education" :field-type "button" :onclick "on_education_modify_submit_clicked()"))))
  ;;             (setf (session-value :errormsg) "Error: could not modify Education. Not found."))))))

  ;; (defun education-modify-submit-json (id school major minor degree progress start_date end_date)
  ;;   (declare (special id school major minor degree progress start_date end_date))
  ;;   (with-auth (instance education/modify-service "resume-modify")
  ;;     (setf (title instance) "Education - Modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (education (get-record resume-pkg (make-instance 'education :id id :user_id (id user)))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'education-modify-submit-json))
  ;;                   do (setf (slot-value education param) (symbol-value param)))
  ;;             (update-record resume-pkg education)
  ;;             (setf (session-value :message) (format nil "Education \"~a, ~a\" modified successfully." school major)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error modifying Education \"~a, ~a\". ~a" school major e)))))))

  ;; (defclass education/delete-service (education/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun education-delete-json (id)
  ;;   (with-auth (instance education/delete-service "resume-modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (education (get-record resume-pkg (make-instance 'education :id id :user_id (id user)))))
  ;;         (if education
  ;;             (progn
  ;;               (delete-record resume-pkg education)
  ;;               (setf (session-value :message) (format nil "Education \"~a, ~a\" deleted successfully." (school education) (major education))))
  ;;             (setf (session-value :errormsg) "Error: could not delete Education: not found."))))))

  ;; ;; language

  ;; (defun language-json ()
  ;;   (with-auth (instance resume-service "resume-view")
  ;;     (setf (title instance) "Languages")))

  ;; (defclass language/view-service (resume-service language)
  ;;   ((languages :initarg :languages
  ;;                :initform nil
  ;;                :accessor languages)
  ;;    (location-p :initform nil))
  ;;   (:documentation ""))

  ;; (defun language-view-json ()
  ;;   (with-auth (instance language/view-service "resume-view")
  ;;     (with-resume-database
  ;;       (let ((resume-pkg (make-instance 'resume-pkg))
  ;;             (user (get-user)))
  ;;         (setf (languages instance) (get-records resume-pkg (make-instance 'language :user_id (id user))))))
  ;;     (sanitize-rest-json instance)
  ;;     (loop for language in (languages instance)
  ;;           do (sanitize-json language))))

  ;; (defclass language/add-service (language/view-service)
  ;;   ((form :initarg :form
  ;;          :initform nil
  ;;          :accessor form))
  ;;   (:documentation ""))

  ;; (defun language-add-json ()
  ;;   (with-auth (instance language/add-service "resume-modify")
  ;;     (setf (title instance) "Language - Add")
  ;;     (setf (form instance) (make-form "language-add-form"
  ;;                                      nil
  ;;                                      t
  ;;                                      `((:name "name" :label "Name" :field-type "text" :required "required")
  ;;                                        (:name "understanding_listening" :label "Understanding Listening" :field-type "select" :options ,(language-options) :required "required")
  ;;                                        (:name "understanding_reading" :label "Understanding Reading" :field-type "select" :options ,(language-options) :required "required")
  ;;                                        (:name "speaking_interaction" :label "Speaking Interaction" :field-type "select" :options ,(language-options) :required "required")
  ;;                                        (:name "speaking_production" :label "Speaking Production" :field-type "select" :options ,(language-options) :required "required")
  ;;                                        (:name "writing" :label "Writing" :field-type "select" :options ,(language-options) :required "required")
  ;;                                        (:label "Add Language" :field-type "button" :onclick "on_language_add_submit_clicked()"))))))

  ;; (defun language-add-submit-json (name understanding_listening understanding_reading speaking_interaction speaking_production writing)
  ;;   (declare (special name understanding_listening understanding_reading speaking_interaction speaking_production writing))
  ;;   (with-auth (instance language/add-service "resume-modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (language (make-instance 'language :user_id (id user))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'language-add-submit-json))
  ;;                   do (setf (slot-value language param) (symbol-value param)))
  ;;             (insert-language resume-pkg language)
  ;;             (setf (session-value :message) (format nil "Language \"~a\" created successfully." name)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error creating Language \"~a\". ~a" name e)))))))

  ;; (defclass language/modify-service (language/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun language-modify-json (id)
  ;;   (with-auth (instance language/modify-service "resume-modify")
  ;;     (setf (title instance) "Language - Modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (language (get-record resume-pkg (make-instance 'language :id id :user_id (id user)))))
  ;;         (if language
  ;;             (setf (form instance) (make-form "language-modify-form"
  ;;                                              nil
  ;;                                              t
  ;;                                              `((:name "id" :field-type "hidden" :value ,(id language) :required "required")
  ;;                                                (:name "name" :label "Name" :field-type "text" :value ,(name language) :required "required")
  ;;                                                (:name "understanding_listening" :label "Understanding Listening" :field-type "select" :options ,(language-options) :value ,(understanding_listening language) :required "required")
  ;;                                                (:name "understanding_reading" :label "Understanding Reading" :field-type "select" :options ,(language-options) :value ,(understanding_reading language) :required "required")
  ;;                                                (:name "speaking_interaction" :label "Speaking Interaction" :field-type "select" :options ,(language-options) :value ,(speaking_interaction language) :required "required")
  ;;                                                (:name "speaking_production" :label "Speaking Production" :field-type "select" :options ,(language-options) :value ,(speaking_production language) :required "required")
  ;;                                                (:name "writing" :label "Writing" :field-type "text" :value ,(writing language) :required "required")
  
  ;;                                                (:label "Modify Language" :field-type "button" :onclick "on_language_modify_submit_clicked()"))))
  ;;             (setf (session-value :errormsg) "Error: could not modify Language. Not found."))))))

  ;; (defun language-modify-submit-json (id name understanding_listening understanding_reading speaking_interaction speaking_production writing)
  ;;   (declare (special id name understanding_listening understanding_reading speaking_interaction speaking_production writing))
  ;;   (with-auth (instance language/modify-service "resume-modify")
  ;;     (setf (title instance) "Language - Modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (language (get-record resume-pkg (make-instance 'language :id id :user_id (id user)))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'language-modify-submit-json))
  ;;                   do (setf (slot-value language param) (symbol-value param)))
  ;;             (update-record resume-pkg language)
  ;;             (setf (session-value :message) (format nil "Language \"~a\" modified successfully." name)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error modifying Language \"~a\". ~a" name e)))))))

  ;; (defclass language/delete-service (language/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun language-delete-json (id)
  ;;   (with-auth (instance language/delete-service "resume-modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (language (get-record resume-pkg (make-instance 'language :id id :user_id (id user)))))
  ;;         (if language
  ;;             (progn
  ;;               (delete-record resume-pkg language)
  ;;               (setf (session-value :message) (format nil "Language \"~a\" deleted successfully." (name language))))
  ;;             (setf (session-value :errormsg) "Error: could not delete Language: not found."))))))

  ;; ;; skill

  ;; (defun skill-json ()
  ;;   (with-auth (instance resume-service "resume-view")
  ;;     (setf (title instance) "Skills")))

  ;; (defclass skill/view-service (resume-service skill)
  ;;   ((skills :initarg :skills
  ;;            :initform nil
  ;;            :accessor skills)
  ;;    (location-p :initform nil))
  ;;   (:documentation ""))

  ;; (defun skill-view-json ()
  ;;   (with-auth (instance skill/view-service "resume-view")
  ;;     (with-resume-database
  ;;       (let ((resume-pkg (make-instance 'resume-pkg))
  ;;             (user (get-user)))
  ;;         (setf (skills instance) (get-records resume-pkg (make-instance 'skill :user_id (id user))))))
  ;;     (sanitize-rest-json instance)
  ;;     (loop for skill in (skills instance)
  ;;           do (sanitize-json skill))))

  ;; (defclass skill/add-service (skill/view-service)
  ;;   ((form :initarg :form
  ;;          :initform nil
  ;;          :accessor form))
  ;;   (:documentation ""))

  ;; (defun skill-add-json ()
  ;;   (with-auth (instance skill/add-service "resume-modify")
  ;;     (setf (title instance) "Skill - Add")
  ;;     (setf (form instance) (make-form "skill-add-form"
  ;;                                      nil
  ;;                                      t
  ;;                                      `((:name "skill" :label "Skill" :field-type "text" :required "required")
  ;;                                        (:label "Add Skill" :field-type "button" :onclick "on_skill_add_submit_clicked()"))))))

  ;; (defun skill-add-submit-json (skill)
  ;;   (declare (special skill))
  ;;   (with-auth (instance skill/add-service "resume-modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (skill (make-instance 'skill :user_id (id user))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'skill-add-submit-json))
  ;;                   do (setf (slot-value skill param) (symbol-value param)))
  ;;             (insert-skill resume-pkg skill)
  ;;             (setf (session-value :message) (format nil "Skill \"~a\" created successfully." skill)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error creating Skill \"~a\". ~a" skill e)))))))

  ;; (defclass skill/modify-service (skill/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun skill-modify-json (id)
  ;;   (with-auth (instance skill/modify-service "resume-modify")
  ;;     (setf (title instance) "Skill - Modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (skill (get-record resume-pkg (make-instance 'skill :id id :user_id (id user)))))
  ;;         (if skill
  ;;             (setf (form instance) (make-form "skill-modify-form"
  ;;                                              nil
  ;;                                              t
  ;;                                              `((:name "id" :field-type "hidden" :value ,(id skill) :required "required")
  ;;                                                (:name "skill" :label "Skill" :field-type "text" :value ,(skill skill) :required "required")
  ;;                                                (:label "Modify Skill" :field-type "button" :onclick "on_skill_modify_submit_clicked()"))))
  ;;             (setf (session-value :errormsg) "Error: could not modify Skill. Not found."))))))

  ;; (defun skill-modify-submit-json (id skill)
  ;;   (declare (special id skill))
  ;;   (with-auth (instance skill/modify-service "resume-modify")
  ;;     (setf (title instance) "Skill - Modify")
  ;;     (with-resume-database
  ;;       (handler-case
  ;;           (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;                  (user (get-user))
  ;;                  (skill (get-record resume-pkg (make-instance 'skill :id id :user_id (id user)))))
  ;;             (loop for param in (remove-if (lambda (x)
  ;;                                             (intersection `(,x) '(id)))
  ;;                                           (sb-introspect:function-lambda-list #'skill-modify-submit-json))
  ;;                   do (setf (slot-value skill param) (symbol-value param)))
  ;;             (update-record resume-pkg skill)
  ;;             (setf (session-value :message) (format nil "Skill \"~a\" modified successfully." skill)))
  ;;         (error (e)
  ;;           (setf (session-value :errormsg) (format nil "Error modifying Skill \"~a\". ~a" skill e)))))))

  ;; (defclass skill/delete-service (skill/add-service)
  ;;   ()
  ;;   (:documentation ""))

  ;; (defun skill-delete-json (id)
  ;;   (with-auth (instance skill/delete-service "resume-modify")
  ;;     (with-resume-database
  ;;       (let* ((resume-pkg (make-instance 'resume-pkg))
  ;;              (user (get-user))
  ;;              (skill (get-record resume-pkg (make-instance 'skill :id id :user_id (id user)))))
  ;;         (if skill
  ;;             (progn
  ;;               (delete-record resume-pkg skill)
  ;;               (setf (session-value :message) (format nil "Skill \"~a\" deleted successfully." (skill skill))))
  ;;             (setf (session-value :errormsg) "Error: could not delete Skill: not found."))))))

  ;; macros

  (defclass resume-component/view-service (resume-service)
    ((components :initarg components
                 :initform nil
                 :accessor components)
     (location-p :initform nil))
    (:documentation ""))

  (defclass resume-component/modify-service (resume-component/view-service)
    ((form :initarg :form
           :initform nil
           :accessor form))
    (:documentation "")))

;; (defmacro ,func-add-s ()
;;   `(with-auth (instance ,,class-modify-s "resume-modify")
;;      (setf (title instance) (format nil "~a - Add" ,,component))
;;      (setf (form instance) (make-form ,,form-add
;;                                       nil
;;                                       t
;;                                       `(() ;;,,@input-add-fields
;;                                            (:label ,,,(format nil "Add ~a" component) :field-type "button" :onclick ,,(format nil "on_~a_add_submit_clicked()" component-lcase)))))))

;; (defmacro ,func-add-submit-s (,@arg-names)
;;   `(progn
;;      (declare (special ,,@arg-names))
;;      (with-auth (instance ,,class-modify-s "resume-modify")
;;        (with-resume-database
;;          (handler-case
;;              (let* ((resume-pkg (make-instance 'resume-pkg))
;;                     (user (get-user))
;;                     (,,component-s (make-instance ',,component-s :user_id (id user))))
;;                (loop for param in (remove-if (lambda (x)
;;                                                (intersection `(,x) '(id)))
;;                                              (sb-introspect:function-lambda-list #',func-add-submit-s))
;;                      do (setf (slot-value ,,component-s param) (symbol-value param)))
;;                (insert-record resume-pkg ,,component-s)
;;                (setf (session-value :message) (format nil "~a created successfully." ,,component)))
;;            (error (e)
;;              (setf (session-value :errormsg) (format nil "Error creating ~a. ~a" ,,component e))))))))

;; (defmacro ,func-modify-s (id)
;;   `(with-auth (instance ,,class-modify-s "resume-modify")
;;      (setf (title instance) (format nil "~a - Modify" ,,component))
;;      (with-resume-database
;;        (let* ((resume-pkg (make-instance 'resume-pkg))
;;               (user (get-user))
;;               (,,component-s (get-record resume-pkg (make-instance ',,component-s :id ,id :user_id (id user)))))
;;          (if ,,component-s
;;              (setf (form instance) (make-form ,,form-modify
;;                                               nil
;;                                               t
;;                                               `((:name "id" :field-type "hidden" :value ,(id ,component-s) :required "required")
;;                                                 ;;,,@input-modify-fields
;;                                                 (:label ,,,(format nil "Modify ~a" component) :field-type "button" :onclick ,,(format nil "on_~a_modify_submit_clicked()" component-lcase)))))
;;              (setf (session-value :errormsg) (format nil "Error: could not modify ~a. Not found." ,,component)))))))

;; (defmacro ,func-modify-submit-s (,@(append '(id) arg-names))
;;   `(progn
;;      (declare (special ,,@(append '(id) arg-names)))
;;      (with-auth (instance ,,class-modify-s "resume-modify")
;;        (setf (title instance) (format nil "~a - Modify" ,,component))
;;        (with-resume-database
;;          (handler-case
;;              (let* ((resume-pkg (make-instance 'resume-pkg))
;;                     (user (get-user))
;;                     (,,component-s (get-record resume-pkg (make-instance ',,component-s :id ,id :user_id (id user)))))
;;                (loop for param in (remove-if (lambda (x)
;;                                                (intersection `(,x) '(id)))
;;                                              (sb-introspect:function-lambda-list #',func-modify-submit-s))
;;                      do (setf (slot-value ,,component-s param) (symbol-value param)))
;;                (update-record resume-pkg ,,component-s)
;;                (setf (session-value :message) (format nil "~a modified successfully." ,,component)))
;;            (error (e)
;;              (setf (session-value :errormsg) (format nil "Error modifying ~a. ~a" ,,component e))))))))

;; (defmacro ,func-delete-s (id)
;;   `(with-auth (instance ,,class-modify-s "resume-modify")
;;      (with-resume-database
;;        (let* ((resume-pkg (make-instance 'resume-pkg))
;;               (user (get-user))
;;               (,,component-s (get-record resume-pkg (make-instance ',,component-s :id ,id :user_id (id user)))))
;;          (if ,,component-s
;;              (progn
;;                (delete-record resume-pkg ,,component-s)
;;                (setf (session-value :message) (format nil "~a deleted successfully." ,,component)))
;;              (setf (session-value :errormsg) (format nil "Error: could not delete ~a: not found." ,,component)))))

(defmacro define-resume-component ((component-s rest-args input-add-fields input-modify-fields))
  "`component-s' is a symbol that matches the component's record object
name, i.e SKILL, JOB, EDUCATION, LANGUAGE, CONTACTINFO. This will be
used all over the place. The record name equals the component name.

`rest-args' is the list of REST API arguments for the add and modify
forms. In the form like this example: ((id :parameter-type 'integer))

`input-add-fields' and `input-modify-fields' are lists of generic form
fields that get inserted into the add and modify forms."
  (let* ((component (symbol-name component-s))
         (component-lcase (string-downcase component))
         (components-s (intern (format nil "~aS" component)))
         (arg-names (loop for arg in rest-args collect (car arg)))
         (func-root-s (intern (format nil "~a-JSON" component)))
         (func-view-s (intern (format nil "~a-VIEW-JSON" component)))
         (func-add-s (intern (format nil "~a-ADD-JSON" component)))
         (func-add-submit-s (intern (format nil "~a-ADD-SUBMIT-JSON" component)))
         (func-modify-s (intern (format nil "~a-MODIFY-JSON" component)))
         (func-modify-submit-s (intern (format nil "~a-MODIFY-SUBMIT-JSON" component)))
         (func-delete-s (intern (format nil "~a-DELETE-JSON" component)))
         (form-add (format nil "~a-add-form" component-lcase))
         (form-modify (format nil "~a-modify-form" component-lcase)))
    `(progn
       (defun ,func-root-s ()
         (with-auth (instance resume-service "resume-view")
           (setf (title instance) ,component)))

       (defun ,func-view-s ()
         (with-auth (instance resume-component/view-service "resume-view")
           (with-resume-database
             (let ((resume-pkg (make-instance 'resume-pkg))
                   (user (get-user)))
               (setf (components instance) (get-records resume-pkg
                                                        (make-instance ',component-s
                                                                       :user_id (id user)
                                                                       :*table "resume.contactinfo_v")
                                                        "state_abbr asc, city asc, address asc"))))
           (sanitize-rest-json instance)
           (loop for component in (components instance)
                 do (sanitize-json component))))
       
       (defun ,func-add-s ()
         (with-auth (instance resume-component/modify-service "resume-modify")
           (with-resume-database
             (let ((resume-pkg (make-instance 'resume-pkg)))
               (setf (title instance) (format nil "~a - Add" ,component))
               (setf (form instance) (make-form ,form-add
                                                nil
                                                t
                                                ,input-add-fields))))))

       (defun ,func-add-submit-s (,@arg-names)
         (declare (special ,@arg-names))
         (with-auth (instance resume-component/modify-service "resume-modify")
           (with-resume-database
             (handler-case
                 (let* ((resume-pkg (make-instance 'resume-pkg))
                        (user (get-user))
                        (,component-s (make-instance ',component-s :user_id (id user))))
                   (loop for param in (remove-if (lambda (x)
                                                   (intersection `(,x) '(id)))
                                                 (sb-introspect:function-lambda-list #',func-add-submit-s))
                         do (setf (slot-value ,component-s param) (symbol-value param)))
                   (insert-record resume-pkg ,component-s)
                   (setf (session-value :message) (format nil "~a created successfully." ,component)))
               (error (e)
                 (setf (session-value :errormsg) (format nil "Error creating ~a. ~a" ,component e)))))))

       (defun ,func-modify-s (id)
         (with-auth (instance resume-component/modify-service "resume-modify")
           (setf (title instance) (format nil "~a - Modify" ,component))
           (with-resume-database
             (let* ((resume-pkg (make-instance 'resume-pkg))
                    (user (get-user))
                    (,component-s (get-record resume-pkg (make-instance ',component-s
                                                                        :id id
                                                                        :user_id (id user)
                                                                        :*table "resume.contactinfo_v"))))
               (if ,component-s
                   (setf (form instance) (make-form ,form-modify
                                                    nil
                                                    t
                                                    ,input-modify-fields))
                   (setf (session-value :errormsg) (format nil "Error: could not modify ~a. Not found." ,component)))))))

       (defun ,func-modify-submit-s (,@(append '(id) arg-names))
         (declare (special ,@(append '(id) arg-names)))
         (with-auth (instance resume-component/modify-service "resume-modify")
           (setf (title instance) (format nil "~a - Modify" ,component))
           (with-resume-database
             (handler-case
                 (let* ((resume-pkg (make-instance 'resume-pkg))
                        (user (get-user))
                        (,component-s (get-record resume-pkg (make-instance ',component-s
                                                                            :id id
                                                                            :user_id (id user)
                                                                            :*table "resume.contactinfo_v"))))
                   (if ,component-s
                       (let ((new-component (make-instance ',component-s)))
                         (loop for param in (sb-introspect:function-lambda-list #',func-modify-submit-s)
                               do (setf (slot-value new-component param) (symbol-value param)))
                         (setf (user_id new-component) (id user))
                         (update-record-no-nulls resume-pkg new-component)
                         (setf (session-value :message) (format nil "~a modified successfully." ,component)))
                       (error (format nil "~a error" ,component))))
               (error (e)
                 (setf (session-value :errormsg) (format nil "Error modifying ~a. ~a" ,component e)))))))

       (defun ,func-delete-s (id)
         (with-auth (instance resume-component/modify-service "resume-modify")
           (with-resume-database
             (let* ((resume-pkg (make-instance 'resume-pkg))
                    (user (get-user))
                    (,component-s (get-record resume-pkg (make-instance ',component-s
                                                                        :id id
                                                                        :user_id (id user)
                                                                        :*table "resume.contactinfo_v"))))
               (if ,component-s
                   (progn
                     (delete-record resume-pkg (make-instance ',component-s :id id))
                     (setf (session-value :message) (format nil "~a deleted successfully." ,component)))
                   (setf (session-value :errormsg) (format nil "Error: could not delete ~a: not found." ,component)))))))

       (define-endpoint (,(format nil "/resume/~a" component-lcase) :method :get) () ,func-root-s)
       (define-endpoint (,(format nil "/resume/~a/view" component-lcase) :method :get) () ,func-view-s)
       (define-endpoint (,(format nil "/resume/~a/add" component-lcase) :method :post) () ,func-add-s)
       (define-endpoint (,(format nil "/resume/~a/add/submit" component-lcase) :method :post) (&post ,@rest-args) ,func-add-submit-s ,@arg-names)
       (define-endpoint (,(format nil "/resume/~a/modify" component-lcase) :method :post) (&post (id :parameter-type 'integer)) ,func-modify-s id)
       (define-endpoint (,(format nil "/resume/~a/modify/submit" component-lcase) :method :post) (&post (id :parameter-type 'integer) ,@rest-args) ,func-modify-submit-s ,@(append '(id) arg-names))
       (define-endpoint (,(format nil "/resume/~a/delete/:id" component-lcase) :method :delete) (&path (id 'integer)) ,func-delete-s id))))

(define-resume-component (contactinfo
                          ((address :parameter-type 'string) (city :parameter-type 'string) (state_id :parameter-type  'integer) (phone :parameter-type 'string) (email :parameter-type 'string) (url :parameter-type 'string) (visastatus_id :parameter-type 'integer))
                          `((:name "address" :label "Address" :field-type "text" :required "required")
                            (:name "city" :label "City" :field-type "text" :required "required")
                            (:name "state_id" :label "State" :field-type "select" :options ,(state-options (get-records resume-pkg (make-instance 'states) "abbr asc")) :required "required")
                            (:name "phone" :label "Phone" :field-type "text" :required "required")
                            (:name "email" :label "Email" :field-type "text" :required "required")
                            (:name "url" :label "URL" :field-type "text")
                            (:name "visastatus_id" :label "VISA Status" :field-type "select" :options ,(visastatus-options (get-records resume-pkg (make-instance 'visastatus) "visastatus asc")) :required "required")
                            (:label "Add CONTACTINFO" :field-type "button" :onclick "on_contactinfo_add_submit_clicked()"))
                          `((:name "id" :field-type "hidden" :value ,(id contactinfo) :required "required")
                            (:name "address" :label "Address" :field-type "text" :value ,(address contactinfo) :required "required")
                            (:name "city" :label "City" :field-type "text" :value ,(city contactinfo) :required "required")
                            (:name "state_id" :label "State" :field-type "select" :value ,(state_id contactinfo) :options ,(state-options (get-records resume-pkg (make-instance 'states) "abbr asc")) :required "required")
                            (:name "phone" :label "Phone" :field-type "text" :value ,(phone contactinfo) :required "required")
                            (:name "email" :label "Email" :field-type "text" :value ,(email contactinfo) :required "required")
                            (:name "url" :label "URL" :field-type "text" :value ,(url contactinfo))
                            (:name "visastatus_id" :label "VISA Status" :field-type "select" :value (visastatus_id contactinfo) :options ,(visastatus-options (get-records resume-pkg (make-instance 'visastatus) "visastatus asc")) :required "required")
                            (:label "Modify CONTACTINFO"  :field-type "button" :onclick ,(format nil "on_contactinfo_modify_submit_clicked(~a)" id)))))