halo_msp_api 0.1.0 → 0.3.0

data/lib/halo_msp_api/resources/actions.rb

@@ -2,84 +2,85 @@
 
 module HaloMspApi
   module Resources
+    # Resource class for Actions
     class Actions < Base
       # GET /Actions - List of Actions
       # Parameters based on swagger.json specification
-      def list(options = {})
+      def actions(options = {})
         params = build_list_params(options)
-        get("/Actions", params)
+        get('/Actions', params)
       end
 
       # GET /Actions/{id} - Get a specific Action
-      def get(id, params = {})
-        get_resource("Actions", id, params)
+      def action(id, params = {})
+        get_resource('Actions', id, params)
       end
 
       # POST /Actions - Create a new Action
-      def create(data)
-        create_resource("Actions", data)
+      def create_action(data)
+        create_resource('Actions', data)
       end
 
       # PUT /Actions/{id} - Update an Action
-      def update(id, data)
-        update_resource("Actions", id, data)
+      def update_action(id, data)
+        update_resource('Actions', id, data)
       end
 
       # DELETE /Actions/{id} - Delete an Action
-      def delete(id)
-        delete_resource("Actions", id)
+      def delete_action(id)
+        delete_resource('Actions', id)
       end
 
       # Action Reactions methods
       # GET /ActionReaction - List action reactions
       def reactions(params = {})
-        get("/ActionReaction", params)
+        list_resource('ActionReaction', params)
       end
 
       # GET /ActionReaction/{id} - Get specific action reaction
       def reaction(id, params = {})
-        get("/ActionReaction/#{id}", params)
+        get_resource('ActionReaction', id, params)
       end
 
       # POST /ActionReaction - Create action reaction
       def create_reaction(data)
-        post("/ActionReaction", data)
+        create_resource('ActionReaction', data)
       end
 
       # PUT /ActionReaction/{id} - Update action reaction
       def update_reaction(id, data)
-        put("/ActionReaction/#{id}", data)
+        update_resource('ActionReaction', id, data)
       end
 
       # DELETE /ActionReaction/{id} - Delete action reaction
       def delete_reaction(id)
-        delete("/ActionReaction/#{id}")
+        delete_resource('ActionReaction', id)
       end
 
       # Action Review methods
       # GET /ActionReview - List action reviews
       def reviews(params = {})
-        get("/ActionReview", params)
+        list_resource('ActionReview', params)
       end
 
       # GET /ActionReview/{id} - Get specific action review
       def review(id, params = {})
-        get("/ActionReview/#{id}", params)
+        get_resource('ActionReview', id, params)
       end
 
       # POST /ActionReview - Create action review
       def create_review(data)
-        post("/ActionReview", data)
+        create_resource('ActionReview', data)
       end
 
       # PUT /ActionReview/{id} - Update action review
       def update_review(id, data)
-        put("/ActionReview/#{id}", data)
+        update_resource('ActionReview', id, data)
       end
 
       # DELETE /ActionReview/{id} - Delete action review
       def delete_review(id)
-        delete("/ActionReview/#{id}")
+        delete_resource('ActionReview', id)
       end
     end
   end

data/lib/halo_msp_api/resources/agents.rb

@@ -2,98 +2,99 @@
 
 module HaloMspApi
   module Resources
+    # Resource class for Agents
     class Agents < Base
       # GET /Agent - List of Agents
-      def list(params = {})
-        list_resource("Agent", params)
+      def agents(params = {})
+        list_resource('Agent', params)
       end
 
       # GET /Agent/{id} - Get a specific Agent
-      def get(id, params = {})
-        get_resource("Agent", id, params)
+      def agent(id, params = {})
+        get_resource('Agent', id, params)
       end
 
       # POST /Agent - Create a new Agent
-      def create(data)
-        create_resource("Agent", data)
+      def create_agent(data)
+        create_resource('Agent', data)
       end
 
       # PUT /Agent/{id} - Update an Agent
-      def update(id, data)
-        update_resource("Agent", id, data)
+      def update_agent(id, data)
+        update_resource('Agent', id, data)
       end
 
       # DELETE /Agent/{id} - Delete an Agent
