spree_delhivery 1.0.0

data/app/models/spree/payment_method/delhivery_cod.rb

@@ -0,0 +1,57 @@
+module Spree
+  class PaymentMethod::DelhiveryCod < PaymentMethod
+    def method_type
+      'delhivery_cod'
+    end
+
+    def payment_icon_name
+      'delhivery_cod'
+    end
+
+    def description_partial_name
+      'delhivery_cod'
+    end
+
+    def configuration_guide_partial_name
+      'delhivery_cod'
+    end
+    
+    def source_required?
+      false
+    end
+
+    def auto_capture?
+      false
+    end
+
+    def actions
+      %w{authorize capture void purchase}
+    end
+
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    def can_void?(payment)
+      payment.state != 'void'
+    end
+
+    # Satisfies the Spree API and Rails Checkout authorization step
+    def authorize(*args)
+      ActiveMerchant::Billing::Response.new(true, "Delhivery COD Authorized", {}, {})
+    end
+
+    # Satisfies checkout engines that try to purchase immediately
+    def purchase(*args)
+      ActiveMerchant::Billing::Response.new(true, "Delhivery COD Purchased", {}, {})
+    end
+
+    def capture(*args)
+      ActiveMerchant::Billing::Response.new(true, "Delhivery COD Captured", {}, {})
+    end
+
+    def void(*args)
+      ActiveMerchant::Billing::Response.new(true, "Delhivery COD Voided", {}, {})
+    end
+  end
+end

data/app/services/spree_delhivery/client.rb

