conjur-asset-ui 1.4.2 → 1.6.0

data/app/src/stores/app_store.js

@@ -0,0 +1,35 @@
+import {createStore} from 'fluxxor';
+import _ from 'lodash';
+import constants from '../constants';
+
+export default createStore({
+    initialize() {
+        this.flashMsgs = [];
+
+        this.bindActions(
+            constants.FLASH_MESSAGE, this.onFlashMessage,
+            constants.FLASH_MESSAGE_CLEAR, this.onFlashMessageClear
+        );
+    },
+
+    onFlashMessage(payload) {
+        this.flashMsgs.push({
+            msg: payload.msg,
+            status: payload.status
+        });
+
+        this.emit('change');
+    },
+
+    onFlashMessageClear() {
+        this.flashMsgs = [];
+
+        this.emit('change');
+    },
+
+    getState() {
+        return {
+            flashMsgs: _.clone(this.flashMsgs, true)
+        };
+    }
+});

data/app/src/stores/audit_store.js

@@ -0,0 +1,143 @@
+import Fluxxor from 'fluxxor';
+import SortedSet from 'collections/sorted-set';
+import _ from 'lodash';
+
+import constants from '../components/audit/constants';
+import c from '../constants';
+
+/**
+ * AuditStore stores audit events
+ *
+ * Use SortedSet as internal data structure.
+ */
+module.exports = Fluxxor.createStore({
+    initialize() {
+        this.loading = 0;
+        this.events = new SortedSet([], function(a, b) {
+            return b.id === a.id;
+        }, function(a, b) {
+            if (a.id < b.id) {
+                return -1;
+            }
+
+            if (a.id > b.id) {
+                return 1;
+            }
+
+            return 0;
+        });
+
+        this.bindActions(
+            c.AUDIT.LOAD, this._onLoad,
+            c.AUDIT.LOAD_SUCCESS, this._onLoadSuccess,
+            c.AUDIT.LOAD_FAIL, this._onLoadFail
+        );
+    },
+
+    _incLoading() {
+        this.loading = this.loading + 1;
+    },
+
+    _decLoading() {
+        this.loading = this.loading - 1 < 0 ? 0 : this.loading - 1;
+    },
+
+    _isLoading() {
+        return Boolean(this.loading);
+    },
+
+    _filterEvent(e) {
+        // remove internal resources creation
+        if (_.isString(e.role) && (e.role.split(':')[1] === '@')) {
+            return false;
+        }
+
+        if (_.isString(e.resource) && (e.resource.split(':')[1] === '@')) {
+            return false;
+        }
+
+        if (_.isString(e.resource) && (e.resource.split(':')[1] === 'secret')) {
+            return false;
+        }
+
+        if (_.isString(e.grantee) && (e.grantee.split(':')[1] === '@')) {
+            return false;
+        }
+
+        // hide automated creation of roles corresponding to resources of known type
+        if ((e.kind === 'role') && (e.action === 'create')) {
+            var roleKind = e.role.split(':')[1];
+
+            if (_.includes(constants.knownRolsourceTypes, roleKind)) {
+                return false;
+            }
+        }
+
+        // hide new event `role:index` / `all_roles`, which is used by role graph only
+        if ((e.kind === 'role') && (e.action === 'index')) {
+            return false;
+        }
+
+        if ((e.kind === 'role') && (e.action === 'all_roles')) {
+            return false;
+        }
+
+        return true;
+    },
+
+    _onLoad() {
+        this._incLoading();
+        this.emit('change');
+    },
+
+    _onLoadSuccess(payload) {
+        if (_.isObject(payload.event)) {
+            this.events.addEach(_.filter([payload.event], this._filterEvent));
+            this.emit('change');
+        } else if (_.isArray(payload.res.body)) {
+            this._decLoading();
+            this.events.addEach(_.filter(payload.res.body, this._filterEvent));
+            this.emit('change');
+        }
+
+        if (payload.startFlow === true) {
+            this.flux.actions.audit.loadFlow(this.events.findGreatest().value.id);
+        }
+    },
+
+    _onLoadFail() {
+        this._decLoading();
+        this.emit('change');
+    },
+
+    /**
+     * Return all exist events in store
+     */
+    getAllEvents() {
+        return {
+            loading: Boolean(this.loading),
+            data: this.events.toArray()
+        };
+    },
+
+    getEventFor(kind, id) {
+        var fullId = window.decodeURIComponent(this.flux.actions.getFullId(kind, id));
+
+        return {
+            loading: this._isLoading(),
+            data: this.events.filter(function(event) {
+
+                var resourceId = event.resource;
+                if ((!event.resource) && (event.resources)) {
+                    resourceId = event.resources[0];
+                }
+                var roleId = event.role;
+                if ((!event.role) && (event.roles)) {
+                    roleId = event.roles[0];
+                }
+
+                return roleId === fullId || resourceId === fullId;
+            }).toArray()
+        };
+    }
+});

