square.rb 44.2.0.20251016 → 45.0.1.20260122

data/lib/square/loyalty/programs/promotions/client.rb

@@ -5,7 +5,9 @@ module Square
     module Programs
       module Promotions
         class Client
-          # @return [Square::Loyalty::Programs::Promotions::Client]
+          # @param client [Square::Internal::Http::RawClient]
+          #
+          # @return [void]
           def initialize(client:)
             @client = client
           end
@@ -13,32 +15,53 @@ module Square
           # Lists the loyalty promotions associated with a [loyalty program](entity:LoyaltyProgram).
           # Results are sorted by the `created_at` date in descending order (newest to oldest).
           #
+          # @param request_options [Hash]
+          # @param params [Hash]
+          # @option request_options [String] :base_url
+          # @option request_options [Hash{String => Object}] :additional_headers
+          # @option request_options [Hash{String => Object}] :additional_query_parameters
+          # @option request_options [Hash{String => Object}] :additional_body_parameters
+          # @option request_options [Integer] :timeout_in_seconds
+          # @option params [String] :program_id
+          # @option params [Square::Types::LoyaltyPromotionStatus, nil] :status
+          # @option params [String, nil] :cursor
+          # @option params [Integer, nil] :limit
+          #
           # @return [Square::Types::ListLoyaltyPromotionsResponse]
           def list(request_options: {}, **params)
-            _query_param_names = [
-              %w[status cursor limit],
-              %i[status cursor limit]
-            ].flatten
-            _query = params.slice(*_query_param_names)
-            params = params.except(*_query_param_names)
+            params = Square::Internal::Types::Utils.normalize_keys(params)
+            query_param_names = %i[status cursor limit]
+            query_params = {}
+            query_params["status"] = params[:status] if params.key?(:status)
+            query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+            query_params["limit"] = params[:limit] if params.key?(:limit)
+            params = params.except(*query_param_names)
 
-            _request = Square::Internal::JSON::Request.new(
-              base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-              method: "GET",
-              path: "v2/loyalty/programs/#{params[:program_id]}/promotions",
-              query: _query
-            )
-            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::ListLoyaltyPromotionsResponse.load(_response.body)
-            else
-              error_class = Square::Errors::ResponseError.subclass_for_code(code)
-              raise error_class.new(_response.body, code: code)
+            Square::Internal::CursorItemIterator.new(
+              cursor_field: :cursor,
+              item_field: :loyalty_promotions,
+              initial_cursor: query_params[:cursor]
+            ) do |next_cursor|
+              query_params[:cursor] = next_cursor
+              request = Square::Internal::JSON::Request.new(
+                base_url: request_options[:base_url],
+                method: "GET",
+                path: "v2/loyalty/programs/#{params[:program_id]}/promotions",
+                query: query_params,
+                request_options: request_options
+              )
+              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::ListLoyaltyPromotionsResponse.load(response.body)
+              else
+                error_class = Square::Errors::ResponseError.subclass_for_code(code)
+                raise error_class.new(response.body, code: code)
+              end
             end
           end
 
@@ -49,50 +72,75 @@ module Square
           # `available_time` setting. A loyalty program can have a maximum of 10 loyalty promotions with an
           # `ACTIVE` or `SCHEDULED` status.
           #
+          # @param request_options [Hash]
+          # @param params [Square::Loyalty::Programs::Promotions::Types::CreateLoyaltyPromotionRequest]
+          # @option request_options [String] :base_url
+          # @option request_options [Hash{String => Object}] :additional_headers
+          # @option request_options [Hash{String => Object}] :additional_query_parameters
+          # @option request_options [Hash{String => Object}] :additional_body_parameters
+          # @option request_options [Integer] :timeout_in_seconds
+          # @option params [String] :program_id
+          #
           # @return [Square::Types::CreateLoyaltyPromotionResponse]
           def create(request_options: {}, **params)
-            _path_param_names = ["program_id"]
+            params = Square::Internal::Types::Utils.normalize_keys(params)
+            request_data = Square::Loyalty::Programs::Promotions::Types::CreateLoyaltyPromotionRequest.new(params).to_h
+            non_body_param_names = ["program_id"]
+            body = request_data.except(*non_body_param_names)
 
