personio, hibob (new) Connector contribution program [Maesn]

src/appmixer/hibob/auth.js

@@ -0,0 +1,47 @@
+module.exports = {
+
+    type: 'pwd',
+
+    definition: {
+
+        accountNameFromProfileInfo: 'serviceUserId',
+        auth: {
+            serviceUserId: {
+                type: 'text',
+                name: 'Servivce User Id',
+                tooltip: 'Servivce User Id'
+            },
+            serviceUserToken: {
+                type: 'password',
+                name: 'Token',
+                tooltip: 'The service user token from your HiBob account'
+            }
+        },
+
+        validate: async context => {
+
+            const { serviceUserId, serviceUserToken } = context;
+            const token = Buffer.from(serviceUserId + ':' + serviceUserToken).toString('base64');
+
+            const auth = 'Basic ' + token;
+            const url = 'https://api.hibob.com/v1/company/named-lists';
+
+            try {
+                await context.httpRequest({
+                    method: 'GET',
+                    url: url,
+                    headers: {
+                        'Authorization': auth
+                    }
+                });
+
+            } catch (error) {
+                throw new Error('Invalid id/token combination.');
+            }
+
+            return {
+                token: token
+            };
+        }
+    }
+};

src/appmixer/hibob/employees/DeletedEmployee/DeletedEmployee.js

@@ -0,0 +1,75 @@
+'use strict';
+const Promise = require('bluebird');
+
+/**
+ * Process employees to find newly deleted.
+ * @param {Array} currentEmployees
+ * @param {Array} deletedEmployees
+ * @param {Object} employeeId
+ */
+
+
+function processEmployees(currentEmployees, deletedEmployees, employeeId) {
+    if (!currentEmployees.includes(employeeId)) {
+        deletedEmployees.push(employeeId);
+    }
+}
+
+/**
+ * Component which triggers whenever an employee is deleted.
+ */
+class DeletedEmployee {
+
+    async receive(context) {
+        try {
+            const auth = 'Basic ' + context.auth.token;
+            let hibobEndpoint = 'https://api.hibob.com/v1/people/search';
+
+            const { data } = await context.httpRequest({
+                url: hibobEndpoint,
+                method: 'POST',
+                headers: {
+                    Authorization: auth
+                },
+                data: {
+                    'humanReadable': 'APPEND',
+                    'showInactive': true,
+                    'fields': [
+                        '/root/firstName',
+                        '/root/surname',
+                        '/root/id',
+                        '/root/email',
+                        '/internal/status',
+                        '/work/manager'
+                    ]
+                },
+                json: true
+            });
+
+            let known = Array.isArray(context.state.known) ? new Set(context.state.known) : new Set();
+            let current = (data.employees || []).map(employee => employee.id);
+            let diff = [];
+
+            if (known.size > 0) {
+                known.forEach(processEmployees.bind(null, current, diff));
+            }
+
+            await Promise.map(diff, employee => {
+                // TODO: Add logging here
+                return context.sendJson({ employee }, 'out');
+            });
+
+            await context.saveState({
+                known: current
+            });
+        } catch (error) {
+            // TODO: Add logging here
+            throw error;
+        }
+
+
+    }
+}
+
+module.exports = new DeletedEmployee('maesn.hibob.employees.DeletedEmployee');
+

src/appmixer/hibob/employees/NewEmployee/NewEmployee.js

@@ -0,0 +1,73 @@
+'use strict';
+const Promise = require('bluebird');
+
+
+/**
+ * Process employees to find newly added.
+ * @param {Set} knownEmployees
+ * @param {Array} currentEmployees
+ * @param {Array} newEmployees
+ * @param {Object} employee
+ */
+function processEmployees(knownEmployees, currentEmployees, newEmployees, employee) {
+    const employeeId = employee.id;
+
+    if (knownEmployees && !knownEmployees.has(employeeId)) {
+        newEmployees.push(employee);
+    }
+    currentEmployees.push(employeeId);
+}
+
+/**
+ * Component which triggers whenever new employee is added.
+ */
+
+
+class NewEmployee {
+
+    async receive(context) {
+        try {
+            const auth = 'Basic ' + context.auth.token;
+            let hibobEndpoint = 'https://api.hibob.com/v1/people/search';
+            const { data } = await context.httpRequest({
+                url: hibobEndpoint,
+                method: 'POST',
+                headers: {
+                    Authorization: auth
+                },
+                data: {
+                    'humanReadable': 'APPEND',
+                    'showInactive': true,
+                    'fields': [
+                        '/root/firstName',
+                        '/root/surname',
+                        '/root/id',
+                        '/root/email',
+                        '/internal/status',
+                        '/work/manager'
+                    ]
+                },
+                json: true
+            });
+            let known = Array.isArray(context.state.known) ? new Set(context.state.known) : new Set();
+            let current = [];
+            let diff = [];
+            if (data.employees) {
+                data.employees.forEach(processEmployees.bind(null, known, current, diff));
+            }
+            const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+            for (const employee of diff) {
+                await delay(1000);
+                await context.sendJson(employee, 'employee');
+                // TODO: Add logging here
+            }
+            await context.saveState({
+                known: current
+            });
+        } catch (error) {
+            // TODO: Add logging here
+            throw error;
+        }
+    }
+}
+module.exports = new NewEmployee('maesn.hibob.employees.NewEmployee');

