Planner: drop deprecated publishing keys #2 (BC)

api/plans.go

@@ -1,6 +1,9 @@
 package api
 
-import "time"
+import (
+	"encoding/json"
+	"time"
+)
 
 type RepeatingPlan struct {
 	Weekdays     []int  `json:"weekdays"`     // 0-6 (Sunday-Saturday)
@@ -15,3 +18,29 @@ type PlanStrategy struct {
 	Continuous   bool          `json:"continuous"`   // force continuous planning
 	Precondition time.Duration `json:"precondition"` // precondition duration in seconds
 }
+
+type planStrategy struct {
+	Continuous   bool  `json:"continuous"`   // force continuous planning
+	Precondition int64 `json:"precondition"` // precondition duration in seconds
+}
+
+func (ps PlanStrategy) MarshalJSON() ([]byte, error) {
+	return json.Marshal(planStrategy{
+		Continuous:   ps.Continuous,
+		Precondition: int64(ps.Precondition.Seconds()),
+	})
+}
+
+func (ps *PlanStrategy) UnmarshalJSON(data []byte) error {
+	var res planStrategy
+	if err := json.Unmarshal(data, &res); err != nil {
+		return err
+	}
+
+	*ps = PlanStrategy{
+		Continuous:   res.Continuous,
+		Precondition: time.Duration(res.Precondition) * time.Second,
+	}
+
+	return nil
+}

assets/js/components/ChargingPlans/ChargingPlan.vue

@@ -121,8 +121,7 @@ export default defineComponent({
 		effectiveLimitSoc: Number,
 		effectivePlanSoc: Number,
 		effectivePlanTime: String,
-		effectivePlanPrecondition: Number,
-		effectivePlanContinuous: Boolean,
+		effectivePlanStrategy: Object as PropType<PlanStrategy>,
 		id: [String, Number],
 		limitEnergy: Number,
 		mode: String,

assets/js/components/ChargingPlans/PlansSettings.vue

@@ -107,8 +107,7 @@ export default defineComponent({
 		effectiveLimitSoc: Number,
 		effectivePlanTime: String,
 		effectivePlanSoc: Number,
-		effectivePlanPrecondition: Number,
-		effectivePlanContinuous: Boolean,
+		effectivePlanStrategy: Object as PropType<PlanStrategy>,
 		planEnergy: Number,
 		limitEnergy: Number,
 		socBasedPlanning: Boolean,
@@ -162,8 +161,8 @@ export default defineComponent({
 		chargingPlanStrategyProps(): any {
 			return {
 				id: this.id,
-				precondition: this.effectivePlanPrecondition,
-				continuous: this.effectivePlanContinuous,
+				precondition: this.effectivePlanStrategy?.precondition,
+				continuous: this.effectivePlanStrategy?.continuous,
 			};
 		},
 		alreadyReached(): boolean {
@@ -186,11 +185,11 @@ export default defineComponent({
 				this.updatePlanDebounced();
 			}
 		},
-		effectivePlanPrecondition() {
-			this.updatePlanDebounced();
-		},
-		effectivePlanContinuous() {
-			this.updatePlanDebounced();
+		effectivePlanStrategy: {
+			deep: true,
+			handler() {
+				this.updatePlanDebounced();
+			},
 		},
 		staticPlan: {
 			deep: true,

assets/js/components/ChargingPlans/types.d.ts

@@ -26,11 +26,13 @@ export type StaticPlan = StaticSocPlan | StaticEnergyPlan;
 export interface StaticSocPlan {
   soc: number;
   time: Date;
+  planStrategy?: PlanStrategy;
 }
 
 export interface StaticEnergyPlan {
   energy: number;
   time: Date;
+  planStrategy?: PlanStrategy;
 }
 
 export interface PlanStrategy {

assets/js/components/Loadpoints/Loadpoint.stories.ts

@@ -51,8 +51,7 @@ const baseState = {
   planActive: false,
   planEnergy: 0,
   planOverrun: 0,
-  planPrecondition: 0,
-  planContinuous: false,
+  planStrategy: { continuous: false, precondition: 0 },
   planProjectedEnd: undefined,
   planProjectedStart: undefined,
   planTime: undefined,
@@ -83,8 +82,6 @@ const baseState = {
       capacity: 8,
       features: ["Offline"],
       repeatingPlans: [],
-      planPrecondition: 0,
-      planContinuous: false,
     },
     {
       name: "vehicle_4",
@@ -93,8 +90,6 @@ const baseState = {
       capacity: 80,
       features: ["Offline"],
       repeatingPlans: [],
-      planPrecondition: 0,
-      planContinuous: false,
     },
   ],
   smartCostType: SMART_COST_TYPE.PRICE_FORECAST,

assets/js/components/Loadpoints/Loadpoint.vue

@@ -127,6 +127,7 @@ import type {
 	Forecast,
 	SMART_COST_TYPE,
 } from "@/types/evcc";
+import type { PlanStrategy } from "@/components/ChargingPlans/types";
 
 export default defineComponent({
 	name: "Loadpoint",
@@ -189,8 +190,7 @@ export default defineComponent({
 		planTime: String as PropType<string | null>,
 		effectivePlanTime: String as PropType<string | null>,
 		effectivePlanSoc: Number,
-		effectivePlanPrecondition: Number,
-		effectivePlanContinuous: Boolean,
+		effectivePlanStrategy: Object as PropType<PlanStrategy>,
 		vehicleProviderLoggedIn: Boolean,
 		vehicleProviderLoginPath: String,
 		vehicleProviderLogoutPath: String,

assets/js/components/Loadpoints/Loadpoints.stories.ts

@@ -48,8 +48,6 @@ const baseArgs = {
       capacity: 8,
       features: ["Offline"],
       repeatingPlans: [],
-      planPrecondition: 0,
-      planContinuous: false,
     },
     {
       name: "vehicle_4",
@@ -58,8 +56,6 @@ const baseArgs = {
       capacity: 80,
       features: ["Offline"],
       repeatingPlans: [],
-      planPrecondition: 0,
-      planContinuous: false,
     },
     {
       name: "vehicle_5",
@@ -68,8 +64,6 @@ const baseArgs = {
       capacity: 0.46,
       features: ["Offline"],
       repeatingPlans: [],
-      planPrecondition: 0,
-      planContinuous: false,
     },
   ],
   smartCostType: SMART_COST_TYPE.PRICE_FORECAST,

assets/js/components/Vehicles/Vehicle.stories.ts

@@ -10,8 +10,6 @@ const baseState = {
     features: [],
     name: "",
     repeatingPlans: [],
-    planPrecondition: 0,
-    planContinuous: false,
   },
   enabled: false,
   connected: true,

assets/js/components/Vehicles/Vehicle.vue

@@ -80,6 +80,7 @@ import LimitEnergySelect from "./LimitEnergySelect.vue";
 import { distanceUnit, distanceValue } from "@/units.ts";
 import { defineComponent, type PropType } from "vue";
 import { CHARGE_MODE, type Forecast, type Vehicle } from "@/types/evcc";
+import type { PlanStrategy } from "@/components/ChargingPlans/types";
 
 export default defineComponent({
 	name: "Vehicle",
@@ -103,8 +104,7 @@ export default defineComponent({
 		effectiveLimitSoc: Number,
 		effectivePlanSoc: Number,
 		effectivePlanTime: String,
-		effectivePlanPrecondition: Number,
-		effectivePlanContinuous: Boolean,
+		effectivePlanStrategy: Object as PropType<PlanStrategy>,
 		batteryBoostActive: Boolean,
 		enabled: Boolean,
 		heating: Boolean,

assets/js/types/evcc.ts

@@ -1,4 +1,4 @@
-import type { StaticPlan, RepeatingPlan } from "../components/ChargingPlans/types";
+import type { StaticPlan, RepeatingPlan, PlanStrategy } from "../components/ChargingPlans/types";
 import type { ForecastSlot, SolarDetails } from "../components/Forecast/types";
 
 // react-native-webview
@@ -191,7 +191,7 @@ export interface ConfigLoadpoint {
   smartCostLimit: number | null;
   planEnergy?: number;
   planTime?: string;
-  planPrecondition?: number;
+  planStrategy?: PlanStrategy;
   limitEnergy?: number;
   limitSoc?: number;
   circuit?: string;
@@ -246,8 +246,7 @@ export interface Loadpoint {
   effectivePlanId: number;
   effectivePlanSoc: number;
   effectivePlanTime: string | null;
-  effectivePlanPrecondition: number;
-  effectivePlanContinuous: boolean;
+  effectivePlanStrategy: PlanStrategy;
   effectivePriority: number;
   enableDelay: number;
   enableThreshold: number;
@@ -265,8 +264,7 @@ export interface Loadpoint {
   planActive: boolean;
   planEnergy: number;
   planOverrun: number;
-  planPrecondition: number;
-  planContinuous: boolean;
+  planStrategy: PlanStrategy;
   planProjectedEnd: string | null;
   planProjectedStart: string | null;
   planTime: string | null;
@@ -481,8 +479,6 @@ export interface Vehicle {
   limitSoc?: number;
   plan?: StaticPlan;
   repeatingPlans: RepeatingPlan[] | null;
-  planPrecondition: number;
-  planContinuous: boolean;
   title: string;
   features?: string[];
   capacity?: number;

core/keys/loadpoint.go

@@ -58,10 +58,8 @@ const (
 	EffectiveMinCurrent = "effectiveMinCurrent" // effective min current
 	EffectiveMaxCurrent = "effectiveMaxCurrent" // effective max current
 
-	EffectiveLimitSoc         = "effectiveLimitSoc"         // effective limit soc
-	EffectivePlanStrategy     = "effectivePlanStrategy"     // effective plan strategy (deprecated, use individual fields)
-	EffectivePlanPrecondition = "effectivePlanPrecondition" // effective plan precondition duration
-	EffectivePlanContinuous   = "effectivePlanContinuous"   // effective plan continuous planning
+	EffectiveLimitSoc     = "effectiveLimitSoc"     // effective limit soc
+	EffectivePlanStrategy = "effectivePlanStrategy" // effective plan strategy
 
 	// measurements
 	ChargePower       = "chargePower"       // charge power
@@ -86,8 +84,6 @@ const (
 	PlanProjectedEnd   = "planProjectedEnd"   // charge plan ends (end of last slot)
 	PlanOverrun        = "planOverrun"        // charge plan goal not reachable in time
 	PlanStrategy       = "planStrategy"       // charge plan strategy (precondition, continuous)
-	PlanPrecondition   = "planPrecondition"   // charge plan precondition duration
-	PlanContinuous     = "planContinuous"     // charge plan continuous planning
 
 	// repeating plans
 	RepeatingPlans = "repeatingPlans" // key to access all repeating plans in db

core/loadpoint.go

@@ -691,8 +691,7 @@ func (lp *Loadpoint) Prepare(site site.API, uiChan chan<- util.Param, pushChan c
 	// restored settings
 	lp.publish(keys.PlanTime, lp.planTime)
 	lp.publish(keys.PlanEnergy, lp.planEnergy)
-	lp.publish(keys.PlanPrecondition, int64(lp.planStrategy.Precondition.Seconds()))
-	lp.publish(keys.PlanContinuous, lp.planStrategy.Continuous)
+	lp.publish(keys.PlanStrategy, lp.planStrategy)
 	lp.publish(keys.LimitSoc, lp.limitSoc)
 	lp.publish(keys.LimitEnergy, lp.limitEnergy)
 

core/loadpoint_api.go

@@ -402,8 +402,7 @@ func (lp *Loadpoint) setPlanStrategy(strategy api.PlanStrategy) error {
 	}
 
 	lp.planStrategy = strategy
-	lp.publish(keys.PlanPrecondition, int64(strategy.Precondition.Seconds()))
-	lp.publish(keys.PlanContinuous, strategy.Continuous)
+	lp.publish(keys.PlanStrategy, strategy)
 
 	lp.requestUpdate()
 

core/loadpoint_effective.go

@@ -12,16 +12,14 @@ import (
 
 // PublishEffectiveValues publishes all effective values
 func (lp *Loadpoint) PublishEffectiveValues() {
-	strategy := lp.EffectivePlanStrategy()
 	lp.publish(keys.EffectivePriority, lp.EffectivePriority())
 	lp.publish(keys.EffectivePlanId, lp.EffectivePlanId())
 	lp.publish(keys.EffectivePlanTime, lp.EffectivePlanTime())
 	lp.publish(keys.EffectivePlanSoc, lp.EffectivePlanSoc())
+	lp.publish(keys.EffectivePlanStrategy, lp.EffectivePlanStrategy())
 	lp.publish(keys.EffectiveMinCurrent, lp.effectiveMinCurrent())
 	lp.publish(keys.EffectiveMaxCurrent, lp.effectiveMaxCurrent())
 	lp.publish(keys.EffectiveLimitSoc, lp.EffectiveLimitSoc())
-	lp.publish(keys.EffectivePlanPrecondition, int64(strategy.Precondition.Seconds()))
-	lp.publish(keys.EffectivePlanContinuous, strategy.Continuous)
 }
 
 // EffectivePriority returns the effective priority

core/site_vehicles.go

@@ -13,27 +13,24 @@ import (
 )
 
 type planStruct struct {
-	Soc          int       `json:"soc"`
-	Continuous   bool      `json:"continuous"`
-	Precondition int64     `json:"precondition"`
-	Time         time.Time `json:"time"`
+	Soc          int              `json:"soc"`
+	Time         time.Time        `json:"time"`
+	PlanStrategy api.PlanStrategy `json:"planStrategy"`
 }
 
 type vehicleStruct struct {
-	Title            string              `json:"title"`
-	Icon             string              `json:"icon,omitempty"`
-	Capacity         float64             `json:"capacity,omitempty"`
-	Phases           int                 `json:"phases,omitempty"`
-	MinSoc           int                 `json:"minSoc,omitempty"`
-	LimitSoc         int                 `json:"limitSoc,omitempty"`
-	MinCurrent       float64             `json:"minCurrent,omitempty"`
-	MaxCurrent       float64             `json:"maxCurrent,omitempty"`
-	Priority         int                 `json:"priority,omitempty"`
-	Features         []string            `json:"features,omitempty"`
-	Plan             *planStruct         `json:"plan,omitempty"`
-	RepeatingPlans   []api.RepeatingPlan `json:"repeatingPlans"`
-	PlanPrecondition int64               `json:"planPrecondition"`
-	PlanContinuous   bool                `json:"planContinuous"`
+	Title          string              `json:"title"`
+	Icon           string              `json:"icon,omitempty"`
+	Capacity       float64             `json:"capacity,omitempty"`
+	Phases         int                 `json:"phases,omitempty"`
+	MinSoc         int                 `json:"minSoc,omitempty"`
+	LimitSoc       int                 `json:"limitSoc,omitempty"`
+	MinCurrent     float64             `json:"minCurrent,omitempty"`
+	MaxCurrent     float64             `json:"maxCurrent,omitempty"`
+	Priority       int                 `json:"priority,omitempty"`
+	Features       []string            `json:"features,omitempty"`
+	Plan           *planStruct         `json:"plan,omitempty"`
+	RepeatingPlans []api.RepeatingPlan `json:"repeatingPlans"`
 }
 
 // publishVehicles returns a list of vehicle titles
@@ -48,28 +45,29 @@ func (site *Site) publishVehicles() {
 		}
 
 		ac := instance.OnIdentified()
-		strategy := v.GetPlanStrategy()
 
 		var plan *planStruct
 		if time, soc := v.GetPlanSoc(); !time.IsZero() {
-			plan = &planStruct{Soc: soc, Precondition: int64(strategy.Precondition.Seconds()), Time: time}
+			plan = &planStruct{
+				Soc:          soc,
+				Time:         time,
+				PlanStrategy: v.GetPlanStrategy(),
+			}
 		}
 
 		res[v.Name()] = vehicleStruct{
-			Title:            instance.GetTitle(),
-			Icon:             instance.Icon(),
-			Capacity:         instance.Capacity(),
-			Phases:           instance.Phases(),
-			MinSoc:           v.GetMinSoc(),
-			LimitSoc:         v.GetLimitSoc(),
-			MinCurrent:       ac.MinCurrent,
-			MaxCurrent:       ac.MaxCurrent,
-			Priority:         ac.Priority,
-			Features:         lo.Map(instance.Features(), func(f api.Feature, _ int) string { return f.String() }),
-			Plan:             plan,
-			RepeatingPlans:   v.GetRepeatingPlans(),
-			PlanPrecondition: int64(strategy.Precondition.Seconds()),
-			PlanContinuous:   strategy.Continuous,
+			Title:          instance.GetTitle(),
+			Icon:           instance.Icon(),
+			Capacity:       instance.Capacity(),
+			Phases:         instance.Phases(),
+			MinSoc:         v.GetMinSoc(),
+			LimitSoc:       v.GetLimitSoc(),
+			MinCurrent:     ac.MinCurrent,
+			MaxCurrent:     ac.MaxCurrent,
+			Priority:       ac.Priority,
+			Features:       lo.Map(instance.Features(), func(f api.Feature, _ int) string { return f.String() }),
+			Plan:           plan,
+			RepeatingPlans: v.GetRepeatingPlans(),
 		}
 
 		if lp := site.coordinator.Owner(instance); lp != nil {