spree_delhivery 1.0.0

data/app/controllers/spree/admin/shipments_controller_decorator.rb

@@ -0,0 +1,198 @@
+module Spree
+    module Admin
+      module ShipmentsControllerDecorator
+        def self.prepended(base)
+          # Ensure we can access these methods inside the controller
+          base.helper_method :delhivery_integration
+        end
+  
+        # POST /admin/shipments/:id/delhivery_manifest
+        def delhivery_manifest
+          @shipment = Spree::Shipment.find(params[:id])
+          
+          # 1. Validation
+          unless delhivery_integration
+            flash[:error] = "Delhivery Integration is not active."
+            return redirect_back(fallback_location: admin_orders_path)
+          end
+  
+          unless @shipment.stock_location.delhivery_warehouse_name.present?
+            flash[:error] = "Stock Location is missing 'Delhivery Warehouse Name'. Please configure it first."
+            return redirect_to edit_admin_stock_location_path(@shipment.stock_location)
+          end
+  
+          # 2. Build Payload
+          # We delegate this complex logic to a dedicated helper method below
+          payload = build_delhivery_payload(@shipment)
+  
+          # 3. Call API
+          client = SpreeDelhivery::Client.new
+          response = client.create_shipment(payload)
+  
+          # 4. Handle Response
+          if response['packages'].present? && response['packages'][0]['status'] == 'Success'
+            # Success!
+            waybill = response['packages'][0]['waybill']
+            ref_id  = response['packages'][0]['refnum'] # Our shipment number
+            
+            @shipment.update!(
+              delhivery_waybill: waybill,
+              delhivery_ref_id: ref_id,
+              tracking: waybill,
+              state: 'shipped', # Mark as shipped in Spree immediately
+              shipped_at: Time.current,
+              delhivery_response_data: response
+            )
+  
+            flash[:success] = "Delhivery Waybill Generated: #{waybill}"
+          else
+            # Error
+            error_msg = response['error'] || response['packages']&.first&.fetch('remarks', nil) || "Unknown API Error"
+            flash[:error] = "Delhivery Failed: #{error_msg}"
+          end
+  
+          redirect_back(fallback_location: edit_admin_order_path(@shipment.order))
+        rescue StandardError => e
+          flash[:error] = "System Error: #{e.message}"
+          redirect_back(fallback_location: edit_admin_order_path(@shipment.order))
+        end
+  
+        # POST /admin/shipments/:id/delhivery_track
+        def delhivery_track
+          @shipment = Spree::Shipment.find(params[:id])
+          
+          if @shipment.delhivery_waybill.blank?
+            flash[:error] = "No Waybill found to track."
+          else
+            client = SpreeDelhivery::Client.new
+            response = client.track_shipment(@shipment.delhivery_waybill)
+            
+            # Parse flexible response (sometimes Array, sometimes Hash)
+            data = response.is_a?(Array) ? response.first : response
+            
+            if data && data['ShipmentData']
+              status = data['ShipmentData'][0]['Shipment']['Status']['Status'] rescue "Unknown"
+              @shipment.update(tracking_status: status)
+              flash[:success] = "Tracking Updated: #{status}"
+            else
+              flash[:warning] = "Tracking info not available yet."
+            end
+          end
+          
+          redirect_back(fallback_location: edit_admin_order_path(@shipment.order))
+        end
+  
+        # POST /admin/shipments/:id/delhivery_cancel
+        def delhivery_cancel
+          @shipment = Spree::Shipment.find(params[:id])
+          
+          client = SpreeDelhivery::Client.new
+          response = client.cancel_shipment(@shipment.delhivery_waybill)
+  
+          # Delhivery cancellation response varies, usually checks for success code
+          if response['status'] == "True" || response['success'] == true
+            @shipment.update(
+              delhivery_waybill: nil, 
+              tracking: nil,
+              state: 'ready' # Revert state so we can ship again
+            )
+            flash[:success] = "Shipment Cancelled successfully."
+          else
+            flash[:error] = "Cancellation Failed: #{response['error'] || response['message']}"
+          end
+          
+          redirect_back(fallback_location: edit_admin_order_path(@shipment.order))
+        end
+  
+        # GET /admin/shipments/:id/delhivery_label
+        def delhivery_label
+          @shipment = Spree::Shipment.find(params[:id])
+          
+          client = SpreeDelhivery::Client.new
+          response = client.fetch_label(@shipment.delhivery_waybill)
+          
+          # API usually returns a JSON with a 'packages' array containing a 'pdf_download_link'
+          # Or sometimes raw PDF data depending on endpoint. 
+          # Assuming the 'packing_slip' endpoint returns JSON with a URL:
+          if response['packages'].present? && response['packages'][0]['pdf_download_link'].present?
+            redirect_to response['packages'][0]['pdf_download_link'], allow_other_host: true
+          else
+            flash[:error] = "Label URL not found in response."
+            redirect_back(fallback_location: edit_admin_order_path(@shipment.order))
+          end
+        end
+  
+        private
+  
+        def delhivery_integration
+          @delhivery_integration ||= Spree::Integrations::Delhivery.active.first
+        end
+  
+        # ---------------------------------------------------------
+        # PAYLOAD BUILDER
+        # This maps Spree Shipment Data -> Delhivery JSON Format
+        # ---------------------------------------------------------
+        def build_delhivery_payload(shipment)
+          order = shipment.order
+          address = order.shipping_address
+          location = shipment.stock_location
+  
+          # Calculate Weight (Convert to Grams if needed)
+          # Assuming Spree weight is in KG. 
+          total_weight_kgs = shipment.line_items.sum { |li| li.variant.weight.to_f * li.quantity }
+          total_weight_gms = (total_weight_kgs * 1000).to_i
+          total_weight_gms = 500 if total_weight_gms < 500 # Minimum 500g
+  
+          payment_mode = order.paid? ? 'Pre-paid' : 'COD'
+          cod_amount = payment_mode == 'COD' ? order.total.to_f : 0.0
+  
+          {
+            shipments: [
+              {
+                name: "#{address.firstname} #{address.lastname}",
+                add: "#{address.address1} #{address.address2}",
+                pin: address.zipcode,
+                city: address.city,
+                state: address.state&.name || address.state_text,
+                country: address.country&.iso || "IN",
+                phone: address.phone,
+                order: shipment.number, # Ref ID
+                payment_mode: payment_mode,
+                return_pin: location.zipcode,
+                return_city: location.city,
+                return_phone: location.phone,
+                return_add: location.address1,
+                products_desc: shipment.line_items.map { |li| li.product.name }.join(', '),
+                hsn_code: "", # Add logic here if you store HSN codes on products
+                cod_amount: cod_amount,
+                order_date: order.completed_at&.strftime('%Y-%m-%d'),
+                total_amount: order.total.to_f,
+                seller_inv_date: Time.current.strftime('%Y-%m-%d'),
+                seller_name: location.delhivery_warehouse_name, # Critical!
+                seller_add: "#{location.address1} #{location.city}",
+                seller_inv: shipment.number,
+                quantity: shipment.line_items.sum(&:quantity),
+                waybill: "", # Blank for creation
+                shipment_width: 10,  # Default or fetch from products
+                shipment_height: 10, # Default
+                shipment_depth: 10,  # Default
+                shipment_weight: total_weight_gms
+              }
+            ],
+            pickup_location: {
+              name: location.delhivery_warehouse_name,
+              add: location.address1,
+              city: location.city,
+              pin_code: location.zipcode,
+              country: location.country&.iso || "IN",
+              phone: location.phone
+            }
+          }
+        end
+  
+      end
+    end
+  end
+  
+  # Apply the decoration
+  Spree::Admin::ShipmentsController.prepend(Spree::Admin::ShipmentsControllerDecorator)

