square.rb 44.0.0.0 → 44.0.1.20250820

data/lib/square/cash_drawers/shifts/client.rb

@@ -14,22 +14,31 @@ module Square
         #
         # @return [Square::Types::ListCashDrawerShiftsResponse]
         def list(request_options: {}, **params)
-          _query_param_names = %w[location_id sort_order begin_time end_time limit cursor]
+          _query_param_names = [
+            %w[location_id sort_order begin_time end_time limit cursor],
+            %i[location_id sort_order begin_time end_time limit cursor]
+          ].flatten
           _query = params.slice(*_query_param_names)
           params.except(*_query_param_names)
 
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "GET",
             path: "v2/cash-drawers/shifts",
             query: _query
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::ListCashDrawerShiftsResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::ListCashDrawerShiftsResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
 
         # Provides the summary details for a single cash drawer shift. See
@@ -37,44 +46,62 @@ module Square
         #
         # @return [Square::Types::GetCashDrawerShiftResponse]
         def get(request_options: {}, **params)
-          _query_param_names = ["location_id"]
+          _query_param_names = [
+            ["location_id"],
+            %i[location_id]
+          ].flatten
           _query = params.slice(*_query_param_names)
           params = params.except(*_query_param_names)
 
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "GET",
             path: "v2/cash-drawers/shifts/#{params[:shift_id]}",
             query: _query
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::GetCashDrawerShiftResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::GetCashDrawerShiftResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
 
         # Provides a paginated list of events for a single cash drawer shift.
         #
         # @return [Square::Types::ListCashDrawerShiftEventsResponse]
         def list_events(request_options: {}, **params)
-          _query_param_names = %w[location_id limit cursor]
+          _query_param_names = [
+            %w[location_id limit cursor],
+            %i[location_id limit cursor]
+          ].flatten
           _query = params.slice(*_query_param_names)
           params = params.except(*_query_param_names)
 
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "GET",
             path: "v2/cash-drawers/shifts/#{params[:shift_id]}/events",
             query: _query
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::ListCashDrawerShiftEventsResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::ListCashDrawerShiftEventsResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
       end
     end

data/lib/square/catalog/client.rb