@@ -0,0 +1,281 @@
+require 'httparty'
+require 'json'
+require 'uri'
+
+module SpreeDelhivery
+  class Client
+    include HTTParty
+    
+    # Base Configuration
+    base_uri 'https://track.delhivery.com' 
+
+    attr_reader :integration
+
+    def initialize
+      @integration = Spree::Integrations::Delhivery.active.first
+      raise "Delhivery Integration is not active or configured" unless @integration
+
+      @api_token = @integration.preferred_api_token.to_s.strip
+      
+      # Environment Logic
+      if @integration.preferred_production_mode
+        self.class.base_uri 'https://track.delhivery.com'
+        @env_name = "PRODUCTION"
+      else
+        self.class.base_uri 'https://staging-express.delhivery.com'
+        @env_name = "STAGING"
+      end
+    end
+
+    # Fetch Shipping Rate
+    def fetch_shipping_rate(source_pin:, dest_pin:, weight_gms:, mode: 'S')
+      path = "/api/kinko/v1/invoice/charges/.json"
+      api_mode = map_mode(mode)
+
+      params = {
+        md: api_mode, 
+        ss: 'Delivered', 
+        d_pin: dest_pin, 
+        o_pin: source_pin, 
+        cgm: weight_gms, 
+        pt: 'Pre-paid'
+      }
+      
+      response = self.class.get(path, query: params, headers: auth_headers)
+      data = response.parsed_response 
+      
+      if data.is_a?(Hash) && data['total_amount']
+        return data['total_amount'].to_f
+      elsif data.is_a?(Array) && data.first && data.first['total_amount']
+        return data.first['total_amount'].to_f
+      else
+        return nil
+      end
+    rescue => e
+      Rails.logger.error "[Delhivery] Rate Exception: #{e.message}"
+      nil
+    end
+
+    # Calculate TAT
+    def calculate_tat(source_pin:, dest_pin:, mode: 'S')
+      path = "/api/dc/expected_tat"
+      api_mode = map_mode(mode)
+
+      params = { 
+        origin_pin: source_pin, 
+        destination_pin: dest_pin, 
+        mot: api_mode, 
+        pdt: 'Pre-paid',
+        token: @api_token 
+      }
+      
+      response = self.class.get(path, query: params, headers: auth_headers)
+      response.parsed_response.is_a?(Hash) ? response.parsed_response : nil
+    rescue => e
+      Rails.logger.error "[Delhivery] TAT Error: #{e.message}"
+      nil
+    end
+    
+    # Fetch Pincode Details
+    def fetch_pincode_details(pincode)
+      path = "/c/api/pin-codes/json/"
+      response = self.class.get(path, query: { filter_codes: pincode }, headers: auth_headers)
+      data = response.parsed_response 
+
+      find_city = ->(obj) do
+        case obj
+        when Hash
+          return obj if obj.key?('city') || obj.key?(:city)
+          obj.each_value { |v| res = find_city.call(v); return res if res }
+        when Array
+          obj.each { |v| res = find_city.call(v); return res if res }
+        end
+        nil
+      end
+
+      find_city.call(data)
+    rescue => e
+      Rails.logger.error "[Delhivery] City Error: #{e.message}"
+      nil
+    end
+
+    # Create Return Shipment
+    def create_return_request(return_auth, options = {})
+      order = return_auth.order
+      stock_location = return_auth.stock_location
+      customer_address = order.ship_address
+      
+      # Defaults if not provided
+      brand_name = options[:brand].presence || @integration.preferred_client_name
+      category_name = options[:category].presence || "General"
+
+      # Data Cleaning
+      clean_phone = ->(p) { p.to_s.gsub(/[^0-9]/, '').last(10) }
+      clean_str = ->(s) { s.to_s.gsub(/[^0-9a-zA-Z\s,\.\-]/, ' ').strip.first(100) }
+      
+      c_phone = clean_phone.call(customer_address.phone)
+      w_phone = clean_phone.call(stock_location.phone)
+      
+      # Construct Custom QC Items
+      custom_qc_items = []
+      
+      return_auth.return_items.each do |ri|
+        variant = ri.inventory_unit.variant
+        
+        img_url = "https://via.placeholder.com/150"
+        if variant.images.any?
+          img_url = variant.images.first.attachment.url(:small) rescue img_url
+        elsif variant.product.images.any?
+          img_url = variant.product.images.first.attachment.url(:small) rescue img_url
+        end
+
+        reason_text = "Customer Return"
+        if ri.respond_to?(:return_reason) && ri.return_reason.present?
+          reason_text = ri.return_reason.name
+        elsif return_auth.respond_to?(:reason) && return_auth.reason.present?
+          reason_text = return_auth.reason.name
+        end
+
+        custom_qc_items << {
+          "item" => variant.name.first(30),
+          "description" => variant.product.description&.first(50) || variant.name,
+          "images" => [img_url], 
+          "return_reason" => reason_text,
+          "quantity" => 1,
+          "brand" => brand_name,       # <--- DYNAMIC
+          "product_category" => category_name, # <--- DYNAMIC
+          "questions" => [] 
+        }
+      end
+
+      # Calculate Weight
+      total_weight_gms = 0.0
+      return_auth.inventory_units.each do |unit|
+        w = unit.variant.weight.to_f
+        w = (w < 50) ? w * 1000.0 : w
+        total_weight_gms += w
+      end
+      total_weight_gms = 500 if total_weight_gms < 500
+
+      # Payload
+      payload = {
+        "shipments" => [
+          {
+            "client" => @integration.preferred_client_name,
+            "order" => return_auth.number,
+            "waybill" => "",
+            "name" => customer_address.full_name,
+            "add" => clean_str.call(customer_address.address1),
+            "city" => customer_address.city,
+            "state" => customer_address.state&.name || customer_address.state_name,
+            "country" => "India",
+            "phone" => c_phone,
+            "pin" => customer_address.zipcode,
+            
+            "return_name" => stock_location.name,
+            "return_add" => clean_str.call(stock_location.address1),
+            "return_city" => stock_location.city,
+            "return_state" => stock_location.state&.name || stock_location.state_name,
+            "return_country" => "India",
+            "return_pin" => stock_location.zipcode,
+            "return_phone" => w_phone,
+            
+            "payment_mode" => "Pickup",
+            "products_desc" => "Return #{order.number}",
+            "quantity" => return_auth.return_items.count,
+            "weight" => total_weight_gms.to_i,
+            "total_amount" => 0,
+            "shipping_mode" => "Surface",
+            "order_date" => Time.current.strftime("%d-%m-%Y"),
+            
+            "qc_type" => "param",
+            "custom_qc" => custom_qc_items
+          }
+        ],
+        "pickup_location" => {
+          "name" => stock_location.delhivery_warehouse_name
+        }
+      }
+
+      Rails.logger.info "[Delhivery] RVP Payload: #{payload.to_json}"
+
+      response = self.class.post(
+        "/api/cmu/create.json",
+        body: { "format" => "json", "data" => payload.to_json },
+        headers: { "Authorization" => "Token #{@api_token}" }
+      )
+      
+      JSON.parse(response.body) rescue { "error" => "Invalid JSON Response" }
+
+    rescue StandardError => e
+      Rails.logger.error "Delhivery Return Exception: #{e.message}"
+      { "error" => e.message }
+    end
+
+    # 5. Forward Shipment
+    def create_shipment(payload_data)
+      response = self.class.post("/api/cmu/create.json", 
+        body: { "format" => "json", "data" => payload_data.to_json }, 
+        headers: { "Authorization" => "Token #{@api_token}" }
+      )
+      JSON.parse(response.body) rescue {}
+    end
+
+    # 6. Fetch Wallet Balance
+    def fetch_balance
+      # This is the standard endpoint for checking Delhivery wallet balance
+      response = self.class.get("/api/client/get_balance_ledger.json", headers: auth_headers)
+      
+      if response.success? && response.parsed_response.is_a?(Hash)
+        # Returns format like: { "cash_balance" => "150.00", ... }
+        return response.parsed_response['cash_balance'] 
+      end
+      nil
+    rescue => e
+      Rails.logger.error "[Delhivery] Balance Fetch Failed: #{e.message}"
+      nil
+    end
+
+    def track_shipment(waybill)
+      send_get_request("/api/v1/packages/json/?waybill=#{waybill}")
+    end
+
+    def fetch_label(waybill)
+      send_get_request("/api/p/packing_slip?wbns=#{waybill}&pdf=true")
+    end
+
+    def create_pickup_request(location_name:, date:, time:, count: 1)
+      payload = { pickup_location: location_name, pickup_date: date, pickup_time: time, expected_package_count: count }
+      post_json("/fm/request/new/", payload)
+    end
+
+    def cancel_shipment(waybill)
+      post_json("/api/p/edit", { waybill: waybill, cancellation: true })
+    end
+
+    private
+
+    def map_mode(val)
+      str = val.to_s.downcase.strip
+      ['express', 'e'].include?(str) ? 'E' : 'S'
+    end
+
+    def send_get_request(path, params = {})
+      response = self.class.get(path, query: params, headers: auth_headers)
+      response.parsed_response
+    rescue => e
+      { "error" => "Request Failed", "details" => e.message }
+    end
+
+    def post_json(path, body = {})
+      response = self.class.post(path, body: body.to_json, headers: auth_headers.merge('Content-Type' => 'application/json'))
+      response.parsed_response
+    rescue => e
+       { "error" => "Request Failed", "details" => e.message }
+    end
+
+    def auth_headers
+      { "Authorization" => "Token #{@api_token}", "Accept" => "application/json" }
+    end
+  end
+end

