conjur-asset-ui 1.4.2 → 1.6.0

data/app/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "conjur-asset-ui",
+  "private": true,
+  "version": "1.5.1",
+  "description": "Conjur UI",
+  "author": "Nikolai Sevostjanov <nikolai.sevostjanov@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/conjurinc/conjur-asset-ui.git"
+  },
+  "bugs": {
+    "url": "https://github.com/conjurinc/conjur-asset-ui/issues"
+  },
+  "dependencies": {
+    "babel-runtime": "^5.2.15",
+    "bootstrap": "^3.3.4",
+    "classnames": "^1.2.0",
+    "collections": "^1.2.2",
+    "d3": "^3.5.5",
+    "dagre": "^0.7.1",
+    "dagre-d3": "^0.4.3",
+    "event-source-polyfill": "0.0.1",
+    "fluxxor": "^1.5.4",
+    "lodash": "^3.6.0",
+    "moment": "^2.10.2",
+    "react": "^0.13.2",
+    "react-bootstrap": "^0.21.2",
+    "react-router": "^0.13.2",
+    "react-router-bootstrap": "^0.13.0",
+    "superagent": "^1.2.0"
+  },
+  "devDependencies": {
+    "autoprefixer-loader": "^1.2.0",
+    "babel-core": "^5.2.15",
+    "babel-eslint": "^3.0.1",
+    "babel-loader": "^5.0.0",
+    "css-loader": "^0.12.0",
+    "del": "^1.1.1",
+    "eslint": "^0.20.0",
+    "eslint-loader": "^0.11.1",
+    "eslint-plugin-react": "git+https://github.com/yannickcr/eslint-plugin-react.git",
+    "exports-loader": "^0.6.2",
+    "extract-text-webpack-plugin": "^0.7.1",
+    "file-loader": "^0.8.1",
+    "gulp": "^3.8.11",
+    "gulp-changed": "^1.2.1",
+    "gulp-concat": "^2.5.2",
+    "gulp-filter": "^2.0.2",
+    "gulp-flatten": "0.0.4",
+    "gulp-if": "^1.2.5",
+    "gulp-insert": "^0.4.0",
+    "gulp-load-plugins": "^0.10.0",
+    "gulp-plumber": "^1.0.0",
+    "gulp-size": "^1.2.1",
+    "gulp-sourcemaps": "^1.5.1",
+    "gulp-uglify": "^1.1.0",
+    "gulp-util": "^3.0.4",
+    "jest-cli": "^0.4.1",
+    "less": "^2.5.0",
+    "less-loader": "^2.2.0",
+    "merge-stream": "^0.1.7",
+    "minimist": "^1.1.1",
+    "protractor": "^1.8.0",
+    "psi": "^1.0.6",
+    "react-tools": "^0.13.2",
+    "run-sequence": "^1.0.2",
+    "style-loader": "^0.12.1",
+    "url-loader": "^0.5.5",
+    "webpack": "^1.8.4",
+    "webpack-dev-server": "^1.8.0"
+  },
+  "main": "",
+  "jest": {
+    "rootDir": "src",
+    "scriptPreprocessor": "../config/preprocessor.js",
+    "unmockedModulePathPatterns": [
+      "react",
+      "lodash"
+    ]
+  },
+  "scripts": {
+    "test": "jest",
+    "eslint": "eslint src"
+  }
+}

data/app/src/actions.js

