ocpp-rails 0.2.4

data/app/services/ocpp/rails/actions/boot_notification_handler.rb

@@ -0,0 +1,62 @@
+module Ocpp
+  module Rails
+    module Actions
+      class BootNotificationHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          # Update charge point with boot information
+          old_connected = @charge_point.connected
+
+          @charge_point.update(
+            vendor: @payload["chargePointVendor"],
+            model: @payload["chargePointModel"],
+            serial_number: @payload["chargePointSerialNumber"],
+            firmware_version: @payload["firmwareVersion"],
+            iccid: @payload["iccid"],
+            imsi: @payload["imsi"],
+            meter_type: @payload["meterType"],
+            meter_serial_number: @payload["meterSerialNumber"],
+            connected: true,
+            last_heartbeat_at: Time.current
+          )
+
+          ::Rails.logger.info("[OCPP] BootNotification from #{@charge_point.identifier}: #{@payload['chargePointVendor']} #{@payload['chargePointModel']}")
+
+          # Log connection state change if it actually changed
+          log_connection_change(old_connected, true)
+
+          # Return acceptance with heartbeat interval
+          {
+            "status" => "Accepted",
+            "currentTime" => Time.current.iso8601,
+            "interval" => Ocpp::Rails.configuration.heartbeat_interval
+          }
+        end
+
+        private
+
+        def log_connection_change(old_connected, new_connected)
+          return if old_connected == new_connected
+
+          begin
+            Ocpp::Rails::StateChange.create!(
+              charge_point: @charge_point,
+              change_type: "connection",
+              connector_id: nil,
+              old_value: old_connected.to_s,
+              new_value: new_connected.to_s,
+              metadata: { source: "boot_notification" }
+            )
+          rescue => error
+            ::Rails.logger.error("Failed to log state change: #{error.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/actions/heartbeat_handler.rb

@@ -0,0 +1,25 @@
+module Ocpp
+  module Rails
+    module Actions
+      class HeartbeatHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          # Update last heartbeat timestamp and ensure connected status
+          @charge_point.heartbeat!
+
+          ::Rails.logger.debug("[OCPP] Heartbeat from #{@charge_point.identifier}")
+
+          # Return current server time
+          {
+            "currentTime" => Time.current.iso8601
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/actions/meter_values_handler.rb

@@ -0,0 +1,97 @@
+module Ocpp
+  module Rails
+    module Actions
+      class MeterValuesHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          connector_id = @payload["connectorId"]
+          transaction_id = @payload["transactionId"]
+
+          # Find active session if transaction ID provided
+          session = if transaction_id
+            @charge_point.charging_sessions.find_by(transaction_id: transaction_id)
+          else
+            @charge_point.charging_sessions.active.find_by(connector_id: connector_id)
+          end
+
+          # Process each meter value set
+          meter_value_sets = @payload["meterValue"] || []
+          meter_value_sets.each do |meter_value_set|
+            timestamp = TimestampParser.parse(meter_value_set["timestamp"])
+
+            sampled_values = meter_value_set["sampledValue"] || []
+            sampled_values.each do |sampled_value|
+              meter_value = create_meter_value(session, connector_id, timestamp, sampled_value)
+              broadcast_meter_value(meter_value) if meter_value
+            end
+          end
+
+          ::Rails.logger.debug("[OCPP] MeterValues from #{@charge_point.identifier}: Connector #{connector_id}, #{meter_value_sets.size} value sets")
+
+          # Return empty response (MeterValues doesn't require data in response)
+          {}
+        end
+
+        private
+
+        def create_meter_value(session, connector_id, timestamp, sampled_value)
+          measurand = sampled_value["measurand"] || "Energy.Active.Import.Register"
+          unit = sampled_value["unit"] || "Wh"
+
+          flag_reason = MeterAnomalyDetector.check(
+            session: session,
+            measurand: measurand,
+            value: sampled_value["value"],
+            unit: unit
+          )
+          if flag_reason
+            ::Rails.logger.warn("[OCPP] Anomalous meter value from #{@charge_point.identifier} (#{flag_reason}): #{sampled_value['value']} #{unit}")
+          end
+
+          @charge_point.meter_values.create!(
+            charging_session: session,
+            connector_id: connector_id,
+            measurand: measurand,
+            phase: sampled_value["phase"],
+            unit: unit,
+            context: sampled_value["context"] || "Sample.Periodic",
+            format: sampled_value["format"] || "Raw",
+            location: sampled_value["location"] || "Outlet",
+            value: sampled_value["value"],
+            timestamp: timestamp.time,
+            raw_timestamp: timestamp.raw,
+            timestamp_source: timestamp.source,
+            flagged: flag_reason.present?,
+            flag_reason: flag_reason
+          )
+        rescue => e
+          ::Rails.logger.error("[OCPP] Failed to create meter value: #{e.message}")
+          nil
+        end
+
+        def broadcast_meter_value(meter_value)
+          ActionCable.server.broadcast(
+            "charge_point_#{@charge_point.id}_meter_values",
+            {
+              connector_id: meter_value.connector_id,
+              measurand: meter_value.measurand,
+              value: meter_value.value.to_f,
+              unit: meter_value.unit,
+              phase: meter_value.phase,
+              context: meter_value.context,
+              timestamp: meter_value.timestamp.iso8601,
+              session_id: meter_value.charging_session_id
+            }
+          )
+        rescue => e
+          ::Rails.logger.error("[OCPP] Failed to broadcast meter value: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/actions/start_transaction_handler.rb

@@ -0,0 +1,126 @@
+module Ocpp
+  module Rails
+    module Actions
+      class StartTransactionHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          id_tag = @payload["idTag"]
+          authorization = authorize(id_tag)
+
+          unless authorization[:status] == "Accepted"
+            ::Rails.logger.warn("[OCPP] StartTransaction from #{@charge_point.identifier} rejected for idTag #{id_tag}: #{authorization[:status]}")
+            # OCPP 1.6 requires transactionId in the response; the station
+            # must ignore it when the idTag was not accepted.
+            return {
+              "idTagInfo" => { "status" => authorization[:status] },
+              "transactionId" => 0
+            }
+          end
+
+          # A duplicate/replayed StartTransaction must not open a second
+          # concurrent session on the connector; resume the open one instead.
+          existing = active_session
+          if existing
+            ::Rails.logger.warn("[OCPP] StartTransaction from #{@charge_point.identifier}: Connector #{@payload['connectorId']} already has active transaction #{existing.transaction_id}, resuming it")
+            return accepted_response(existing, authorization)
+          end
+
+          started_at = TimestampParser.parse(@payload["timestamp"])
+
+          begin
+            session = @charge_point.charging_sessions.create!(
+              connector_id: @payload["connectorId"],
+              id_tag: id_tag,
+              start_meter_value: @payload["meterStart"],
+              started_at: started_at.time,
+              status: "Charging",
+              metadata: session_metadata(started_at)
+            )
+          rescue ActiveRecord::RecordNotUnique
+            # Lost a race against a concurrent StartTransaction; the winner's
+            # session is the one to resume.
+            session = active_session
+            raise unless session
+            return accepted_response(session, authorization)
+          end
+
+          ::Rails.logger.info("[OCPP] StartTransaction from #{@charge_point.identifier}: Connector #{@payload['connectorId']}, Transaction ID: #{session.transaction_id}")
+
+          # Update charge point status
+          @charge_point.update(status: "Charging")
+
+          # Broadcast session started event for real-time UI updates
+          broadcast_session_started(session)
+
+          accepted_response(session, authorization)
+        end
+
+        private
+
+        def active_session
+          @charge_point.charging_sessions.active.find_by(connector_id: @payload["connectorId"])
+        end
+
+        def accepted_response(session, authorization)
+          id_tag_info = { "status" => "Accepted" }
+          id_tag_info["expiryDate"] = authorization[:expiry_date].iso8601 if authorization[:expiry_date].present?
+
+          {
+            "idTagInfo" => id_tag_info,
+            "transactionId" => session.transaction_id
+          }
+        end
+
+        # Same decision the AuthorizeHandler makes, persisted for audit.
+        def authorize(id_tag)
+          result = Ocpp::Rails::AuthorizationHookManager.execute_hooks(@charge_point.id, id_tag)
+
+          begin
+            Ocpp::Rails::Authorization.create!(
+              charge_point_id: @charge_point.id,
+              id_tag: id_tag,
+              status: result[:status],
+              expiry_date: result[:expiry_date]
+            )
+          rescue => error
+            ::Rails.logger.error("[OCPP] Failed to persist Authorization record: #{error.message}")
+          end
+
+          result
+        end
+
+        def session_metadata(started_at)
+          return {} unless started_at.server_fallback?
+
+          {
+            "started_at_source" => started_at.source,
+            "raw_start_timestamp" => started_at.raw
+          }
+        end
+
+        def broadcast_session_started(session)
+          ActionCable.server.broadcast(
+            "charge_point_#{@charge_point.id}_sessions",
+            {
+              event: "started",
+              session: {
+                id: session.id,
+                connector_id: session.connector_id,
+                id_tag: session.id_tag,
+                started_at: session.started_at.iso8601,
+                start_meter_value: session.start_meter_value
+              }
+            }
+          )
+        rescue => e
+          ::Rails.logger.error("[OCPP] Failed to broadcast session started: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/actions/status_notification_handler.rb

@@ -0,0 +1,99 @@
+module Ocpp
+  module Rails
+    module Actions
+      class StatusNotificationHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          connector_id = @payload["connectorId"]
+          status = @payload["status"]
+          error_code = @payload["errorCode"]
+
+          ::Rails.logger.info("[OCPP] StatusNotification from #{@charge_point.identifier}: Connector #{connector_id} is #{status}")
+
+          # Update charge point or connector status
+          if connector_id == 0
+            # Status for entire charge point
+            old_status = @charge_point.status
+            @charge_point.update(status: status)
+
+            # Log state change if status actually changed
+            log_status_change(nil, old_status, status, {
+              error_code: error_code,
+              info: @payload["info"],
+              vendor_id: @payload["vendorId"],
+              vendor_error_code: @payload["vendorErrorCode"]
+            })
+          else
+            # Status for specific connector - store in metadata
+            update_connector_status(connector_id, status, error_code)
+          end
+
+          # Broadcast status change for real-time UI updates
+          broadcast_status_change
+
+          # Return empty response (StatusNotification doesn't require data in response)
+          {}
+        end
+
+        private
+
+        def update_connector_status(connector_id, status, error_code)
+          metadata = @charge_point.metadata || {}
+          old_status = metadata["connector_#{connector_id}_status"]
+
+          metadata["connector_#{connector_id}_status"] = status
+          metadata["connector_#{connector_id}_error_code"] = error_code if error_code
+          metadata["connector_#{connector_id}_updated_at"] = Time.current.iso8601
+          @charge_point.update(metadata: metadata)
+
+          # Log state change if status actually changed
+          log_status_change(connector_id, old_status, status, {
+            error_code: error_code,
+            info: @payload["info"],
+            vendor_id: @payload["vendorId"],
+            vendor_error_code: @payload["vendorErrorCode"]
+          })
+        end
+
+        def log_status_change(connector_id, old_status, new_status, additional_metadata = {})
+          return if old_status == new_status
+
+          begin
+            Ocpp::Rails::StateChange.create!(
+              charge_point: @charge_point,
+              change_type: "status",
+              connector_id: connector_id,
+              old_value: old_status,
+              new_value: new_status,
+              metadata: additional_metadata.compact
+            )
+          rescue => error
+            ::Rails.logger.error("Failed to log state change: #{error.message}")
+          end
+        end
+
+        def broadcast_status_change
+          ActionCable.server.broadcast(
+            "charge_point_#{@charge_point.id}_status",
+            {
+              connector_id: @payload["connectorId"],
+              status: @payload["status"],
+              error_code: @payload["errorCode"],
+              info: @payload["info"],
+              vendor_id: @payload["vendorId"],
+              vendor_error_code: @payload["vendorErrorCode"],
+              timestamp: @payload["timestamp"] || Time.current.iso8601
+            }
+          )
+        rescue => e
+          ::Rails.logger.error("[OCPP] Failed to broadcast status change: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/actions/stop_transaction_handler.rb

@@ -0,0 +1,121 @@
+module Ocpp
+  module Rails
+    module Actions
+      class StopTransactionHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          # Find the session by the wire transaction ID
+          session = @charge_point.charging_sessions.find_by(transaction_id: @payload["transactionId"])
+
+          unless session
+            ::Rails.logger.error("[OCPP] StopTransaction: Session not found for transaction ID #{@payload['transactionId']}")
+            return {
+              "idTagInfo" => {
+                "status" => "Invalid"
+              }
+            }
+          end
+
+          # Stop the session
+          session.stop!(
+            reason: @payload["reason"] || "Local",
+            meter_value: @payload["meterStop"]
+          )
+
+          ::Rails.logger.info("[OCPP] StopTransaction from #{@charge_point.identifier}: Transaction ID #{session.transaction_id}, Energy: #{session.energy_consumed} Wh")
+
+          # Process transaction data (meter values during charging) if provided
+          if @payload["transactionData"]
+            process_transaction_data(session, @payload["transactionData"])
+          end
+
+          # Update charge point status if no other active sessions
+          if @charge_point.charging_sessions.active.empty?
+            @charge_point.update(status: "Available")
+          end
+
+          # Broadcast session stopped event for real-time UI updates
+          broadcast_session_stopped(session)
+
+          # Return authorization status
+          {
+            "idTagInfo" => {
+              "status" => "Accepted"
+            }
+          }
+        end
+
+        private
+
+        def process_transaction_data(session, transaction_data)
+          transaction_data.each do |meter_values_set|
+            timestamp = TimestampParser.parse(meter_values_set["timestamp"])
+
+            sampled_values = meter_values_set["sampledValue"] || []
+            sampled_values.each do |sampled_value|
+              create_meter_value(session, timestamp, sampled_value)
+            end
+          end
+        rescue => e
+          ::Rails.logger.error("[OCPP] Error processing transaction data: #{e.message}")
+        end
+
+        def create_meter_value(session, timestamp, sampled_value)
+          measurand = sampled_value["measurand"] || "Energy.Active.Import.Register"
+          unit = sampled_value["unit"] || "Wh"
+
+          flag_reason = MeterAnomalyDetector.check(
+            session: session,
+            measurand: measurand,
+            value: sampled_value["value"],
+            unit: unit
+          )
+          if flag_reason
+            ::Rails.logger.warn("[OCPP] Anomalous meter value from #{@charge_point.identifier} (#{flag_reason}): #{sampled_value['value']} #{unit}")
+          end
+
+          session.meter_values.create!(
+            charge_point: @charge_point,
+            connector_id: session.connector_id,
+            measurand: measurand,
+            phase: sampled_value["phase"],
+            unit: unit,
+            context: sampled_value["context"] || "Transaction.End",
+            format: sampled_value["format"] || "Raw",
+            location: sampled_value["location"] || "Outlet",
+            value: sampled_value["value"],
+            timestamp: timestamp.time,
+            raw_timestamp: timestamp.raw,
+            timestamp_source: timestamp.source,
+            flagged: flag_reason.present?,
+            flag_reason: flag_reason
+          )
+        end
+
+        def broadcast_session_stopped(session)
+          ActionCable.server.broadcast(
+            "charge_point_#{@charge_point.id}_sessions",
+            {
+              event: "stopped",
+              session: {
+                id: session.id,
+                connector_id: session.connector_id,
+                stopped_at: session.stopped_at.iso8601,
+                energy_consumed: session.energy_consumed,
+                duration_seconds: session.duration_seconds,
+                stop_reason: session.stop_reason
+              }
+            }
+          )
+        rescue => e
+          ::Rails.logger.error("[OCPP] Failed to broadcast session stopped: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/app/services/ocpp/rails/authorization_hook_manager.rb

@@ -0,0 +1,102 @@
+module Ocpp
+  module Rails
+    module AuthorizationHookManager
+      VALID_STATUSES = [ "Accepted", "Blocked", "Expired", "Invalid", "ConcurrentTx" ].freeze
+      DEFAULT_EXPIRY = 1.year
+
+      def self.execute_hooks(charge_point_id, id_tag)
+        hooks = Ocpp::Rails.configuration.authorization_hooks
+        sync_hooks = hooks.reject { |hook| hook.respond_to?(:async?) && hook.async? }
+
+        # If no sync hooks, default to accepted
+        if sync_hooks.empty?
+          return {
+            status: "Accepted",
+            expiry_date: Time.current + DEFAULT_EXPIRY
+          }
+        end
+
+        # Execute sync hooks
+        expiry_dates = []
+
+        sync_hooks.each do |hook|
+          begin
+            result = hook.call(charge_point_id, id_tag)
+
+            # Validate return value
+            unless result.is_a?(Hash)
+              ::Rails.logger.error("AuthorizationHook #{hook.class.name} returned non-hash: #{result.inspect}")
+              return { status: "Invalid", expiry_date: nil }
+            end
+
+            # Normalize keys to strings
+            result = result.stringify_keys
+
+            # Validate status key exists
+            unless result.key?("status")
+              ::Rails.logger.error("AuthorizationHook #{hook.class.name} returned hash without status key: #{result.inspect}")
+              return { status: "Invalid", expiry_date: nil }
+            end
+
+            status = result["status"]
+
+            # Validate status value
+            unless VALID_STATUSES.include?(status)
+              ::Rails.logger.error("AuthorizationHook #{hook.class.name} returned invalid status: #{status}")
+              return { status: "Invalid", expiry_date: nil }
+            end
+
+            # If rejected, return immediately
+            if status != "Accepted"
+              ::Rails.logger.info("AuthorizationHook #{hook.class.name} rejected with status: #{status}")
+              return { status: status, expiry_date: nil }
+            end
+
+            # If accepted, collect expiry date
+            if result["expiry_date"].present?
+              expiry_dates << parse_expiry_date(result["expiry_date"])
+            end
+          rescue => error
+            ::Rails.logger.error("AuthorizationHook #{hook.class.name} raised exception: #{error.message}")
+            ::Rails.logger.error(error.backtrace.join("\n"))
+            return { status: "Invalid", expiry_date: nil }
+          end
+        end
+
+        # All hooks accepted, return with latest expiry
+        {
+          status: "Accepted",
+          expiry_date: expiry_dates.max || (Time.current + DEFAULT_EXPIRY)
+        }
+      end
+
+      def self.execute_async_hooks(authorization)
+        hooks = Ocpp::Rails.configuration.authorization_hooks
+        async_hooks = hooks.select { |hook| hook.respond_to?(:async?) && hook.async? }
+
+        async_hooks.each do |hook|
+          begin
+            Ocpp::Rails::AuthorizationAsyncHookJob.perform_later(authorization.id, hook.class.name)
+          rescue => error
+            ::Rails.logger.error("Failed to enqueue AuthorizationAsyncHookJob for #{hook.class.name}: #{error.message}")
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def self.parse_expiry_date(expiry_date)
+        return expiry_date if expiry_date.is_a?(Time) || expiry_date.is_a?(DateTime) || expiry_date.is_a?(ActiveSupport::TimeWithZone)
+
+        begin
+          Time.parse(expiry_date.to_s)
+        rescue
+          ::Rails.logger.error("Failed to parse expiry_date: #{expiry_date.inspect}, using default")
+          Time.current + DEFAULT_EXPIRY
+        end
+      end
+    end
+  end
+end