-      def delete(id)
-        delete_resource("Agent", id)
+      def delete_agent(id)
+        delete_resource('Agent', id)
       end
 
       # GET /Agent/me - Get current Agent information
       def me(params = {})
-        get(resource_path("Agent", nil, "me"), params)
+        get_resource('Agent', 'me', params)
       end
 
       # POST /Agent/ClearCache - Clear Agent cache
       def clear_cache
-        post(resource_path("Agent", nil, "ClearCache"))
+        post(resource_path('Agent', nil, 'ClearCache'))
       end
 
       # GET /AgentImage/{id} - Get Agent image
       def image(id)
-        get(resource_path("AgentImage", id))
+        get_resource('AgentImage', id)
       end
 
       # Agent Check-in related methods
       # GET /AgentCheckIn - List Agent check-ins
       def check_ins(params = {})
-        get("/AgentCheckIn", params)
+        list_resource('AgentCheckIn', params)
       end
 
       # GET /AgentCheckIn/{id} - Get specific Agent check-in
       def check_in(id, params = {})
-        get("/AgentCheckIn/#{id}", params)
+        get_resource('AgentCheckIn', id, params)
       end
 
       # POST /AgentCheckIn - Create Agent check-in
       def create_check_in(data)
-        post("/AgentCheckIn", data)
+        create_resource('AgentCheckIn', data)
       end
 
       # Agent Event Subscription methods
       # GET /AgentEventSubscription - List Agent event subscriptions
       def event_subscriptions(params = {})
-        get("/AgentEventSubscription", params)
+        list_resource('AgentEventSubscription', params)
       end
 
       # GET /AgentEventSubscription/{id} - Get specific Agent event subscription
       def event_subscription(id, params = {})
-        get("/AgentEventSubscription/#{id}", params)
+        get_resource('AgentEventSubscription', id, params)
       end
 
       # POST /AgentEventSubscription - Create Agent event subscription
       def create_event_subscription(data)
-        post("/AgentEventSubscription", data)
+        create_resource('AgentEventSubscription', data)
       end
 
       # Agent Presence related methods
       # GET /AgentPresenceRule - List Agent presence rules
       def presence_rules(params = {})
-        get("/AgentPresenceRule", params)
+        list_resource('AgentPresenceRule', params)
       end
 
       # GET /AgentPresenceSubscription - List Agent presence subscriptions
       def presence_subscriptions(params = {})
-        get("/AgentPresenceSubscription", params)
+        list_resource('AgentPresenceSubscription', params)
       end
 
       # GET /AgentPresenceSubscription/{id} - Get specific Agent presence subscription
       def presence_subscription(id, params = {})
-        get("/AgentPresenceSubscription/#{id}", params)
+        get_resource('AgentPresenceSubscription', id, params)
       end
 
       # POST /AgentPresenceSubscription - Create Agent presence subscription
       def create_presence_subscription(data)
-        post("/AgentPresenceSubscription", data)
+        create_resource('AgentPresenceSubscription', data)
       end
     end
   end

data/lib/halo_msp_api/resources/appointments.rb

@@ -2,65 +2,66 @@
 
 module HaloMspApi
   module Resources
+    # Resource class for Appointments
     class Appointments < Base
       # GET /Appointment - List of Appointments
-      def list(params = {})
-        list_resource("Appointment", params)
+      def appointments(params = {})
+        list_resource('Appointment', params)
       end
 
       # GET /Appointment/{id} - Get a specific Appointment
-      def get(id, params = {})
-        get_resource("Appointment", id, params)
+      def appointment(id, params = {})
+        get_resource('Appointment', id, params)
       end
 
       # POST /Appointment - Create a new Appointment
-      def create(data)
-        create_resource("Appointment", data)
+      def create_appointment(data)
+        create_resource('Appointment', data)
       end
 
       # PUT /Appointment/{id} - Update an Appointment
-      def update(id, data)
-        update_resource("Appointment", id, data)
+      def update_appointment(id, data)
+        update_resource('Appointment', id, data)
       end
 
       # DELETE /Appointment/{id} - Delete an Appointment
-      def delete(id)
-        delete_resource("Appointment", id)
+      def delete_appointment(id)
+        delete_resource('Appointment', id)
       end
 
       # GET /Appointment/Availability - Get Appointment availability
       def availability(params = {})
