feat: ocpp 2.1 (wip)

Author: xBlaz3kx

ocpp2.1/authorization/authorization.go

@@ -0,0 +1,24 @@
+// The authorization functional block contains OCPP 2.1 authorization-related features. It contains different ways of authorizing a user, online and/or offline .
+package authorization
+
+import "github.com/lorenzodonini/ocpp-go/ocpp"
+
+// Needs to be implemented by a CSMS for handling messages part of the OCPP 2.1 Authorization profile.
+type CSMSHandler interface {
+	// OnAuthorize is called on the CSMS whenever an AuthorizeRequest is received from a charging station.
+	OnAuthorize(chargingStationID string, request *AuthorizeRequest) (confirmation *AuthorizeResponse, err error)
+}
+
+// Needs to be implemented by Charging stations for handling messages part of the OCPP 2.1 Authorization profile.
+type ChargingStationHandler interface {
+	// OnClearCache is called on a charging station whenever a ClearCacheRequest is received from the CSMS.
+	OnClearCache(request *ClearCacheRequest) (confirmation *ClearCacheResponse, err error)
+}
+
+const ProfileName = "authorization"
+
+var Profile = ocpp.NewProfile(
+	ProfileName,
+	AuthorizeFeature{},
+	ClearCacheFeature{},
+)

ocpp2.1/authorization/authorize.go

@@ -0,0 +1,94 @@
+package authorization
+
+import (
+	"reflect"
+
+	"gopkg.in/go-playground/validator.v9"
+
+	"github.com/lorenzodonini/ocpp-go/ocpp2.1/types"
+)
+
+// -------------------- Authorize (CS -> CSMS) --------------------
+
+const AuthorizeFeatureName = "Authorize"
+
+// The Certificate status information.
+type AuthorizeCertificateStatus string
+
+const (
+	CertificateStatusAccepted               AuthorizeCertificateStatus = "Accepted"
+	CertificateStatusSignatureError         AuthorizeCertificateStatus = "SignatureError"
+	CertificateStatusCertificateExpired     AuthorizeCertificateStatus = "CertificateExpired"
+	CertificateStatusCertificateRevoked     AuthorizeCertificateStatus = "CertificateRevoked"
+	CertificateStatusNoCertificateAvailable AuthorizeCertificateStatus = "NoCertificateAvailable"
+	CertificateStatusCertChainError         AuthorizeCertificateStatus = "CertChainError"
+	CertificateStatusContractCancelled      AuthorizeCertificateStatus = "ContractCancelled"
+)
+
+func isValidAuthorizeCertificateStatus(fl validator.FieldLevel) bool {
+	status := AuthorizeCertificateStatus(fl.Field().String())
+	switch status {
+	case CertificateStatusAccepted, CertificateStatusCertChainError, CertificateStatusCertificateExpired, CertificateStatusSignatureError, CertificateStatusNoCertificateAvailable, CertificateStatusCertificateRevoked, CertificateStatusContractCancelled:
+		return true
+	default:
+		return false
+	}
+}
+
+// The field definition of the Authorize request payload sent by the Charging Station to the CSMS.
+type AuthorizeRequest struct {
+	Certificate         string                      `json:"certificate,omitempty" validate:"max=5500"`
+	IdToken             types.IdToken               `json:"idToken" validate:"required"`
+	CertificateHashData []types.OCSPRequestDataType `json:"iso15118CertificateHashData,omitempty" validate:"max=4,dive"`
+}
+
+// This field definition of the Authorize response payload, sent by the Charging Station to the CSMS in response to an AuthorizeRequest.
+// In case the request was invalid, or couldn't be processed, an error will be sent instead.
+type AuthorizeResponse struct {
+	CertificateStatus AuthorizeCertificateStatus `json:"certificateStatus,omitempty" validate:"omitempty,authorizeCertificateStatus21"`
+	IdTokenInfo       types.IdTokenInfo          `json:"idTokenInfo" validate:"required"`
+}
+
+// Before the owner of an electric vehicle can start or stop charging, the Charging Station has to authorize the operation.
+// Upon receipt of an AuthorizeRequest, the CSMS SHALL respond with an AuthorizeResponse.
+// This response payload SHALL indicate whether or not the idTag is accepted by the CSMS.
+// If the CSMS accepts the idToken then the response payload MUST include an authorization status value indicating acceptance or a reason for rejection.
+//
+// A Charging Station MAY authorize identifier locally without involving the CSMS, as described in Local Authorization List.
+//
+// The Charging Station SHALL only supply energy after authorization.
+type AuthorizeFeature struct{}
+
+func (f AuthorizeFeature) GetFeatureName() string {
+	return AuthorizeFeatureName
+}
+
+func (f AuthorizeFeature) GetRequestType() reflect.Type {
+	return reflect.TypeOf(AuthorizeRequest{})
+}
+
+func (f AuthorizeFeature) GetResponseType() reflect.Type {
+	return reflect.TypeOf(AuthorizeResponse{})
+}
+
+func (r AuthorizeRequest) GetFeatureName() string {
+	return AuthorizeFeatureName
+}
+
+func (c AuthorizeResponse) GetFeatureName() string {
+	return AuthorizeFeatureName
+}
+
+// Creates a new AuthorizeRequest, containing all required fields. There are no optional fields for this message.
+func NewAuthorizationRequest(idToken string, tokenType types.IdTokenType) *AuthorizeRequest {
+	return &AuthorizeRequest{IdToken: types.IdToken{IdToken: idToken, Type: tokenType}}
+}
+
+// Creates a new AuthorizeResponse. There are no optional fields for this message.
+func NewAuthorizationResponse(idTokenInfo types.IdTokenInfo) *AuthorizeResponse {
+	return &AuthorizeResponse{IdTokenInfo: idTokenInfo}
+}
+
+func init() {
+	_ = types.Validate.RegisterValidation("authorizeCertificateStatus21", isValidAuthorizeCertificateStatus)
+}