data/app/controllers/spree/admin/stock_locations_controller_decorator.rb

@@ -0,0 +1,38 @@
+module Spree
+    module Admin
+      module StockLocationsControllerDecorator
+        def delhivery_pickup
+          @stock_location = Spree::StockLocation.find(params[:id])
+          
+          # 1. Capture Params
+          count = params[:count].to_i
+          count = 1 if count <= 0
+          
+          date = params[:pickup_date] # Format: "YYYY-MM-DD" from HTML5 input
+          time = params[:pickup_time] # Format: "HH:MM"
+  
+          # 2. Call Service
+          # passing the named arguments your service expects
+          service = SpreeDelhivery::PickupService.new(
+            @stock_location, 
+            date: date, 
+            time: time, 
+            count: count
+          )
+          
+          result = service.call
+  
+          # 3. Handle Result
+          if result.success?
+            flash[:success] = result.message
+          else
+            flash[:error] = "Delhivery Error: #{result.message}"
+          end
+  
+          redirect_to edit_admin_stock_location_path(@stock_location)
+        end
+      end
+    end
+  end
+  
+  Spree::Admin::StockLocationsController.prepend(Spree::Admin::StockLocationsControllerDecorator)

data/app/controllers/spree/api/v3/store/delhivery_controller.rb

