Refactor

- Introduce use case specific interface
- Introduce generic event mechanism
- Start implementation of EVSECC and EVCC Use Cases

Author: DerAndereAndi

.github/workflows/default.yml

@@ -33,7 +33,10 @@ jobs:
           skip-build-cache: true
 
       - name: Test
-        run: go test -race -v -coverprofile=coverage.out  -covermode=atomic ./...
+        run: go test -race -v -coverprofile=coverage_temp.out  -covermode=atomic ./...
+
+      - name: Remove mocks and cmd from coverage
+        run: grep -v -e "/cemd/mocks/" -e "/cemd/cmd/" coverage_temp.out > coverage.out
 
       - name: Send coverage
         uses: coverallsapp/github-action@v2

.mockery.yaml

@@ -0,0 +1,10 @@
+with-expecter: true
+inpackage: false
+dir: "{{ .InterfaceDir }}/mocks/"
+mockname: "{{.InterfaceName}}"
+outpkg: "mocks"
+filename: "{{.InterfaceName}}.go"
+all: true
+packages:
+  github.com/enbility/cemd/api:
+  github.com/enbility/cemd/evsecc:

api/api.go

@@ -1,9 +1,60 @@
 package api
 
 import (
+	"errors"
+
 	shipapi "github.com/enbility/ship-go/api"
+	spineapi "github.com/enbility/spine-go/api"
+	"github.com/enbility/spine-go/model"
 )
 