@@ -0,0 +1,550 @@
+import _ from 'lodash';
+
+import * as audit from './clients/audit';
+import * as generic from './clients/generic';
+import * as list from './clients/list';
+import * as search from './clients/search';
+import * as members from './clients/members';
+import * as layerMembers from './clients/layer_members';
+import * as graph from './clients/graph';
+
+import {RManager} from './clients/request';
+
+import constants from './constants';
+import {readCookie} from './utils';
+
+let rmanager;
+
+function getFullId(kind, id) {
+    return window.encodeURIComponent(
+        `${rmanager.account}:${kind}:${id}`
+    );
+}
+
+export default {
+    getRManager() {
+        if (_.isUndefined(rmanager)) {
+            rmanager = new RManager(this.flux, readCookie('conjur_configuration'));
+        }
+
+        return rmanager;
+    },
+
+    getFullId(kind, id) {
+        return getFullId(kind, id);
+    },
+
+    flashMessage(msg, level) {
+        this.dispatch(constants.FLASH_MESSAGE, {msg: msg, level: level});
+    },
+
+    flashMessageClear() {
+        this.dispatch(constants.FLASH_MESSAGE_CLEAR);
+    },
+
+    routes: {
+        transition(params) {
+            this.dispatch(constants.ROUTES.TRANSITION, {params: params});
+        }
+    },
+
+    search(query) {
+        this.dispatch(constants.SEARCH.LOAD, {id: query});
+
+        search
+            .fetch(rmanager, query)
+            .then(
+                res => {
+                    const payload = {id: query, type: 'SEARCH_RESULT', res: res};
+
+                    this.dispatch(
+                        constants.SEARCH.LOAD_SUCCESS,
+                        payload
+                    );
+                },
+                () => {
+                    this.dispatch(constants.SEARCH.LOAD_FAIL, {id: query, type: 'SEARCH_RESULT'});
+                });
+    },
+
+    audit: {
+        loadAll(startFlow) {
+            this.dispatch(constants.AUDIT.LOAD);
+
+            audit
+                .fetch(rmanager, audit.c.AUDIT_ALL, null)
+                .then(
+                    res => {
+                        const payload = {res: res, startFlow: startFlow};
+
+                        this.dispatch(
+                            constants.AUDIT.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.AUDIT.LOAD_FAIL);
+                    });
+        },
+
+        loadFlow(/*lastEventId*/) {
+            // let eventSource = audit.fetch(audit.c.AUDIT_FLOW, null);
+
+            // eventSource.onmessage = event => {
+            //     const data = JSON.parse(event.data);
+
+            //     if (data.id > lastEventId) {
+            //         const payload = {event: data};
+
+            //         this.dispatch(
+            //             constants.AUDIT.LOAD_SUCCESS,
+            //             payload);
+            //     }
+            // };
+
+            // eventSource.onerror = () => {
+            //     // this.dispatch(constants.AUDIT.LOAD_FAIL);
+            // };
+        },
+
+        loadForRole(kind, id) {
+            this.dispatch(constants.AUDIT.LOAD);
+
+            audit
+                .fetch(
+                    rmanager,
+                    audit.c.AUDIT_ROLE,
+                    getFullId(kind, id)
+                )
+                .then(
+                    res => {
+                        const payload = {res: res};
+
+                        this.dispatch(
+                            constants.AUDIT.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.AUDIT.LOAD_FAIL, {kind: kind, id: id});
+                    });
+        },
+
+        loadForResource(kind, id) {
+            this.dispatch(constants.AUDIT.LOAD);
+
+            audit
+                .fetch(
+                    rmanager,
+                    audit.c.AUDIT_RESOURCE,
+                    getFullId(kind, id)
+                )
+                .then(
+                    res => {
+                        const payload = {res: res};
+
+                        this.dispatch(
+                            constants.AUDIT.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.AUDIT.LOAD_FAIL, {kind: kind, id: id});
+                    });
+        }
+    },
+
+    resources: {
+        load(kind) {
+            this.dispatch(constants.RESOURCES.LOAD);
+
+            list
+                .fetch(rmanager, kind)
+                .then(
+                    res => {
+                        this.dispatch(constants.RESOURCES.LOAD_SUCCESS, {res: res});
+                    },
+                    () => {
+                        this.dispatch(constants.RESOURCES.LOAD_FAIL, {id: kind});
+                    });
+        },
+
+        loadOne(kind, id) {
+            this.dispatch(constants.RESOURCE.LOAD);
+
+            list
+                .fetchOne(rmanager, kind, id)
+                .then(
+                    res => {
+                        this.dispatch(constants.RESOURCE.LOAD_SUCCESS, {kind: kind, id: id, res: res});
+                    },
+                    () => {
+                        this.dispatch(constants.RESOURCE.LOAD_FAIL, {kind: kind, id: id});
+                    });
+        }
+    },
+
+    graph: {
+        load(kind, id) {
+            this.dispatch(constants.GRAPH.LOAD);
+
+            graph
+                .fetch(
+                    rmanager,
+                    getFullId(kind, id)
+                )
+                .then(
+                    res => {
+                        const payload = {kind: kind, id: id, res: res};
+
+                        this.dispatch(
+                            constants.GRAPH.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.GRAPH.LOAD_FAIL, {id: id});
+                    });
+        }
+    },
+
+    user: {
+        load(id) {
+            this.dispatch(constants.USER.LOAD, {id: id});
+
+            [
+                generic.c.ATTRIBUTES,
+                generic.c.OWNED_RESOURCES,
+                generic.c.ALL_ROLES,
+                generic.c.PUBLIC_KEYS
+            ].forEach((type) => {
+                this.dispatch(constants.USER.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'user', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.USER.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.USER.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            this.dispatch(constants.USER.LOAD, {id: id, type: 'RESOURCES'});
+
+            list
+                .fetchResources(rmanager, getFullId('user', id))
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'RESOURCES', res: res};
+
+                        this.dispatch(
+                            constants.USER.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.USER.LOAD_FAIL, {type: 'RESOURCES'});
+                    });
+        }
+    },
+
+    group: {
+        load(id) {
+            this.dispatch(constants.GROUP.LOAD, {id: id});
+
+            [
+                generic.c.ATTRIBUTES,
+                generic.c.OWNED_RESOURCES,
+                generic.c.ALL_ROLES
+            ].forEach((type) => {
+                this.dispatch(constants.GROUP.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'group', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.GROUP.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.GROUP.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            this.dispatch(constants.GROUP.LOAD, {id: id, type: 'GROUP_ROLES'});
+
+            list
+                .fetchGroupRoles(rmanager, id)
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'GROUP_ROLES', res: res};
+
+                        this.dispatch(
+                            constants.GROUP.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.GROUP.LOAD_FAIL, {type: 'GROUP_ROLES'});
+                    });
+
+            this.dispatch(constants.GROUP.LOAD, {id: id, type: 'RESOURCES'});
+
+            list
+                .fetchResources(rmanager, getFullId('group', id))
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'RESOURCES', res: res};
+
+                        this.dispatch(
+                            constants.GROUP.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.GROUP.LOAD_FAIL, {type: 'RESOURCES'});
+                    });
+        }
+    },
+
+    host: {
+        load(id) {
+            this.dispatch(constants.HOST.LOAD, {id: id});
+
+            [
+                generic.c.ATTRIBUTES,
+                generic.c.OWNED_RESOURCES,
+                generic.c.ALL_ROLES
+            ].forEach((type) => {
+                this.dispatch(constants.HOST.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'host', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.HOST.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.HOST.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            [
+                members.c.MEMBERS_EXECUTE,
+                members.c.MEMBERS_UPDATE
+            ].forEach((type) => {
+                this.dispatch(constants.HOST.LOAD, {id: id, type: type});
+
+                members
+                    .fetch(rmanager, constants.HOST.ASSET_TYPE, type, id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.HOST.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.HOST.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            this.dispatch(constants.HOST.LOAD, {id: id, type: 'RESOURCES'});
+
+            list
+                .fetchResources(rmanager, getFullId('host', id))
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'RESOURCES', res: res};
+
+                        this.dispatch(
+                            constants.HOST.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.HOST.LOAD_FAIL, {type: 'RESOURCES'});
+                    });
+        }
+    },
+
+    layer: {
+        load(id) {
+            this.dispatch(constants.LAYER.LOAD, {id: id});
+
+            [
+                generic.c.ATTRIBUTES,
+                generic.c.OWNED_RESOURCES,
+                generic.c.ALL_ROLES
+            ].forEach((type) => {
+                this.dispatch(constants.LAYER.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'layer', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.LAYER.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.LAYER.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            [
+                layerMembers.c.LAYER_MEMBERS_USE,
+                layerMembers.c.LAYER_MEMBERS_ADMIN
+            ].forEach((type) => {
+                this.dispatch(constants.LAYER.LOAD, {id: id, type: type});
+
+                layerMembers
+                    .fetch(rmanager, type, id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.LAYER.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.LAYER.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            this.dispatch(constants.LAYER.LOAD, {id: id, type: 'RESOURCES'});
+
+            list
+                .fetchResources(rmanager, getFullId('layer', id))
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'RESOURCES', res: res};
+
+                        this.dispatch(
+                            constants.LAYER.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.LAYER.LOAD_FAIL, {type: 'RESOURCES'});
+                    });
+        }
+    },
+
+    variable: {
+        load(id) {
+            this.dispatch(constants.VARIABLE.LOAD, {id: id});
+
+            [
+                generic.c.ATTRIBUTES
+            ].forEach((type) => {
+                this.dispatch(constants.VARIABLE.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'variable', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.VARIABLE.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.VARIABLE.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            [
+                members.c.MEMBERS_EXECUTE,
+                members.c.MEMBERS_UPDATE
+            ].forEach((type) => {
+                this.dispatch(constants.VARIABLE.LOAD, {id: id, type: type});
+
+                members
+                    .fetch(rmanager, constants.VARIABLE.ASSET_TYPE, type, id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.VARIABLE.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.VARIABLE.LOAD_FAIL, {type: type});
+                        });
+            });
+        }
+    },
+
+    policy: {
+        load(id) {
+            this.dispatch(constants.POLICY.LOAD, {id: id});
+
+            [
+                generic.c.OWNED_RESOURCES,
+                generic.c.ALL_ROLES
+            ].forEach((type) => {
+                this.dispatch(constants.POLICY.LOAD, {id: id, type: type});
+
+                generic
+                    .fetch(rmanager, type, 'policy', id)
+                    .then(
+                        res => {
+                            const payload = {id: id, type: type, res: res};
+
+                            this.dispatch(
+                                constants.POLICY.LOAD_SUCCESS,
+                                payload
+                            );
+                        },
+                        () => {
+                            this.dispatch(constants.POLICY.LOAD_FAIL, {type: type});
+                        });
+            });
+
+            this.dispatch(constants.POLICY.LOAD, {id: id, type: 'RESOURCES'});
+
+            list
+                .fetchResources(rmanager, getFullId('policy', id))
+                .then(
+                    res => {
+                        const payload = {id: id, type: 'RESOURCES', res: res};
+
+                        this.dispatch(
+                            constants.POLICY.LOAD_SUCCESS,
+                            payload
+                        );
+                    },
+                    () => {
+                        this.dispatch(constants.POLICY.LOAD_FAIL, {type: 'RESOURCES'});
+                    });
+        }
+    }
+};