@@ -0,0 +1,126 @@
+module Spree
+  module Api
+    module V3
+      module Store
+        class DelhiveryController < ::Spree::Api::V3::BaseController
+          # V3 best practice: skip size checks for simple GET/POST validation requests
+          skip_before_action :ensure_payload_size, raise: false
+          skip_before_action :check_payload_size, raise: false
+
+          def check
+            pincode = params[:pincode]
+            mode = params[:mode] || 'Surface'
+            
+            cutoff_h = (params[:cutoff_hour] || '14').to_i
+            cutoff_m = params[:cutoff_meridiem] || 'PM'
+
+            return render json: { error: "Invalid Pincode" }, status: 400 if pincode.blank? || pincode.length != 6
+
+            # Determine Source Pin using Spree 5.4 methods
+            stock_location = Spree::StockLocation.where(active: true).where.not(zipcode: nil).first
+            source_pin = stock_location&.zipcode || "110001" 
+
+            client = SpreeDelhivery::Client.new
+            
+            # --- 1. IMPROVED LOCATION LOGIC (City + District + State) ---
+            location_text = "Valid Location"
+            begin
+              details = client.fetch_pincode_details(pincode)
+              if details
+                d = details.with_indifferent_access
+                
+                # Clean City (Remove S.O/B.O suffixes)
+                raw_city = d[:city].presence || ""
+                city_name = raw_city.to_s.gsub(/\s+(S\.?O|B\.?O|H\.?O)\.?$/i, '').strip.titleize
+
+                # Clean District
+                raw_dist = d[:district].presence || ""
+                dist_name = raw_dist.to_s.gsub(/\s+District$/i, '').strip.titleize
+
+                # Parse State
+                raw_state = (d[:state] || d[:state_code] || d[:province]).to_s.strip
+                state_name = raw_state.titleize
+
+                # India State Map Correction
+                state_map = {
+                  'TS' => 'Telangana', 'TG' => 'Telangana', 'DL' => 'Delhi',
+                  'MH' => 'Maharashtra', 'KA' => 'Karnataka', 'TN' => 'Tamil Nadu',
+                  'UP' => 'Uttar Pradesh', 'WB' => 'West Bengal', 'AP' => 'Andhra Pradesh',
+                  'GJ' => 'Gujarat', 'RJ' => 'Rajasthan', 'KL' => 'Kerala', 'HR' => 'Haryana',
+                  'PB' => 'Punjab', 'MP' => 'Madhya Pradesh', 'BR' => 'Bihar',
+                  'CG' => 'Chhattisgarh', 'JH' => 'Jharkhand', 'UK' => 'Uttarakhand', 
+                  'HP' => 'Himachal Pradesh', 'AS' => 'Assam', 'OR' => 'Odisha'
+                }
+
+                # Resolve Official State Name via Spree DB
+                india = Spree::Country.find_by(iso: 'IN')
+                if india
+                  state_match = india.states.where("LOWER(abbr) = ? OR LOWER(name) = ?", raw_state.downcase, raw_state.downcase).first
+                  if state_match
+                    state_name = state_match.name 
+                  elsif state_map[raw_state.upcase]
+                    state_name = state_map[raw_state.upcase]
+                  end
+                end
+
+                # Build Full Location String
+                parts = []
+                parts << city_name if city_name.present?
+                parts << dist_name if dist_name.present? && dist_name.downcase != city_name.downcase
+                if state_name.present? && state_name.downcase != city_name.downcase && state_name.downcase != dist_name.downcase
+                  parts << state_name
+                end
+
+                location_text = parts.join(', ') if parts.any?
+              end
+            rescue => e
+              Rails.logger.error "Delhivery City Parse Error: #{e.message}"
+            end
+
+            # --- 2. TAT & Timer Logic ---
+            response = client.calculate_tat(source_pin: source_pin, dest_pin: pincode, mode: mode)
+
+            if response && (response['success'] == true || response['estimated_delivery_date'])
+              if response['data'] && response['data']['tat']
+                 delivery_date = Date.today + response['data']['tat'].to_i.days
+              elsif response['estimated_delivery_date']
+                 delivery_date = Date.parse(response['estimated_delivery_date'])
+              else
+                 delivery_date = Date.today + 5.days
+              end
+              
+              date_text = "Delivery by #{delivery_date.strftime("%A, %B %d")}"
+              
+              # Timer Calculation
+              cutoff_24 = cutoff_h
+              if cutoff_m.upcase == 'PM' && cutoff_h < 12
+                cutoff_24 += 12
+              elsif cutoff_m.upcase == 'AM' && cutoff_h == 12
+                cutoff_24 = 0
+              end
+
+              now = Time.current
+              target_time = now.change(hour: cutoff_24, min: 0, sec: 0)
+              target_time += 1.day if now > target_time
+              
+              remaining = (target_time - now).to_i
+              timer_text = "#{remaining / 3600} hrs #{(remaining % 3600) / 60} mins"
+
+              # V3 Standard: Wrap response in a 'data' block
+              render json: { 
+                success: true, 
+                data: {
+                  date_text: date_text,
+                  location_text: location_text, 
+                  timer_text: timer_text
+                }
+              }
+            else
+              render json: { success: false, error: "Delivery not available." }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree_delhivery/base_job.rb