+//go:generate mockery
+
+// Implemented by CEM
+type CemInterface interface {
+	// Setup the EEBUS service
+	Setup() error
+
+	// Start the EEBUS service
+	Start()
+
+	// Shutdown the EEBUS service
+	Shutdown()
+
+	// Add a use case implementation
+	AddUseCase(usecase UseCaseInterface)
+}
+
+// Implemented by each UseCase
+type UseCaseInterface interface {
+	// provide the usecase name
+	UseCaseName() model.UseCaseNameType
+
+	// add the features
+	AddFeatures()
+
+	// add the usecase
+	AddUseCase()
+}
+
+// interface for informing the cem about specific events
+// for each supported usecase
+//
+// UseCaseEventType values can be found in the api definition of each
+// supported usecase
+//
+// implemented by the actual CEM, used by UCEvseCCInterface implementation
+type UseCaseEventReaderInterface interface {
+	// Inform about a new usecase specific event
+	SpineEvent(ski string, entity spineapi.EntityRemoteInterface, event UseCaseEventType)
+}
+
+// type for usecase specfic event names
+type UseCaseEventType string
+
+var ErrNoEvseEntity = errors.New("entity is not an EVSE")
+var ErrNoEvEntity = errors.New("entity is not an EV")
+
 // Implemented by *Solutions, used by Cem
 type SolutionInterface interface {
 	RegisterRemoteDevice(details *shipapi.ServiceDetails, dataProvider any) any

cem/cem.go

@@ -1,21 +1,24 @@
 package cem
 
 import (
-	"github.com/enbility/eebus-go/api"
+	"github.com/enbility/cemd/api"
+	eebusapi "github.com/enbility/eebus-go/api"
 	"github.com/enbility/eebus-go/service"
 	"github.com/enbility/ship-go/logging"
 	"github.com/enbility/spine-go/model"
 )
 
 // Generic CEM implementation
-type CemImpl struct {
-	Service api.ServiceInterface
+type Cem struct {
+	Service eebusapi.ServiceInterface
 
 	Currency model.CurrencyType
+
+	usecases []api.UseCaseInterface
 }
 
-func NewCEM(serviceDescription *api.Configuration, serviceHandler api.ServiceReaderInterface, log logging.LoggingInterface) *CemImpl {
-	cem := &CemImpl{
+func NewCEM(serviceDescription *eebusapi.Configuration, serviceHandler eebusapi.ServiceReaderInterface, log logging.LoggingInterface) *Cem {
+	cem := &Cem{
 		Service:  service.NewService(serviceDescription, serviceHandler),
 		Currency: model.CurrencyTypeEur,
 	}
@@ -25,19 +28,27 @@ func NewCEM(serviceDescription *api.Configuration, serviceHandler api.ServiceRea
 	return cem
 }
 
-// Set up the supported usecases and features
-func (h *CemImpl) Setup() error {
-	if err := h.Service.Setup(); err != nil {
-		return err
-	}
+var _ api.CemInterface = (*Cem)(nil)
 
-	return nil
+// Set up the eebus service
+func (h *Cem) Setup() error {
+	return h.Service.Setup()
 }
 
-func (h *CemImpl) Start() {
+// Start the EEBUS service
+func (h *Cem) Start() {
 	h.Service.Start()
 }
 
-func (h *CemImpl) Shutdown() {
+// Shutdown the EEBUS servic
+func (h *Cem) Shutdown() {
 	h.Service.Shutdown()
 }
+
+// Add a use case implementation
+func (h *Cem) AddUseCase(usecase api.UseCaseInterface) {
+	h.usecases = append(h.usecases, usecase)
+
+	usecase.AddFeatures()
+	usecase.AddUseCase()
+}

cmd/democem/democem.go

@@ -0,0 +1,32 @@
+package democem
+
+import (
+	"github.com/enbility/cemd/cem"
+	"github.com/enbility/cemd/ucevsecc"
+	eebusapi "github.com/enbility/eebus-go/api"
+)
+
+type DemoCem struct {
+	cem *cem.Cem
+}
+
+func NewDemoCem(configuration *eebusapi.Configuration) *DemoCem {
+	demo := &DemoCem{}
+
+	demo.cem = cem.NewCEM(configuration, demo, demo)
+
+	return demo
+}
+
+func (d *DemoCem) Setup() error {
+	if err := d.cem.Setup(); err != nil {
+		return err
+	}
+
+	evsecc := ucevsecc.NewUCEvseCC(d.cem.Service, d.cem.Service.LocalService(), d)
+	d.cem.AddUseCase(evsecc)
+
+	d.cem.Start()
+
+	return nil
+}

cmd/democem/evsecc.go

@@ -0,0 +1,12 @@
+package democem
+
+import (
+	"github.com/enbility/cemd/api"
+	spineapi "github.com/enbility/spine-go/api"
+)
+
+var _ api.UseCaseEventReaderInterface = (*DemoCem)(nil)
+
+// Handle incomfing usecase specific event
+func (h *DemoCem) SpineEvent(ski string, entity spineapi.EntityRemoteInterface, event api.UseCaseEventType) {
+}

cmd/democem/logging.go

@@ -0,0 +1,50 @@
+package democem
+
+import (
+	"fmt"
+	"time"
+)
+
+// Logging interface
+
+func (d *DemoCem) log(level string, args ...interface{}) {
+	t := time.Now()
+	fmt.Printf("%s: %s %s", t.Format(time.RFC3339), level, fmt.Sprintln(args...))
+}
+
+func (d *DemoCem) logf(level, format string, args ...interface{}) {
+	t := time.Now()
+	fmt.Printf("%s: %s %s\n", t.Format(time.RFC3339), level, fmt.Sprintf(format, args...))
+}
+
+func (d *DemoCem) Trace(args ...interface{}) {
+	d.log("TRACE", args...)
+}
+
+func (d *DemoCem) Tracef(format string, args ...interface{}) {
+	d.logf("TRACE", format, args...)
+}
+
+func (d *DemoCem) Debug(args ...interface{}) {
+	d.log("DEBUG", args...)
+}
+
+func (d *DemoCem) Debugf(format string, args ...interface{}) {
+	d.logf("DEBUG", format, args...)
+}
+
+func (d *DemoCem) Info(args ...interface{}) {
+	d.log("INFO", args...)
+}
+
+func (d *DemoCem) Infof(format string, args ...interface{}) {
+	d.logf("INFO", format, args...)
+}
+
+func (d *DemoCem) Error(args ...interface{}) {
+	d.log("ERROR", args...)
+}
+
+func (d *DemoCem) Errorf(format string, args ...interface{}) {
+	d.logf("ERROR", format, args...)
+}

cmd/democem/service.go

@@ -0,0 +1,27 @@
+package democem
+
+import (
+	eebusapi "github.com/enbility/eebus-go/api"
+	shipapi "github.com/enbility/ship-go/api"
+	"github.com/enbility/ship-go/logging"
+)
+
+// report the Ship ID of a newly trusted connection
+func (d *DemoCem) RemoteServiceShipIDReported(service eebusapi.ServiceInterface, ski string, shipID string) {
+	// we should associated the Ship ID with the SKI and store it
+	// so the next connection can start trusted
+	logging.Log().Info("SKI", ski, "has Ship ID:", shipID)
+}
+
+func (d *DemoCem) RemoteSKIConnected(service eebusapi.ServiceInterface, ski string) {}
+
+func (d *DemoCem) RemoteSKIDisconnected(service eebusapi.ServiceInterface, ski string) {}
+
+func (d *DemoCem) VisibleRemoteServicesUpdated(service eebusapi.ServiceInterface, entries []shipapi.RemoteService) {
+}
+
+func (h *DemoCem) ServiceShipIDUpdate(ski string, shipdID string) {}
+
+func (h *DemoCem) ServicePairingDetailUpdate(ski string, detail *shipapi.ConnectionStateDetail) {}
+
+func (h *DemoCem) AllowWaitingForTrust(ski string) bool { return true }