ocpp2.1/authorization/clear_cache.go

@@ -0,0 +1,82 @@
+package authorization
+
+import (
+	"reflect"
+
+	"gopkg.in/go-playground/validator.v9"
+
+	"github.com/lorenzodonini/ocpp-go/ocpp2.1/types"
+)
+
+// -------------------- Clear Cache (CSMS -> CS) --------------------
+
+const ClearCacheFeatureName = "ClearCache"
+
+// Status returned in response to ClearCacheRequest.
+type ClearCacheStatus string
+
+const (
+	ClearCacheStatusAccepted ClearCacheStatus = "Accepted"
+	ClearCacheStatusRejected ClearCacheStatus = "Rejected"
+)
+
+func isValidClearCacheStatus(fl validator.FieldLevel) bool {
+	status := ClearCacheStatus(fl.Field().String())
+	switch status {
+	case ClearCacheStatusAccepted, ClearCacheStatusRejected:
+		return true
+	default:
+		return false
+	}
+}
+
+// The field definition of the ClearCache request payload sent by the CSMS to the Charging Station.
+type ClearCacheRequest struct {
+}
+
+// This field definition of the ClearCache response payload, sent by the Charging Station to the CSMS in response to a ClearCacheRequest.
+// In case the request was invalid, or couldn't be processed, an error will be sent instead.
+type ClearCacheResponse struct {
+	Status     ClearCacheStatus  `json:"status" validate:"required,cacheStatus21"`
+	StatusInfo *types.StatusInfo `json:"statusInfo,omitempty" validate:"omitempty"`
+}
+
+// CSMS can request a Charging Station to clear its Authorization Cache.
+// The CSMS SHALL send a ClearCacheRequest payload for clearing the Charging Station’s Authorization Cache.
+// Upon receipt of a ClearCacheRequest, the Charging Station SHALL respond with a ClearCacheResponse payload.
+// The response payload SHALL indicate whether the Charging Station was able to clear its Authorization Cache.
+type ClearCacheFeature struct{}
+
+func (f ClearCacheFeature) GetFeatureName() string {
+	return ClearCacheFeatureName
+}
+
+func (f ClearCacheFeature) GetRequestType() reflect.Type {
+	return reflect.TypeOf(ClearCacheRequest{})
+}
+
+func (f ClearCacheFeature) GetResponseType() reflect.Type {
+	return reflect.TypeOf(ClearCacheResponse{})
+}
+
+func (r ClearCacheRequest) GetFeatureName() string {
+	return ClearCacheFeatureName
+}
+
+func (c ClearCacheResponse) GetFeatureName() string {
+	return ClearCacheFeatureName
+}
+
+// Creates a new ClearCacheRequest, which doesn't contain any required or optional fields.
+func NewClearCacheRequest() *ClearCacheRequest {
+	return &ClearCacheRequest{}
+}
+
+// Creates a new ClearCacheResponse, containing all required fields. There are no optional fields for this message.
+func NewClearCacheResponse(status ClearCacheStatus) *ClearCacheResponse {
+	return &ClearCacheResponse{Status: status}
+}
+
+func init() {
+	_ = types.Validate.RegisterValidation("cacheStatus21", isValidClearCacheStatus)
+}

ocpp2.1/availability/availability.go

@@ -0,0 +1,28 @@
+// The availability functional block contains OCPP 2.0 features for notifying the CSMS of availability and status changes.
+// A CSMS can also instruct a charging station to change its availability.
+package availability
+
+import "github.com/lorenzodonini/ocpp-go/ocpp"
+
+// Needs to be implemented by a CSMS for handling messages part of the OCPP 2.0 Availability profile.
+type CSMSHandler interface {
+	// OnHeartbeat is called on the CSMS whenever a HeartbeatResponse is received from a charging station.
+	OnHeartbeat(chargingStationID string, request *HeartbeatRequest) (response *HeartbeatResponse, err error)
+	// OnStatusNotification is called on the CSMS whenever a StatusNotificationRequest is received from a charging station.
+	OnStatusNotification(chargingStationID string, request *StatusNotificationRequest) (response *StatusNotificationResponse, err error)
+}
+
+// Needs to be implemented by Charging stations for handling messages part of the OCPP 2.0 Availability profile.
+type ChargingStationHandler interface {
+	// OnChangeAvailability is called on a charging station whenever a ChangeAvailabilityRequest is received from the CSMS.
+	OnChangeAvailability(request *ChangeAvailabilityRequest) (response *ChangeAvailabilityResponse, err error)
+}
+
+const ProfileName = "availability"
+
+var Profile = ocpp.NewProfile(
+	ProfileName,
+	ChangeAvailabilityFeature{},
+	HeartbeatFeature{},
+	StatusNotificationFeature{},
+)