-        get(resource_path("Appointment", nil, "Availability"), params)
+        get_resource('Appointment', 'Availability', params)
       end
 
       # GET /Appointment/Calendar - Get Appointment calendar
       def calendar(params = {})
-        get(resource_path("Appointment", nil, "Calendar"), params)
+        get_resource('Appointment', 'Calendar', params)
       end
 
       # POST /Appointment/CheckAvailability - Check Appointment availability
       def check_availability(data)
-        post(resource_path("Appointment", nil, "CheckAvailability"), data)
+        post(resource_path('Appointment', nil, 'CheckAvailability'), data)
       end
 
       # GET /Appointment/Slots - Get Appointment slots
       def slots(params = {})
-        get(resource_path("Appointment", nil, "Slots"), params)
+        list_resource('Appointment', 'Slots', params)
       end
 
       # POST /Appointment/Slots - Create Appointment slots
       def create_slots(data)
-        post(resource_path("Appointment", nil, "Slots"), data)
+        create_resource('Appointment', 'Slots', data)
       end
 
       # GET /Appointment/Types - Get Appointment types
       def types(params = {})
-        get(resource_path("Appointment", nil, "Types"), params)
+        list_resource('Appointment', 'Types', params)
       end
 
       # POST /Appointment/Types - Create Appointment type
       def create_type(data)
-        post(resource_path("Appointment", nil, "Types"), data)
+        create_resource('Appointment', 'Types', data)
       end
     end
   end

data/lib/halo_msp_api/resources/assets.rb

@@ -2,145 +2,146 @@
 
 module HaloMspApi
   module Resources
+    # Resource class for Assets
     class Assets < Base
       # GET /Asset - List of Assets
-      def list(params = {})
-        list_resource("Asset", params)
+      def assets(params = {})
+        list_resource('Asset', params)
       end
 
       # GET /Asset/{id} - Get a specific Asset
-      def get(id, params = {})
-        get_resource("Asset", id, params)
+      def asset(id, params = {})
+        get_resource('Asset', id, params)
       end
 
       # POST /Asset - Create a new Asset
-      def create(data)
-        create_resource("Asset", data)
+      def create_asset(data)
+        create_resource('Asset', data)
       end
 
       # PUT /Asset/{id} - Update an Asset
-      def update(id, data)
-        update_resource("Asset", id, data)
+      def update_asset(id, data)
+        update_resource('Asset', id, data)
       end
 
       # DELETE /Asset/{id} - Delete an Asset
-      def delete(id)
-        delete_resource("Asset", id)
+      def delete_asset(id)
+        delete_resource('Asset', id)
       end
 
       # GET /Asset/GetAllSoftwareVersions - Get all software versions
       def software_versions(params = {})
-        get(resource_path("Asset", nil, "GetAllSoftwareVersions"), params)
+        list_resource('Asset', params, 'GetAllSoftwareVersions')
       end
 
       # GET /Asset/NextTag - Get next asset tag
       def next_tag(params = {})
-        get(resource_path("Asset", nil, "NextTag"), params)
+        get_resource('Asset', 'NextTag', params)
       end
 
       # Asset Change related methods
       # GET /AssetChange - List Asset changes
       def changes(params = {})
-        get("/AssetChange", params)
+        list_resource('AssetChange', params)
       end
 
       # POST /AssetChange - Create Asset change
       def create_change(data)
-        post("/AssetChange", data)
+        create_resource('AssetChange', data)
       end
 
       # Asset Group methods
       # GET /AssetGroup - List Asset groups
       def groups(params = {})
-        get("/AssetGroup", params)
+        list_resource('AssetGroup', params)
       end
 
       # GET /AssetGroup/{id} - Get specific Asset group
       def group(id, params = {})
-        get("/AssetGroup/#{id}", params)
+        get_resource('AssetGroup', id, params)
       end
 
       # POST /AssetGroup - Create Asset group
       def create_group(data)
-        post("/AssetGroup", data)
+        create_resource('AssetGroup', data)
       end
 
       # PUT /AssetGroup/{id} - Update Asset group
       def update_group(id, data)
-        put("/AssetGroup/#{id}", data)
+        update_resource('AssetGroup', id, data)
       end
 
       # DELETE /AssetGroup/{id} - Delete Asset group
       def delete_group(id)
