divhunt 2.0.0

package/addons/modules/schedules/back/functions/trigger.js

@@ -0,0 +1,134 @@
+import divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+schedules.Fn('trigger', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.events = divhunt.AddonGet('events');
+    this.commands = divhunt.AddonGet('commands');
+
+    this.methods.init = async (resolve) =>
+    {
+        this.resolve = resolve;
+        this.item = this.ItemGet(id);
+
+        if(!this.item)
+        {
+            return this.methods.done(null, `Schedule "${id}" not found.`, 404);
+        }
+
+        if(!this.item.Get('enabled'))
+        {
+            return this.methods.done(null, `Schedule "${id}" is disabled.`, 403);
+        }
+
+        this.methods.emit();
+        this.methods.track();
+
+        const callback = this.item.Get('callback');
+        const command = this.item.Get('command');
+
+        if(callback)
+        {
+            await this.methods.callback(callback, props);
+        }
+        else if(command)
+        {
+            await this.methods.command(command, props);
+        }
+        else
+        {
+            return this.methods.done(null, `Schedule "${id}" has no callback or command.`, 400);
+        }
+    };
+
+    this.methods.emit = () =>
+    {
+        if(this.events)
+        {
+            this.events.Fn('emit', 'schedule.triggered', {
+                id,
+                type: this.item.Get('type'),
+                runs: this.item.Get('runs')
+            });
+        }
+    };
+
+    this.methods.track = () =>
+    {
+        const runs = this.item.Get('runs') || 0;
+        const repeat = this.item.Get('repeat');
+        const type = this.item.Get('type');
+
+        this.item.Set('runs', runs + 1);
+        this.item.Set('last', new Date().toISOString());
+
+        if(type === 'once')
+        {
+            this.Fn('disable', id);
+        }
+        else if(repeat !== null && runs + 1 >= repeat)
+        {
+            this.Fn('disable', id);
+        }
+    };
+
+    this.methods.callback = async (fn, props) =>
+    {
+        try
+        {
+            const data = await fn(props);
+            return this.methods.done(data, 'Schedule executed.', 200);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.command = async (command, props) =>
+    {
+        if(!this.commands)
+        {
+            return this.methods.done(null, 'Commands addon not available.', 500);
+        }
+
+        const commandId = typeof command === 'string' ? command : command.id;
+        const merged = typeof command === 'object' ? { ...command, ...props, id: undefined } : props;
+
+        const item = this.commands.ItemGet(commandId);
+
+        if(!item)
+        {
+            return this.methods.done(null, `Command "${commandId}" not found.`, 404);
+        }
+
+        try
+        {
+            const result = await item.Fn('run', merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.done = (data, message, code) =>
+    {
+        this.resolve({ data, message, code });
+    };
+
+    return new Promise((resolve) =>
+    {
+        try
+        {
+            this.methods.init(resolve);
+        }
+        catch(error)
+        {
+            resolve({ data: null, message: error.message, code: 500 });
+        }
+    });
+});

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

@@ -0,0 +1,82 @@
+import divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+divhunt.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 || divhunt.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 divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+divhunt.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 divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+divhunt.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 divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+divhunt.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 divhunt from '#divhunt';
+import schedules from '../addon.js';
+
+divhunt.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 divhunt from '#divhunt';
+
+const schedules = divhunt.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;
+});