data/app/services/spree_delhivery/pickup_service.rb

@@ -0,0 +1,49 @@
+module SpreeDelhivery
+    class PickupService
+      Result = Struct.new(:success?, :message, :data)
+  
+      def initialize(stock_location, date: nil, time: "16:00:00", count: 1)
+        @stock_location = stock_location
+        @date = date || Date.tomorrow.strftime('%Y-%m-%d')
+        @time = time
+        @count = count
+        @client = SpreeDelhivery::Client.new
+      end
+  
+      def call
+        # 1. Validation
+        unless @stock_location.delhivery_warehouse_name.present?
+          return Result.new(false, "Stock Location is missing Warehouse Name.")
+        end
+  
+        # 2. Call API
+        begin
+          response = @client.create_pickup_request(
+            location_name: @stock_location.delhivery_warehouse_name,
+            date: @date,
+            time: @time,
+            count: @count
+          )
+  
+          # --- [DEBUG] START: Add this line ---
+          puts "\n\n🔴 [DELHIVERY DEBUG] RAW RESPONSE: #{response.inspect}\n\n"
+          # --- [DEBUG] END ---
+  
+          # 3. Parse Response
+          if response['pickup_id'].present?
+            return Result.new(true, "Pickup Scheduled! ID: #{response['pickup_id']}", response)
+          elsif response['error'].present?
+            return Result.new(false, response['error'])
+          else
+            # Fallback
+            msg = response['pre_feed_back'] || "Unknown Response: #{response}"
+            return Result.new(false, msg)
+          end
+  
+        rescue StandardError => e
+          Rails.logger.error "[Delhivery] Pickup Error: #{e.message}"
+          return Result.new(false, e.message)
+        end
+      end
+    end
+  end

data/app/services/spree_delhivery/shipment_canceler.rb