@@ -0,0 +1,5 @@
+module SpreeDelhivery
+  class BaseJob < Spree::BaseJob
+    queue_as SpreeDelhivery.queue
+  end
+end

data/app/models/spree/calculator/shipping/delhivery.rb

@@ -0,0 +1,97 @@
+module Spree
+  module Calculator::Shipping
+    class Delhivery < Spree::ShippingCalculator
+      
+      preference :handling_fee, :decimal, default: 0.0
+      preference :service_mode, :string, default: 'Surface' # Full Name
+
+      def self.description
+        "Delhivery Live Rate"
+      end
+
+      def compute_package(package)
+        integration = Spree::Integrations::Delhivery.active.first
+        return nil unless integration
+
+        order = package.order
+        stock_location = package.stock_location
+        return nil unless stock_location&.zipcode && order.ship_address&.zipcode
+
+        origin_pin = stock_location.zipcode
+        dest_pin = order.ship_address.zipcode
+
+        store_weight_unit = integration.preferred_store_weight_unit.to_s.downcase
+        store_dim_unit    = integration.preferred_store_dimension_unit.to_s.downcase
+
+        total_actual_weight_gms = 0.0
+        total_volumetric_weight_gms = 0.0
+
+        package.contents.each do |item|
+          variant = item.variant
+          qty = item.quantity
+
+          # Weight to Grams
+          w_raw = variant.weight.to_f
+          w_gms = case store_weight_unit
+                  when 'kg', 'kilograms' then w_raw * 1000.0
+                  when 'lbs', 'pounds'   then w_raw * 453.592
+                  when 'oz', 'ounces'    then w_raw * 28.3495
+                  when 'g', 'grams'      then w_raw
+                  else w_raw * 1000.0
+                  end
+          
+          total_actual_weight_gms += (w_gms * qty)
+
+          # Dimensions to CM
+          l_raw = variant.depth.to_f
+          w_raw = variant.width.to_f
+          h_raw = variant.height.to_f
+
+          if l_raw.zero?
+             l_raw = (store_dim_unit == 'mm' ? 100.0 : 10.0)
+             w_raw = (store_dim_unit == 'mm' ? 100.0 : 10.0)
+             h_raw = (store_dim_unit == 'mm' ? 10.0 : 1.0)
+          end
+
+          to_cm = ->(val) {
+            case store_dim_unit
+            when 'mm', 'millimeters' then val / 10.0
+            when 'm', 'meters'       then val * 100.0
+            when 'in', 'inches'      then val * 2.54
+            when 'cm', 'centimeters' then val
+            else val
+            end
+          }
+
+          vol_weight_kg = (to_cm.call(l_raw) * to_cm.call(w_raw) * to_cm.call(h_raw)) / 5000.0
+          total_volumetric_weight_gms += (vol_weight_kg * 1000.0 * qty)
+        end
+
+        chargeable_weight_gms = [total_actual_weight_gms, total_volumetric_weight_gms].max.to_i
+        chargeable_weight_gms = 50 if chargeable_weight_gms < 50
+        
+        client = SpreeDelhivery::Client.new
+        
+        begin
+          # Mode 'Surface'/'Express' passed directly
+          mode = preferred_service_mode 
+          cache_key = "delhivery_rate_#{origin_pin}_#{dest_pin}_#{chargeable_weight_gms}_#{mode}"
+          
+          rate = Rails.cache.fetch(cache_key, expires_in: 15.minutes) do
+            client.fetch_shipping_rate(
+              source_pin: origin_pin, 
+              dest_pin: dest_pin, 
+              weight_gms: chargeable_weight_gms,
+              mode: mode
+            )
+          end
+          
+          rate ? rate + preferred_handling_fee : nil
+        rescue StandardError => e
+          Rails.logger.error "Delhivery Calculator Error: #{e.message}"
+          return nil 
+        end
+      end
+    end
+  end
+end