data/app/src/stores/graph_store.js

@@ -0,0 +1,51 @@
+import {createStore} from 'fluxxor';
+import c from '../constants';
+
+export default createStore({
+    initialize() {
+        this.error = false;
+        this.loading = false;
+        this.graphs = {};
+
+        this.bindActions(
+            c.GRAPH.LOAD, this.onLoad,
+            c.GRAPH.LOAD_SUCCESS, this.onLoadSuccess,
+            c.GRAPH.LOAD_FAIL, this.onLoadFail
+        );
+    },
+
+    onLoad() {
+        this.error = false;
+        this.loading = true;
+        this.emit('change');
+    },
+
+    onLoadSuccess(payload) {
+        this.error = false;
+        this.loading = false;
+
+        if (typeof this.graphs[payload.kind] !== 'object') {
+            this.graphs[payload.kind] = {};
+        }
+
+        if (typeof this.graphs[payload.kind][payload.id] !== 'object') {
+            this.graphs[payload.kind][payload.id] = payload.res.body.graph;
+        }
+
+        this.emit('change');
+    },
+
+    onLoadFail() {
+        this.error = true;
+        this.loading = false;
+        this.emit('change');
+    },
+
+    getGraph(kind, id) {
+        return {
+            loading: this.loading,
+            error: this.error,
+            data: (this.graphs[kind] || {})[id] || []
+        };
+    }
+});

data/app/src/stores/group_store.js

@@ -0,0 +1,104 @@
+import {createStore} from 'fluxxor';
+import {c as generic} from '../clients/generic';
+import {GROUP as constants} from '../constants';
+
+var fieldMapping = {
+    ATTRIBUTES: 'group',
+    OWNED_RESOURCES: 'owned',
+    ALL_ROLES: 'roles',
+    GROUP_ROLES: 'members',
+    RESOURCES: 'resources'
+};
+
+export default createStore({
+    initialize() {
+        this.data = this._fresh();
+
+        this.bindActions(
+            constants.LOAD, this.onLoad,
+            constants.LOAD_SUCCESS, this.onLoadSuccess,
+            constants.LOAD_FAIL, this.onLoadFail
+        );
+    },
+
+    _fresh() {
+        return {
+            group: {
+                id: ''
+            },
+            loading: {
+                group: true,
+                owned: true,
+                roles: true,
+                members: true,
+                resources: true
+            }
+        };
+    },
+
+    onLoad(payload) {
+        if (typeof payload.type === 'undefined') {
+            this.data = this._fresh();
+            this.data.identifier = payload.id;
+            this.emit('change');
+        } else if (payload.id === this.data.identifier) {
+            this.turn(payload.type, true);
+            this.emit('change');
+        }
+    },
+
+    onLoadSuccess(payload) {
+        if (payload.id === this.data.identifier) {
+            this.turn(payload.type, false);
+
+            this.setData(payload);
+            this.emit('change');
+        }
+    },
+
+    onLoadFail(payload) {
+        this.turn(payload.type, false);
+    },
+
+    turn(type, state) {
+        var fields = fieldMapping[type];
+
+        if (typeof fields === 'object') {
+            fields.forEach((field) => {
+                this.data.loading[field] = state;
+            });
+        } else {
+            this.data.loading[fields] = state;
+        }
+    },
+
+    setData(payload) {
+        switch (payload.type) {
+        case generic.ATTRIBUTES:
+            this.data.group = payload.res.body;
+            break;
+
+        case generic.OWNED_RESOURCES:
+            this.data.owned = payload.res.body;
+            break;
+
+        case generic.ALL_ROLES:
+            this.data.roles = payload.res.body;
+            break;
+
+        case 'GROUP_ROLES':
+            this.data.members = payload.res.body;
+            break;
+
+        case 'RESOURCES':
+            this.data.resources = payload.res.body;
+            break;
+
+        default:
+        }
+    },
+
+    getData() {
+        return this.data;
+    }
+});

data/app/src/stores/host_store.js

