@onetype/framework 2.0.20

package/addons/modules/schedules/back/items/create.js

@@ -0,0 +1,82 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'schedules:create',
+        method: 'POST',
+        endpoint: '/api/schedules',
+        exposed: true,
+        description: 'Create a new schedule',
+        in: {
+            id: ['string', null],
+            name: ['string', null],
+            group: ['string', null],
+            description: ['string', null],
+            type: ['string', 'once'],
+            time: ['string|number', null, true],
+            command: ['string|object', null],
+            enabled: ['boolean', true],
+            repeat: ['number', null],
+            timezone: ['string', null]
+        },
+        out: {
+            schedule: ['object']
+        },
+        callback: async function(props)
+        {
+            const id = props.id || onetype.GenerateTID();
+
+            if(schedules.ItemGet(id))
+            {
+                throw new Error(`Schedule "${id}" already exists.`);
+            }
+
+            const item = schedules.Item({
+                id,
+                name: props.name,
+                group: props.group,
+                description: props.description,
+                type: props.type,
+                time: props.time,
+                command: props.command,
+                enabled: props.enabled,
+                repeat: props.repeat,
+                timezone: props.timezone,
+                runs: 0,
+                last: null,
+                next: null,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString()
+            });
+
+            await item.Create();
+
+            if(props.enabled)
+            {
+                schedules.Fn('start', id);
+            }
+
+            return {
+                schedule: {
+                    id: item.Get('id'),
+                    name: item.Get('name'),
+                    group: item.Get('group'),
+                    description: item.Get('description'),
+                    type: item.Get('type'),
+                    time: item.Get('time'),
+                    command: item.Get('command'),
+                    enabled: item.Get('enabled'),
+                    repeat: item.Get('repeat'),
+                    timezone: item.Get('timezone'),
+                    runs: item.Get('runs'),
+                    last: item.Get('last'),
+                    next: item.Get('next'),
+                    created_at: item.Get('created_at'),
+                    updated_at: item.Get('updated_at')
+                }
+            };
+        }
+    });
+});

package/addons/modules/schedules/back/items/delete.js

@@ -0,0 +1,38 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'schedules:delete',
+        method: 'DELETE',
+        endpoint: '/api/schedules/:id',
+        exposed: true,
+        description: 'Delete a schedule',
+        in: {
+            id: ['string', null, true]
+        },
+        out: {
+            deleted: ['boolean']
+        },
+        callback: async function(props)
+        {
+            const item = schedules.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Schedule "${props.id}" not found.`);
+            }
+
+            schedules.Fn('stop', props.id);
+
+            await item.Delete();
+
+            schedules.ItemRemove(props.id);
+
+            return {
+                deleted: true
+            };
+        }
+    });
+});

package/addons/modules/schedules/back/items/many.js

@@ -0,0 +1,90 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'schedules:many',
+        method: 'GET',
+        endpoint: '/api/schedules',
+        exposed: true,
+        description: 'Get all schedules',
+        in: {
+            page: ['number', 1],
+            limit: ['number', 50],
+            group: ['string', null],
+            enabled: ['boolean', null]
+        },
+        out: {
+            schedules: {
+                type: 'array',
+                each: {
+                    type: 'object',
+                    config: {
+                        id: ['string'],
+                        name: ['string'],
+                        group: ['string'],
+                        description: ['string'],
+                        type: ['string'],
+                        time: ['string|number'],
+                        command: ['string|object'],
+                        enabled: ['boolean'],
+                        repeat: ['number'],
+                        timezone: ['string'],
+                        runs: ['number'],
+                        last: ['string'],
+                        next: ['string'],
+                        created_at: ['string'],
+                        updated_at: ['string']
+                    }
+                }
+            },
+            total: ['number']
+        },
+        callback: async function(props)
+        {
+            const result = [];
+
+            for(const id in schedules.items.data)
+            {
+                const item = schedules.items.data[id];
+
+                if(props.group && item.Get('group') !== props.group)
+                {
+                    continue;
+                }
+
+                if(props.enabled !== null && item.Get('enabled') !== props.enabled)
+                {
+                    continue;
+                }
+
+                result.push({
+                    id: item.Get('id'),
+                    name: item.Get('name'),
+                    group: item.Get('group'),
+                    description: item.Get('description'),
+                    type: item.Get('type'),
+                    time: item.Get('time'),
+                    command: item.Get('command'),
+                    enabled: item.Get('enabled'),
+                    repeat: item.Get('repeat'),
+                    timezone: item.Get('timezone'),
+                    runs: item.Get('runs'),
+                    last: item.Get('last'),
+                    next: item.Get('next'),
+                    created_at: item.Get('created_at'),
+                    updated_at: item.Get('updated_at')
+                });
+            }
+
+            const start = (props.page - 1) * props.limit;
+            const end = start + props.limit;
+
+            return {
+                schedules: result.slice(start, end),
+                total: result.length
+            };
+        }
+    });
+});

package/addons/modules/schedules/back/items/one.js

@@ -0,0 +1,48 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'schedules:one',
+        method: 'GET',
+        endpoint: '/api/schedules/:id',
+        exposed: true,
+        description: 'Get a single schedule by ID',
+        in: {
+            id: ['string', null, true]
+        },
+        out: {
+            schedule: ['object']
+        },
+        callback: async function(props)
+        {
+            const item = schedules.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Schedule "${props.id}" not found.`);
+            }
+
+            return {
+                schedule: {
+                    id: item.Get('id'),
+                    name: item.Get('name'),
+                    group: item.Get('group'),
+                    description: item.Get('description'),
+                    type: item.Get('type'),
+                    time: item.Get('time'),
+                    command: item.Get('command'),
+                    enabled: item.Get('enabled'),
+                    repeat: item.Get('repeat'),
+                    timezone: item.Get('timezone'),
+                    runs: item.Get('runs'),
+                    last: item.Get('last'),
+                    next: item.Get('next'),
+                    created_at: item.Get('created_at'),
+                    updated_at: item.Get('updated_at')
+                }
+            };
+        }
+    });
+});

