Add setting for minimum on time (#20)

tbowmo · web-flow · commit 15204424f731 · 2023-07-26T10:40:56.000+02:00
* Add setting for minimum on time
diff --git a/README.md b/README.md
@@ -132,7 +132,7 @@ The debug output will contain the following data
     nextStart: number,
     nextEnd: number,
     onState: boolean,
-    noOnStateToday: boolean,
+    operationToday: 'normal' | 'noMidnightWrap' | 'minimumOnTimeNotMet',
 }
 ```
 All the above numbers will be number of minutes since midnight on the day the event happens, except nextStart and nextEnd, which will be the number of minutes until the next event.
diff --git a/package.json b/package.json
@@ -3,7 +3,7 @@
     "author": {
         "name": "Thomas Bowman Mørch"
     },
-    "version": "0.6.0",
+    "version": "0.7.0",
     "engines": {
         "node": ">=14.0.0"
     },
diff --git a/sonar-project.properties b/sonar-project.properties
@@ -11,3 +11,7 @@ sonar.organization=tbowmogithub
 # Encoding of the source code. Default is default system encoding
 #sonar.sourceEncoding=UTF-8
 sonar.javascript.lcov.reportPaths=./.test_output/coverage/lcov.info
+sonar.sources=src/
+sonar.tests=src/
+sonar.exclusions=**/*.spec.ts
+sonar.test.inclusions=**/*.spec.ts
diff --git a/src/lib/small-timer-runner.spec.ts b/src/lib/small-timer-runner.spec.ts
@@ -35,6 +35,7 @@ describe('lib/small-timer-runner', () => {
             onMsgType: 'str',
             wrapMidnight: false,
             debugEnable: false,
+            minimumOnTime: 0,
             id: '',
             type: '',
             name: '',
@@ -46,7 +47,7 @@ describe('lib/small-timer-runner', () => {
             getTimeToNextStartEvent: sinon.stub(),
             getTimeToNextEndEvent: sinon.stub(),
             getOnState: sinon.stub().returns(false),
-            noOnStateToday: sinon.stub().returns(false),
+            operationToday: sinon.stub().returns('normal'),
             debug: sinon.stub().returns({debug: 'this is debug'}),
         }
 
@@ -74,15 +75,33 @@ describe('lib/small-timer-runner', () => {
         const stubs = setupTest()
         stubs.stubbedTimeCalc.getTimeToNextStartEvent.returns(10)
         stubs.stubbedTimeCalc.getTimeToNextEndEvent.returns(20)
-        stubs.stubbedTimeCalc.noOnStateToday.returns(true)
+        stubs.stubbedTimeCalc.operationToday.returns('noMidnightWrap')
 
-        new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
+        const runner = new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
 
+        runner.onMessage({payload: 'sync', _msgid: ''})
         sinon.assert.calledWith(stubs.node.status, {
             fill: 'yellow',
             shape: 'dot',
             text: 'No action today - off time is before on time',
         })
+
+    })
+
+    it('should handle no action today, due to minimum on time not met', () => {
+        const stubs = setupTest()
+        stubs.stubbedTimeCalc.getTimeToNextStartEvent.returns(10)
+        stubs.stubbedTimeCalc.getTimeToNextEndEvent.returns(20)
+        stubs.stubbedTimeCalc.operationToday.returns('minimumOnTimeNotMet')
+
+        const runner = new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
+
+        runner.onMessage({payload: 'sync', _msgid: ''})
+        sinon.assert.calledWith(stubs.node.status, {
+            fill: 'yellow',
+            shape: 'dot',
+            text: 'No action today - minimum on time not met',
+        })
     })
 
     it('should handle temporary on and use timeout to calculate next change', () => {
@@ -138,7 +157,9 @@ describe('lib/small-timer-runner', () => {
         stubs.stubbedTimeCalc.getTimeToNextEndEvent.returns(120.6)
         stubs.stubbedTimeCalc.getOnState.returns(false)
 
-        new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
+        const runner = new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
+
+        runner.onMessage({payload: 'sync', _msgid: ''})
         sinon.clock.tick(60000)
 
         sinon.assert.calledWithExactly(stubs.status, { fill: 'red', shape: 'dot', text: 'OFF for 00mins 00secs' })
@@ -184,8 +205,9 @@ describe('lib/small-timer-runner', () => {
         stubs.stubbedTimeCalc.getTimeToNextEndEvent.returns(120.6)
         stubs.stubbedTimeCalc.getOnState.returns(false)
 
-        new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
+        const runner = new SmallTimerRunner(stubs.position, stubs.configuration, stubs.node)
 
+        runner.onMessage({payload: 'sync', _msgid: ''})
         sinon.clock.tick(2000)
         sinon.assert.calledWith(stubs.send, [
             {
@@ -200,8 +222,8 @@ describe('lib/small-timer-runner', () => {
             },
             { debug: 'this is debug', override: 'auto', topic: 'debug' },
         ])
-
     })
+
     it('should stop timer, and not advance anything after cleanup has been called', async () => {
         const stubs = setupTest({
             topic: 'test-topic',
@@ -297,8 +319,6 @@ describe('lib/small-timer-runner', () => {
                 payload: '0',
                 topic: 'test-topic',
             })
-
-
         })
 
         it('should output node status when sync message is received, without changing properties', () => {
diff --git a/src/lib/small-timer-runner.ts b/src/lib/small-timer-runner.ts
@@ -1,4 +1,4 @@
-/*eslint complexity: ["error", 12]*/
+/*eslint complexity: ["error", 13]*/
 import {
     Node,
     NodeMessage,
@@ -41,7 +41,6 @@ export class SmallTimerRunner {
     private repeat: boolean
     private onTimeout: number
     private offTimeout: number
-    // private currentTimeout = 0
 
     private timeCalc: TimeCalc
     private debugMode = false
@@ -61,6 +60,7 @@ export class SmallTimerRunner {
             Number(configuration.endTime),
             Number(configuration.startOffset),
             Number(configuration.endOffset),
+            Number(configuration.minimumOnTime),
         )
 
         this.topic = configuration.topic
@@ -205,7 +205,7 @@ export class SmallTimerRunner {
         if (minutes >= 2 || hour) {
             str.push(`${pad(minutes)}mins`)
         }
-        if (minutes<2 && !hour) {
+        if (minutes < 2 && !hour) {
             str.push(`${pad(Math.floor(minutes))}mins`)
             str.push(`${pad(seconds)}secs`)
         }
@@ -219,14 +219,18 @@ export class SmallTimerRunner {
         let fill: NodeStatusFill = 'yellow'
         const text: string[] = []
 
-        const activeToday = !this.timeCalc.noOnStateToday() && (this.isDayOk() || this.currentState)
+        const activeToday = this.timeCalc.operationToday() === 'normal' && (this.isDayOk() || this.currentState)
 
         if (!activeToday) {
             text.push('No action today')
         }
 
-        if (this.timeCalc.noOnStateToday()) {
+        switch (this.timeCalc.operationToday()) {
+        case 'noMidnightWrap':
             text.push('off time is before on time')
+            break
+        case 'minimumOnTimeNotMet':
+            text.push('minimum on time not met')
         }
 
         if (activeToday || this.override !== 'auto') {
diff --git a/src/lib/time-calculation.spec.ts b/src/lib/time-calculation.spec.ts
@@ -42,6 +42,7 @@ describe('lib/time-calculation', () => {
             minutes + 120, // 12:00
             0,
             0,
+            0,
         )
 
         sinon.assert.calledWith(stubs.getTimes, currentTime, 10, 10)
@@ -67,15 +68,16 @@ describe('lib/time-calculation', () => {
             5006,
             0,
             0,
+            0,
         )
 
         expect(timeCalc.getOnState()).to.equal(true)
         expect(timeCalc.getTimeToNextEndEvent()).to.equal(180)
         expect(timeCalc.getTimeToNextStartEvent()).to.equal(22 * 60)
-        expect(timeCalc.noOnStateToday()).to.equal(false)
+        expect(timeCalc.operationToday()).to.equal('normal')
     })
 
-    it('should not signal on, if off time is before on time', () => {
+    it('should indicate that on time wraps midnight, if off time is before on time', () => {
         setupTest()
         const currentTime = new Date('2023-01-01 01:00')
         sinon.clock.setSystemTime(currentTime)
@@ -87,12 +89,34 @@ describe('lib/time-calculation', () => {
             5006,
             0,
             0,
+            0,
         )
 
         expect(timeCalc.getOnState()).to.equal(false)
         expect(timeCalc.getTimeToNextEndEvent()).to.equal(180)
         expect(timeCalc.getTimeToNextStartEvent()).to.equal(22 * 60)
-        expect(timeCalc.noOnStateToday()).to.equal(true)
+        expect(timeCalc.operationToday()).to.equal('noMidnightWrap')
+    })
+
+    it('should indicate that on time is lower than minimum on time', () => {
+        setupTest()
+        const currentTime = new Date('2023-01-01 01:00')
+        sinon.clock.setSystemTime(currentTime)
+        const timeCalc = new TimeCalc(
+            10,
+            10,
+            false,
+            45,
+            75,
+            0,
+            0,
+            60,
+        )
+
+        expect(timeCalc.getOnState()).to.equal(false)
+        expect(timeCalc.getTimeToNextEndEvent()).to.equal(15)
+        expect(timeCalc.getTimeToNextStartEvent()).to.equal(1425)
+        expect(timeCalc.operationToday()).to.equal('minimumOnTimeNotMet')
     })
 
     const testData: {
@@ -127,6 +151,7 @@ describe('lib/time-calculation', () => {
                 data.endTime,
                 0,
                 0,
+                0,
             )
 
             expect(timeCalc.getTimeToNextStartEvent()).to.equal(data.expectedStart, 'startEvent')
@@ -140,7 +165,7 @@ describe('lib/time-calculation', () => {
         stubs.getMoonTimes.returns({
             rise: false,
             set: false,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any)
 
         const timeCalc = new TimeCalc(
@@ -151,6 +176,7 @@ describe('lib/time-calculation', () => {
             5008,
             0,
             0,
+            0,
         )
 
         expect(timeCalc.getTimeToNextStartEvent()).to.equal(715, 'startEvent')
@@ -169,6 +195,7 @@ describe('lib/time-calculation', () => {
             5001,
             0,
             0,
+            0,
         )
 
         expect(timeCalc.setStartEndTime.bind(timeCalc, 6001, 6002))
@@ -186,6 +213,7 @@ describe('lib/time-calculation', () => {
             5002,
             0,
             0,
+            0,
         )
 
         expect(timeCalc.debug()).to.deep.equal({
@@ -205,7 +233,7 @@ describe('lib/time-calculation', () => {
             },
             nextEnd: 1320,
             nextStart: 480,
-            noOnStateToday: false,
+            operationToday: 'normal',
 
             actualEnd: 660,
             actualStart: 1260,
diff --git a/src/lib/time-calculation.ts b/src/lib/time-calculation.ts
@@ -69,6 +69,7 @@ export class TimeCalc {
         private endTime: number,
         private startOffset: number,
         private endOffset: number,
+        private minimumOnTime: number,
     ) {
         this.eventCalculation()
     }
@@ -106,7 +107,7 @@ export class TimeCalc {
             nextStart: this.getTimeToNextStartEvent(),
             nextEnd: this.getTimeToNextEndEvent(),
             onState: this.getOnState(),
-            noOnStateToday: this.noOnStateToday(),
+            operationToday: this.operationToday(),
         }
     }
 
@@ -159,6 +160,16 @@ export class TimeCalc {
         return nextEvent >= 0 ? nextEvent : (nextEvent + wholeDay)
     }
 
+    private onTime(): number {
+        const onTime = this.actualEnd - this.actualStart
+
+        if (this.wrapMidnight && onTime < 0) {
+            return onTime + wholeDay
+        }
+
+        return onTime 
+    }
+
     /**
      * Returns the actual on state, according to the current time
      *
@@ -169,20 +180,30 @@ export class TimeCalc {
         const currentTime = this.getTime(date)
 
         this.eventCalculation(false, date)
-
+    
+        if (this.onTime() < this.minimumOnTime) {
+            return false
+        }
+    
         if (this.actualEnd < this.actualStart) {
             return this.wrapMidnight && ((currentTime < this.actualEnd) || (currentTime > this.actualStart))
         }
         return (currentTime > this.actualStart) && (currentTime < this.actualEnd)
     }
 
     /**
-     * Check if we will have an on event today,
-     * returns false if wrapMidnight is false, and actualEnd is before actualStart
+     * Check how the operational status is today,
+     * returns 'normal' in case of normal operation or 'noMinomumOnTime' / 'noMidnightWrap' if we do not turn on today
      * @returns
      */
-    public noOnStateToday(): boolean {
-        return !this.wrapMidnight && (this.actualEnd < this.actualStart)
+    public operationToday(): 'normal' | 'minimumOnTimeNotMet' | 'noMidnightWrap' {
+        const onTime = this.onTime()
+
+        if (onTime >= 0 && onTime < this.minimumOnTime) {
+            return 'minimumOnTimeNotMet'
+        }
+
+        return !this.wrapMidnight && (this.actualEnd < this.actualStart) ? 'noMidnightWrap' : 'normal'
     }
 
     private eventCalculation(forceUpdate = false, now = new Date()) {
diff --git a/src/nodes/common.ts b/src/nodes/common.ts
@@ -43,4 +43,5 @@ export interface ISmallTimerProperties extends NodeDef {
     offTimeout: number,
     wrapMidnight: boolean,
     debugEnable: boolean,
+    minimumOnTime: number,
 }
diff --git a/src/nodes/small-timer.html b/src/nodes/small-timer.html
@@ -135,6 +135,10 @@ <h3>References</h3>
             <input type="text" id="node-input-offTimeout" placeholder="1440">
         </div>
     </div>
+    <div class="form-row">
+        <label for="node-input-minimumOnTime">Minimum on time</label>
+        <input style="width:80px" type="text" id="node-input-minimumOnTime" placeholder="0">
+    </div>
     <div class="form-row">
         <label for="node-input-name"><i class="fa fa-tasks"></i> Topic</label>
         <input type="text" id="node-input-topic" placeholder="Topic">
@@ -336,6 +340,7 @@ <h3>References</h3>
                 onMsg: { value: '1' },
                 onMsgType: { value: 'str' },
                 onTimeout: { value: 1440, required: true },
+                minimumOnTime: { value: 0, required: true},
 
                 offMsg: { value: '0' },
                 offMsgType: { value: 'str' },

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ The debug output will contain the following data`
`132`	`132`	`nextStart: number,`
`133`	`133`	`nextEnd: number,`
`134`	`134`	`onState: boolean,`
`135`		`- noOnStateToday: boolean,`
	`135`	`+ operationToday: 'normal' \| 'noMidnightWrap' \| 'minimumOnTimeNotMet',`
`136`	`136`	`}`
`137`	`137`	```
`138`	`138`	`All the above numbers will be number of minutes since midnight on the day the event happens, except nextStart and nextEnd, which will be the number of minutes until the next event.`
Original file line number	Diff line number	Diff line change
`@@ -43,4 +43,5 @@ export interface ISmallTimerProperties extends NodeDef {`
`43`	`43`	`offTimeout: number,`
`44`	`44`	`wrapMidnight: boolean,`
`45`	`45`	`debugEnable: boolean,`
	`46`	`+ minimumOnTime: number,`
`46`	`47`	`}`