@@ -0,0 +1,111 @@
+import {createStore} from 'fluxxor';
+import {c as generic} from '../clients/generic';
+import {c as members} from '../clients/members';
+import {HOST as constants} from '../constants';
+
+var fieldMapping = {
+    ATTRIBUTES: 'host',
+    OWNED_RESOURCES: 'owned',
+    ALL_ROLES: 'roles',
+    RESOURCES: 'resources',
+    MEMBERS_EXECUTE: 'executors',
+    MEMBERS_UPDATE: 'updaters'
+};
+
+export default createStore({
+    initialize() {
+        this.data = this._fresh();
+
+        this.bindActions(
+            constants.LOAD, this.onLoad,
+            constants.LOAD_SUCCESS, this.onLoadSuccess,
+            constants.LOAD_FAIL, this.onLoadFail
+        );
+    },
+
+    _fresh() {
+        return {
+            host: {},
+            loading: {
+                host: true,
+                owned: true,
+                roles: true,
+                resources: true
+            }
+        };
+    },
+
+    onLoad(payload) {
+        if (typeof payload.type === 'undefined') {
+            this.data = this._fresh();
+            this.data.identifier = payload.id;
+            this.emit('change');
+        } else if (payload.id === this.data.identifier) {
+            this.turn(payload.type, true);
+            this.emit('change');
+        }
+    },
+
+    onLoadSuccess(payload) {
+        if (payload.id === this.data.identifier) {
+            this.turn(payload.type, false);
+
+            this.setData(payload);
+            this.emit('change');
+        }
+    },
+
+    onLoadFail(payload) {
+        this.turn(payload.type, false);
+    },
+
+    turn(type, state) {
+        var fields = fieldMapping[type];
+
+        if (typeof fields === 'object') {
+            fields.forEach((field) => {
+                this.data.loading[field] = state;
+            });
+        } else {
+            this.data.loading[fields] = state;
+        }
+    },
+
+    notInternalRole(item) {
+        return item.split(':')[1] !== '@';
+    },
+
+    setData(payload) {
+        switch (payload.type) {
+        case generic.ATTRIBUTES:
+            this.data.host = payload.res.body;
+            break;
+
+        case generic.OWNED_RESOURCES:
+            this.data.owned = payload.res.body;
+            break;
+
+        case generic.ALL_ROLES:
+            this.data.roles = payload.res.body;
+            break;
+
+        case members.MEMBERS_EXECUTE:
+            this.data.executors = payload.res.body.filter(this.notInternalRole);
+            break;
+
+        case members.MEMBERS_UPDATE:
+            this.data.updaters = payload.res.body.filter(this.notInternalRole);
+            break;
+
+        case 'RESOURCES':
+            this.data.resources = payload.res.body;
+            break;
+
+        default:
+        }
+    },
+
+    getData() {
+        return this.data;
+    }
+});

data/app/src/stores/layer_store.js

@@ -0,0 +1,115 @@
+import {createStore} from 'fluxxor';
+import {pluck} from 'lodash';
+
+import {c as generic} from '../clients/generic';
+import {c as layerMembers} from '../clients/layer_members';
+import {LAYER as constants} from '../constants';
+
+var fieldMapping = {
+    ATTRIBUTES: 'layer',
+    OWNED_RESOURCES: 'owned',
+    ALL_ROLES: 'roles',
+    LAYER_MEMBERS_USE: 'users',
+    LAYER_MEMBERS_ADMIN: 'admins',
+    RESOURCES: 'resources'
+};
+
+export default createStore({
+    initialize() {
+        this.data = this._fresh();
+
+        this.bindActions(
+            constants.LOAD, this.onLoad,
+            constants.LOAD_SUCCESS, this.onLoadSuccess,
+            constants.LOAD_FAIL, this.onLoadFail
+        );
+    },
+
+    _fresh() {
+        return {
+            layer: {
+                hosts: []
+            },
+            admins: [],
+            users: [],
+            loading: {
+                layer: true,
+                owned: true,
+                roles: true,
+                users: true,
+                admins: true,
+                resources: true
+            }
+        };
+    },
+
+    onLoad(payload) {
+        if (typeof payload.type === 'undefined') {
+            this.data = this._fresh();
+            this.data.identifier = payload.id;
+            this.emit('change');
+        } else if (payload.id === this.data.identifier) {
+            this.turn(payload.type, true);
+            this.emit('change');
+        }
+    },
+
+    onLoadSuccess(payload) {
+        if (payload.id === this.data.identifier) {
+            this.turn(payload.type, false);
+
+            this.setData(payload);
+            this.emit('change');
+        }
+    },
+
+    onLoadFail(payload) {
+        this.turn(payload.type, false);
+    },
+
+    turn(type, state) {
+        var fields = fieldMapping[type];
+
+        if (typeof fields === 'object') {
+            fields.forEach((field) => {
+                this.data.loading[field] = state;
+            });
+        } else {
+            this.data.loading[fields] = state;
+        }
+    },
+
+    setData(payload) {
+        switch (payload.type) {
+        case generic.ATTRIBUTES:
+            this.data.layer = payload.res.body;
+            break;
+
+        case generic.OWNED_RESOURCES:
+            this.data.owned = payload.res.body;
+            break;
+
+        case generic.ALL_ROLES:
+            this.data.roles = payload.res.body;
+            break;
+
+        case layerMembers.LAYER_MEMBERS_USE:
+            this.data.users = pluck(payload.res.body, 'member');
+            break;
+
+        case layerMembers.LAYER_MEMBERS_ADMIN:
+            this.data.admins = pluck(payload.res.body, 'member');
+            break;
+
+        case 'RESOURCES':
+            this.data.resources = payload.res.body;
+            break;
+
+        default:
+        }
+    },
+
+    getData() {
+        return this.data;
+    }
+});