mirror of
https://github.com/mickael-kerjean/filestash.git
synced 2025-11-01 19:32:27 +08:00
470 lines
36 KiB
JavaScript
470 lines
36 KiB
JavaScript
import React, { useState, useEffect } from "react";
|
|
import { FormBuilder, Icon, Input, Alert, Loader } from "../../components/";
|
|
import { Backend, Config, Middleware } from "../../model/";
|
|
import { FormObjToJSON, notify, format, createFormBackend, objectGet, JSONStringify } from "../../helpers/";
|
|
import { t } from "../../locales/";
|
|
|
|
import "./backend.scss";
|
|
|
|
export class BackendPage extends React.Component {
|
|
constructor(props) {
|
|
super(props);
|
|
this.state = {
|
|
backend_enabled: [],
|
|
backend_available: {},
|
|
auth_enabled: null,
|
|
auth_available: {},
|
|
config: null,
|
|
isLoading: true,
|
|
};
|
|
}
|
|
|
|
componentDidMount() {
|
|
Promise.all([
|
|
Backend.all(),
|
|
Config.all(),
|
|
Middleware.getAllAuthentication(),
|
|
]).then((data) => {
|
|
const [backend, config, middleware_auth] = data;
|
|
delete config["constants"];
|
|
this.setState({
|
|
isLoading: false,
|
|
backend_available: backend,
|
|
backend_enabled: window.CONFIG["connections"].filter((b) => b).map((conn) => {
|
|
const f = createFormBackend(backend, conn);
|
|
if (Object.keys(f).length === 0) {
|
|
return null;
|
|
}
|
|
return f;
|
|
}).filter((a) => a !== null),
|
|
config: config,
|
|
auth_available: middleware_auth,
|
|
auth_enabled: {
|
|
// We are storing the config in a fixed schema as we had issues with handling
|
|
// different schema for each authentication middleware.
|
|
"identity_provider": (function() {
|
|
let { type, params } = objectGet(config, ["middleware", "identity_provider"]) || {};
|
|
type = objectGet(type, ["value"]);
|
|
params = objectGet(params, ["value"]);
|
|
if (!type) return {};
|
|
const idpParams = JSON.parse(params);
|
|
const idpForm = middleware_auth[type] || {};
|
|
let key = null;
|
|
for (key in idpParams) {
|
|
if (!idpForm[key]) continue;
|
|
idpForm[key]["value"] = idpParams[key];
|
|
}
|
|
return idpForm;
|
|
}()),
|
|
"attribute_mapping": (function(state) {
|
|
let { related_backend, params = {} } = objectGet(config, ["middleware", "attribute_mapping"]) || {};
|
|
related_backend = objectGet(related_backend, ["value"]);
|
|
params = JSON.parse(objectGet(params, ["value"]) || "{}");
|
|
const backendsForm = Object.keys(params).reduce((acc, key) => {
|
|
const t = createFormBackend(
|
|
backend,
|
|
params[key],
|
|
);
|
|
acc[key] = t[params[key]["type"]];
|
|
return acc;
|
|
}, {});
|
|
return {
|
|
"related_backend": {
|
|
"label": "Related Backend",
|
|
"type": "text",
|
|
"description": "List of backends to have behind the authentication process. Can be either a backend type of the actual label",
|
|
"placeholder": "eg: ftp,sftp,webdav",
|
|
"readonly": false,
|
|
"default": null,
|
|
"value": related_backend,
|
|
"multi": true,
|
|
"datalist": window.CONFIG["connections"].map((r) => r.label),
|
|
"required": true,
|
|
},
|
|
...backendsForm,
|
|
};
|
|
})(),
|
|
},
|
|
});
|
|
});
|
|
}
|
|
|
|
componentWillUnmount() {
|
|
this.props.isSaving(false);
|
|
Config.clear();
|
|
}
|
|
|
|
refresh() {
|
|
// refresh the screen to refresh the mutation
|
|
// that have happenned down the stack which react couldn't detect directly
|
|
this.setState({ refresh: Math.random() });
|
|
}
|
|
|
|
_buildConfig() {
|
|
const json = FormObjToJSON(this.state.config);
|
|
json.connections = this.state.backend_enabled.map((backend) => {
|
|
const data = FormObjToJSON(backend, (obj, key) => {
|
|
if (obj[key].enabled === true) {
|
|
obj[key] = obj[key].value || obj[key].default;
|
|
} else {
|
|
delete obj[key];
|
|
}
|
|
});
|
|
const key = Object.keys(data)[0];
|
|
return data[key];
|
|
});
|
|
return json;
|
|
}
|
|
|
|
onUpdateStorageBackend(e) {
|
|
this.refresh();
|
|
const json = this._buildConfig();
|
|
this.props.isSaving(true);
|
|
return Config.save(json, true, () => {
|
|
this.props.isSaving(false);
|
|
}, (err) => {
|
|
notify.send(err && err.message || t("Oops"), "error");
|
|
this.props.isSaving(false);
|
|
});
|
|
}
|
|
|
|
onUpdateAuthenticationMiddleware(middlewareData = null) {
|
|
this.refresh();
|
|
const json = this._buildConfig();
|
|
json["middleware"] = {
|
|
"identity_provider": (function() {
|
|
const { type, ...other } = objectGet(middlewareData, ["identity_provider"]) || {};
|
|
return {
|
|
"type": type || null,
|
|
"params": JSONStringify(other),
|
|
};
|
|
})(),
|
|
"attribute_mapping": (function() {
|
|
let { related_backend = null, ...params } = objectGet(middlewareData, ["attribute_mapping"]) || {};
|
|
const obj = {
|
|
"related_backend": related_backend || "nop"
|
|
};
|
|
if(Object.keys(params).length > 0) {
|
|
obj.params = JSONStringify(params);
|
|
}
|
|
return obj;
|
|
})(),
|
|
};
|
|
|
|
this.props.isSaving(true);
|
|
return Config.save(json, true, () => {
|
|
this.props.isSaving(false);
|
|
}, (err) => {
|
|
notify.send(err && err.message || t("Oops"), "error");
|
|
this.props.isSaving(false);
|
|
});
|
|
}
|
|
|
|
addBackend(backend_id) {
|
|
this.setState({
|
|
backend_enabled: this.state.backend_enabled.concat(
|
|
createFormBackend(this.state.backend_available, {
|
|
type: backend_id,
|
|
label: function() {
|
|
const existingLabels = this.state.backend_enabled
|
|
.filter((b) => !!b[backend_id])
|
|
.map((b) => b[backend_id]["label"]["value"]);
|
|
|
|
for (let i=1; i<=existingLabels.length; i++) {
|
|
const desiredLabel = backend_id.toUpperCase() + i;
|
|
if (existingLabels.indexOf(desiredLabel) === -1) {
|
|
return desiredLabel;
|
|
}
|
|
}
|
|
return backend_id.toUpperCase();
|
|
}.bind(this)(),
|
|
}),
|
|
),
|
|
}, this.onUpdateStorageBackend.bind(this));
|
|
}
|
|
|
|
removeBackend(n) {
|
|
this.setState({
|
|
backend_enabled: this.state.backend_enabled.filter((_, i) => i !== n),
|
|
}, this.onUpdateStorageBackend.bind(this));
|
|
}
|
|
|
|
changeAuthentication(auth) {
|
|
this.setState({
|
|
auth_enabled: {
|
|
"identity_provider": auth === null ? {} : this.state.auth_available[auth],
|
|
"attribute_mapping": objectGet(this.state.auth_enabled, ["attribute_mapping"]) || {},
|
|
},
|
|
}, () => {
|
|
this.onUpdateAuthenticationMiddleware(FormObjToJSON(this.state.auth_enabled));
|
|
});
|
|
}
|
|
|
|
render() {
|
|
const formRender = ($input, props, struct, onChange) => {
|
|
if (struct.type === "enable") {
|
|
// toggle buttons is to hide info from the login page
|
|
// in this screen, we don't want users to have to click through too many things
|
|
return null;
|
|
}
|
|
return (
|
|
<label className={"no-select input_type_" + props.params["type"]}>
|
|
<div>
|
|
<span>
|
|
{ format(struct.label) }:
|
|
</span>
|
|
<div style={{ width: "100%" }}>
|
|
{ $input }
|
|
</div>
|
|
</div>
|
|
<div>
|
|
<span className="nothing"></span>
|
|
<div style={{ width: "100%" }}>
|
|
{
|
|
struct.description ? (
|
|
<div className="description" dangerouslySetInnerHTML={{
|
|
__html: function() {
|
|
const regLink = /\[([^\]]*)\]\(([^\)]+)\)/g;
|
|
return struct.description
|
|
.replace(regLink, "<a target=\"_blank\" href=\"$2\">$1</a>")
|
|
.replaceAll("\n", "<br>");
|
|
}()
|
|
}}></div>
|
|
) : null
|
|
}
|
|
</div>
|
|
</div>
|
|
</label>
|
|
);
|
|
};
|
|
|
|
return (
|
|
<div className="component_dashboard sticky">
|
|
{
|
|
this.state.isLoading ? (
|
|
<Loader />
|
|
) : (
|
|
<React.Fragment>
|
|
<StorageBackend
|
|
backend_available={this.state.backend_available}
|
|
backend_enabled={this.state.backend_enabled}
|
|
backend_add={this.addBackend.bind(this)}
|
|
backend_remove={this.removeBackend.bind(this)}
|
|
formChange={this.onUpdateStorageBackend.bind(this)}
|
|
formRender={formRender}
|
|
/>
|
|
<br/><Alert className="info">
|
|
Once you have selected one or more storage backend, you can add some middleware to:<br/>
|
|
1. link the storage to an identity provider using an authentication middleware plugin<br/>
|
|
2. change who can do what and where using an authorisation middleware plugin<br/>
|
|
<br/>
|
|
<img
|
|
style={{display: "block", margin: "0 auto", border: "none"}}
|
|
src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!-- Do not edit this file with editors other than diagrams.net -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="393px" height="222px" viewBox="-0.5 -0.5 393 222" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2022-11-14T08:00:44.515Z&quot; agent=&quot;5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36&quot; etag=&quot;REHWLQNVk8jRhT1Meiis&quot; version=&quot;20.4.1&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;k57LS8GZpEZ4xsVlqrtw&quot; name=&quot;Page-1&quot;&gt;7Zpfc9o4EMA/DY9hbMvC8AgJSS9Dp+nRmbs+Glux1QiLEaLAffqTbPmvDLiJ3bgZJjMZaSVL1v52V9LiAbhdHx6Yuwk/Ux+RgWX4hwG4G1jWxATivxQcE4EDjEQQMOwnIjMXLPF/SAnTbjvso22pI6eUcLwpCz0aRcjjJZnLGN2Xuz1TUp514wZIEyw9l+jSf7DPw0Q6tpxc/gnhIExnNkeTpGXtpp3VSrah69N9QQTmA3DLKOVJaX24RUTqLtVL8tz9idbsxRiKeJMH8NcFCH+8sE/B49fHx8Ujv5+HN2qUny7ZqQWrl+XHVAPivTeyKGZyCUGEBsxdD8BsgxheI45Yte0pb5jtQ8zRcuN6coS9sBAhC/maiJopis/4gFLosu672xD5qrLljL6gW0ooi98ETGz5Fz9GSCqPaISyzikiodyZrp90sYhxdCiIlL4eEBWvzY6ii2oFtmJ3TI1S1fe5KYyUKCxawVgJXWV9QTZ0DkgUFKNf4GX1i9cbET3TiNc93AI6e9Q3dKA5ut2aTD0u1TKTK8YiHC3cFSJPdIs5ppHosqKc03Whw5TgQDZwWmFGd5zgSEBKA6TRC9+yqoCgqQECNYBGXfFxND7THQ/FAoV2Y6VXaYmF8rKqy1pV2qtRqKtYeWJ0xGogrrHvy2lq/ZHRXeTHUdKIa9xVNnEztpVTpS7qnHGyuJ9ajdFGsDQrQB2oATWtGqKgK6JjjeiT0Bb1KPloLNsImKBv+Ez9cHL/12I+sEZEsloxUQpkafnty9/Th/nJcOodRQD0EQOXN7hVwmOxygSu9xLElL4kcTQ1D0UF1lA6E1xP+eJvCroQViBbIw3ypG5XNOyuIPfsRNOzE6ht9O0YY+rnGLlPUoa3H3KbbGNndHoXWu3mXuftGDnOmIiDiF/2p1zrZo2SixQm58+h3VzoxrBEQsynk6iNf52RGGkkPsdWvRfr7KkvlWLk646b4sXFDDgKvsnryt0NaIlv5VKRbWYXwmV3jqbfKjSoKPKnMlMl6RB3u8XeKZcyavQtlMWO/6rGuPJdVoYWTOt3h2Lr3XFw6Qr4C66H/FL6TAdTUDysUXwqY4iIwPCznHSro6FmeKJYvMnpu0f1lrilO+Yh9VQxSVYdCFrDMXRM20r+T6rDDq1is1WehbssQFybJbacTCdvSP4YXRvTR7IJG8IKPPN1NmE7FwbqGnuDJO0Ve+bBE7udUGCbFwbqGnuDm9EVe+6klZ2/emJrjB1eGKhr7A3yxFfsuZO2hB1M3hl7gxvZFXt+TGsL+yX76Ro77Br7ifvBmcsByG4OhTxae1eGRKNndGL2y9ag2dI5EoJ3PkfqqYbfFmLQAfPMCEX5e6Gcm6CsSOU4UNXqDbCRmSVU/iAzAy2FNPjeIa1ByuMj5hahDYcVBx+PhzWZ3hobsowz9vK2D0b0H0GXnDL51ZNlyB+3hMdreK5pxgu/ylQvGzVpRtOp4fyKPKOo5t+IJT6af2gH5v8D&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><path d="M 81 181 L 101 1 L 141 1 L 121 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="6 6" pointer-events="all"/><path d="M 201 181 L 221 1 L 261 1 L 241 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><ellipse cx="16" cy="59.5" rx="7.5" ry="7.5" fill="none" stroke="#949494" stroke-width="2" pointer-events="all"/><path d="M 16 67 L 16 92 M 16 72 L 1 72 M 16 72 L 31 72 M 16 92 L 1 112 M 16 92 L 31 112" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><rect x="51" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,111,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 111 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 52px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Authentication</div></div></div></foreignObject><text x="111" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Authentication</text></switch></g><rect x="171" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,231,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 231 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 172px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Protocol</div></div></div></foreignObject><text x="231" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Protocol</text></switch></g><path d="M 291 42 C 291 33.72 311.15 27 336 27 C 347.93 27 359.38 28.58 367.82 31.39 C 376.26 34.21 381 38.02 381 42 L 381 116 C 381 124.28 360.85 131 336 131 C 311.15 131 291 124.28 291 116 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 381 42 C 381 50.28 360.85 57 336 57 C 311.15 57 291 50.28 291 42" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 92px; margin-left: 292px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">FILE<br />STORAGE</div></div></div></foreignObject><text x="336" y="97" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">FILE...</text></switch></g><path d="M 141 181 L 161 1 L 201 1 L 181 181 Z" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="6 6" pointer-events="all"/><rect x="111" y="76" width="120" height="30" fill="none" stroke="none" transform="rotate(-84,171,91)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-84 171 91)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 91px; margin-left: 112px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Authorisation</div></div></div></foreignObject><text x="171" y="96" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Authorisation</text></switch></g><path d="M 136 140 L 133.5 140 Q 131 140 131 150 L 131 180 Q 131 190 128.5 190 L 127.25 190 Q 126 190 128.5 190 L 129.75 190 Q 131 190 131 200 L 131 230 Q 131 240 133.5 240 L 136 240" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" transform="rotate(-90,131,190)" pointer-events="all"/><rect x="101" y="191" width="60" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 205px; margin-left: 102px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Middleware</div></div></div></foreignObject><text x="131" y="210" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Middlew...</text></switch></g><path d="M 51 61 L 85.62 61.23" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 91.62 61.27 L 83.59 65.22 L 85.62 61.23 L 83.65 57.22 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 196 62 L 207.76 62" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 213.76 62 L 205.76 66 L 207.76 62 L 205.76 58 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 135 61 L 146.76 61" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 152.76 61 L 144.76 65 L 146.76 61 L 144.76 57 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 211 101 L 199.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 193.24 101 L 201.24 97 L 199.24 101 L 201.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 151 101 L 139.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 133.24 101 L 141.24 97 L 139.24 101 L 141.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 91 101 L 59.24 101" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 53.24 101 L 61.24 97 L 59.24 101 L 61.24 105 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 256 62 L 282.76 62" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 288.76 62 L 280.76 66 L 282.76 62 L 280.76 58 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 291 102 L 259.23 101.21" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 253.24 101.06 L 261.33 97.26 L 259.23 101.21 L 261.13 105.25 Z" fill="#949494" stroke="#949494" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/><path d="M 296.5 89.5 L 294 89.5 Q 291.5 89.5 291.5 99.5 L 291.5 180 Q 291.5 190 289 190 L 287.75 190 Q 286.5 190 289 190 L 290.25 190 Q 291.5 190 291.5 200 L 291.5 280.5 Q 291.5 290.5 294 290.5 L 296.5 290.5" fill="none" stroke="#949494" stroke-width="2" stroke-miterlimit="10" transform="rotate(-90,291.5,190)" pointer-events="all"/><rect x="211" y="191" width="170" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 168px; height: 1px; padding-top: 205px; margin-left: 212px;"><div data-drawio-colors="color: #949494; " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 17px; font-family: Helvetica; color: rgb(148, 148, 148); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">Storage backend</div></div></div></foreignObject><text x="296" y="210" fill="#949494" font-family="Helvetica" font-size="17px" text-anchor="middle">Storage backend</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.diagrams.net/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>
"
|
|
/>
|
|
ref: <a href="https://www.filestash.app/docs/plugin/">plugin documentation</a>
|
|
</Alert>
|
|
<AuthenticationMiddleware
|
|
authentication_available={this.state.auth_available}
|
|
authentication_enabled={this.state.auth_enabled}
|
|
authentication_update={this.changeAuthentication.bind(this)}
|
|
backend_available={this.state.backend_available}
|
|
backend_enabled={this.state.backend_enabled}
|
|
formChange={this.onUpdateAuthenticationMiddleware.bind(this)}
|
|
formRender={formRender}
|
|
/>
|
|
</React.Fragment>
|
|
)
|
|
}
|
|
</div>
|
|
);
|
|
}
|
|
}
|
|
|
|
function StorageBackend({ backend_available, backend_enabled, backend_add, backend_remove, formChange, formRender }) {
|
|
const isActiveBackend = (backend_key) => {
|
|
return backend_enabled
|
|
.map((b) => Object.keys(b)[0])
|
|
.indexOf(backend_key) !== -1;
|
|
};
|
|
|
|
return (
|
|
<div className="component_storagebackend">
|
|
<h2>Storage Backend</h2>
|
|
<div className="box-container">
|
|
{
|
|
Object.keys(backend_available)
|
|
.sort((a, b) => a > b)
|
|
.map((backend_available_current, index) => (
|
|
<div
|
|
key={index}
|
|
onClick={() => backend_add(backend_available_current)}
|
|
className={"box-item pointer no-select" + (isActiveBackend(backend_available_current) ? " active": "")}>
|
|
<div>
|
|
{ backend_available_current }
|
|
<span className="no-select">
|
|
<span className="icon">+</span>
|
|
</span>
|
|
</div>
|
|
</div>
|
|
))
|
|
}
|
|
</div>
|
|
{
|
|
backend_enabled.length !== 0 ? (
|
|
<div>
|
|
<form>
|
|
{
|
|
backend_enabled.map((backend_enabled_current, index) => {
|
|
return (
|
|
<div key={index}>
|
|
<div className="icons no-select"
|
|
onClick={() => backend_remove(index)}>
|
|
<Icon name="close" />
|
|
</div>
|
|
<FormBuilder
|
|
onChange={formChange}
|
|
idx={index}
|
|
key={index}
|
|
form={{ "": backend_enabled_current }}
|
|
render={formRender} />
|
|
</div>
|
|
);
|
|
})
|
|
}
|
|
</form>
|
|
</div>
|
|
) : <Alert className="error">There is no storage selected. Where do you want to connect to?</Alert>
|
|
}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
|
|
function AuthenticationMiddleware({ authentication_available, authentication_enabled, backend_available, backend_enabled, authentication_update, formChange, formRender }) {
|
|
const [formSpec, setFormSpec] = useState(authentication_enabled);
|
|
const formChangeHandler = (e) => {
|
|
formChange(e[""]);
|
|
};
|
|
|
|
useEffect(() => {
|
|
setFormSpec(authentication_enabled);
|
|
}, [authentication_enabled]);
|
|
|
|
// we want to update the form in a few scenarios:
|
|
// 1. user remove a storage backend
|
|
// 2. user add a storage backend
|
|
// 3. add a related backend in attribute mapping
|
|
// 4. remove a related backend in attribute mapping
|
|
|
|
// we want to update the form whenever a user change the related_backend input.
|
|
// The change could be to either:
|
|
// 1. add something to the list => create a new form in the attribute_mapping section
|
|
// 2. remove something from the list => remove something in the attribute_mapping section
|
|
useEffect(() => {
|
|
if (!formSpec["identity_provider"]) return;
|
|
|
|
const existingValues = (formSpec["attribute_mapping"]["related_backend"]["value"] || "")
|
|
.split(/, ?/)
|
|
.map((a) => a.trim());
|
|
const { identity_provider, attribute_mapping } = formSpec;
|
|
const selected = backend_enabled.map((b) => {
|
|
const type = Object.keys(b)[0];
|
|
return {
|
|
label: b[type].label.value,
|
|
type: Object.keys(b)[0],
|
|
};
|
|
});
|
|
let needToSave = false;
|
|
|
|
// detect missing form from the existing attribute_mapping
|
|
// this happen whenever a user added something in the related_backend input
|
|
for (let i=0; i<selected.length; i++) {
|
|
if (attribute_mapping[selected[i].label]) continue;
|
|
for (let j=0; j<existingValues.length; j++) {
|
|
if (selected[i].label === existingValues[j]) {
|
|
attribute_mapping[selected[i].label] = JSON.parse(JSON.stringify(backend_available[selected[i].type]));
|
|
needToSave = true;
|
|
}
|
|
}
|
|
}
|
|
// detect out of date attribute_mapping that are still showing but shouldn't
|
|
Object.keys(formSpec["attribute_mapping"]).map((key) => {
|
|
if (key === "related_backend") return;
|
|
if (existingValues.indexOf(key) !== -1) return;
|
|
needToSave = true;
|
|
delete attribute_mapping[key];
|
|
});
|
|
if (needToSave === false) return;
|
|
const d = {
|
|
identity_provider,
|
|
attribute_mapping: attribute_mapping,
|
|
};
|
|
formChange(FormObjToJSON(d));
|
|
setFormSpec(d);
|
|
}, [
|
|
formSpec["attribute_mapping"]["related_backend"]["value"],
|
|
!formSpec["identity_provider"],
|
|
]);
|
|
|
|
useEffect(() => { // autocompletion of the related_backend field
|
|
const f = { ...formSpec };
|
|
f.attribute_mapping.related_backend.datalist = backend_enabled
|
|
.map((r) => r[Object.keys(r)[0]].label.value);
|
|
|
|
const enabledBackendLabel = backend_enabled.map((b) => b[Object.keys(b)[0]].label.value);
|
|
f.attribute_mapping.related_backend.value = (f.attribute_mapping.related_backend.value || "")
|
|
.split(/, ?/)
|
|
.filter((value) => enabledBackendLabel.indexOf(value) !== -1)
|
|
.join(", ");
|
|
|
|
setFormSpec(f);
|
|
}, [backend_enabled]);
|
|
|
|
const isActiveAuth = (auth_key) => {
|
|
return auth_key === objectGet(authentication_enabled, ["identity_provider", "type", "value"]);
|
|
};
|
|
|
|
if (Object.keys(authentication_available).length === 0) return null;
|
|
return (
|
|
<div className="component_authenticationmiddleware" style={{ minHeight: "400px" }}>
|
|
<h2>Authentication Middleware</h2>
|
|
|
|
<div className="box-container">
|
|
{
|
|
Object.keys(authentication_available)
|
|
.map((auth_current) => (
|
|
<div key={auth_current}
|
|
onClick={() => authentication_update(isActiveAuth(auth_current) ? null : auth_current)}
|
|
className={"box-item pointer no-select" + (isActiveAuth(auth_current) ? " active": "")}>
|
|
<div>
|
|
{ auth_current }
|
|
<span className="no-select">
|
|
<span className="icon">
|
|
{
|
|
isActiveAuth(auth_current) === false ?
|
|
"+" :
|
|
<Icon name="delete" />
|
|
}
|
|
</span>
|
|
</span>
|
|
</div>
|
|
</div>
|
|
))
|
|
}
|
|
</div>
|
|
{
|
|
objectGet(authentication_enabled, ["identity_provider", "type"]) && (
|
|
<div className="authentication-middleware">
|
|
<FormBuilder
|
|
onChange={formChangeHandler}
|
|
form={{ "": formSpec }}
|
|
render={formRender}
|
|
/>
|
|
</div>
|
|
)
|
|
}
|
|
</div>
|
|
);
|
|
}
|