package/addons/modules/schedules/back/items/update.js

@@ -0,0 +1,115 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'schedules:update',
+        method: 'PUT',
+        endpoint: '/api/schedules/:id',
+        exposed: true,
+        description: 'Update a schedule',
+        in: {
+            id: ['string', null, true],
+            name: ['string', null],
+            group: ['string', null],
+            description: ['string', null],
+            type: ['string', null],
+            time: ['string|number', null],
+            command: ['string|object', null],
+            enabled: ['boolean', null],
+            repeat: ['number', null],
+            timezone: ['string', null]
+        },
+        out: {
+            schedule: ['object']
+        },
+        callback: async function(props)
+        {
+            const item = schedules.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Schedule "${props.id}" not found.`);
+            }
+
+            const wasEnabled = item.Get('enabled');
+
+            schedules.Fn('stop', props.id);
+
+            if(props.name !== null && props.name !== undefined)
+            {
+                item.Set('name', props.name);
+            }
+
+            if(props.group !== null && props.group !== undefined)
+            {
+                item.Set('group', props.group);
+            }
+
+            if(props.description !== null && props.description !== undefined)
+            {
+                item.Set('description', props.description);
+            }
+
+            if(props.type !== null && props.type !== undefined)
+            {
+                item.Set('type', props.type);
+            }
+
+            if(props.time !== null && props.time !== undefined)
+            {
+                item.Set('time', props.time);
+            }
+
+            if(props.command !== null && props.command !== undefined)
+            {
+                item.Set('command', props.command);
+            }
+
+            if(props.enabled !== null && props.enabled !== undefined)
+            {
+                item.Set('enabled', props.enabled);
+            }
+
+            if(props.repeat !== null && props.repeat !== undefined)
+            {
+                item.Set('repeat', props.repeat);
+            }
+
+            if(props.timezone !== null && props.timezone !== undefined)
+            {
+                item.Set('timezone', props.timezone);
+            }
+
+            item.Set('updated_at', new Date().toISOString());
+
+            await item.Update();
+
+            if(item.Get('enabled'))
+            {
+                schedules.Fn('start', props.id);
+            }
+
+            return {
+                schedule: {
+                    id: item.Get('id'),
+                    name: item.Get('name'),
+                    group: item.Get('group'),
+                    description: item.Get('description'),
+                    type: item.Get('type'),
+                    time: item.Get('time'),
+                    command: item.Get('command'),
+                    enabled: item.Get('enabled'),
+                    repeat: item.Get('repeat'),
+                    timezone: item.Get('timezone'),
+                    runs: item.Get('runs'),
+                    last: item.Get('last'),
+                    next: item.Get('next'),
+                    created_at: item.Get('created_at'),
+                    updated_at: item.Get('updated_at')
+                }
+            };
+        }
+    });
+});

package/addons/modules/schedules/back/load.js

@@ -0,0 +1,16 @@
+import schedules from './addon.js';
+
+import './functions/start.js';
+import './functions/stop.js';
+import './functions/trigger.js';
+import './functions/enable.js';
+import './functions/disable.js';
+import './functions/next.js';
+
+import './items/one.js';
+import './items/many.js';
+import './items/create.js';
+import './items/update.js';
+import './items/delete.js';
+
+export default schedules;

package/addons/modules/schedules/front/addon.js

@@ -0,0 +1,23 @@
+import onetype from '#onetype';
+
+const schedules = onetype.Addon('schedules', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null]);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('type', ['string', 'once']);
+    addon.Field('time', ['string|number']);
+    addon.Field('action', ['string|object', null]);
+    addon.Field('command', ['string|object', null]);
+    addon.Field('callback', ['function', null]);
+    addon.Field('enabled', ['boolean', true]);
+    addon.Field('repeat', ['number', null]);
+    addon.Field('timezone', ['string', null]);
+    addon.Field('runs', ['number', 0]);
+    addon.Field('timer', ['any', null]);
+    addon.Field('last', ['string', null]);
+    addon.Field('next', ['string', null]);
+});
+
+export default schedules;

package/addons/modules/schedules/front/functions/disable.js

@@ -0,0 +1,17 @@
+import schedules from '../addon.js';
+
+schedules.Fn('disable', function(id)
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return false;
+    }
+
+    item.Set('enabled', false);
+
+    this.Fn('stop', id);
+
+    return true;
+});

package/addons/modules/schedules/front/functions/enable.js

@@ -0,0 +1,17 @@
+import schedules from '../addon.js';
+
+schedules.Fn('enable', function(id)
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return false;
+    }
+
+    item.Set('enabled', true);
+
+    this.Fn('start', id);
+
+    return true;
+});

package/addons/modules/schedules/front/functions/next.js

@@ -0,0 +1,142 @@
+import schedules from '../addon.js';
+
+schedules.Fn('next', function(id)
+{
+    this.item = this.ItemGet(id);
+
+    if(!this.item)
+    {
+        return null;
+    }
+
+    this.type = this.item.Get('type');
+    this.time = this.item.Get('time');
+    this.timezone = this.item.Get('timezone');
+
+    this.methods.once = () =>
+    {
+        const target = typeof this.time === 'string' ? new Date(this.time).getTime() : this.time;
+
+        if(target <= Date.now())
+        {
+            return null;
+        }
+
+        return target;
+    };
+
+    this.methods.interval = () =>
+    {
+        const ms = typeof this.time === 'string' ? parseInt(this.time, 10) : this.time;
+        return Date.now() + ms;
+    };
+
+    this.methods.cron = () =>
+    {
+        const parsed = this.methods.parse(this.time);
+
+        if(!parsed)
+        {
+            return null;
+        }
+
+        return this.methods.calculate(parsed);
+    };
+
+    this.methods.parse = (expr) =>
+    {
+        const parts = expr.trim().split(/\s+/);
+
+        if(parts.length !== 5)
+        {
+            return null;
+        }
+
+        return {
+            minute: parts[0],
+            hour: parts[1],
+            day: parts[2],
+            month: parts[3],
+            weekday: parts[4]
+        };
+    };
+
+    this.methods.calculate = (cron) =>
+    {
+        const now = new Date();
+
+        for(let i = 1; i < 525600; i++)
+        {
+            const next = new Date(now.getTime() + i * 60000);
+
+            if(this.methods.matches(next, cron))
+            {
+                return next.getTime();
+            }
+        }
+
+        return null;
+    };
+
+    this.methods.matches = (date, cron) =>
+    {
+        const minute = date.getMinutes();
+        const hour = date.getHours();
+        const day = date.getDate();
+        const month = date.getMonth() + 1;
+        const weekday = date.getDay();
+
+        return (
+            this.methods.field(cron.minute, minute, 0, 59) &&
+            this.methods.field(cron.hour, hour, 0, 23) &&
+            this.methods.field(cron.day, day, 1, 31) &&
+            this.methods.field(cron.month, month, 1, 12) &&
+            this.methods.field(cron.weekday, weekday, 0, 6)
+        );
+    };
+
+    this.methods.field = (expr, value, min, max) =>
+    {
+        if(expr === '*')
+        {
+            return true;
+        }
+
+        if(expr.includes(','))
+        {
+            const values = expr.split(',').map(v => parseInt(v, 10));
+            return values.includes(value);
+        }
+
+        if(expr.includes('-'))
+        {
+            const [start, end] = expr.split('-').map(v => parseInt(v, 10));
+            return value >= start && value <= end;
+        }
+
+        if(expr.includes('/'))
+        {
+            const [base, step] = expr.split('/');
+            const stepNum = parseInt(step, 10);
+            const startNum = base === '*' ? min : parseInt(base, 10);
+            return (value - startNum) % stepNum === 0 && value >= startNum;
+        }
+
+        return parseInt(expr, 10) === value;
+    };
+
+    if(this.type === 'once')
+    {
+        return this.methods.once();
+    }
+    else if(this.type === 'interval')
+    {
+        return this.methods.interval();
+    }
+    else if(this.type === 'cron')
+    {
+        return this.methods.cron();
+    }
+
+    return null;
+});