DhanHQ 2.4.0 → 2.6.0

data/lib/DhanHQ/contracts/place_order_contract.rb

@@ -1,168 +1,41 @@
 # frozen_string_literal: true
 
+require_relative "order_contract"
+
 module DhanHQ
   module Contracts
     # Validation contract for placing an order via Dhanhq's API.
-    #
-    # This contract validates the parameters required to place an order,
-    # ensuring the correctness of inputs based on API requirements. It includes:
-    # - Mandatory fields for order placement.
-    # - Conditional validation for optional fields based on provided values.
-    # - Validation of enumerated values using constants for consistency.
-    #
-    # Example usage:
-    #   contract = Dhanhq::Contracts::PlaceOrderContract.new
-    #   result = contract.call(
-    #     dhanClientId: "123456",
-    #     transaction_type: "BUY",
-    #     exchange_segment: "NSE_EQ",
-    #     product_type: "CNC",
-    #     order_type: "LIMIT",
-    #     validity: "DAY",
-    #     security_id: "1001",
-    #     quantity: 10,
-    #     price: 150.0
-    #   )
-    #   result.success? # => true or false
-    #
-    # @see https://dhanhq.co/docs/v2/ Dhanhq API Documentation
-    class PlaceOrderContract < BaseContract
-      # Parameters and validation rules for the place order request.
-      #
-      # @!attribute [r] correlation_id
-      #   @return [String] Optional. Identifier for tracking, max length 25 characters.
-      # @!attribute [r] transaction_type
-      #   @return [String] Required. BUY or SELL.
-      # @!attribute [r] exchange_segment
-      #   @return [String] Required. Exchange segment for the order.
-      #     Must be one of: `EXCHANGE_SEGMENTS`.
-      # @!attribute [r] product_type
-      #   @return [String] Required. Product type for the order.
-      #     Must be one of: `PRODUCT_TYPES`.
-      # @!attribute [r] order_type
-      #   @return [String] Required. Type of order.
-      #     Must be one of: `ORDER_TYPES`.
-      # @!attribute [r] validity
-      #   @return [String] Required. Validity of the order.
-      #     Must be one of: DAY, IOC.
-      # @!attribute [r] trading_symbol
-      #   @return [String] Optional. Trading symbol of the instrument.
-      # @!attribute [r] security_id
-      #   @return [String] Required. Security identifier for the order.
-      # @!attribute [r] quantity
-      #   @return [Integer] Required. Quantity of the order, must be greater than 0.
-      # @!attribute [r] disclosed_quantity
-      #   @return [Integer] Optional. Disclosed quantity, must be >= 0 if provided.
-      # @!attribute [r] price
-      #   @return [Float] Optional. Price for the order, must be > 0 if provided.
-      # @!attribute [r] trigger_price
-      #   @return [Float] Optional. Trigger price for stop-loss orders, must be > 0 if provided.
-      # @!attribute [r] after_market_order
-      #   @return [Boolean] Optional. Indicates if this is an after-market order.
-      # @!attribute [r] amo_time
-      #   @return [String] Optional. Time for after-market orders. Must be one of: OPEN, OPEN_30, OPEN_60.
-      # @!attribute [r] bo_profit_value
-      #   @return [Float] Optional. Profit value for Bracket Orders, must be > 0 if provided.
-      # @!attribute [r] bo_stop_loss_value
-      #   @return [Float] Optional. Stop-loss value for Bracket Orders, must be > 0 if provided.
-      # @!attribute [r] drv_expiry_date
-      #   @return [String] Optional. Expiry date for derivative contracts.
-      # @!attribute [r] drv_option_type
-      #   @return [String] Optional. Option type for derivatives, must be one of: CALL, PUT, NA.
-      # @!attribute [r] drv_strike_price
-      #   @return [Float] Optional. Strike price for options, must be > 0 if provided.
+    class PlaceOrderContract < OrderContract
       params do
