@agilemotion/oui-react-js 0.1.0

package/src/lib/event/EventListener.js

@@ -0,0 +1,59 @@
+import Utils from "../Utils"
+
+class EventSubscription {
+
+    constructor(subscriberRef, viewId, publisher, eventType, actions, callback) {
+        this.subscriberRef = subscriberRef;
+        this.subscriber =
+            !Utils.isNull(subscriberRef) && !Utils.isNull(subscriberRef.api.id) ? subscriberRef.api.id : null;
+        this.eventType = eventType;
+        this.viewId = viewId;
+        this.publisher = publisher;
+        this.actions = actions;
+        this.callback = callback;
+    };
+
+    /**
+     *
+     */
+    getSubscriberRef = () => {
+        return this.subscriberRef
+    };
+
+    /**
+     *
+     */
+    getEventType = () => {
+        return this.eventType
+    };
+
+    /**
+     *
+     */
+    getViewId = () => {
+        return this.viewId;
+    };
+
+    /**
+     *
+     */
+    getPublisher = () => {
+        return this.publisher;
+    };
+
+    /**
+     *
+     */
+    getActions = () => {
+        return this.actions;
+    };
+
+    /**
+     *
+     */
+    getCallback = () => {
+        return this.callback;
+    };
+}
+
+export default EventSubscription;

package/src/lib/event/EventType.js

@@ -0,0 +1,14 @@
+export default class EventType {
+    static CLICK = "CLICK";
+    static SELECTION_CHANGE = "SELECTION_CHANGE";
+    static SERVICE_CALL_SUCCESS = "SERVICE_CALL_SUCCESS";
+    static SERVICE_CALL_FAILURE = "SERVICE_CALL_FAILURE";
+    static COMPONENT_LOAD = "COMPONENT_LOAD";
+    static VALUE_CHANGE = "VALUE_CHANGE";
+    static ROW_DELETED = "ROW_DELETED";
+    static VIEW_CLOSED = "VIEW_CLOSED";
+    static BARCODE_SCANNED = "BARCODE_SCANNED";
+    static APPLICATION_CONTEXT_CHANGE = "APPLICATION_CONTEXT_CHANGE";
+    static MESSAGE_ARRIVED = "MESSAGE_ARRIVED";
+    static DATA_ARRIVED = "DATA_ARRIVED";
+}

package/src/lib/event/LoadDataActionHandler.js

@@ -0,0 +1,24 @@
+import React from "react";
+import Utils from './../Utils';
+
+class LoadDataActionHandler {
+
+    constructor() {
+        if (!LoadDataActionHandler.instance) {
+            LoadDataActionHandler.instance = this;
+        }
+
+        return LoadDataActionHandler.instance;
+    }
+
+    execute(actionConfig, event, component, currentViewId) {
+        if(!Utils.isNull(component)) {
+            component.api.loadData(actionConfig);
+        }
+    }
+}
+
+const instance = new LoadDataActionHandler();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/event/Observable.js