@@ -0,0 +1,59 @@
+module SpreeDelhivery
+    class ShipmentCanceler
+      def initialize(shipment)
+        @shipment = shipment
+        @client = SpreeDelhivery::Client.new
+      end
+  
+      def call
+        waybill = @shipment.delhivery_waybill
+        return error("No Waybill found to cancel") unless waybill.present?
+  
+        # 1. Call API
+        begin
+          response = @client.cancel_shipment(waybill)
+        rescue StandardError => e
+          return error("API Connection Error: #{e.message}")
+        end
+  
+        # Delhivery success response is usually { "status" => true/false, ... } or "success" => true
+        # Sometimes it returns specific codes. We check general success/failure keys.
+        api_success = response['success'] || response['status'] == true || response['status'] == "Success"
+  
+        if api_success
+          # 2. Clear Data & Revert State in Spree
+          # We use update_columns to skip state machine transitions/validations
+          @shipment.update_columns(
+            tracking: nil,
+            delhivery_waybill: nil,
+            delhivery_ref_id: nil,
+            delhivery_label_url: nil,
+            delhivery_response_data: nil,
+            state: 'ready',      # Move back to Ready
+            shipped_at: nil      # Clear the shipped timestamp
+          )
+  
+          # 3. Update the Order's overall shipment state
+          # This ensures the order status bar updates correctly
+          @shipment.order.updater.update_shipment_state
+          @shipment.order.save
+  
+          return success
+        else
+          return error(response['error'] || response['message'] || "Failed to cancel at Delhivery")
+        end
+      rescue StandardError => e
+        return error(e.message)
+      end
+  
+      private
+  
+      def success
+        OpenStruct.new(success?: true)
+      end
+  
+      def error(msg)
+        OpenStruct.new(success?: false, error: msg)
+      end
+    end
+  end

data/app/services/spree_delhivery/shipment_sender.rb