-        delete("/AssetGroup/#{id}")
+        delete_resource('AssetGroup', id)
       end
 
       # Asset Software methods
       # GET /AssetSoftware - List Asset software
       def software(params = {})
-        get("/AssetSoftware", params)
+        list_resource('AssetSoftware', params)
       end
 
       # POST /AssetSoftware - Create Asset software
       def create_software(data)
-        post("/AssetSoftware", data)
+        create_resource('AssetSoftware', data)
       end
 
       # Asset Type methods
       # GET /AssetType - List Asset types
       def types(params = {})
-        get("/AssetType", params)
+        list_resource('AssetType', params)
       end
 
       # GET /AssetType/{id} - Get specific Asset type
       def type(id, params = {})
-        get("/AssetType/#{id}", params)
+        get_resource('AssetType', id, params)
       end
 
       # POST /AssetType - Create Asset type
       def create_type(data)
-        post("/AssetType", data)
+        create_resource('AssetType', data)
       end
 
       # PUT /AssetType/{id} - Update Asset type
       def update_type(id, data)
-        put("/AssetType/#{id}", data)
+        update_resource('AssetType', id, data)
       end
 
       # DELETE /AssetType/{id} - Delete Asset type
       def delete_type(id)
-        delete("/AssetType/#{id}")
+        delete_resource('AssetType', id)
       end
 
       # GET /AssetTypeInfo - Get Asset type info
       def type_info(params = {})
-        get("/AssetTypeInfo", params)
+        get(resource_path('AssetTypeInfo'), params)
       end
 
       # Asset Type Mappings methods
       # GET /AssetTypeMappings - List Asset type mappings
       def type_mappings(params = {})
-        get("/AssetTypeMappings", params)
+        list_resource('AssetTypeMappings', params)
       end
 
       # GET /AssetTypeMappings/{id} - Get specific Asset type mapping
       def type_mapping(id, params = {})
-        get("/AssetTypeMappings/#{id}", params)
+        get_resource('AssetTypeMappings', id, params)
       end
 
       # POST /AssetTypeMappings - Create Asset type mapping
       def create_type_mapping(data)
-        post("/AssetTypeMappings", data)
+        create_resource('AssetTypeMappings', data)
       end
 
       # PUT /AssetTypeMappings/{id} - Update Asset type mapping
       def update_type_mapping(id, data)
-        put("/AssetTypeMappings/#{id}", data)
+        update_resource('AssetTypeMappings', id, data)
       end
 
       # DELETE /AssetTypeMappings/{id} - Delete Asset type mapping
       def delete_type_mapping(id)
-        delete("/AssetTypeMappings/#{id}")
+        delete_resource('AssetTypeMappings', id)
       end
     end
   end

data/lib/halo_msp_api/resources/base.rb

@@ -2,38 +2,39 @@
 
 module HaloMspApi
   module Resources
+    # Base class for all resources
     class Base
-      attr_reader :client
+      attr_reader :client_instance
 
-      def initialize(client)
-        @client = client
+      def initialize(client_instance)
+        @client_instance = client_instance
       end
 
       protected
 
       def get(path, params = {})
-        client.get(path, params)
+        client_instance.get(path, params)
       end
 
       def post(path, body = {})
-        client.post(path, body)
+        client_instance.post(path, body)
       end
 
       def put(path, body = {})
-        client.put(path, body)
+        client_instance.put(path, body)
       end
 
       def patch(path, body = {})
-        client.patch(path, body)
+        client_instance.patch(path, body)
       end
 
       def delete(path)
-        client.delete(path)
+        client_instance.delete(path)
       end
 
       # Helper method to build resource path
       def resource_path(resource_name, id = nil, action = nil)
-        path = "/#{resource_name}"
+        path = "/api/#{resource_name}"
         path += "/#{id}" if id
         path += "/#{action}" if action
         path
@@ -56,7 +57,8 @@ module HaloMspApi
 
       # Helper method for update operations
       def update_resource(resource_name, id, data)
-        put(resource_path(resource_name, id), data)
+        data_with_id = data.merge(id: id)
+        post(resource_path(resource_name), data_with_id)
       end
 
       # Helper method for delete operations