@@ -0,0 +1,252 @@
+/**
+ * Class for objects that register subscriptions and fire events.
+ */
+
+import ActionHandlers from './ActionHandlers';
+import Utils from "../Utils";
+import EventSubscription from "./EventListener";
+import applicationContext, {SYSTEM_EVENT} from "../ApplicationContext";
+import {TEMPLATE_REGEX} from "../DynamicJS";
+
+class Observable {
+    constructor() {
+        if (!Observable.instance) {
+            this.subscriptions = [];
+            this.systemGeneratedSubscriptions = [];
+            Observable.instance = this;
+        }
+
+        return Observable.instance;
+    }
+
+    /**
+     * Adds a subscription bound by the given event type.
+     *
+     * @param subscription the subscription to be added
+     */
+    addSubscription = (subscription) => this.subscriptions.push(subscription);
+
+    /**
+     * Adds a listener bound by the given event type.
+     *
+     * @param eventHandlingConfig the listener config from back-end
+     * @param componentHandle reference to the component owning the event
+     * @param viewId the id of the view where the component is rendered
+     */
+    addSubscriptions = (eventHandlingConfig, componentHandle, viewId) => {
+        if (!Utils.isNull(eventHandlingConfig)) {
+            let subscriptions = eventHandlingConfig.subscriptions;
+            for (const subscription of subscriptions) {
+                this.addSubscription(new EventSubscription(componentHandle, viewId,
+                    !Utils.isNull(subscription.publisher) ? subscription.publisher : componentHandle.api.id,
+                    subscription.eventType, subscription.actions));
+            }
+        }
+    };
+
+    /**
+     * Adds system generated component subscriptions, such as the ones to re-run disabled and required scriplets after events are fired
+     *
+     * @param config the component config
+     *
+     */
+    addSystemSubscriptions = (config) => {
+        if (!Utils.isNull(config.disabled)) {
+            let matches = config.disabled.match(TEMPLATE_REGEX);
+            if (!Utils.isNull(matches)) {
+                for (const match of matches) {
+                    let component = match.replace("@#{", "").replace("}", "");
+                    this.addSystemGeneratedSubscription(component, config.id);
+                }
+            }
+        }
+
+        if (!Utils.isNull(config.visible)) {
+            let matches = config.visible.match(TEMPLATE_REGEX);
+            if (!Utils.isNull(matches)) {
+                for (const match of matches) {
+                    let component = match.replace("@#{", "").replace("}", "");
+                    this.addSystemGeneratedSubscription(component, config.id);
+                }
+            }
+        }
+
+        if (!Utils.isNull(config.validator) && !Utils.isNull(config.validator.nullable)) {
+            let matches = config.validator.nullable.match(TEMPLATE_REGEX);
+            if (!Utils.isNull(matches)) {
+                for (const match of matches) {
+                    let component = match.replace("@#{", "").replace("}", "");
+                    this.addSystemGeneratedSubscription(component, config.id);
+                }
+            }
+        }
+    };
+
+    /**
+     * Fires an event.
+     *
+     * @param eventType eventType the event type
+     * @param be the base event
+     * @return false if any subscriptions cancel the event.
+     */
+    async fireEvent(eventType, be) {
+
+        // Components could be unloading on the cases where screens are busy closing,
+        // meaning the "current" object may be nullified, so we need the null check
+        // This happens on async events such as RPC_CALL. If there is no view masking,
+        // the REST call may return while the component has been destroyed, and the source's current could be null
+        // Proper masking when doing REST CALL should prevent this from happening. The null check provides the sort of defence
+
+        if (!Utils.isNull(be.getSource())) {
+            let sourceId = be.getSource().api.id;
+            let viewId = be.viewId;
+
+            if (!Utils.isNull(sourceId)) {
+                for (const subscription of this.subscriptions) {
+                    /*if (sourceId === 'jobTitlesMenuIem') {
+                        console.log("CHECKING VIEW [" + subscription.getViewId() + " - " + viewId + "], PUB : ["
+                            + subscription.getPublisher() + " - " + sourceId + "], EVENT: [" + subscription.getEventType() + " - " + eventType + "]");
+                    }*/
+
+                    if ((subscription.getViewId() === viewId || SYSTEM_EVENT === viewId)
+                        && subscription.getPublisher() === sourceId
+                        && subscription.getEventType() === eventType) {
+                        if (!Utils.isNull(subscription.getActions())) {
+                            for (let j = 0; j < subscription.getActions().length; j++) {
+                                let action = subscription.getActions()[j];
+                                ActionHandlers.invoke(action, be, subscription);
+                            }
+                        } else if (!Utils.isNull(subscription.getCallback())) {
+                            subscription.getCallback()(be);
+                        }
+                    }
+                }
+
+                this.processSystemGeneratedSubscriptions(sourceId);
+            }
+        }
+    }
+
+    getNextIndexToRemove(val, prop, listenerCollection) {
+        let counter = 0;
+        for (const listener of listenerCollection) {
+            if (listener[prop] === val) {
+                return counter;
+            }
+
+            counter++;
+        }
+
+        return -1;
+    }
+
+    /**
+     * Clears all event subscriptions
+     *
+     */
+    clearAllEventListeners() {
+        this.subscriptions.splice(0, this.subscriptions.length);
+        this.systemGeneratedSubscriptions.splice(0, this.systemGeneratedSubscriptions.length);
+    };
+
+    /**
+     * Clears all event subscriptions for the specified view
+     *
+     * @param viewId the view
+     */
+    clearEventListeners(viewId) {
+        let indexes = [];
+
+        let index = -2;
+        while ((index = this.getNextIndexToRemove(viewId, 'viewId', this.subscriptions)) !== -1) {
+            this.subscriptions.splice(index, 1)
+        }
+
+        if (!Utils.isNull(this.systemGeneratedSubscriptions)) {
+            index = -2;
+            while ((index = this.getNextIndexToRemove(viewId, 'viewId', this.systemGeneratedSubscriptions)) !== -1) {
+                this.systemGeneratedSubscriptions.splice(index, 1)
+            }
+        }
+    };
+
+    /**
+     * Clears all event subscriptions for the specified view
+     *
+     * @param componentId the view
+     */
+    clearComponentEventListeners(componentId) {
+        let indexes = [];
+
+        let index = -2;
+        while ((index = this.getNextIndexToRemove(componentId, 'subscriber', this.subscriptions)) !== -1) {
+            this.subscriptions.splice(index, 1)
+        }
+
+        if (!Utils.isNull(this.systemGeneratedSubscriptions)) {
+            index = -2;
+            while ((index = this.getNextIndexToRemove(componentId, 'subscriber', this.systemGeneratedSubscriptions)) !== -1) {
+                this.systemGeneratedSubscriptions.splice(index, 1)
+            }
+        }
+    };
+
+    /**
+     *
+     * @param componentId
+     *
+     */
+    processSystemGeneratedSubscriptions = (componentId) => {
+        let component = applicationContext.resolveComponentApi(componentId);
+
+        if(!Utils.isNull(component)) {
+            for (const subscription of this.systemGeneratedSubscriptions) {
+                if (subscription.publisher === componentId) {
+                    let component = applicationContext.resolveComponentApi(subscription.subscriber);
+                    if (!Utils.isNull(component)) {
+                        if (!Utils.isNull(subscription.callback)) {
+                            subscription.callback();
+                        } else if (!Utils.isNull(component.refresh)) {
+                            component.refresh();
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     *
+     * @param publisher
+     * @param subscriber
+     * @param callback
+     *
+     */
+    addSystemGeneratedSubscription = (publisher, subscriber, callback) => {
+        let found = false;
+        let currentViewid = applicationContext.getCurrentView().config.id;
+
+        for (const systemGeneratedSubscription of this.systemGeneratedSubscriptions) {
+            if (publisher === systemGeneratedSubscription.publisher
+                && subscriber === systemGeneratedSubscription.subscriber
+                && currentViewid === systemGeneratedSubscription.viewId) {
+                found = true;
+            }
+        }
+
+        if (!found) {
+            let subscription = {};
+            subscription.publisher = publisher;
+            subscription.subscriber = subscriber;
+            subscription.callback = callback;
+            subscription.viewId = currentViewid;
+
+            this.systemGeneratedSubscriptions.push(subscription);
+        }
+    };
+}
+
+const instance = new Observable();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/event/RouteActionHandler.js

@@ -0,0 +1,113 @@
+import React from "react";
+import {sendRequest} from "../RestUtils";
+import applicationContext from "../ApplicationContext";
+import Utils from "../Utils";
+import dynamicJS from "../DynamicJS";
+
+const location = window.location.protocol + "//" + window.location.hostname;
+class RouteActionHandler {
+
+    constructor() {
+        if (!RouteActionHandler.instance) {
+            RouteActionHandler.instance = this;
+        }
+
+        return RouteActionHandler.instance;
+    }
+
+    execute(actionConfig, event, component, currentViewId) {
+
+        // TODO : Implement this full URL
+        //String url = webUrl + "?version=1.0" + (viewPath != null ? "&id=" + URL.encodeQueryString(viewPath) : "")
+        //    + (viewPathRequestDto != null ? "&serviceRequest=" + URL.encodeQueryString(requestDtoWriter.write(viewPathRequestDto)) : "")
+        //    + (portalCurrentOrg != null ? "&profile=" + portalCurrentOrg : "");
+
+        applicationContext.enableFormMarkers(false);
+
+        let forward = true;
+        let path = null;
+        let isParent = Utils.isNull(actionConfig.parent) ? false : actionConfig.parent;
+        let isPopup = Utils.isNull(actionConfig.popUp) ? false : actionConfig.popUp;
+
+        if (!Utils.isNull(actionConfig.pathEvaluator)) {
+            path = dynamicJS.executeScriptObject(currentViewId + 'ViewEvaluator_' + event.source.id,
+                actionConfig.pathEvaluator);
+        } else {
+            path = actionConfig.path === '$event.data' ? event.data : actionConfig.path;
+            if("@#{history.back}" === path) {
+                let historyElement = applicationContext.getPreviousHistoryElement();
+                if(historyElement === null) {
+                    console.error("Invalid path. Cannot got back in history");
+                    return;
+                }
+
+                path = historyElement.path;
+                forward = false;
+            }
+        }
+
+        let parameterValues = [];
+        if(!Utils.isNull(actionConfig.parameters)) {
+            for (let i = 0; i < actionConfig.parameters.length; i++) {
+                let parameter = actionConfig.parameters[i];
+                let parameterValue = applicationContext.resolveParameterValue(parameter);
+                let validator = parameter.validator;
+
+                if (Utils.isNull(parameterValue) && !Utils.isNull(validator) &&
+                    Utils.evaluateBooleanExpression(validator.nullable, parameter.name) === false) {
+                    console.error('Routing to path ' + path + ', failed. A null value for a NON-NULLABLE parameter was found - ' + JSON.stringify(parameter));
+                    // TODO : Display the configured error message at the correct error panel
+                    return;
+                }
+
+                let param = {};
+                param.name = parameter.name;
+                param.value = Utils.isNull(parameterValue) ? null :
+                    parameterValue.instanceType === "TypedValue" ? parameterValue.value : parameterValue;
+
+                parameterValues.push(param);
+            }
+        }
+
+        let url = location + "/agility/app/controller/view?version=1.0&id=" + path;
+        sendRequest(url,
+            (data) => {
+                if(isParent) {
+                    applicationContext.removeLoadedGraph();
+                }
+
+                if(data.type === 'view') {
+                    let currentView = applicationContext.getCurrentView();
+                    if (Utils.isNull(currentView) || !currentView.popUp) {
+                        let view = {};
+                        view.config = data;
+                        view.handle = {
+                        };
+
+                        view.parameters = parameterValues;
+                        view.parent = isParent;
+                        view.popUp = isPopup;
+
+                        applicationContext.addView(view, path, forward);
+                        // None-existing route to ensure that the current view unloads
+                        if (Utils.isNull(actionConfig.popUp) || actionConfig.popUp === false) {
+                            applicationContext.getViewPortHistory().push("/switch");
+                            applicationContext.getViewPortHistory().push("/view/" + data.id);
+                        }
+                    } else {
+                        applicationContext.closeCurrentView(false);
+                        applicationContext.getCurrentView().handle.api.updateModel(parameterValues);
+                    }
+                } else if(data.type === 'graph') {
+                    applicationContext.loadGraph(isParent, isPopup, data);
+                }
+            }, (e) => {
+                console.error(e);
+            }, true, false);
+    }
+}
+
+const instance = new RouteActionHandler();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/event/ScriptActionHandler.js

@@ -0,0 +1,23 @@
+import React from "react";
+import dynamicJS from "../DynamicJS";
+
+class ScriptActionHandler {
+
+    constructor(){
+        if(! ScriptActionHandler.instance){
+            ScriptActionHandler.instance = this;
+        }
+
+        return ScriptActionHandler.instance;
+    }
+
+    execute(actionConfig, event, component, currentViewId) {
+        let componentId = event.getSource().api.id;
+        dynamicJS.executeScriptObject(currentViewId + '_' + componentId + '_script', actionConfig.script, componentId, {}, event);
+    }
+}
+
+const instance = new ScriptActionHandler();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/event/ServiceCallActionHandler.js

@@ -0,0 +1,47 @@
+import React from "react";
+import {invokeRpc, invokeRest} from "../RestUtils";
+import dynamicJS from "./../DynamicJS";
+import Utils from './../Utils';
+
+class ServiceCallActionHandler {
+
+    constructor() {
+        if (!ServiceCallActionHandler.instance) {
+            ServiceCallActionHandler.instance = this;
+        }
+
+        return ServiceCallActionHandler.instance;
+    }
+    
+    execute(actionConfig, event, component, currentViewId, successCallback, errorCallback) {
+        let method = actionConfig.service.type === 'remoteObjectProxy' ? invokeRpc : invokeRest;
+        method(actionConfig.service, component, currentViewId, (result) => {
+                let handle = !Utils.isNull(component) && !Utils.isNull(component.current) ? component.current : component;
+                if (!Utils.isNull(actionConfig.postScript)) {
+                    try {
+                        let valuesMap = {};
+                        valuesMap.response = result.data;
+                        dynamicJS.executeScriptObject('postScript_' + currentViewId + '_' + handle.getId(),
+                            actionConfig.postScript, handle.getId(), valuesMap);
+                    } catch (e) {
+                        console.error(e);
+                    }
+                }
+
+                if(!Utils.isNull(successCallback)) {
+                    successCallback(result);
+                }
+            },
+            (e) => {
+                Utils.publishSystemErrorMessage(currentViewId);
+                if(!Utils.isNull(errorCallback)) {
+                    errorCallback(e)
+                }
+            }, null, actionConfig.returnValueBinding, actionConfig.successMessage);
+    }
+}
+
+const instance = new ServiceCallActionHandler();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/event/SignalGraphActionHandler.js

@@ -0,0 +1,23 @@
+import React from "react";
+import Utils from './../Utils';
+import applicationContext from "../ApplicationContext";
+
+class SignalGraphActionHandler {
+
+    constructor() {
+        if (!SignalGraphActionHandler.instance) {
+            SignalGraphActionHandler.instance = this;
+        }
+
+        return SignalGraphActionHandler.instance;
+    }
+
+    execute(actionConfig, event, component, currentViewId) {
+        applicationContext.signalGraph(actionConfig.graphId, event);
+    }
+}
+
+const instance = new SignalGraphActionHandler();
+Object.freeze(instance);
+
+export default instance;

package/src/lib/js/Addresses.js

@@ -0,0 +1,20 @@
+export default class Addresses {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+
+    copy(from, to, checked) {
+        if(checked) {
+            let currentViewModel = this.resolver.resolveComponentApi('view').model;
+            let fromAddressLine1 = currentViewModel[from + '.line1'];
+            let fromAddressLine2 = currentViewModel[from + '.line2'];
+            let fromAddressLine3 = currentViewModel[from + '.line3'];
+            let fromAddressCode = currentViewModel[from + '.code'];
+
+            this.resolver.resolveComponentApi(to + '.line1').value = fromAddressLine1;
+            this.resolver.resolveComponentApi(to + '.line2').value = fromAddressLine2;
+            this.resolver.resolveComponentApi(to + '.line3').value = fromAddressLine3;
+            this.resolver.resolveComponentApi(to + '.code').value = fromAddressCode;
+        }
+    }
+}

package/src/lib/js/DynamicLib.js

@@ -0,0 +1,15 @@
+import Utils from "./../Utils";
+
+export default class DynamicLib {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+
+    evaluateExpression = (expression) => {
+        return this.resolver.resolveExpressionValue(expression);
+    };
+
+    isNull = (value) => {
+        return Utils.isNull(value);
+    }
+}

package/src/lib/js/Validators.js

@@ -0,0 +1,7 @@
+import Utils from '../Utils';
+
+export default class Validators {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+}

package/src/lib/redux/store/ConfigureStore.js

@@ -0,0 +1,35 @@
+import { applyMiddleware, combineReducers, compose, createStore } from 'redux';
+import thunk from 'redux-thunk';
+import { connectRouter, routerMiddleware } from "connected-react-router"
+import * as Security from './SecurityStore';
+import * as Dashboard from './DashboardStore';
+
+export default function ConfigureStore(history, initialState) {
+   const reducers = {
+        security: Security.reducer,
+        dashboard: Dashboard.reducer
+  };
+
+  const middleware = [
+    thunk,
+    routerMiddleware(history)
+  ];
+
+  // In development, use the browser's Redux dev tools extension if installed
+  const enhancers = [];
+  const isDevelopment = process.env.NODE_ENV === 'development';
+  if (isDevelopment && typeof window !== 'undefined' && window.devToolsExtension) {
+    enhancers.push(window.devToolsExtension());
+  }
+
+  const rootReducer = combineReducers({
+    ...reducers,
+    router: connectRouter(history),
+  });
+
+  return createStore(
+    rootReducer,
+    initialState,
+    compose(applyMiddleware(...middleware), ...enhancers)
+  );
+}