@configuratorware/configurator-admingui 1.41.1 → 1.42.1

package/src/App/Data.js

@@ -1,351 +0,0 @@
-import _ from 'lodash';
-import { validate } from 'validate.js';
-import isArray from 'lodash/isArray';
-import { t } from './i18n';
-
-export const whiteSpacePattern = /^[\S]+$/;
-
-export const identifierPattern = /^[A-za-z0-9_.-]+$/;
-
-validate.validators.nonEmptyArray = function(value, options) {
-    if (options && options === true && isArray(value) && value.length !== 0) {
-        return null;
-    }
-    return t('customValidators.nonEmptyArray');
-};
-
-validate.validators.emptyOrPositive = function(value, options) {
-    if (options && options === true && ((!isNaN(+value) && +value > 0) || !value)) {
-        return null;
-    }
-
-    return t('customValidators.numericality');
-};
-
-validate.validators.numericOrEmpty = function (value, options) {
-    if (value === '' || value === null ) {
-        return null;
-    }
-    else {
-        return validate.validators.numericality(value, options);
-    }
-}
-
-validate.validators.identifier = function(value, options) {
-    if (
-        options &&
-        options === true &&
-        typeof value === 'string' &&
-        value.match(identifierPattern) &&
-        value.match(identifierPattern)[0] === value
-    ) {
-        return null;
-    }
-    return t('customValidators.identifier');
-};
-
-validate.validators.decimalPoint = function(value, options) {
-    if (options === true && (!value || !value.length || /^[\d]+\.?[\d]*$/.test(value))) {
-        return null;
-    }
-    return t('customValidators.decimalPoint');
-};
-
-validate.validators.color = function(value, options) {
-    if (value === '' || value === undefined) {
-        return t('customValidators.balnkError');
-    }
-    const pattern = /^#[0-9a-fA-F]{6}$/i;
-    const s = new Option().style;
-    s.color = value;
-    const isValidColorText = s.color == value;
-    if (
-        options &&
-        options === true &&
-        typeof value === 'string' &&
-        (isValidColorText || (value.match(pattern) && value.match(pattern)[0] === value))
-    ) {
-        return null;
-    }
-    return true;
-};
-
-validate.validators.noWhitespace = function(value, options) {
-    if (
-        options === true &&
-        typeof value === 'string' &&
-        value.match(whiteSpacePattern) &&
-        value.match(whiteSpacePattern)[0] === value
-    ) {
-        return null;
-    }
-    return t('customValidators.noWhitespace');
-}
-
-export default class Data {
-    static EventTypes = {
-        init: 'init',
-        update: 'update',
-        reset: 'reset',
-        validate: 'validate',
-        setValue: 'setValue',
-        setErrors: 'setErrors',
-    };
-
-    get value() {
-        return this.getData();
-    }
-
-    set value(data) {
-        this.init(data);
-    }
-
-    addListener(event, fn) {
-        if (!this._listeners[event]) {
-            this._listeners[event] = [];
-        }
-        this._listeners[event].push(fn);
-    }
-
-    removeListener(event, fn) {
-        if (!_.isArray(this._listeners[event])) {
-            return;
-        }
-        this._listeners[event] = this._listeners[event].filter(function(item) {
-            if (item !== fn) {
-                return item;
-            }
-        });
-    }
-
-    _trigger(event, data) {
-        if (this._listeners[event]) {
-            this._listeners[event].forEach(item => item({ data: this, event: { type: event, ...data } }));
-        }
-    }
-
-    /*** *** ***/
-    static instances = 0;
-
-    constructor(dataObject, mutate = false) {
-        Data.instances++;
-        this._listeners = {};
-        if (dataObject) {
-            this.init(dataObject, mutate);
-        }
-    }
-
-    init(dataObject, mutate = false) {
-        this._data = dataObject ? (mutate ? dataObject : _.cloneDeep(dataObject)) : _.cloneDeep(this);
-        this._initialObject = _.cloneDeep(this._data);
-        this._validator = new DataValidator(this._data);
-        for (let prop in this._data) {
-            Object.defineProperty(this, prop, {
-                get: () => {
-                    return this._data[prop];
-                },
-                set: value => {
-                    if (this._data[prop].value !== value) {
-                        this._data[prop].value = value;
-                        this._validator.invalidate();
-                        this._trigger(Data.EventTypes.setValue, { prop, value });
-                    }
-                },
-            });
-        }
-        this._trigger(Data.EventTypes.init);
-        return this;
-    }
-
-    updateSchemaObject(schemaObject) {
-        for (let p in this._data) {
-            if (p in schemaObject) {
-                this._data[p] = _.cloneDeep(schemaObject[p]);
-            }
-        }
-    }
-
-    updateValues(dataObject) {
-        // skip if dataObject is not a real object
-        if (!_.isPlainObject(dataObject)) {
-            return this;
-        }
-        const modifiedProps = [];
-        for (let p in this._data) {
-            if (p in dataObject && this._data[p].value !== dataObject[p]) {
-                this._data[p].value = dataObject[p];
-                modifiedProps.push(p);
-            }
-        }
-        // trigger setValue event for each modified property
-        modifiedProps.forEach(prop => this._trigger(Data.EventTypes.setValue, { prop, value: this[prop] }));
-        // trigger the update event
-        if (modifiedProps.length > 0) {
-            this._trigger(Data.EventTypes.update);
-        }
-        return this;
-    }
-
-    reset(evtData) {
-        this._data = _.cloneDeep(this._initialObject);
-        this._validator.setDataObject(this._data);
-        this._trigger(Data.EventTypes.reset, evtData);
-    }
-
-    getValue(prop) {
-        return this._data[prop].value;
-    }
-
-    setValue(prop, value) {
-        if (this._data[prop].value !== value) {
-            this._data[prop].value = value;
-            this._trigger(Data.EventTypes.setValue, { prop, value });
-        }
-    }
-
-    getError(prop) {
-        return this._data[prop].error;
-    }
-    setError(prop, error) {
-        this._data[prop].error = error;
-    }
-
-    validate() {
-        const isValid = this._validator.validate();
-        this._trigger(Data.EventTypes.validate, { isValid });
-        return isValid;
-    }
-
-    getErrors() {
-        return this._validator.getErrors();
-    }
-
-    setErrors(errorObject) {
-        if (!_.isObject(errorObject)) {
-            errorObject = {};
-        }
-        for (let p in this._data) {
-            if (p in errorObject) {
-                this._data[p].error = errorObject[p];
-            } else {
-                delete this._data[p].error;
-            }
-        }
-        this._trigger(Data.EventTypes.setErrors, errorObject);
-    }
-
-    getData() {
-        const data = {};
-        for (let p in this._data) {
-            data[p] = this._data[p].value;
-        }
-        return data;
-    }
-}
-
-export class DataValidator {
-    constructor(dataObject, mutate = true) {
-        this.setDataObject(dataObject, mutate);
-    }
-
-    setDataObject(dataObject, mutate = true) {
-        this._data = mutate ? dataObject : _.cloneDeep(dataObject);
-        this._validation = {
-            isDone: false,
-        };
-    }
-
-    invalidate() {
-        this._validation.isDone = false;
-    }
-
-    isValidated() {
-        return this._validation.isDone;
-    }
-
-    validate() {
-        let isValid = true;
-        for (let prop in this._data) {
-            const dataSchema = _.get(this._data[prop], 'schema');
-            if (dataSchema instanceof Data) {
-                isValid = dataSchema.validate() && isValid;
-            }
-        }
-        isValid = validateDataObject(this._data) && isValid;
-        this._validation.isDone = true;
-        return isValid;
-    }
-
-    getValidatedData() {
-        if (!this._validation.isDone) {
-            this.validate();
-        }
-        return this._data;
-    }
-
-    getErrors() {
-        if (!this._validation.isDone) {
-            this.validate();
-        }
-        return getErrorsFromValidatedDataObject(this._data);
-    }
-}
-
-const validateField = (prop, valueToValidate, idx) => {
-    let valid = true;
-
-    if (prop.constraints) {
-        const result = validate.single(valueToValidate, prop.constraints);
-        if (idx !== undefined) {
-            prop.error = prop.error || [];
-            prop.error[idx] = result ? result.join(', ') : undefined;
-        } else {
-            if (result) {
-                prop.error = result.join(', ');
-            } else if (prop.error) {
-                delete prop.error;
-            }
-        }
-        valid = valid && !result;
-    }
-
-    return valid;
-};
-
-export const validateDataObject = (dataObject, valueObject, idx) => {
-    let valid = true;
-    for (let p in dataObject) {
-        const prop = dataObject[p];
-        const valueToValidate = valueObject ? valueObject[p] : prop.value;
-
-        valid = validateField(prop, valueToValidate, idx) && valid;
-
-        if (prop.schema) {
-            if (_.isArray(prop.value)) {
-                // validate all values against the schema rules
-                prop.value.forEach((value, idx) => {
-                    valid = validateDataObject(prop.schema, value, idx) && valid;
-                });
-            } else if (prop.value === null) {
-                // skip validation, if the value is null
-            } else {
-                valid = validateDataObject(prop.schema, prop.value) && valid;
-            }
-        }
-    }
-    return valid;
-};
-
-export const getErrorsFromValidatedDataObject = dataObject => {
-    let errors = [];
-    for (let p in dataObject) {
-        const prop = dataObject[p];
-        if (prop.error) {
-            errors.push({ property: p, message: prop.error });
-        }
-        if (prop.schema) {
-            errors = errors.concat(getErrorsFromValidatedDataObject(prop.schema));
-        }
-    }
-    return errors;
-};