src/appmixer/hibob/employees/UpdatedEmployee/UpdatedEmployee.js

@@ -0,0 +1,90 @@
+'use strict';
+const Promise = require('bluebird');
+
+/**
+ * Process employees to find newly updated.
+ * @param {Array} knownEmployees
+ * @param {Array} currentEmployees
+ * @param {Array} updatedEmployees
+ * @param {Object} employee
+ */
+
+function processEmployees(knownEmployees, currentEmployees, updatedEmployees, employee) {
+    let employeeId = employee.id;
+    let foundEmployee = knownEmployees.find(emp => emp.id === employeeId);
+
+    if (foundEmployee && !isEqual(foundEmployee, employee)) {
+        updatedEmployees.push(employee);
+    }
+    currentEmployees.push(employee);
+}
+
+
+function isEqual(obj1, obj2) {
+    return JSON.stringify(obj1) === JSON.stringify(obj2);
+}
+
+/**
+ * Component which triggers whenever new employee is updated.
+ */
+
+class UpdatedEmployee {
+
+    async receive(context) {
+        try {
+            const auth = 'Basic ' + context.auth.token;
+            const { storeId } = context.properties;
+            const key = 'HiBobEmployeeStorage' + context.flowId;
+
+            let hibobEndpoint = 'https://api.hibob.com/v1/people/search';
+
+            const { data } = await context.httpRequest({
+                url: hibobEndpoint,
+                method: 'POST',
+                headers: {
+                    Authorization: auth
+                },
+                data: {
+                    'humanReadable': 'APPEND',
+                    'showInactive': true,
+                    'fields': [
+                        '/root/firstName',
+                        '/root/surname',
+                        '/root/id',
+                        '/root/email',
+                        '/internal/status',
+                        '/work/manager'
+                    ]
+                },
+                json: true
+            });
+
+
+            let storage = await context.store.get(storeId, key);
+            let known = [];
+
+            if (storage && storage.value) {
+                known = storage.value;
+            };
+
+            let current = [];
+            let updated = [];
+
+            if (data.employees && known) {
+                data.employees.forEach(processEmployees.bind(null, known, current, updated));
+            }
+
+            await Promise.map(updated, employee => {
+                return context.sendJson(employee, 'employee');
+            });
+
+
+            await context.store.set(storeId, key, current);
+        } catch (error) {
+            // TODO: Add logging here
+            throw error;
+        }
+    }
+}
+
+module.exports = new UpdatedEmployee('maesn.hibob.employees.UpdatedEmployee');

src/appmixer/hibob/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "maesn.hibob",
+    "author": "Rovan Talani <[email protected]>",
+    "version": "1.0.1",
+    "dependencies": {
+        "axios": "^0.21.0",
+        "bluebird": "^3.7.1",
+        "request-promise": "^4.2.2"
+    }
+}

src/appmixer/personio/auth.js

@@ -0,0 +1,54 @@
+'use strict';
+module.exports = {
+
+    type: 'pwd',
+
+    definition: {
+        accountNameFromProfileInfo: 'clientId',
+        auth: {
+            clientId: {
+                type: 'text',
+                name: 'Client Id',
+                tooltip: 'Client Id'
+            },
+            clientSecret: {
+                type: 'password',
+                name: 'Client Secret',
+                tooltip: 'Client Secret'
+            }
+        },
+
+        validate: async context => {
+
+            const { clientId, clientSecret } = context;
+            const authorizationUrl = 'https://api.personio.de/v1/auth';
+
+            const { data } = await context.httpRequest({
+                url: authorizationUrl,
+                method: 'POST',
+                headers: {
+                    'accept': 'application/json',
+                    'content-type': 'application/json'
+                },
+                data: {
+                    client_id: clientId,
+                    client_secret: clientSecret
+                },
+                json: true
+            });
+            if (data.error) {
+                throw new Error('Invalid username/password combination.');
+            }
+
+            const { token, expiresIn } = data.data;
+
+            return {
+                token: token,
+                expires: expiresIn,
+                clientId: clientId,
+                clientSecret: clientSecret
+
+            };
+        }
+    }
+};