-            _request = Square::Internal::JSON::Request.new(
-              base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+            request = Square::Internal::JSON::Request.new(
+              base_url: request_options[:base_url],
               method: "POST",
               path: "v2/loyalty/programs/#{params[:program_id]}/promotions",
-              body: params.except(*_path_param_names)
+              body: body,
+              request_options: request_options
             )
             begin
-              _response = @client.send(_request)
+              response = @client.send(request)
             rescue Net::HTTPRequestTimeout
               raise Square::Errors::TimeoutError
             end
-            code = _response.code.to_i
+            code = response.code.to_i
             if code.between?(200, 299)
-              Square::Types::CreateLoyaltyPromotionResponse.load(_response.body)
+              Square::Types::CreateLoyaltyPromotionResponse.load(response.body)
             else
               error_class = Square::Errors::ResponseError.subclass_for_code(code)
-              raise error_class.new(_response.body, code: code)
+              raise error_class.new(response.body, code: code)
             end
           end
 
           # Retrieves a loyalty promotion.
           #
+          # @param request_options [Hash]
+          # @param params [Hash]
+          # @option request_options [String] :base_url
+          # @option request_options [Hash{String => Object}] :additional_headers
+          # @option request_options [Hash{String => Object}] :additional_query_parameters
+          # @option request_options [Hash{String => Object}] :additional_body_parameters
+          # @option request_options [Integer] :timeout_in_seconds
+          # @option params [String] :program_id
+          # @option params [String] :promotion_id
+          #
           # @return [Square::Types::GetLoyaltyPromotionResponse]
           def get(request_options: {}, **params)
-            _request = Square::Internal::JSON::Request.new(
-              base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+            params = Square::Internal::Types::Utils.normalize_keys(params)
+            request = Square::Internal::JSON::Request.new(
+              base_url: request_options[:base_url],
               method: "GET",
-              path: "v2/loyalty/programs/#{params[:program_id]}/promotions/#{params[:promotion_id]}"
+              path: "v2/loyalty/programs/#{params[:program_id]}/promotions/#{params[:promotion_id]}",
+              request_options: request_options
             )
             begin
-              _response = @client.send(_request)
+              response = @client.send(request)
             rescue Net::HTTPRequestTimeout
               raise Square::Errors::TimeoutError
             end
-            code = _response.code.to_i
+            code = response.code.to_i
             if code.between?(200, 299)
-              Square::Types::GetLoyaltyPromotionResponse.load(_response.body)
+              Square::Types::GetLoyaltyPromotionResponse.load(response.body)
             else
               error_class = Square::Errors::ResponseError.subclass_for_code(code)
-              raise error_class.new(_response.body, code: code)
+              raise error_class.new(response.body, code: code)
             end
           end
 
@@ -103,24 +151,36 @@ module Square
           #
           # This endpoint sets the loyalty promotion to the `CANCELED` state
           #
+          # @param request_options [Hash]
+          # @param params [Hash]
+          # @option request_options [String] :base_url
+          # @option request_options [Hash{String => Object}] :additional_headers
+          # @option request_options [Hash{String => Object}] :additional_query_parameters
+          # @option request_options [Hash{String => Object}] :additional_body_parameters
+          # @option request_options [Integer] :timeout_in_seconds
+          # @option params [String] :program_id
+          # @option params [String] :promotion_id
+          #
           # @return [Square::Types::CancelLoyaltyPromotionResponse]
           def cancel(request_options: {}, **params)
-            _request = Square::Internal::JSON::Request.new(
-              base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+            params = Square::Internal::Types::Utils.normalize_keys(params)
+            request = Square::Internal::JSON::Request.new(
+              base_url: request_options[:base_url],
               method: "POST",
-              path: "v2/loyalty/programs/#{params[:program_id]}/promotions/#{params[:promotion_id]}/cancel"
+              path: "v2/loyalty/programs/#{params[:program_id]}/promotions/#{params[:promotion_id]}/cancel",
+              request_options: request_options
             )
             begin
-              _response = @client.send(_request)
+              response = @client.send(request)
             rescue Net::HTTPRequestTimeout
               raise Square::Errors::TimeoutError
             end
-            code = _response.code.to_i
+            code = response.code.to_i
             if code.between?(200, 299)
-              Square::Types::CancelLoyaltyPromotionResponse.load(_response.body)
+              Square::Types::CancelLoyaltyPromotionResponse.load(response.body)
             else
               error_class = Square::Errors::ResponseError.subclass_for_code(code)
-              raise error_class.new(_response.body, code: code)
+              raise error_class.new(response.body, code: code)
             end
           end
         end

data/lib/square/loyalty/rewards/client.rb

@@ -4,7 +4,9 @@ module Square
   module Loyalty
     module Rewards
       class Client
-        # @return [Square::Loyalty::Rewards::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
@@ -18,29 +20,40 @@ module Square
         # After a reward is created, the points are locked and
         # not available for the buyer to redeem another reward.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Loyalty::Rewards::Types::CreateLoyaltyRewardRequest]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        #
         # @return [Square::Types::CreateLoyaltyRewardResponse]
         def create(request_options: {}, **params)
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "POST",
             path: "v2/loyalty/rewards",
-            body: params
+            body: Square::Loyalty::Rewards::Types::CreateLoyaltyRewardRequest.new(params).to_h,
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::CreateLoyaltyRewardResponse.load(_response.body)
+            Square::Types::CreateLoyaltyRewardResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
 
-        # Searches for loyalty rewards. This endpoint accepts a request with no query filters and returns results for all loyalty accounts.
+        # Searches for loyalty rewards. This endpoint accepts a request with no query filters and returns results for
+        # all loyalty accounts.
         # If you include a `query` object, `loyalty_account_id` is required and `status` is  optional.
         #
         # If you know a reward ID, use the
@@ -48,48 +61,69 @@ module Square
         #
         # Search results are sorted by `updated_at` in descending order.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Loyalty::Rewards::Types::SearchLoyaltyRewardsRequest]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        #
         # @return [Square::Types::SearchLoyaltyRewardsResponse]
         def search(request_options: {}, **params)
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "POST",
             path: "v2/loyalty/rewards/search",
-            body: params
+            body: Square::Loyalty::Rewards::Types::SearchLoyaltyRewardsRequest.new(params).to_h,
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::SearchLoyaltyRewardsResponse.load(_response.body)
+            Square::Types::SearchLoyaltyRewardsResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
 
         # Retrieves a loyalty reward.
         #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :reward_id
+        #
         # @return [Square::Types::GetLoyaltyRewardResponse]
         def get(request_options: {}, **params)
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "GET",
-            path: "v2/loyalty/rewards/#{params[:reward_id]}"
+            path: "v2/loyalty/rewards/#{params[:reward_id]}",
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::GetLoyaltyRewardResponse.load(_response.body)
+            Square::Types::GetLoyaltyRewardResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
 
@@ -103,24 +137,35 @@ module Square
         #
         # You cannot delete a reward that has reached the terminal state (REDEEMED).
         #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :reward_id
+        #
         # @return [Square::Types::DeleteLoyaltyRewardResponse]
         def delete(request_options: {}, **params)
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "DELETE",
-            path: "v2/loyalty/rewards/#{params[:reward_id]}"
+            path: "v2/loyalty/rewards/#{params[:reward_id]}",
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::DeleteLoyaltyRewardResponse.load(_response.body)
+            Square::Types::DeleteLoyaltyRewardResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
 
@@ -136,27 +181,40 @@ module Square
         # In other words, points used for the reward cannot be returned
         # to the account.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Loyalty::Rewards::Types::RedeemLoyaltyRewardRequest]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :reward_id
+        #
         # @return [Square::Types::RedeemLoyaltyRewardResponse]
         def redeem(request_options: {}, **params)
-          _path_param_names = ["reward_id"]
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request_data = Square::Loyalty::Rewards::Types::RedeemLoyaltyRewardRequest.new(params).to_h
+          non_body_param_names = ["reward_id"]
+          body = request_data.except(*non_body_param_names)
 
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "POST",
             path: "v2/loyalty/rewards/#{params[:reward_id]}/redeem",
-            body: params.except(*_path_param_names)
+            body: body,
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::RedeemLoyaltyRewardResponse.load(_response.body)
+            Square::Types::RedeemLoyaltyRewardResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
       end

data/lib/square/loyalty/rewards/types/search_loyalty_rewards_request.rb

@@ -5,9 +5,7 @@ module Square
     module Rewards
       module Types
         class SearchLoyaltyRewardsRequest < Internal::Types::Model
-          field :query, lambda {
-            Square::Types::SearchLoyaltyRewardsRequestLoyaltyRewardQuery
-          }, optional: true, nullable: false
+          field :query, -> { Square::Types::SearchLoyaltyRewardsRequestLoyaltyRewardQuery }, optional: true, nullable: false
           field :limit, -> { Integer }, optional: true, nullable: false
           field :cursor, -> { String }, optional: true, nullable: false
         end

data/lib/square/merchants/client.rb

@@ -3,7 +3,9 @@
 module Square
   module Merchants
     class Client
-      # @return [Square::Merchants::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
@@ -19,55 +21,82 @@ module Square
       # If you know the merchant ID, you can also use the [RetrieveMerchant](api-endpoint:Merchants-RetrieveMerchant)
       # endpoint to retrieve the merchant information.
       #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [Integer, nil] :cursor
+      #
       # @return [Square::Types::ListMerchantsResponse]
       def list(request_options: {}, **params)
-        _query_param_names = [
-          ["cursor"],
-          %i[cursor]
-        ].flatten
-        _query = params.slice(*_query_param_names)
-        params.except(*_query_param_names)
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[cursor]
+        query_params = {}
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        params.except(*query_param_names)
 
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-          method: "GET",
-          path: "v2/merchants",
-          query: _query
-        )
-        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::ListMerchantsResponse.load(_response.body)
-        else
-          error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+        Square::Internal::CursorItemIterator.new(
+          cursor_field: :cursor,
+          item_field: :merchant,
+          initial_cursor: query_params[:cursor]
+        ) do |next_cursor|
+          query_params[:cursor] = next_cursor
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
+            method: "GET",
+            path: "v2/merchants",
+            query: query_params,
+            request_options: request_options
+          )
+          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::ListMerchantsResponse.load(response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
         end
       end
 
       # Retrieves the `Merchant` object for the given `merchant_id`.
       #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :merchant_id
+      #
       # @return [Square::Types::GetMerchantResponse]
       def get(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "GET",
-          path: "v2/merchants/#{params[:merchant_id]}"
+          path: "v2/merchants/#{params[:merchant_id]}",
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::GetMerchantResponse.load(_response.body)
+          Square::Types::GetMerchantResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end