package/src/App/Entity.js

@@ -1,93 +0,0 @@
-import React from 'react';
-import { connect } from 'react-redux';
-
-import Dialog from '../UIComponents/Dialog';
-import FlatButton from '../UIComponents/FlatButton';
-import { T } from './i18n';
-
-const Styles = {
-    dialog: {
-        zIndex: 99999999999,
-    },
-};
-
-/**
- * A component to show the Entity related modal dialogs
- *  - connected with redux, uses the Entity reducer
- * Responsibilities:
- *  - renders a dialog when an unsaved entity is present during the navigation
- *  - renders a dialog to confirm the deletion of entities
- * @param props
- * @constructor
- */
-
-const Entity = props => {
-    function handleUnsavedEntityClose() {
-        props.unsavedEntity && props.unsavedEntity.cancel();
-    }
-
-    function handleDeleteEntityClose() {
-        props.deleteEntities && props.deleteEntities.cancel();
-    }
-
-    return (
-        <div>
-            <Dialog
-                title={T('Leaving edit view')}
-                onClose={handleUnsavedEntityClose}
-                actions={
-                    <React.Fragment>
-                        <FlatButton
-                            label={T('Save and leave')}
-                            primary={true}
-                            onClick={props.unsavedEntity && props.unsavedEntity.saveAndHide}
-                        />
-                        <FlatButton
-                            label={T('Leave without saving')}
-                            onClick={props.unsavedEntity && props.unsavedEntity.hide}
-                        />
-                        <FlatButton
-                            label={T('Cancel')}
-                            onClick={props.unsavedEntity && props.unsavedEntity.cancel}
-                        />
-                    </React.Fragment>
-                }
-                open={props.unsavedEntityDialog}
-                style={Styles.dialog}
-            >
-                {T('entity.modificationsNotSaved')}
-            </Dialog>
-
-            <Dialog
-                title={T('entity.deleteTitle')}
-                onClose={handleDeleteEntityClose}
-                actions={
-                    <React.Fragment>
-                        <FlatButton
-                            label={T('entity.deleteTitle')}
-                            primary={true}
-                            onClick={props.deleteEntities && props.deleteEntities.onDelete}
-                        />
-                        <FlatButton
-                            label={T('Cancel')}
-                            onClick={props.deleteEntities && props.deleteEntities.cancel}
-                        />
-                    </React.Fragment>
-                }
-                open={props.deleteEntitiesDialog}
-                style={Styles.dialog}
-            >
-                {T('entity.deleteConfirm')}
-            </Dialog>
-        </div>
-    );
-};
-
-const mapStateToProps = ({ entity }) => ({
-    unsavedEntity: entity.unsavedEntity,
-    unsavedEntityDialog: entity.unsavedEntity.showDialog,
-    deleteEntities: entity.deleteEntities,
-    deleteEntitiesDialog: entity.deleteEntities.showDialog,
-});
-
-export default connect(mapStateToProps)(Entity);

