ocpp-rails 0.2.4

data/app/jobs/ocpp/rails/change_availability_job.rb

@@ -0,0 +1,42 @@
+module Ocpp
+  module Rails
+    class ChangeAvailabilityJob < ApplicationJob
+      queue_as :default
+
+      # connector_id/type are the OCPP ChangeAvailability.req fields; type is
+      # "Operative" or "Inoperative", and connectorId 0 targets the whole charge
+      # point rather than a single connector.
+      def perform(charge_point_id, connector_id, type)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          connectorId: connector_id.to_i,
+          type: type
+        }
+
+        message = Protocol.build_call(message_id, "ChangeAvailability", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "ChangeAvailability",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/change_configuration_job.rb

@@ -0,0 +1,41 @@
+module Ocpp
+  module Rails
+    class ChangeConfigurationJob < ApplicationJob
+      queue_as :default
+
+      # key/value are the OCPP ChangeConfiguration.req fields; value is always a
+      # string, even for numeric configuration keys.
+      def perform(charge_point_id, key, value)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          key: key,
+          value: value
+        }
+
+        message = Protocol.build_call(message_id, "ChangeConfiguration", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "ChangeConfiguration",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/cleanup_authorizations_job.rb

@@ -0,0 +1,28 @@
+module Ocpp
+  module Rails
+    class CleanupAuthorizationsJob < ApplicationJob
+      queue_as :ocpp_maintenance
+
+      def perform
+        unless Ocpp::Rails.configuration.authorization_cleanup_enabled
+          ::Rails.logger.info("Authorization cleanup disabled, skipping")
+          return
+        end
+
+        begin
+          retention_days = Ocpp::Rails.configuration.authorization_retention_days
+          deleted_count = Ocpp::Rails::Authorization.older_than(retention_days).delete_all
+
+          ::Rails.logger.info("Deleted #{deleted_count} Authorization records older than #{retention_days} days")
+        rescue => error
+          ::Rails.logger.error("Authorization cleanup failed: #{error.message}")
+        ensure
+          # Re-enqueue for next run (24 hours later) only if cleanup is enabled
+          if Ocpp::Rails.configuration.authorization_cleanup_enabled
+            self.class.set(wait: 24.hours).perform_later
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/cleanup_state_changes_job.rb

@@ -0,0 +1,28 @@
+module Ocpp
+  module Rails
+    class CleanupStateChangesJob < ApplicationJob
+      queue_as :ocpp_maintenance
+
+      def perform
+        unless Ocpp::Rails.configuration.state_change_cleanup_enabled
+          ::Rails.logger.info("StateChange cleanup disabled, skipping")
+          return
+        end
+
+        begin
+          retention_days = Ocpp::Rails.configuration.state_change_retention_days
+          deleted_count = Ocpp::Rails::StateChange.older_than(retention_days).delete_all
+
+          ::Rails.logger.info("Deleted #{deleted_count} StateChange records older than #{retention_days} days")
+        rescue => error
+          ::Rails.logger.error("StateChange cleanup failed: #{error.message}")
+        ensure
+          # Re-enqueue for next run (24 hours later) only if cleanup is enabled
+          if Ocpp::Rails.configuration.state_change_cleanup_enabled
+            self.class.set(wait: 24.hours).perform_later
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/clear_cache_job.rb

@@ -0,0 +1,37 @@
+module Ocpp
+  module Rails
+    class ClearCacheJob < ApplicationJob
+      queue_as :default
+
+      def perform(charge_point_id)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        # ClearCache.req carries no fields.
+        payload = {}
+
+        message = Protocol.build_call(message_id, "ClearCache", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "ClearCache",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/get_configuration_job.rb

@@ -0,0 +1,38 @@
+module Ocpp
+  module Rails
+    class GetConfigurationJob < ApplicationJob
+      queue_as :default
+
+      # keys is the OCPP GetConfiguration.req optional key array; when blank the
+      # station returns every configuration key.
+      def perform(charge_point_id, keys = [])
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = keys.blank? ? {} : { key: Array(keys) }
+
+        message = Protocol.build_call(message_id, "GetConfiguration", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "GetConfiguration",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/remote_start_transaction_job.rb

@@ -0,0 +1,39 @@
+module Ocpp
+  module Rails
+    class RemoteStartTransactionJob < ApplicationJob
+      queue_as :default
+
+      def perform(charge_point_id, connector_id, id_tag)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          connectorId: connector_id.to_i,
+          idTag: id_tag
+        }
+
+        message = Protocol.build_call(message_id, "RemoteStartTransaction", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "RemoteStartTransaction",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/remote_stop_transaction_job.rb

@@ -0,0 +1,38 @@
+module Ocpp
+  module Rails
+    class RemoteStopTransactionJob < ApplicationJob
+      queue_as :default
+
+      def perform(charge_point_id, transaction_id)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          transactionId: transaction_id
+        }
+
+        message = Protocol.build_call(message_id, "RemoteStopTransaction", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "RemoteStopTransaction",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/reset_job.rb

@@ -0,0 +1,39 @@
+module Ocpp
+  module Rails
+    class ResetJob < ApplicationJob
+      queue_as :default
+
+      # type is the OCPP Reset.req ResetType: "Hard" or "Soft".
+      def perform(charge_point_id, type)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          type: type
+        }
+
+        message = Protocol.build_call(message_id, "Reset", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "Reset",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/jobs/ocpp/rails/unlock_connector_job.rb

@@ -0,0 +1,38 @@
+module Ocpp
+  module Rails
+    class UnlockConnectorJob < ApplicationJob
+      queue_as :default
+
+      def perform(charge_point_id, connector_id)
+        charge_point = ChargePoint.find(charge_point_id)
+        message_id = SecureRandom.uuid
+
+        payload = {
+          connectorId: connector_id.to_i
+        }
+
+        message = Protocol.build_call(message_id, "UnlockConnector", payload)
+
+        Message.create!(
+          charge_point: charge_point,
+          message_id: message_id,
+          direction: "outbound",
+          action: "UnlockConnector",
+          message_type: "CALL",
+          payload: payload,
+          status: "pending"
+        )
+
+        send_to_charge_point(charge_point, message)
+      end
+
+      private
+
+      def send_to_charge_point(charge_point, message)
+        # stream_for in ChargePointChannel relays this straight down the
+        # station's WebSocket, the same path CALLRESULTs already use.
+        ChargePointChannel.broadcast_to(charge_point, { message: message })
+      end
+    end
+  end
+end

data/app/mailers/ocpp/rails/application_mailer.rb

@@ -0,0 +1,8 @@
+module Ocpp
+  module Rails
+    class ApplicationMailer < ActionMailer::Base
+      default from: "from@example.com"
+      layout "mailer"
+    end
+  end
+end

data/app/models/ocpp/rails/application_record.rb

@@ -0,0 +1,7 @@
+module Ocpp
+  module Rails
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/ocpp/rails/authorization.rb

@@ -0,0 +1,26 @@
+module Ocpp
+  module Rails
+    class Authorization < ApplicationRecord
+      self.table_name = "ocpp_authorizations"
+
+      belongs_to :charge_point, class_name: "Ocpp::Rails::ChargePoint"
+
+      validates :status, presence: true, inclusion: { in: [ "Accepted", "Blocked", "Expired", "Invalid", "ConcurrentTx" ] }
+      validates :id_tag, presence: true
+      validates :charge_point, presence: true
+
+      scope :accepted, -> { where(status: "Accepted") }
+      scope :rejected, -> { where.not(status: "Accepted") }
+      scope :for_id_tag, ->(tag) { where(id_tag: tag) }
+      scope :older_than, ->(days) { where("created_at < ?", days.days.ago) }
+
+      after_commit :trigger_async_hooks, on: :create
+
+      private
+
+      def trigger_async_hooks
+        Ocpp::Rails::AuthorizationHookManager.execute_async_hooks(self)
+      end
+    end
+  end
+end

data/app/models/ocpp/rails/charge_point.rb

@@ -0,0 +1,69 @@
+module Ocpp
+  module Rails
+    class ChargePoint < ApplicationRecord
+      self.table_name = "ocpp_charge_points"
+
+      has_many :charging_sessions, dependent: :destroy, class_name: "Ocpp::Rails::ChargingSession"
+      has_many :meter_values, dependent: :destroy, class_name: "Ocpp::Rails::MeterValue"
+      has_many :messages, dependent: :destroy, class_name: "Ocpp::Rails::Message"
+      has_many :state_changes, dependent: :destroy, class_name: "Ocpp::Rails::StateChange"
+      has_many :authorizations, dependent: :destroy, class_name: "Ocpp::Rails::Authorization"
+
+      validates :identifier, presence: true, uniqueness: true
+      validates :ocpp_protocol, inclusion: { in: Ocpp::Rails.supported_versions }
+
+      scope :connected, -> { where(connected: true) }
+      scope :available, -> { where(status: "Available") }
+      scope :charging, -> { where(status: "Charging") }
+
+      # Stores the station's Basic Auth password as a SHA-256 digest.
+      # OCPP-J passwords are high-entropy machine credentials (the spec
+      # mandates 16-40 random bytes), so a fast unsalted hash is appropriate,
+      # like for API tokens.
+      def auth_password=(password)
+        self.auth_password_digest = password.nil? ? nil : Digest::SHA256.hexdigest(password)
+      end
+
+      def authenticate_password?(password)
+        return false if auth_password_digest.blank? || password.blank?
+
+        ActiveSupport::SecurityUtils.fixed_length_secure_compare(
+          Digest::SHA256.hexdigest(password),
+          auth_password_digest
+        )
+      end
+
+      def heartbeat!
+        old_connected = connected
+        update(last_heartbeat_at: Time.current, connected: true)
+
+        # Log connection state change only if reconnecting (false -> true)
+        if old_connected == false
+          begin
+            state_changes.create!(
+              change_type: "connection",
+              connector_id: nil,
+              old_value: "false",
+              new_value: "true",
+              metadata: { source: "heartbeat" }
+            )
+          rescue => error
+            ::Rails.logger.error("Failed to log state change: #{error.message}")
+          end
+        end
+      end
+
+      def disconnect!
+        update(connected: false)
+      end
+
+      def current_session
+        charging_sessions.where(stopped_at: nil).order(started_at: :desc).first
+      end
+
+      def available?
+        status == "Available" && connected?
+      end
+    end
+  end
+end

data/app/models/ocpp/rails/charging_session.rb

@@ -0,0 +1,72 @@
+module Ocpp
+  module Rails
+    class ChargingSession < ApplicationRecord
+      self.table_name = "ocpp_charging_sessions"
+
+      belongs_to :charge_point, class_name: "Ocpp::Rails::ChargePoint"
+      has_many :meter_values, dependent: :destroy, class_name: "Ocpp::Rails::MeterValue"
+
+      validates :connector_id, presence: true
+      validates :transaction_id, uniqueness: true, allow_nil: true
+
+      scope :active, -> { where(stopped_at: nil) }
+      scope :completed, -> { where.not(stopped_at: nil) }
+
+      before_create :generate_transaction_id
+
+      def active?
+        stopped_at.nil?
+      end
+
+      def stop!(reason: "Local", meter_value: nil)
+        energy = calculate_energy_consumed(meter_value)
+        new_metadata = metadata || {}
+
+        if energy.nil?
+          ::Rails.logger.warn("[OCPP] Session #{transaction_id}: stop meter value below meterStart (rollover or meter swap?); flagging instead of recording negative energy")
+          new_metadata = new_metadata.merge("energy_anomaly" => "stop_below_start")
+        end
+
+        update(
+          stopped_at: Time.current,
+          stop_meter_value: meter_value,
+          stop_reason: reason,
+          duration_seconds: calculate_duration,
+          energy_consumed: energy,
+          status: "Completed",
+          metadata: new_metadata
+        )
+      end
+
+      def calculate_duration
+        return 0 unless started_at
+        ((stopped_at || Time.current) - started_at).to_i
+      end
+
+      # Returns nil (never a negative number) when the stop value is below
+      # meterStart, e.g. after a register rollover or meter swap.
+      def calculate_energy_consumed(stop_value = nil)
+        return 0 unless start_meter_value
+        stop_val = stop_value || stop_meter_value || start_meter_value
+        return nil if stop_val < start_meter_value
+        stop_val - start_meter_value
+      end
+
+      # OCPP 1.6 transactionId is a signed 32-bit integer
+      MAX_TRANSACTION_ID = (2**31) - 1
+
+      def self.generate_wire_transaction_id
+        loop do
+          candidate = SecureRandom.random_number(MAX_TRANSACTION_ID) + 1
+          break candidate unless exists?(transaction_id: candidate)
+        end
+      end
+
+      private
+
+      def generate_transaction_id
+        self.transaction_id ||= self.class.generate_wire_transaction_id
+      end
+    end
+  end
+end

data/app/models/ocpp/rails/message.rb

@@ -0,0 +1,17 @@
+module Ocpp
+  module Rails
+    class Message < ApplicationRecord
+      self.table_name = "ocpp_messages"
+
+      belongs_to :charge_point, class_name: "Ocpp::Rails::ChargePoint"
+
+      validates :message_id, presence: true
+      validates :direction, inclusion: { in: %w[inbound outbound] }
+      validates :message_type, inclusion: { in: %w[CALL CALLRESULT CALLERROR] }
+
+      scope :inbound, -> { where(direction: "inbound") }
+      scope :outbound, -> { where(direction: "outbound") }
+      scope :recent, -> { order(created_at: :desc) }
+    end
+  end
+end

data/app/models/ocpp/rails/meter_value.rb

@@ -0,0 +1,24 @@
+module Ocpp
+  module Rails
+    class MeterValue < ApplicationRecord
+      self.table_name = "ocpp_meter_values"
+
+      belongs_to :charging_session, optional: true, class_name: "Ocpp::Rails::ChargingSession"
+      belongs_to :charge_point, class_name: "Ocpp::Rails::ChargePoint"
+
+      validates :measurand, presence: true
+
+      scope :energy, -> { where(measurand: "Energy.Active.Import.Register") }
+      scope :power, -> { where(measurand: "Power.Active.Import") }
+      scope :current, -> { where(measurand: "Current.Import") }
+      scope :voltage, -> { where(measurand: "Voltage") }
+      scope :recent, -> { order(timestamp: :desc) }
+      scope :flagged, -> { where(flagged: true) }
+
+      def value_in_wh
+        return nil if value.nil?
+        unit == "kWh" ? value * 1000 : value
+      end
+    end
+  end
+end

data/app/models/ocpp/rails/state_change.rb

@@ -0,0 +1,26 @@
+module Ocpp
+  module Rails
+    class StateChange < ApplicationRecord
+      self.table_name = "ocpp_state_changes"
+
+      belongs_to :charge_point, class_name: "Ocpp::Rails::ChargePoint"
+
+      validates :change_type, presence: true, inclusion: { in: [ "status", "connection" ] }
+      validates :new_value, presence: true
+      validates :connector_id, numericality: { greater_than_or_equal_to: 0, only_integer: true }, allow_nil: true
+
+      scope :status_changes, -> { where(change_type: "status") }
+      scope :connection_changes, -> { where(change_type: "connection") }
+      scope :for_connector, ->(connector_id) { where(connector_id: connector_id) }
+      scope :older_than, ->(days) { where("created_at < ?", days.days.ago) }
+
+      after_commit :trigger_hooks, on: :create
+
+      private
+
+      def trigger_hooks
+        Ocpp::Rails::StateChangeHookManager.execute_hooks(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Ocpp
+  module Rails
+    module Actions
+      class AuthorizeHandler
+        def initialize(charge_point, message_id, payload)
+          @charge_point = charge_point
+          @message_id = message_id
+          @payload = payload
+        end
+
+        def call
+          id_tag = @payload["idTag"]
+
+          ::Rails.logger.info("[OCPP] Authorize request from #{@charge_point.identifier} for idTag: #{id_tag}")
+
+          # Execute authorization hooks to determine access decision
+          result = Ocpp::Rails::AuthorizationHookManager.execute_hooks(@charge_point.id, id_tag)
+
+          # Persist authorization record for audit trail
+          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}")
+            # Continue - authorization decision already made, persistence failure shouldn't block response
+          end
+
+          # Build OCPP response
+          id_tag_info = { "status" => result[:status] }
+
+          # Only include expiryDate if status is Accepted and expiry_date is present
+          if result[:status] == "Accepted" && result[:expiry_date].present?
+            id_tag_info["expiryDate"] = result[:expiry_date].iso8601
+          end
+
+          {
+            "idTagInfo" => id_tag_info
+          }
+        end
+      end
+    end
+  end
+end