+        # Common required fields
         required(:transaction_type).filled(:string, included_in?: TRANSACTION_TYPES)
         required(:exchange_segment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
         required(:product_type).filled(:string, included_in?: PRODUCT_TYPES)
         required(:order_type).filled(:string, included_in?: ORDER_TYPES)
         required(:validity).filled(:string, included_in?: VALIDITY_TYPES)
-        required(:security_id).filled(:string)
+        required(:security_id).filled(:string, max_size?: 20)
         required(:quantity).filled(:integer, gt?: 0)
+
+        # Optional fields
+        optional(:correlation_id).maybe(:string, max_size?: 30, format?: /\A[a-zA-Z0-9 _-]*\z/)
         optional(:disclosed_quantity).maybe(:integer, gteq?: 0)
-        optional(:trading_symbol).maybe(:string)
-        optional(:correlation_id).maybe(:string, max_size?: 25)
         optional(:price).maybe(:float, gt?: 0)
         optional(:trigger_price).maybe(:float, gt?: 0)
         optional(:after_market_order).maybe(:bool)
-        optional(:amo_time).maybe(:string, included_in?: %w[OPEN OPEN_30 OPEN_60])
+        optional(:amo_time).maybe(:string, included_in?: AMO_TIMES)
         optional(:bo_profit_value).maybe(:float, gt?: 0)
         optional(:bo_stop_loss_value).maybe(:float, gt?: 0)
+
+        # Derivative specific fields
+        optional(:trading_symbol).maybe(:string)
         optional(:drv_expiry_date).maybe(:string)
         optional(:drv_option_type).maybe(:string, included_in?: %w[CALL PUT NA])
         optional(:drv_strike_price).maybe(:float, gt?: 0)
       end
 
-      # Validate that float values are finite (not NaN or Infinity) and within reasonable bounds
-      rule(:price) do
-        if values[:price].is_a?(Float)
-          if values[:price].nan? || values[:price].infinite?
-            key(:price).failure("must be a finite number")
-          elsif values[:price] > 1_000_000_000
-            key(:price).failure("must be less than 1,000,000,000")
-          end
-        end
-      end
-
-      rule(:trigger_price) do
-        if values[:trigger_price].is_a?(Float)
-          if values[:trigger_price].nan? || values[:trigger_price].infinite?
-            key(:trigger_price).failure("must be a finite number")
-          elsif values[:trigger_price] > 1_000_000_000
-            key(:trigger_price).failure("must be less than 1,000,000,000")
-          end
-        end
-      end
-
-      rule(:bo_profit_value) do
-        if values[:bo_profit_value].is_a?(Float)
-          if values[:bo_profit_value].nan? || values[:bo_profit_value].infinite?
-            key(:bo_profit_value).failure("must be a finite number")
-          elsif values[:bo_profit_value] > 1_000_000_000
-            key(:bo_profit_value).failure("must be less than 1,000,000,000")
-          end
-        end
-      end
-
-      rule(:bo_stop_loss_value) do
-        if values[:bo_stop_loss_value].is_a?(Float)
-          if values[:bo_stop_loss_value].nan? || values[:bo_stop_loss_value].infinite?
-            key(:bo_stop_loss_value).failure("must be a finite number")
-          elsif values[:bo_stop_loss_value] > 1_000_000_000
-            key(:bo_stop_loss_value).failure("must be less than 1,000,000,000")
-          end
-        end
-      end
-
       rule(:drv_strike_price) do
-        if values[:drv_strike_price].is_a?(Float)
-          if values[:drv_strike_price].nan? || values[:drv_strike_price].infinite?
-            key(:drv_strike_price).failure("must be a finite number")
-          elsif values[:drv_strike_price] > 1_000_000_000
-            key(:drv_strike_price).failure("must be less than 1,000,000,000")
-          end
-        end
-      end
-
-      # Custom validation for trigger price when the order type is STOP_LOSS or STOP_LOSS_MARKET.
-      rule(:trigger_price, :order_type) do
-        if values[:order_type] =~ /^STOP_LOSS/ && !values[:trigger_price]
-          key(:trigger_price).failure("is required for order_type STOP_LOSS or STOP_LOSS_MARKET")
-        end
-      end
-
-      # Custom validation for AMO time when the order is marked as after-market.
-      rule(:after_market_order, :amo_time) do
-        if values[:after_market_order] == true && !values[:amo_time]
-          key(:amo_time).failure("is required when after_market_order is true")
-        end
-      end
-
-      # Custom validation for Bracket Order (BO) fields.
-      rule(:bo_profit_value, :bo_stop_loss_value, :product_type) do
-        if values[:product_type] == "BO" && (!values[:bo_profit_value] || !values[:bo_stop_loss_value])
-          key(:bo_profit_value).failure("is required for Bracket Orders")
-          key(:bo_stop_loss_value).failure("is required for Bracket Orders")
+        if value.is_a?(Float) && (value.nan? || value.infinite?)
+          key.failure("must be a finite number")
         end
       end
     end

data/lib/DhanHQ/contracts/pnl_based_exit_contract.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests for P&L based exit configurations.
+    class PnlBasedExitContract < BaseContract
+      params do
+        optional(:dhanClientId).maybe(:string)
+        optional(:profitValue).maybe(:float, gt?: 0)
+        optional(:lossValue).maybe(:float, gt?: 0)
+        optional(:enableKillSwitch).maybe(:bool)
+        optional(:productType).array(:string, included_in?: %w[INTRADAY DELIVERY])
+      end
+
+      rule(:profitValue, :lossValue) do
+        key.failure("at least one of profitValue or lossValue must be provided") if !values[:profitValue] && !values[:lossValue]
+      end
+    end
+  end
+end

data/lib/DhanHQ/contracts/position_conversion_contract.rb

@@ -7,7 +7,7 @@ module DhanHQ
       params do
         required(:dhanClientId).filled(:string)
         required(:fromProductType).filled(:string, included_in?: PRODUCT_TYPES)
-        required(:exchangeSegment).filled(:string, included_in?: EXCHANGE_SEGMENTS)
+        required(:exchangeSegment).filled(:string, included_in?: EXCHANGE_SEGMENTS - %w[IDX_I NSE_COMM])
         required(:positionType).filled(:string, included_in?: %w[LONG SHORT CLOSED])
         required(:securityId).filled(:string)
         required(:convertQty).filled(:integer, gt?: 0)
@@ -15,9 +15,21 @@ module DhanHQ
       end
 
       rule(:toProductType, :fromProductType) do
-        next unless values[:toProductType] == values[:fromProductType]
+        key(:toProductType).failure("must be different from fromProductType") if values[:toProductType] == values[:fromProductType]
 
-        key(:toProductType).failure("must be different from fromProductType")
+        if %w[BO CO].include?(values[:toProductType]) || %w[BO CO].include?(values[:fromProductType])
+          key(:base).failure("cannot convert to or from Bracket (BO) or Cover (CO) orders")
+        end
+      end
+
+      # Segment-Based Product Restrictions for conversion
+      rule(:toProductType, :exchangeSegment) do
+        case values[:toProductType]
+        when DhanHQ::Constants::ProductType::CNC, DhanHQ::Constants::ProductType::MTF
+          key(:toProductType).failure("is only allowed for Equity segments (NSE_EQ, BSE_EQ)") unless /_EQ$/.match?(values[:exchangeSegment])
+        when DhanHQ::Constants::ProductType::MARGIN
+          key(:toProductType).failure("is not allowed for Equity Cash segments; use CNC or INTRADAY") if /_EQ$/.match?(values[:exchangeSegment])
+        end
       end
     end
   end

data/lib/DhanHQ/contracts/slice_order_contract.rb

@@ -93,9 +93,14 @@ module DhanHQ
         optional(:drvStrikePrice).maybe(:float, gt?: 0)
       end
 
+      # Institutional macros
+      rule(:quantity).validate(:lot_size_multiple)
+      rule(:price).validate(:tick_size_multiple)
+      rule(:triggerPrice).validate(:tick_size_multiple)
+
       # Custom validation for trigger price when the order type is STOP_LOSS or STOP_LOSS_MARKET.
       rule(:triggerPrice, :orderType) do
-        if values[:orderType].start_with?("STOP_LOSS") && !values[:triggerPrice]
+        if values[:orderType].start_with?(DhanHQ::Constants::OrderType::STOP_LOSS) && !values[:triggerPrice]
           key(:triggerPrice).failure("is required for orderType STOP_LOSS or STOP_LOSS_MARKET")
         end
       end
@@ -106,6 +111,10 @@ module DhanHQ
           key(:amoTime).failure("is required when afterMarketOrder is true")
         end
       end
+
+      # Validation to ensure slice amounts don't sum to more than something?
+      # For SliceOrder, total quantity might be split by exchange limits if it exceeds. Since the API handles splitting,
+      # we just need to make sure quantity matches lot sizes.
     end
   end
 end

data/lib/DhanHQ/contracts/user_ip_contract.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Contracts
+    # Validates requests for configuring static IP addresses.
+    class UserIpContract < BaseContract
+      params do
+        optional(:dhanClientId).maybe(:string)
+        required(:ip).filled(:string)
+        required(:ipFlag).filled(:string, included_in?: %w[PRIMARY SECONDARY])
+      end
+    end
+  end
+end

data/lib/DhanHQ/core/base_model.rb

@@ -80,11 +80,12 @@ module DhanHQ
         self::HTTP_PATH
       end
 
-      # Every model must either override this or set a Dry::Validation contract if they need validation
+      # Default class-level validation contract — returns nil (no validation).
+      # Override in subclasses to provide a contract for class-level validation.
       #
-      # @return [Dry::Validation::Contract] The validation contract
+      # @return [nil]
       def validation_contract
-        raise NotImplementedError, "#{name} must implement `validation_contract`"
+        nil
       end
 
       # Validate attributes before creating a new instance
@@ -155,6 +156,14 @@ module DhanHQ
 
     # Instance Methods
 
+    # Default validation contract — returns nil (no validation).
+    # Models that require instance-level validation must override this method.
+    #
+    # @return [nil]
+    def validation_contract
+      nil
+    end
+
     # Update an existing resource
     #
     # @param attributes [Hash] Attributes to update
@@ -264,7 +273,7 @@ module DhanHQ
 
     # Validate attributes using contract
     def valid?
-      contract_class = respond_to?(:validation_contract) ? validation_contract : self.class.validation_contract
+      contract_class = validation_contract || self.class.validation_contract
       return true unless contract_class
 
       contract = contract_class.is_a?(Class) ? contract_class.new : contract_class

data/lib/DhanHQ/helpers/response_helper.rb

@@ -48,7 +48,7 @@ module DhanHQ
 
       error_code = body[:errorCode] || response.status.to_s
       error_message = body[:errorMessage] || body[:message] || "Unknown error"
-      if error_code == "DH-1111"
+      if error_code == DhanHQ::Constants::TradingErrorCode::NO_HOLDINGS
         error_message = "No holdings found for this account. Add holdings or wait for them to settle before retrying."
       end
 
@@ -71,7 +71,7 @@ module DhanHQ
       end
 
       error_text =
-        if error_code == "DH-1111"
+        if error_code == DhanHQ::Constants::TradingErrorCode::NO_HOLDINGS
           "#{error_message} (error code: #{error_code})"
         else
           "#{error_code}: #{error_message}"

data/lib/DhanHQ/helpers/validation_helper.rb

@@ -16,7 +16,7 @@ module DhanHQ
 
     # Validate instance attributes using the defined validation contract
     def validate!
-      contract_class = respond_to?(:validation_contract) ? validation_contract : self.class.validation_contract
+      contract_class = validation_contract || self.class.validation_contract
       return unless contract_class
 
       contract = contract_class.is_a?(Class) ? contract_class.new : contract_class

data/lib/DhanHQ/models/alert_order.rb

@@ -6,6 +6,8 @@ module DhanHQ
   module Models
     # Model for alert/conditional orders. CRUD via AlertOrders resource; validated by AlertOrderContract.
     class AlertOrder < BaseModel
+      include Concerns::ApiResponseHandler
+
       HTTP_PATH = "/alerts/orders"
 
       attributes :alert_id, :exchange_segment, :security_id, :condition,
@@ -27,9 +29,7 @@ module DhanHQ
 
         def all
           response = resource.all
-          return [] unless response.is_a?(Array)
-
-          response.map { |attrs| new(attrs, skip_validation: true) }
+          parse_collection_response(response)
         end
 
         def find(alert_id)
@@ -48,27 +48,45 @@ module DhanHQ
 
           find(response["alertId"])
         end
+
+        ##
+        # Modify an existing conditional trigger/alert order.
+        #
+        # @param alert_id [String] The alert ID to modify
+        # @param params [Hash] Updated parameters (condition, orders, etc.)
+        #
+        # @return [AlertOrder, nil] Updated AlertOrder instance, or nil on failure
+        #
+        # @example Modify an alert order's condition
+        #   updated = DhanHQ::Models::AlertOrder.modify("12345",
+        #     condition: { comparing_value: 300 },
+        #     orders: [{ quantity: 20 }]
+        #   )
+        #
+        def modify(alert_id, params)
+          normalized = snake_case(params)
+          response = resource.update(alert_id, camelize_keys(normalized))
+          return nil unless success_response?(response)
+
+          find(alert_id)
+        end
       end
 
       def id
         alert_id&.to_s
       end
 
-      def save # rubocop:disable Naming/PredicateMethod
+      def save
         return false unless valid?
 
         payload = to_request_params
         response = if new_record?
-                     self.class.resource.create(camelize_keys(payload))
+                     self.class.resource.create(payload)
                    else
-                     self.class.resource.update(id, camelize_keys(payload))
+                     self.class.resource.update(id, payload)
                    end
-        return false if new_record? && !(response.is_a?(Hash) && response["alertId"])
-        return false if !new_record? && !success_response?(response)
 
-        @attributes.merge!(normalize_keys(response))
-        assign_attributes
-        true
+        handle_api_response(response, success_key: new_record? ? "alertId" : nil)
       end
 
       def destroy # rubocop:disable Naming/PredicateMethod

data/lib/DhanHQ/models/concerns/api_response_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    module Concerns
+      # Shared behavior for handling API responses and error logging in models.
+      module ApiResponseHandler
+        private
+
+        # Handles a standard API response, merging attributes on success or logging error on failure.
+        #
+        # @param response [Hash, Array] The raw API response
+        # @param success_key [String, nil] Key to check for specific success identifier (e.g., "orderId")
+        # @param context [String] Context for logging (e.g., "[DhanHQ::Models::Order] Placement")
+        # @param error_target [Symbol] Where to store errors (defaults to :@errors)
+        # @return [Boolean] True if successful
+        def handle_api_response(response, success_key: nil, context: nil) # rubocop:disable Naming/PredicateMethod
+          response = response.with_indifferent_access if response.respond_to?(:with_indifferent_access)
+          is_hash = response.is_a?(Hash)
+          is_success = success_response?(response) || (is_hash && success_key && response[success_key])
+
+          if is_success
+            @attributes.merge!(normalize_keys(response))
+            assign_attributes
+            DhanHQ.logger&.info("#{context} successfully: #{identifier_from(response, success_key) || id}") if context
+            true
+          else
+            error_msg = is_hash ? response[:errorMessage] || response[:message] || "Unknown error" : "Invalid response format"
+            DhanHQ.logger&.error("#{context} failed: #{error_msg}") if context
+            instance_variable_set(error_target_variable, response) if is_hash
+            false
+          end
+        end
+
+        def error_target_variable
+          :@errors
+        end
+
+        # Safely fetches an ID or response identifier
+        def identifier_from(response, key)
+          response.is_a?(Hash) ? response[key] : nil
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/models/edis.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    ##
+    # Model for EDIS (Electronic Delivery Instruction Slip) operations.
+    #
+    # EDIS is used for selling holdings from your demat account. The API provides
+    # endpoints to generate T-PIN, create eDIS forms, and check authorization status.
+    #
+    # @example Generate T-PIN
+    #   DhanHQ::Models::Edis.generate_tpin
+    #
+    # @example Generate eDIS form
+    #   response = DhanHQ::Models::Edis.generate_form(
+    #     isin: "INE155A01022",
+    #     qty: 10,
+    #     exchange: "NSE",
+    #     segment: "E",
+    #     bulk: false
+    #   )
+    #
+    # @example Check EDIS status for a security
+    #   status = DhanHQ::Models::Edis.inquire(isin: "INE155A01022")
+    #
+    class Edis < BaseModel
+      HTTP_PATH = "/edis"
+
+      class << self
+        ##
+        # Provides a shared instance of the Edis resource.
+        #
+        # @return [DhanHQ::Resources::Edis] The Edis resource client instance
+        def resource
+          @resource ||= DhanHQ::Resources::Edis.new
+        end
+
+        ##
+        # Generate T-PIN for eDIS authorization.
+        #
+        # Triggers T-PIN generation which is sent to the user's registered mobile/email.
+        #
+        # @return [Hash] API response
+        #
+        # @example Generate T-PIN before selling holdings
+        #   DhanHQ::Models::Edis.generate_tpin
+        #
+        def generate_tpin
+          resource.tpin
+        end
+
+        ##
+        # Generate an eDIS form for authorizing sale of holdings.
+        #
+        # @param isin [String] ISIN of the security (e.g., "INE155A01022")
+        # @param qty [Integer] Quantity to authorize for sale
+        # @param exchange [String] Exchange name (e.g., "NSE", "BSE")
+        # @param segment [String] Segment identifier (e.g., "E")
+        # @param bulk [Boolean] Whether this is a bulk authorization (default: false)
+        #
+        # @return [Hash] API response containing the eDIS form data
+        #
+        # @example Authorize sale of 10 shares
+        #   DhanHQ::Models::Edis.generate_form(
+        #     isin: "INE155A01022",
+        #     qty: 10,
+        #     exchange: "NSE",
+        #     segment: "E"
+        #   )
+        #
+        def generate_form(isin:, qty:, exchange:, segment:, bulk: false)
+          resource.form({ isin: isin, qty: qty, exchange: exchange, segment: segment, bulk: bulk })
+        end
+
+        ##
+        # Generate a bulk eDIS form for multiple securities.
+        #
+        # @param params [Hash] Bulk form parameters
+        # @return [Hash] API response
+        #
+        def generate_bulk_form(params)
+          resource.bulk_form(params)
+        end
+
+        ##
+        # Check EDIS authorization status for a security.
+        #
+        # @param isin [String] ISIN of the security to check
+        #
+        # @return [Hash] API response containing authorization status
+        #
+        # @example Check if EDIS is authorized
+        #   status = DhanHQ::Models::Edis.inquire(isin: "INE155A01022")
+        #
+        def inquire(isin:)
+          resource.inquire(isin)
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/models/expired_options_data.rb

@@ -180,12 +180,6 @@ module DhanHQ
         end
       end
 
-      ##
-      # ExpiredOptionsData objects are read-only, so no validation contract needed
-      def validation_contract
-        nil
-      end
-
       ##
       # Gets call option data from the response.
       #
@@ -238,9 +232,9 @@ module DhanHQ
       #   See {#call_data} or {#put_data} for structure details.
       def data_for_type(option_type)
         case option_type.upcase
-        when "CALL"
+        when DhanHQ::Constants::OptionType::CALL
           call_data
-        when "PUT"
+        when DhanHQ::Constants::OptionType::PUT
           put_data
         end
       end
@@ -466,7 +460,7 @@ module DhanHQ
       #
       # @return [Boolean] true if instrument type is "OPTIDX", false otherwise
       def index_options?
-        instrument == "OPTIDX"
+        instrument == DhanHQ::Constants::InstrumentType::OPTIDX
       end
 
       ##
@@ -474,7 +468,7 @@ module DhanHQ
       #
       # @return [Boolean] true if instrument type is "OPTSTK", false otherwise
       def stock_options?
-        instrument == "OPTSTK"
+        instrument == DhanHQ::Constants::InstrumentType::OPTSTK
       end
 
       ##
@@ -498,7 +492,7 @@ module DhanHQ
       #
       # @return [Boolean] true if drv_option_type is "CALL", false otherwise
       def call_option?
-        drv_option_type == "CALL"
+        drv_option_type == DhanHQ::Constants::OptionType::CALL
       end
 
       ##
@@ -506,7 +500,7 @@ module DhanHQ
       #
       # @return [Boolean] true if drv_option_type is "PUT", false otherwise
       def put_option?
-        drv_option_type == "PUT"
+        drv_option_type == DhanHQ::Constants::OptionType::PUT
       end
 
       ##

data/lib/DhanHQ/models/forever_order.rb

@@ -64,6 +64,8 @@ module DhanHQ
     #   orders.each { |order| puts order.order_status }
     #
     class ForeverOrder < BaseModel
+      include Concerns::ApiResponseHandler
+
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,
                  :transaction_type, :exchange_segment, :product_type, :order_flag,
                  :order_type, :validity, :trading_symbol, :security_id, :quantity,
@@ -115,9 +117,7 @@ module DhanHQ
         #   end
         def all
           response = resource.all
-          return [] unless response.is_a?(Array)
-
-          response.map { |o| new(o, skip_validation: true) }
+          parse_collection_response(response)
         end
 
         ##
@@ -290,8 +290,11 @@ module DhanHQ
       def modify(new_params)
         raise "Order ID is required to modify a forever order" unless order_id
 
+        DhanHQ.logger&.info("[DhanHQ::Models::ForeverOrder] Modifying order #{order_id}")
         response = self.class.resource.update(order_id, new_params)
-        return self.class.find(order_id) if self.class.send(:success_response?, response)
+        ctx = "[DhanHQ::Models::ForeverOrder] Modification"
+        success = handle_api_response(response, success_key: "orderId", context: ctx)
+        return self.class.find(order_id) if success
 
         nil
       end
@@ -317,7 +320,7 @@ module DhanHQ
         raise "Order ID is required to cancel a forever order" unless order_id
 
         response = self.class.resource.cancel(order_id)
-        response["orderStatus"] == "CANCELLED"
+        response["orderStatus"] == DhanHQ::Constants::OrderStatus::CANCELLED
       end
     end
   end