pike13-cli 0.1.4

data/lib/pike13/cli/commands/desk/event_occurrence.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class EventOccurrence < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk event_occurrences"
+          end
+          desc "list", "List event occurrences"
+          map "ls" => :list
+          format_options
+          option :from, type: :string, desc: "Start date (YYYY-MM-DD)"
+          option :to, type: :string, desc: "End date (YYYY-MM-DD)"
+          def list
+            # Validate date formats
+            validate_date_format(options[:from], "from") if options[:from]
+            validate_date_format(options[:to], "to") if options[:to]
+
+            handle_error do
+              params = {}
+              params[:from] = options[:from] if options[:from]
+              params[:to] = options[:to] if options[:to]
+
+              result = with_progress("Fetching event occurrences") do
+                Pike13::Desk::EventOccurrence.all(**params)
+              end
+              output(result)
+            end
+          end
+
+          desc "get ID", "Get an event occurrence by ID"
+          format_options
+          def get(id)
+            handle_error do
+              result = Pike13::Desk::EventOccurrence.find(id)
+              output(result)
+            end
+          end
+
+          desc "summary", "Get event occurrence summary"
+          format_options
+          def summary
+            handle_error do
+              result = Pike13::Desk::EventOccurrence.summary
+              output(result)
+            end
+          end
+
+          desc "eligibilities ID", "Get enrollment eligibilities for an event occurrence"
+          format_options
+          def eligibilities(id)
+            handle_error do
+              result = Pike13::Desk::EventOccurrence.enrollment_eligibilities(id: id)
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/event_occurrence_note.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class EventOccurrenceNote < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk event_occurrence_notes"
+          end
+          desc "list EVENT_OCCURRENCE_ID", "List notes for an event occurrence"
+          format_options
+          def list(event_occurrence_id)
+            handle_error do
+              result = with_progress("Fetching event occurrence notes") do
+                Pike13::Desk::EventOccurrenceNote.all(event_occurrence_id: event_occurrence_id)
+              end
+              output(result)
+            end
+          end
+
+          desc "get EVENT_OCCURRENCE_ID ID", "Get a specific note for an event occurrence"
+          format_options
+          def get(event_occurrence_id, id)
+            handle_error do
+              result = Pike13::Desk::EventOccurrenceNote.find(event_occurrence_id: event_occurrence_id, id: id)
+              output(result)
+            end
+          end
+
+          desc "create EVENT_OCCURRENCE_ID", "Create a note for an event occurrence"
+          format_options
+          option :note, type: :string, required: true, desc: "Note content"
+          option :subject, type: :string, required: true, desc: "Note subject"
+          def create(event_occurrence_id)
+            handle_error do
+              attributes = {
+                note: options[:note],
+                subject: options[:subject]
+              }
+              result = with_progress("Creating event occurrence note") do
+                Pike13::Desk::EventOccurrenceNote.create(event_occurrence_id: event_occurrence_id,
+                                                         attributes: attributes)
+              end
+              output(result)
+            end
+          end
+
+          desc "update EVENT_OCCURRENCE_ID ID", "Update a note for an event occurrence"
+          format_options
+          option :note, type: :string, desc: "Updated note content"
+          option :subject, type: :string, desc: "Updated note subject"
+          def update(event_occurrence_id, id)
+            handle_error do
+              attributes = {}
+              attributes[:note] = options[:note] if options[:note]
+              attributes[:subject] = options[:subject] if options[:subject]
+
+              result = with_progress("Updating event occurrence note") do
+                Pike13::Desk::EventOccurrenceNote.update(event_occurrence_id: event_occurrence_id, id: id,
+                                                         attributes: attributes)
+              end
+              output(result)
+            end
+          end
+
+          desc "delete EVENT_OCCURRENCE_ID ID", "Delete a note for an event occurrence"
+          format_options
+          def delete(event_occurrence_id, id)
+            handle_error do
+              result = with_progress("Deleting event occurrence note") do
+                Pike13::Desk::EventOccurrenceNote.destroy(event_occurrence_id: event_occurrence_id, id: id)
+              end
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/event_occurrence_visit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class EventOccurrenceVisit < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk event_occurrence_visits"
+          end
+          desc "list EVENT_OCCURRENCE_ID", "List visits for an event occurrence"
+          format_options
+          def list(event_occurrence_id)
+            handle_error do
+              result = with_progress("Fetching event occurrence visits") do
+                Pike13::Desk::EventOccurrenceVisit.all(event_occurrence_id: event_occurrence_id)
+              end
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/event_occurrence_waitlist_entry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class EventOccurrenceWaitlistEntry < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk event_occurrence_waitlist_entries"
+          end
+          desc "list EVENT_OCCURRENCE_ID", "List waitlist entries for an event occurrence"
+          format_options
+          def list(event_occurrence_id)
+            handle_error do
+              result = with_progress("Fetching event occurrence waitlist entries") do
+                Pike13::Desk::EventOccurrenceWaitlistEntry.all(event_occurrence_id: event_occurrence_id)
+              end
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/form_of_payment.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class FormOfPayment < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk forms_of_payment"
+          end
+          desc "list PERSON_ID", "List forms of payment for a person"
+          map "ls" => :list
+          format_options
+          def list(person_id)
+            handle_error do
+              result = with_progress("Fetching forms of payment") do
+                Pike13::Desk::FormOfPayment.all(person_id: person_id)
+              end
+              output(result)
+            end
+          end
+
+          desc "get PERSON_ID FOP_ID", "Get a form of payment by ID"
+          format_options
+          def get(person_id, fop_id)
+            handle_error do
+              result = Pike13::Desk::FormOfPayment.find(person_id: person_id, id: fop_id)
+              output(result)
+            end
+          end
+
+          desc "create PERSON_ID", "Create a form of payment for a person"
+          format_options
+          option :type, type: :string, required: true, desc: "Payment type (creditcard, ach, etc.)"
+          option :token, type: :string, required: true, desc: "Payment token from payment processor"
+          option :is_default, type: :boolean, default: false, desc: "Set as default payment method"
+          def create(person_id)
+            handle_error do
+              attributes = {
+                type: options[:type],
+                token: options[:token],
+                is_default: options[:is_default]
+              }
+              result = Pike13::Desk::FormOfPayment.create(person_id: person_id, attributes: attributes)
+              output(result)
+              success_message "Form of payment created successfully"
+            end
+          end
+
+          desc "update PERSON_ID FOP_ID", "Update a form of payment"
+          format_options
+          option :is_default, type: :boolean, desc: "Set as default payment method"
+          def update(person_id, fop_id)
+            handle_error do
+              attributes = {}
+              attributes[:is_default] = options[:is_default] if options.key?(:is_default)
+              result = Pike13::Desk::FormOfPayment.update(person_id: person_id, id: fop_id, attributes: attributes)
+              output(result)
+              success_message "Form of payment updated successfully"
+            end
+          end
+
+          desc "delete PERSON_ID FOP_ID", "Delete a form of payment"
+          def delete(person_id, fop_id)
+            handle_error do
+              Pike13::Desk::FormOfPayment.destroy(person_id: person_id, id: fop_id)
+              success_message "Form of payment #{fop_id} deleted successfully"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/invoice.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class Invoice < Base
+          desc "list", "List all invoices"
+          map "ls" => :list
+          format_options
+          def list
+            handle_error do
+              result = with_progress("Fetching invoices") do
+                Pike13::Desk::Invoice.all
+              end
+              output(result)
+            end
+          end
+
+          desc "get ID", "Get a invoice by ID"
+          format_options
+          def get(id)
+            handle_error { output(Pike13::Desk::Invoice.find(id)) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/location.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class Location < Base
+          desc "list", "List all locations"
+          map "ls" => :list
+          format_options
+          def list
+            handle_error do
+              result = with_progress("Fetching locations") do
+                Pike13::Desk::Location.all
+              end
+              output(result)
+            end
+          end
+
+          desc "get ID", "Get a location by ID"
+          format_options
+          def get(id)
+            handle_error { output(Pike13::Desk::Location.find(id)) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/make_up.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class MakeUp < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk make_ups"
+          end
+          desc "get ID", "Get a make-up by ID"
+          format_options
+          def get(id)
+            handle_error do
+              result = Pike13::Desk::MakeUp.find(id)
+              output(result)
+            end
+          end
+
+          desc "reasons", "List make-up reasons"
+          format_options
+          def reasons
+            handle_error do
+              result = with_progress("Fetching make-up reasons") do
+                Pike13::Desk::MakeUp.reasons
+              end
+              output(result)
+            end
+          end
+
+          desc "generate VISIT_ID", "Generate a make-up credit"
+          format_options
+          option :make_up_reason_id, type: :numeric, required: true, desc: "Make-up reason ID"
+          option :free_form_reason, type: :string, desc: "Free form reason text"
+          def generate(visit_id)
+            handle_error do
+              result = Pike13::Desk::MakeUp.generate(
+                visit_id: visit_id,
+                make_up_reason_id: options[:make_up_reason_id],
+                free_form_reason: options[:free_form_reason]
+              )
+              output(result)
+              success_message "Make-up generated successfully"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/note.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class Note < Base
+          desc "list PERSON_ID", "List notes for a person"
+          map "ls" => :list
+          format_options
+          def list(person_id)
+            handle_error do
+              result = with_progress("Fetching notes") do
+                Pike13::Desk::Note.all(person_id: person_id)
+              end
+              output(result)
+            end
+          end
+
+          desc "get PERSON_ID NOTE_ID", "Get a note by ID"
+          format_options
+          def get(person_id, note_id)
+            handle_error do
+              result = Pike13::Desk::Note.find(person_id: person_id, id: note_id)
+              output(result)
+            end
+          end
+
+          desc "create PERSON_ID", "Create a note for a person"
+          format_options
+          option :subject, type: :string, required: true, desc: "Note subject"
+          option :note, type: :string, required: true, desc: "Note content"
+          def create(person_id)
+            handle_error do
+              attributes = {
+                subject: options[:subject],
+                note: options[:note]
+              }
+              result = Pike13::Desk::Note.create(person_id: person_id, attributes: attributes)
+              output(result)
+              success_message "Note created successfully"
+            end
+          end
+
+          desc "update PERSON_ID NOTE_ID", "Update a note"
+          format_options
+          option :subject, type: :string, desc: "Note subject"
+          option :note, type: :string, desc: "Note content"
+          def update(person_id, note_id)
+            handle_error do
+              attributes = {}
+              attributes[:subject] = options[:subject] if options[:subject]
+              attributes[:note] = options[:note] if options[:note]
+              result = Pike13::Desk::Note.update(person_id: person_id, id: note_id, attributes: attributes)
+              output(result)
+              success_message "Note updated successfully"
+            end
+          end
+
+          desc "delete PERSON_ID NOTE_ID", "Delete a note"
+          def delete(person_id, note_id)
+            handle_error do
+              Pike13::Desk::Note.destroy(person_id: person_id, id: note_id)
+              success_message "Note #{note_id} deleted successfully"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/pack.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class Pack < Base
+          desc "get ID", "Get a pack by ID"
+          format_options
+          def get(id)
+            handle_error do
+              result = Pike13::Desk::Pack.find(id)
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/pack_product.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class PackProduct < Base
+          # Override base_usage to match the actual subcommand registration
+          def self.base_usage
+            "desk pack_products"
+          end
+          desc "list", "List all pack products"
+          format_options
+          def list
+            handle_error do
+              result = with_progress("Fetching pack products") do
+                Pike13::Desk::PackProduct.all
+              end
+              output(result)
+            end
+          end
+
+          desc "get ID", "Get a pack product by ID"
+          format_options
+          def get(id)
+            handle_error do
+              result = Pike13::Desk::PackProduct.find(id)
+              output(result)
+            end
+          end
+
+          desc "create", "Create a pack product"
+          format_options
+          option :name, type: :string, required: true, desc: "Pack product name"
+          option :description, type: :string, desc: "Pack product description"
+          option :price, type: :numeric, required: true, desc: "Pack product price"
+          option :visit_count, type: :numeric, required: true, desc: "Number of visits"
+          def create
+            handle_error do
+              attributes = {
+                name: options[:name],
+                description: options[:description],
+                price: options[:price],
+                visit_count: options[:visit_count]
+              }
+              result = with_progress("Creating pack product") do
+                Pike13::Desk::PackProduct.create(attributes: attributes)
+              end
+              output(result)
+            end
+          end
+
+          desc "update ID", "Update a pack product"
+          format_options
+          option :name, type: :string, desc: "Updated pack product name"
+          option :description, type: :string, desc: "Updated pack product description"
+          option :price, type: :numeric, desc: "Updated pack product price"
+          option :visit_count, type: :numeric, desc: "Updated number of visits"
+          def update(id)
+            handle_error do
+              attributes = {}
+              attributes[:name] = options[:name] if options[:name]
+              attributes[:description] = options[:description] if options[:description]
+              attributes[:price] = options[:price] if options[:price]
+              attributes[:visit_count] = options[:visit_count] if options[:visit_count]
+
+              result = with_progress("Updating pack product") do
+                Pike13::Desk::PackProduct.update(id, attributes: attributes)
+              end
+              output(result)
+            end
+          end
+
+          desc "delete ID", "Delete a pack product"
+          format_options
+          def delete(id)
+            handle_error do
+              result = with_progress("Deleting pack product") do
+                Pike13::Desk::PackProduct.destroy(id)
+              end
+              output(result)
+            end
+          end
+
+          desc "create-pack PACK_PRODUCT_ID", "Create a pack within a pack product"
+          format_options
+          option :person_id, type: :numeric, required: true, desc: "Person ID to assign pack to"
+          def create_pack(pack_product_id)
+            handle_error do
+              attributes = { person_id: options[:person_id].to_i }
+              result = with_progress("Creating pack") do
+                Pike13::Desk::PackProduct.create_pack(pack_product_id, attributes)
+              end
+              output(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pike13/cli/commands/desk/payment.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pike13
+  module CLI
+    module Commands
+      class Desk < Base
+        class Payment < Base
+          desc "get ID", "Get a payment by ID"
+          format_options
+          def get(id)
+            handle_error do
+              result = Pike13::Desk::Payment.find(id)
+              output(result)
+            end
+          end
+
+          desc "configuration", "Get payment configuration"
+          format_options
+          def configuration
+            handle_error do
+              result = Pike13::Desk::Payment.configuration
+              output(result)
+            end
+          end
+
+          desc "void PAYMENT_ID", "Void a payment"
+          format_options
+          option :invoice_item_ids, type: :array, desc: "Invoice item IDs to cancel"
+          def void(payment_id)
+            handle_error do
+              invoice_item_ids_to_cancel = options[:invoice_item_ids] || []
+              result = Pike13::Desk::Payment.void(
+                payment_id: payment_id,
+                invoice_item_ids_to_cancel: invoice_item_ids_to_cancel
+              )
+              output(result)
+              success_message "Payment #{payment_id} voided successfully"
+            end
+          end
+        end
+      end
+    end
+  end
+end