@@ -0,0 +1,210 @@
+module SpreeDelhivery
+  class ShipmentSender
+    def initialize(shipment)
+      @shipment = shipment
+      @order = shipment.order
+      @address = @order.ship_address
+      @client = SpreeDelhivery::Client.new
+      @integration = @client.integration
+    end
+
+    def call
+      return error("Shipment already has a Waybill") if @shipment.delhivery_waybill.present?
+
+      payload = build_payload
+      
+      # Send API Request
+      response = @client.create_shipment(payload)
+      
+      # Check for explicit success or package success status
+      success_status = response['success'] || 
+                       (response['packages'].present? && response['packages'][0]['status'] == 'Success')
+
+      if success_status
+        pkg_data = response['packages'].first
+        
+        # 1. Update Data Columns Safely 
+        # Using update_columns to bypass Spree callbacks that might confuse the hash response with a model
+        @shipment.update_columns(
+          tracking: pkg_data['waybill'],
+          delhivery_waybill: pkg_data['waybill'],
+          delhivery_ref_id: pkg_data['refnum'], 
+          delhivery_response_data: response # Rails handles JSON serialization automatically
+        )
+        
+        # 2. Reload object to ensure fresh state
+        @shipment.reload 
+
+        # 3. Fire Spree Shipment State Machine
+        # This moves state from 'ready' -> 'shipped'
+        if @shipment.can_ship?
+          @shipment.ship! 
+        end
+
+        # 4. Fetch Label URL immediately
+        begin
+          label_res = @client.fetch_label(pkg_data['waybill'])
+          if label_res['packages'] && label_res['packages'][0]['pdf_download_link']
+             @shipment.update_column(:delhivery_label_url, label_res['packages'][0]['pdf_download_link'])
+          end
+        rescue => e
+          Rails.logger.error("Delhivery Label Fetch Failed: #{e.message}")
+        end
+
+        return success(@shipment)
+      else
+        # --- IMPROVED ERROR HANDLING ---
+        # 1. Extract the deep error message first (it's more accurate than 'rmk')
+        raw_error = response.dig('packages', 0, 'remarks')&.join(', ') || response['rmk'] || "Unknown Error"
+        
+        # 2. Map known API errors to friendly user messages
+        friendly_error = case raw_error.to_s.downcase
+                         when /insufficient balance/
+                           # Fetch live balance to show the user
+                           current_bal = @client.fetch_balance rescue nil
+                           msg = "Authorization Failed: Insufficient Delhivery Wallet Balance."
+                           msg += " Current Balance: ₹#{current_bal}." if current_bal
+                           msg + " Please recharge."
+                         when /duplicate/
+                           "Duplicate Order: This order ID has already been processed."
+                         when /pincode/
+                           "Serviceability Error: Pincode (#{@address.zipcode}) not serviceable."
+                         else
+                           "Delhivery Error: #{raw_error}"
+                         end
+
+        return error(friendly_error)
+      end
+    rescue StandardError => e
+      Rails.logger.error(e.backtrace.join("\n"))
+      return error(e.message)
+    end
+
+    private
+
+    def build_payload
+      # --- ROBUST PAYMENT MODE DETECTION ---
+      # Instead of relying on order.paid?, look at valid payments assigned to the order
+      is_cod_payment = @order.payments.valid.any? do |payment|
+        payment.payment_method&.type == 'Spree::PaymentMethod::DelhiveryCod'
+      end
+
+      payment_mode = is_cod_payment ? 'COD' : 'Prepaid'
+      
+      # Sanitization: Ensure phone is exactly 10 digits (removes +91 or 0 prefix)
+      phone = @address.phone.to_s.gsub(/[^0-9]/, '').last(10)
+      
+      # 1. Calculate and Convert Weight to Grams
+      total_weight_grams = calculate_total_weight
+      
+      # 2. Calculate and Convert Dimensions to CM
+      dims = calculate_dimensions # Returns [L, W, H] in CM
+
+      # 3. Detect Shipping Mode dynamically from Customer Choice
+      shipping_method_name = @shipment.shipping_method&.name.to_s.downcase
+      
+      final_shipping_mode = if shipping_method_name.include?('express')
+                              'Express'
+                            elsif shipping_method_name.include?('surface')
+                              'Surface'
+                            else
+                              # Fallback to Admin Setting if name is generic (e.g. "Free Shipping")
+                              @integration.preferred_shipping_mode || 'Surface'
+                            end
+
+      {
+        pickup_location: {
+          name: @integration.preferred_pickup_location_name
+        },
+        shipments: [
+          {
+            name: @address.full_name,
+            add: [@address.address1, @address.address2].compact.join(', ').truncate(250),
+            pin: @address.zipcode,
+            city: @address.city,
+            state: @address.state&.name || @address.state_name,
+            country: 'India',
+            phone: phone,
+            order: @shipment.number,
+            payment_mode: payment_mode,
+            products_desc: @shipment.line_items.map { |i| i.variant.name }.join(', ').truncate(50),
+            
+            # --- DYNAMIC COD COLLECTION VALUES ---
+            cod_amount: payment_mode == 'COD' ? @order.total.to_f : 0.0,
+            total_amount: @order.total.to_f,
+            
+            # Use the detected mode ('Express' or 'Surface')
+            shipping_mode: final_shipping_mode,
+            quantity: @shipment.line_items.sum(&:quantity).to_i,
+            
+            # Dynamic Values
+            weight: total_weight_grams,
+            shipment_length: dims[0],
+            shipment_width: dims[1],
+            shipment_height: dims[2],
+            
+            # Client Name (Dynamic based on settings)
+            client: @integration.preferred_client_name
+          }
+        ]
+      }
+    end
+
+    def calculate_total_weight
+      raw_weight = @shipment.line_items.sum { |li| (li.variant.weight || 0) * li.quantity }
+      raw_weight = 0.5 if raw_weight.zero?
+
+      unit = @integration.preferred_store_weight_unit || 'kg'
+
+      grams = case unit
+              when 'kg' then raw_weight * 1000
+              when 'lbs' then raw_weight * 453.592
+              when 'oz' then raw_weight * 28.3495
+              when 'g' then raw_weight
+              else raw_weight * 1000
+              end
+      
+      grams.to_i
+    end
+
+    def calculate_dimensions
+      max_l = 0
+      max_w = 0
+      total_h = 0
+
+      @shipment.line_items.each do |line_item|
+        v = line_item.variant
+        q = line_item.quantity
+        
+        l = (v.depth || 10).to_f
+        w = (v.width || 10).to_f
+        h = (v.height || 10).to_f
+
+        max_l = [max_l, l].max
+        max_w = [max_w, w].max
+        total_h += (h * q)
+      end
+
+      unit = @integration.preferred_store_dimension_unit || 'cm'
+      
+      [max_l, max_w, total_h].map do |val|
+        cm = case unit
+             when 'cm' then val
+             when 'in' then val * 2.54
+             when 'm' then val * 100
+             when 'mm' then val / 10.0
+             else val
+             end
+        cm.round(2)
+      end
+    end
+
+    def success(shipment)
+      OpenStruct.new(success?: true, shipment: shipment)
+    end
+
+    def error(message)
+      OpenStruct.new(success?: false, error: message)
+    end
+  end
+end