@@ -26,17 +26,23 @@ module Square
       # @return [Square::Types::BatchDeleteCatalogObjectsResponse]
       def batch_delete(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/batch-delete",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::BatchDeleteCatalogObjectsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::BatchDeleteCatalogObjectsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Returns a set of objects based on the provided ID.
@@ -49,17 +55,23 @@ module Square
       # @return [Square::Types::BatchGetCatalogObjectsResponse]
       def batch_get(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/batch-retrieve",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::BatchGetCatalogObjectsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::BatchGetCatalogObjectsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Creates or updates up to 10,000 target objects based on the provided
@@ -79,17 +91,23 @@ module Square
       # @return [Square::Types::BatchUpsertCatalogObjectsResponse]
       def batch_upsert(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/batch-upsert",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::BatchUpsertCatalogObjectsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::BatchUpsertCatalogObjectsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Retrieves information about the Square Catalog API, such as batch size
@@ -98,16 +116,22 @@ module Square
       # @return [Square::Types::CatalogInfoResponse]
       def info(request_options: {}, **_params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "GET",
           path: "v2/catalog/info"
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::CatalogInfoResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::CatalogInfoResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Returns a list of all [CatalogObject](entity:CatalogObject)s of the specified types in the catalog.
@@ -121,22 +145,31 @@ module Square
       #
       # @return [Square::Types::ListCatalogResponse]
       def list(request_options: {}, **params)
-        _query_param_names = %w[cursor types catalog_version]
+        _query_param_names = [
+          %w[cursor types catalog_version],
+          %i[cursor types catalog_version]
+        ].flatten
         _query = params.slice(*_query_param_names)
         params.except(*_query_param_names)
 
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "GET",
           path: "v2/catalog/list",
           query: _query
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::ListCatalogResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::ListCatalogResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Searches for [CatalogObject](entity:CatalogObject) of any type by matching supported search attribute values,
@@ -153,17 +186,23 @@ module Square
       # @return [Square::Types::SearchCatalogObjectsResponse]
       def search(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/search",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::SearchCatalogObjectsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::SearchCatalogObjectsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Searches for catalog items or item variations by matching supported search attribute values, including
@@ -180,17 +219,23 @@ module Square
       # @return [Square::Types::SearchCatalogItemsResponse]
       def search_items(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/search-catalog-items",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::SearchCatalogItemsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::SearchCatalogItemsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Updates the [CatalogModifierList](entity:CatalogModifierList) objects
@@ -200,17 +245,23 @@ module Square
       # @return [Square::Types::UpdateItemModifierListsResponse]
       def update_item_modifier_lists(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/update-item-modifier-lists",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::UpdateItemModifierListsResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::UpdateItemModifierListsResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # Updates the [CatalogTax](entity:CatalogTax) objects that apply to the
@@ -220,17 +271,23 @@ module Square
       # @return [Square::Types::UpdateItemTaxesResponse]
       def update_item_taxes(request_options: {}, **params)
         _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
           method: "POST",
           path: "v2/catalog/update-item-taxes",
           body: params
         )
-        _response = @client.send(_request)
-        if _response.code >= "200" && _response.code < "300"
-          return Square::Types::UpdateItemTaxesResponse.load(_response.body)
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Square::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Square::Types::UpdateItemTaxesResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
         end
-
-        raise _response.body
       end
 
       # @return [Square::Images::Client]

data/lib/square/catalog/images/client.rb

@@ -34,12 +34,18 @@ module Square
             path: "v2/catalog/images",
             body: body
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::CreateCatalogImageResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::CreateCatalogImageResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
 
         # Uploads a new image file to replace the existing one in the specified [CatalogImage](entity:CatalogImage) object.
@@ -65,12 +71,18 @@ module Square
             path: "v2/catalog/images/#{params[:image_id]}",
             body: body
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::UpdateCatalogImageResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::UpdateCatalogImageResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
       end
     end

data/lib/square/catalog/object/client.rb

@@ -18,17 +18,23 @@ module Square
         # @return [Square::Types::UpsertCatalogObjectResponse]
         def upsert(request_options: {}, **params)
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "POST",
             path: "v2/catalog/object",
             body: params
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::UpsertCatalogObjectResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::UpsertCatalogObjectResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
 
         # Returns a single [CatalogItem](entity:CatalogItem) as a
@@ -41,22 +47,31 @@ module Square
         #
         # @return [Square::Types::GetCatalogObjectResponse]
         def get(request_options: {}, **params)
-          _query_param_names = %w[include_related_objects catalog_version include_category_path_to_root]
+          _query_param_names = [
+            %w[include_related_objects catalog_version include_category_path_to_root],
+            %i[include_related_objects catalog_version include_category_path_to_root]
+          ].flatten
           _query = params.slice(*_query_param_names)
           params = params.except(*_query_param_names)
 
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "GET",
             path: "v2/catalog/object/#{params[:object_id]}",
             query: _query
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::GetCatalogObjectResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::GetCatalogObjectResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
 
         # Deletes a single [CatalogObject](entity:CatalogObject) based on the
@@ -73,16 +88,22 @@ module Square
         # @return [Square::Types::DeleteCatalogObjectResponse]
         def delete(request_options: {}, **params)
           _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::SANDBOX,
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
             method: "DELETE",
             path: "v2/catalog/object/#{params[:object_id]}"
           )
-          _response = @client.send(_request)
-          if _response.code >= "200" && _response.code < "300"
-            return Square::Types::DeleteCatalogObjectResponse.load(_response.body)
+          begin
+            _response = @client.send(_request)
+          rescue Net::HTTPRequestTimeout
+            raise Square::Errors::TimeoutError
+          end
+          code = _response.code.to_i
+          if code.between?(200, 299)
+            Square::Types::DeleteCatalogObjectResponse.load(_response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(_response.body, code: code)
           end
-
-          raise _response.body
         end
       end
     end

data/lib/square/catalog/object/types/delete_object_request.rb

@@ -5,7 +5,7 @@ module Square
     module Object_
       module Types
         class DeleteObjectRequest < Internal::Types::Model
-          field :object_id, -> { String }, optional: false, nullable: false
+          field :object_id_, -> { String }, optional: false, nullable: false
         end
       end
     end

data/lib/square/catalog/object/types/get_object_request.rb

@@ -5,7 +5,7 @@ module Square
     module Object_
       module Types
         class GetObjectRequest < Internal::Types::Model
-          field :object_id, -> { String }, optional: false, nullable: false
+          field :object_id_, -> { String }, optional: false, nullable: false
           field :include_related_objects, -> { Internal::Types::Boolean }, optional: true, nullable: false
           field :catalog_version, -> { Integer }, optional: true, nullable: false
           field :include_category_path_to_root, -> { Internal::Types::Boolean }, optional: true, nullable: false