package/src/App/ErrorBoundary.js

@@ -1,67 +0,0 @@
-import React from 'react';
-
-const styles = {
-    wrapper: {
-        textAlign: 'center',
-    },
-    title: {
-        paddingTop: 50,
-        paddingBottom: 25,
-    },
-    button: {
-        display: 'block',
-        margin: 'auto',
-    },
-    error: {
-        display: 'inline-block',
-        textAlign: 'left',
-        paddingTop: 25,
-    },
-    errorText: {
-        color: 'red',
-    },
-    label: {
-        fontWeight: 'bold',
-        marginTop: 15,
-    },
-};
-
-export default class ErrorBoundary extends React.Component {
-    constructor(props) {
-        super(props);
-        this.state = { hasError: false, error: null, info: null };
-    }
-
-    componentDidCatch(error, info) {
-        this.setState({ hasError: true, error, info });
-        // eslint-disable-next-line no-console
-        console.error(error, info);
-    }
-
-    reload = () => {
-        location.reload();
-    };
-
-    render() {
-        if (this.state.hasError) {
-            return (
-                <div style={styles.wrapper}>
-                    <h1 style={styles.title}>Something went wrong.</h1>
-                    <button style={styles.button} onClick={this.reload}>
-                        Reload
-                    </button>
-                    <pre style={styles.error}>
-                        <span style={styles.errorText}>{this.state.error.toString()}</span>
-
-                        <div style={styles.label}>JS Stack:</div>
-                        {this.state.error.stack && this.state.error.stack.match(/((^.+\n){6})/m)[0]}
-
-                        <div style={styles.label}>Component Stack:</div>
-                        {this.state.info.componentStack.replace(/^\n+/, '')}
-                    </pre>
-                </div>
-            );
-        }
-        return this.props.children;
-    }
-}