data/app/models/spree/integrations/delhivery.rb

@@ -0,0 +1,48 @@
+module Spree
+    module Integrations
+      class Delhivery < Spree::Integration
+        # Configuration Fields
+        preference :api_token, :password
+        preference :client_name, :string # "REGULAR" or specific client name
+        preference :pickup_location_name, :string # Must match Delhivery Dashboard Warehouse Name EXACTLY
+        preference :production_mode, :boolean, default: false
+        preference :shipping_mode, :string, default: 'Surface' # Options: Surface, Express
+        preference :cod_surcharge_amount, :decimal, default: 0.0
+
+        # --- NEW UNIT PREFERENCES ---
+        preference :store_weight_unit, :string, default: 'kg' # Options: kg, lbs, oz, g
+        preference :store_dimension_unit, :string, default: 'cm' # Options: cm, in, m, mm
+        
+        validates :preferred_api_token, presence: true
+        validates :preferred_pickup_location_name, presence: true
+  
+        def self.integration_name
+          "Delhivery"
+        end
+        
+        # This method is required for the Admin Index page sorting
+        def self.integration_group
+          "Shipping"
+        end
+        # --- FIX ENDS HERE ---
+  
+        def self.icon_path
+          "integration_icons/delhivery.png" # Make sure this image exists in your assets folder
+        end
+
+        # 4. Helper to get the token (used in your Client)
+        def preferred_api_token
+        # You can add logic here to decrypt if you want extra security
+          preferences[:api_token]
+        end
+  
+        def api_url
+          if preferred_production_mode
+            "https://track.delhivery.com"
+          else
+            "https://staging-express.delhivery.com"
+          end
+        end
+      end
+    end
+  end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,63 @@
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      # Hook 1: Add/Remove COD Surcharge for both Rails (confirm) and Next.js (complete) flows
+      base.state_machine.before_transition to: [:confirm, :complete], do: :manage_cod_surcharge
+      
+      # Hook 2: Auto-void Delhivery waybills if the order is canceled
+      base.state_machine.after_transition to: :canceled, do: :cancel_delhivery_shipments
+    end
+
+    def manage_cod_surcharge
+      # 1. Check if the customer chose Delhivery COD
+      is_cod = payments.valid.any? { |p| p.payment_method&.type == 'Spree::PaymentMethod::DelhiveryCod' }
+      
+      # 2. Fetch your Delhivery configuration
+      integration = Spree::Integrations::Delhivery.active.first
+      surcharge_amount = integration&.preferred_cod_surcharge_amount.to_f
+
+      # 3. Apply or Remove the financial adjustment
+      if is_cod && surcharge_amount > 0
+        # Destroy any old COD fees to prevent duplicate stacking
+        adjustments.where(label: 'COD Surcharge').destroy_all
+        
+        # Create the new fee
+        adjustments.create!(
+          order: self,
+          adjustable: self, # Apply to the whole order
+          label: 'COD Surcharge',
+          amount: surcharge_amount,
+          state: 'closed', # Prevents Spree's auto-calculator from zeroing it out
+          included: false
+        )
+      else
+        # If they switched back to Prepaid, cleanly remove the fee
+        adjustments.where(label: 'COD Surcharge').destroy_all
+      end
+
+      # Force Spree to recalculate the grand total with the new fee
+      updater.update
+    end
+
+    private
+
+    def cancel_delhivery_shipments
+      shipments.where.not(delhivery_waybill: nil).each do |shipment|
+        client = SpreeDelhivery::Client.new
+        response = client.cancel_shipment(shipment.delhivery_waybill)
+
+        if response['status'] == "True" || response['success'] == true
+          Rails.logger.info "[Delhivery] Auto-Cancellation Success for #{shipment.number}"
+          shipment.update_columns(delhivery_waybill: nil, tracking: nil)
+        else
+          Rails.logger.error "[Delhivery] Auto-Cancellation FAILED for #{shipment.number}: #{response}"
+        end
+      end
+    rescue StandardError => e
+      Rails.logger.error "[Delhivery] System Error during Auto-Cancellation: #{e.message}"
+    end
+  end
+end
+
+# Apply the decorator
+Spree::Order.prepend(Spree::OrderDecorator)

