halo_msp_api 0.1.0 → 0.2.0

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_path('Agent', nil, '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_path('AgentImage', id))
       end
 
       # Agent Check-in related methods
       # GET /AgentCheckIn - List Agent check-ins
       def check_ins(params = {})
-        get("/AgentCheckIn", params)
+        get('AgentCheckIn', params)
       end
 
       # GET /AgentCheckIn/{id} - Get specific Agent check-in
       def check_in(id, params = {})
-        get("/AgentCheckIn/#{id}", params)
+        get("AgentCheckIn/#{id}", params)
       end
 
       # POST /AgentCheckIn - Create Agent check-in
       def create_check_in(data)
-        post("/AgentCheckIn", data)
+        post('AgentCheckIn', data)
       end
 
       # Agent Event Subscription methods
       # GET /AgentEventSubscription - List Agent event subscriptions
       def event_subscriptions(params = {})
-        get("/AgentEventSubscription", params)
+        get('AgentEventSubscription', params)
       end
 
       # GET /AgentEventSubscription/{id} - Get specific Agent event subscription
       def event_subscription(id, params = {})
-        get("/AgentEventSubscription/#{id}", params)
+        get("AgentEventSubscription/#{id}", params)
       end
 
       # POST /AgentEventSubscription - Create Agent event subscription
       def create_event_subscription(data)
-        post("/AgentEventSubscription", data)
+        post('AgentEventSubscription', data)
       end
 
       # Agent Presence related methods
       # GET /AgentPresenceRule - List Agent presence rules
       def presence_rules(params = {})
-        get("/AgentPresenceRule", params)
+        get('AgentPresenceRule', params)
       end
 
       # GET /AgentPresenceSubscription - List Agent presence subscriptions
       def presence_subscriptions(params = {})
-        get("/AgentPresenceSubscription", params)
+        get('AgentPresenceSubscription', params)
       end
 
       # GET /AgentPresenceSubscription/{id} - Get specific Agent presence subscription
       def presence_subscription(id, params = {})
-        get("/AgentPresenceSubscription/#{id}", params)
+        get("AgentPresenceSubscription/#{id}", params)
       end
 
       # POST /AgentPresenceSubscription - Create Agent presence subscription
       def create_presence_subscription(data)
-        post("/AgentPresenceSubscription", data)
+        post('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_path('Appointment', nil, 'Availability'), params)
       end
 
       # GET /Appointment/Calendar - Get Appointment calendar
       def calendar(params = {})
-        get(resource_path("Appointment", nil, "Calendar"), params)
+        get(resource_path('Appointment', nil, '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)
+        get(resource_path('Appointment', nil, 'Slots'), params)
       end
 
       # POST /Appointment/Slots - Create Appointment slots
       def create_slots(data)
-        post(resource_path("Appointment", nil, "Slots"), data)
+        post(resource_path('Appointment', nil, 'Slots'), data)
       end
 
       # GET /Appointment/Types - Get Appointment types
       def types(params = {})
-        get(resource_path("Appointment", nil, "Types"), params)
+        get(resource_path('Appointment', nil, 'Types'), params)
       end
 
       # POST /Appointment/Types - Create Appointment type
       def create_type(data)
-        post(resource_path("Appointment", nil, "Types"), data)
+        post(resource_path('Appointment', nil, '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)
+        get(resource_path('Asset', nil, 'GetAllSoftwareVersions'), params)
       end
 
       # GET /Asset/NextTag - Get next asset tag
       def next_tag(params = {})
-        get(resource_path("Asset", nil, "NextTag"), params)
+        get(resource_path('Asset', nil, 'NextTag'), params)
       end
 
       # Asset Change related methods
       # GET /AssetChange - List Asset changes
       def changes(params = {})
-        get("/AssetChange", params)
+        get('AssetChange', params)
       end
 
       # POST /AssetChange - Create Asset change
       def create_change(data)
-        post("/AssetChange", data)
+        post('AssetChange', data)
       end
 
       # Asset Group methods
       # GET /AssetGroup - List Asset groups
       def groups(params = {})
-        get("/AssetGroup", params)
+        get('AssetGroup', params)
       end
 
       # GET /AssetGroup/{id} - Get specific Asset group
       def group(id, params = {})
-        get("/AssetGroup/#{id}", params)
+        get("AssetGroup/#{id}", params)
       end
 
       # POST /AssetGroup - Create Asset group
       def create_group(data)
-        post("/AssetGroup", data)
+        post('AssetGroup', data)
       end
 
       # PUT /AssetGroup/{id} - Update Asset group
       def update_group(id, data)
-        put("/AssetGroup/#{id}", data)
+        put("AssetGroup/#{id}", data)
       end
 
       # DELETE /AssetGroup/{id} - Delete Asset group
       def delete_group(id)
-        delete("/AssetGroup/#{id}")
+        delete("AssetGroup/#{id}")
       end
 
       # Asset Software methods
       # GET /AssetSoftware - List Asset software
       def software(params = {})
-        get("/AssetSoftware", params)
+        get('AssetSoftware', params)
       end
 
       # POST /AssetSoftware - Create Asset software
       def create_software(data)
-        post("/AssetSoftware", data)
+        post('AssetSoftware', data)
       end
 
       # Asset Type methods
       # GET /AssetType - List Asset types
       def types(params = {})
-        get("/AssetType", params)
+        get('AssetType', params)
       end
 
       # GET /AssetType/{id} - Get specific Asset type
       def type(id, params = {})
-        get("/AssetType/#{id}", params)
+        get("AssetType/#{id}", params)
       end
 
       # POST /AssetType - Create Asset type
       def create_type(data)
-        post("/AssetType", data)
+        post('AssetType', data)
       end
 
       # PUT /AssetType/{id} - Update Asset type
       def update_type(id, data)
-        put("/AssetType/#{id}", data)
+        put("AssetType/#{id}", data)
       end
 
       # DELETE /AssetType/{id} - Delete Asset type
       def delete_type(id)
-        delete("/AssetType/#{id}")
+        delete("AssetType/#{id}")
       end
 
       # GET /AssetTypeInfo - Get Asset type info
       def type_info(params = {})
-        get("/AssetTypeInfo", params)
+        get('AssetTypeInfo', params)
       end
 
       # Asset Type Mappings methods
       # GET /AssetTypeMappings - List Asset type mappings
       def type_mappings(params = {})
-        get("/AssetTypeMappings", params)
+        get('AssetTypeMappings', params)
       end
 
       # GET /AssetTypeMappings/{id} - Get specific Asset type mapping
       def type_mapping(id, params = {})
-        get("/AssetTypeMappings/#{id}", params)
+        get("AssetTypeMappings/#{id}", params)
       end
 
       # POST /AssetTypeMappings - Create Asset type mapping
       def create_type_mapping(data)
-        post("/AssetTypeMappings", data)
+        post('AssetTypeMappings', data)
       end
 
       # PUT /AssetTypeMappings/{id} - Update Asset type mapping
       def update_type_mapping(id, data)
-        put("/AssetTypeMappings/#{id}", data)
+        put("AssetTypeMappings/#{id}", data)
       end
 
       # DELETE /AssetTypeMappings/{id} - Delete Asset type mapping
       def delete_type_mapping(id)
-        delete("/AssetTypeMappings/#{id}")
+        delete("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

data/lib/halo_msp_api/resources/clients.rb

@@ -2,113 +2,109 @@
 
 module HaloMspApi
   module Resources
+    # Resource class for Clients
     class Clients < Base
       # GET /Client - List of Clients
-      def list(params = {})
-        list_resource("Client", params)
+      def clients(params = {})
+        list_resource('Client', params)
       end
 
       # GET /Client/{id} - Get a specific Client
-      def get(id, params = {})
-        get_resource("Client", id, params)
+      def client(id, params = {})
+        get_resource('Client', id, params)
       end
 
       # POST /Client - Create a new Client
-      def create(data)
-        create_resource("Client", data)
+      def create_client(data)
+        create_resource('Client', data)
       end
 
       # PUT /Client/{id} - Update a Client
-      def update(id, data)
-        update_resource("Client", id, data)
+      def update_client(id, data)
+        update_resource('Client', id, data)
       end
 
       # DELETE /Client/{id} - Delete a Client
-      def delete(id)
-        delete_resource("Client", id)
-      end
-
-      # GET /Client/me - Get current Client information
-      def me(params = {})
-        get(resource_path("Client", nil, "me"), params)
+      def delete_client(id)
+        delete_resource('Client', id)
       end
 
       # GET /Client/NewAccountsId - Get new accounts ID
       def new_accounts_id(params = {})
-        get(resource_path("Client", nil, "NewAccountsId"), params)
+        get(resource_path('Client', nil, 'NewAccountsId'), params)
       end
 
       # POST /Client/PaymentMethodUpdate - Update payment method
       def update_payment_method(data)
-        post(resource_path("Client", nil, "PaymentMethodUpdate"), data)
+        post(resource_path('Client', nil, 'PaymentMethodUpdate'), data)
       end
 
       # Client Cache methods
       # GET /ClientCache - Get Client cache
       def cache(params = {})
-        get("/ClientCache", params)
+        get('ClientCache', params)
       end
 
       # Client Contract methods
       # GET /ClientContract - List Client contracts
       def contracts(params = {})
-        get("/ClientContract", params)
+        get('ClientContract', params)
       end
 
       # GET /ClientContract/{id} - Get specific Client contract
       def contract(id, params = {})
-        get("/ClientContract/#{id}", params)
+        get("ClientContract/#{id}", params)
       end
 
       # POST /ClientContract - Create Client contract
       def create_contract(data)
-        post("/ClientContract", data)
+        post('ClientContract', data)
       end
 
       # PUT /ClientContract/{id} - Update Client contract
       def update_contract(id, data)
-        put("/ClientContract/#{id}", data)
+        put("ClientContract/#{id}", data)
       end
 
       # DELETE /ClientContract/{id} - Delete Client contract
       def delete_contract(id)
-        delete("/ClientContract/#{id}")
+        delete("ClientContract/#{id}")
       end
 
       # POST /ClientContract/Approval - Client contract approval
       def contract_approval(data)
-        post("/ClientContract/Approval", data)
+        post('ClientContract/Approval', data)
       end
 
       # GET /ClientContract/NextRef - Get next contract reference
       def next_contract_ref(params = {})
-        get("/ClientContract/NextRef", params)
+        get('ClientContract/NextRef', params)
       end
 
       # Client Prepay methods
       # GET /ClientPrepay - List Client prepayments
       def prepayments(params = {})
-        get("/ClientPrepay", params)
+        get('ClientPrepay', params)
       end
 
       # GET /ClientPrepay/{id} - Get specific Client prepayment
       def prepayment(id, params = {})
-        get("/ClientPrepay/#{id}", params)
+        get("ClientPrepay/#{id}", params)
       end
 
       # POST /ClientPrepay - Create Client prepayment
       def create_prepayment(data)
-        post("/ClientPrepay", data)
+        post('ClientPrepay', data)
       end
 
       # PUT /ClientPrepay/{id} - Update Client prepayment
       def update_prepayment(id, data)
-        put("/ClientPrepay/#{id}", data)
+        put("ClientPrepay/#{id}", data)
       end
 
       # DELETE /ClientPrepay/{id} - Delete Client prepayment
       def delete_prepayment(id)
-        delete("/ClientPrepay/#{id}")
+        delete("ClientPrepay/#{id}")
       end
     end
   end