ocpp2.1/availability/change_availability.go

@@ -0,0 +1,105 @@
+package availability
+
+import (
+	"reflect"
+
+	"gopkg.in/go-playground/validator.v9"
+
+	"github.com/lorenzodonini/ocpp-go/ocpp2.1/types"
+)
+
+// -------------------- Change Availability (CSMS -> CS) --------------------
+
+const ChangeAvailabilityFeatureName = "ChangeAvailability"
+
+// Requested availability change in ChangeAvailabilityRequest.
+type OperationalStatus string
+
+const (
+	OperationalStatusInoperative OperationalStatus = "Inoperative"
+	OperationalStatusOperative   OperationalStatus = "Operative"
+)
+
+func isValidOperationalStatus(fl validator.FieldLevel) bool {
+	status := OperationalStatus(fl.Field().String())
+	switch status {
+	case OperationalStatusInoperative, OperationalStatusOperative:
+		return true
+	default:
+		return false
+	}
+}
+
+// Status returned in response to ChangeAvailabilityRequest
+type ChangeAvailabilityStatus string
+
+const (
+	ChangeAvailabilityStatusAccepted  ChangeAvailabilityStatus = "Accepted"
+	ChangeAvailabilityStatusRejected  ChangeAvailabilityStatus = "Rejected"
+	ChangeAvailabilityStatusScheduled ChangeAvailabilityStatus = "Scheduled"
+)
+
+func isValidChangeAvailabilityStatus(fl validator.FieldLevel) bool {
+	status := ChangeAvailabilityStatus(fl.Field().String())
+	switch status {
+	case ChangeAvailabilityStatusAccepted, ChangeAvailabilityStatusRejected, ChangeAvailabilityStatusScheduled:
+		return true
+	default:
+		return false
+	}
+}
+
+// The field definition of the ChangeAvailability request payload sent by the CSMS to the Charging Station.
+type ChangeAvailabilityRequest struct {
+	OperationalStatus OperationalStatus `json:"operationalStatus" validate:"required,operationalStatus"`
+	Evse              *types.EVSE       `json:"evse,omitempty" validate:"omitempty"`
+}
+
+// This field definition of the ChangeAvailability response payload, sent by the Charging Station to the CSMS in response to a ChangeAvailabilityRequest.
+// In case the request was invalid, or couldn't be processed, an error will be sent instead.
+type ChangeAvailabilityResponse struct {
+	Status     ChangeAvailabilityStatus `json:"status" validate:"required,changeAvailabilityStatus"`
+	StatusInfo *types.StatusInfo        `json:"statusInfo,omitempty" validate:"omitempty"`
+}
+
+// CSMS can request a Charging Station to change its availability.
+// A Charging Station is considered available (“operative”) when it is charging or ready for charging.
+// A Charging Station is considered unavailable when it does not allow any charging.
+// The CSMS SHALL send a ChangeAvailabilityRequest for requesting a Charging Station to change its availability.
+// The CSMS can change the availability to available or unavailable.
+type ChangeAvailabilityFeature struct{}
+
+func (f ChangeAvailabilityFeature) GetFeatureName() string {
+	return ChangeAvailabilityFeatureName
+}
+
+func (f ChangeAvailabilityFeature) GetRequestType() reflect.Type {
+	return reflect.TypeOf(ChangeAvailabilityRequest{})
+}
+
+func (f ChangeAvailabilityFeature) GetResponseType() reflect.Type {
+	return reflect.TypeOf(ChangeAvailabilityResponse{})
+}
+
+func (r ChangeAvailabilityRequest) GetFeatureName() string {
+	return ChangeAvailabilityFeatureName
+}
+
+func (c ChangeAvailabilityResponse) GetFeatureName() string {
+	return ChangeAvailabilityFeatureName
+}
+
+// Creates a new ChangeAvailabilityRequest, containing all required fields. Optional fields may be set afterwards.
+func NewChangeAvailabilityRequest(operationalStatus OperationalStatus) *ChangeAvailabilityRequest {
+	return &ChangeAvailabilityRequest{OperationalStatus: operationalStatus}
+}
+
+// Creates a new ChangeAvailabilityResponse, containing all required fields. Optional fields may be set afterwards.
+func NewChangeAvailabilityResponse(status ChangeAvailabilityStatus) *ChangeAvailabilityResponse {
+	return &ChangeAvailabilityResponse{Status: status}
+}
+
+func init() {
+	_ = types.Validate.RegisterValidation("operationalStatus", isValidOperationalStatus)
+	_ = types.Validate.RegisterValidation("changeAvailabilityStatus", isValidChangeAvailabilityStatus)
+}