data/app/models/spree/page_blocks/products/delhivery_edd.rb

@@ -0,0 +1,42 @@
+module Spree
+  module PageBlocks
+    module Products
+      class DelhiveryEdd < (defined?(Spree::PageBlock) ? Spree::PageBlock : Object)
+        if defined?(Spree::PageBlock)
+          preference :heading_text, :string, default: 'Estimated Delivery Date'
+          preference :placeholder_text, :string, default: 'Enter PIN Code'
+          preference :button_text, :string, default: 'Check'
+          preference :default_mode, :string, default: 'Surface'
+          preference :cutoff_time, :string, default: '14:00'
+          preference :cutoff_hour, :string, default: '2' 
+          preference :cutoff_meridiem, :string, default: 'PM'
+          preference :input_border_color, :string, default: '#E2E8F0'
+          preference :button_bg_color, :string, default: '#000000'
+          preference :button_text_color, :string, default: '#FFFFFF'
+          preference :success_color, :string, default: '#10B981'
+          preference :error_color, :string, default: '#EF4444'
+
+          def self.block_name
+            "Delhivery EDD Widget"
+          end
+
+          def self.display_name
+            "Delhivery Delivery Checker"
+          end
+
+          def icon_name
+            "truck-delivery" 
+          end
+
+          def render(view_context, locals = {})
+            if respond_to?(:available?, true)
+              return '' unless available?(locals)
+            end
+            view_context.render partial: 'spree/page_blocks/products/delhivery_edd/delhivery_edd',
+                                locals: locals.merge(block: self)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/page_sections/product_details_decorator.rb

@@ -0,0 +1,26 @@
+module Spree
+  module PageSections
+    module ProductDetailsDecorator
+      def default_blocks
+        # Safely add blocks only if they are loaded into memory
+        blocks = super
+        blocks << Spree::PageBlocks::Products::RazorpayAffordability.new if defined?(Spree::PageBlocks::Products::RazorpayAffordability)
+        blocks << Spree::PageBlocks::Products::DelhiveryEdd.new if defined?(Spree::PageBlocks::Products::DelhiveryEdd)
+        blocks
+      end
+
+      def available_blocks_to_add
+        blocks = super
+        blocks << Spree::PageBlocks::Products::RazorpayAffordability if defined?(Spree::PageBlocks::Products::RazorpayAffordability)
+        blocks << Spree::PageBlocks::Products::DelhiveryEdd if defined?(Spree::PageBlocks::Products::DelhiveryEdd)
+        blocks
+      end
+    end
+  end
+end
+
+# ONLY prepend if the core Storefront class exists. 
+# This sits OUTSIDE the module definition.
+if defined?(Spree::PageSections::ProductDetails)
+  Spree::PageSections::ProductDetails.prepend(Spree::PageSections::ProductDetailsDecorator)
+end