package/src/App/FeatureReducers.js

@@ -1,36 +0,0 @@
-/**
- * Collect and store all the feature reducers in this object
- * @type {{}}
- */
-const featureReducers = {};
-
-export function addReducers(reducers) {
-    if (reducers instanceof Array) {
-        for (let reducer of reducers) {
-            addReducers(reducer);
-        }
-    } else if (reducers instanceof Function && reducers.name) {
-        featureReducers[reducers.name] = reducers;
-    } else if (typeof reducers === 'object') {
-        const names = Object.keys(reducers);
-        for (let name of names) {
-            featureReducers[name] = reducers[name];
-        }
-    } else {
-        throw new Error(
-            'Wrong argument given when calling addReducers, ' +
-                'it should be a single named function (created by createFeatureReducer), ' +
-                'an array of named functions ' +
-                'or a map of functions (a simple object like {anyReducerName: function}). '
-        );
-    }
-}
-
-export function getReducers() {
-    return featureReducers;
-}
-
-export function createFeatureReducer(name, fn) {
-    Object.defineProperty(fn, 'name', { value: name });
-    return fn;
-}

package/src/App/Frame.js

@@ -1,125 +0,0 @@
-import React from 'react';
-import { connect } from 'react-redux';
-
-import { cancelErrorMessage } from './Reducers/Frame/Actions';
-
-import _ from 'lodash';
-
-import Main from './Main';
-import { T } from './i18n';
-import Entity from './Entity';
-
-import Snackbar from '../UIComponents/Snackbar';
-import LinearProgress from '../UIComponents/LinearProgress';
-
-import './Styles.scss';
-import withStyles from '@material-ui/core/styles/withStyles';
-import ThemeProvider from './ThemeProvider';
-
-const styles = {
-    linearRoot: {
-        background: 'transparent',
-        position: 'fixed',
-        top: 0,
-        zIndex: 9999,
-        borderRadius: 0,
-        height: 64,
-        width: '100%',
-    },
-    linearBarColorPrimary: {
-        backgroundColor: 'rgba(255, 255, 255, 0.5)',
-    },
-};
-
-/**
- * A wrapper component which applies the Material-UI theme and handles global application related status
- *  - connected with redux, uses the Frame reducer
- * Responsibilities:
- *  - displays a loading progress bar while any async call is in progress
- *  - renders the Frame related messages if any (eg. unhandled network errors)
- *  - renders the Entity Component
- *  - renders the Main Component
- * @param props
- * @constructor
- */
-const Frame = ({ classes, ...props }) => {
-    const LoginComponent = props.route.loginComponent;
-    return (
-        <ThemeProvider>
-            {!props.isLoggedIn ? (
-                <LoginComponent {...props} />
-            ) : (
-                <Main
-                    credentials={props.credentials}
-                    license={props.license}
-                    version={props.version}
-                    latestReleasedVersion={props.latestReleasedVersion}
-                >
-                    {props.children}
-                </Main>
-            )}
-
-            <Entity />
-
-            {props.loading > 0 && (
-                <LinearProgress
-                    variant="indeterminate"
-                    classes={{
-                        root: classes.linearRoot,
-                        barColorPrimary: classes.linearBarColorPrimary,
-                    }}
-                />
-            )}
-
-            {props.message.show && (
-                <Snackbar
-                    open={props.message.show}
-                    message={props.message.text}
-                    action={
-                        props.message.data && (
-                            <a
-                                className="view-error-details"
-                                href=""
-                                onClick={e => {
-                                    e.preventDefault();
-                                    const w = window.open();
-                                    w.document.write(
-                                        _.isObject(props.message.data)
-                                            ? JSON.stringify(props.message.data)
-                                            : props.message.data
-                                    );
-                                }}
-                            >
-                                {T('View details')}
-                            </a>
-                        )
-                    }
-                    autoHideDuration={10000}
-                    onClose={props.cancelErrorMessage}
-                />
-            )}
-        </ThemeProvider>
-    );
-};
-
-const mapStateToProps = ({ frame, loginData, versionData }) => {
-    const { message, loading, rehydrationComplete } = frame;
-    const { isLoggedIn, credentials, license } = loginData;
-    const { version, latestReleasedVersion } = versionData;
-    return {
-        message,
-        loading,
-        rehydrationComplete,
-        isLoggedIn,
-        credentials,
-        license,
-        version,
-        latestReleasedVersion,
-    };
-};
-
-const mapDispatchToProps = dispatch => ({
-    cancelErrorMessage: () => dispatch(cancelErrorMessage()),
-});
-
-export default connect(mapStateToProps, mapDispatchToProps)(withStyles(styles)(Frame));

package/src/App/Listeners.js

@@ -1,20 +0,0 @@
-import { loginListener } from '../Screens/Login/Reducers/Listener';
-import { orderListListener } from '../App/Reducers/Common/OrderList/Listener';
-
-import { getFlattenedFeatures } from '../App/Config/app';
-import { features } from '../Screens';
-
-const initFeatureListeners = () => {
-    const listeners = [];
-    for (let { name } of getFlattenedFeatures()) {
-        const listener = features[name].Listener;
-        if (listener && listeners.indexOf(listener) === -1) {
-            listeners.push(listener);
-        }
-    }
-    return listeners;
-};
-
-const listeners = [loginListener, orderListListener, ...initFeatureListeners()];
-
-export default listeners;