argous 1.2.131 → 1.2.135

package/lib/fieldsRedux/fieldsRedux.js

@@ -0,0 +1,391 @@
+import * as argous from '../actions';
+import { agGet, agSet, action } from '../api';
+import { getStore } from '../utils/store';
+
+export const getCurrentProgram = () => {
+  const state = getStore().getState();
+  const { currentProgram } = state.argous;
+  return currentProgram;
+};
+
+/**
+ * @deprecated
+ */
+export const initField = async (field, defaultValue) => {
+
+  if (!getField(field).ready) {
+
+    const state = getStore().getState();
+    const { currentProgram, fields } = state.argous;
+
+    setField(field, 'ready', true);
+
+    const res = await agGet({ pgCode: currentProgram, field });
+    let value = handleFieldValue(currentProgram, fields, field, res, defaultValue);
+    const alreadyHaveValue = typeof getField(field).value !== 'undefined';
+    if (!alreadyHaveValue) {
+      setField(field, 'value', value);
+    }
+    setField(field, 'defaultValue', value);
+    return value;
+  } 
+  return new Promise((resolve) => resolve());  
+};
+
+export const setField = (field, key, value, ajax) => {
+  const currentProgram = getStore().getState().argous.currentProgram;
+
+  const fieldInfo = getField(field);
+
+  if ((typeof key !== 'object' || Array.isArray(key)) && typeof value === 'undefined') {
+    key = { value: key };
+  }
+
+  if (typeof key === 'string' && typeof value !== 'undefined') {
+    getStore().dispatch(argous.setCurrentField(currentProgram, field, {
+      ...fieldInfo,
+      [key]: value
+    }));
+  } else {
+    getStore().dispatch(argous.setCurrentField(currentProgram, field, {
+      ...fieldInfo,
+      ...key
+    }));
+  }
+
+  if ((key === 'value' && ajax) || (typeof key !== 'string' && key['value'] && value)) {
+    return agSet({ [field]: value, pgCode: currentProgram });
+  } 
+  return new Promise((resolve) => resolve({ pgmOk: false }));  
+};
+
+export const setAnotherProgramField = (field, obj, program) => {
+
+  const fieldInfo = getField(field);
+
+  if ((typeof obj !== 'object' || Array.isArray(obj))) {
+    obj = { value: obj };
+  }
+
+  getStore().dispatch(argous.setCurrentField(program, field, {
+    ...fieldInfo,
+    ...obj
+  }));
+};
+
+/**
+ * @deprecated
+ */
+export const setFieldsByObject = (object, prefix) => {
+  Object.keys(object).forEach(o => {
+    if (typeof object[o] !== 'object' || Array.isArray(object[o])) {
+      setField(`${prefix ? prefix : ''}${o}`, object[o]);
+    }
+  });
+};
+
+/**
+ * @deprecated
+ */
+export const getFieldsByPrefix = (prefix, letPrefix) => {
+  const state = getStore().getState();
+  const { fields, currentProgram } = state.argous;
+
+  const prefixLength = prefix.length;
+  const fieldsPgm = fields[currentProgram] || {};
+  const fieldsWithPrefix = {};
+
+  for (let key of Object.keys(fieldsPgm)) {
+    if (key.indexOf(prefix) === 0 && typeof fieldsPgm[key].value !== 'undefined') {
+      fieldsWithPrefix[letPrefix ? key : key.substring(prefixLength)] = fieldsPgm[key].value;
+    }
+  }
+
+  return fieldsWithPrefix;
+};
+
+export const getField = (field, key, program) => {
+  const state = getStore().getState();
+  const { fields, currentProgram } = state.argous;
+
+  const exist = fields[program || currentProgram]
+    ? fields[program || currentProgram][field]
+      ? fields[program || currentProgram][field]
+      : ''
+    : '';
+
+  if (exist) {
+    if (key) {
+      return typeof exist[key] === 'undefined'
+        ? ''
+        : exist[key];
+    } 
+    return exist;
+    
+  } 
+  return '';  
+};
+
+/**
+ * @deprecated
+ */
+export const getPreviousField = (field, prevProps, key) => {
+  const state = getStore().getState();
+
+  const { currentProgram } = state.argous;
+
+  const exist = prevProps.fields
+    ? prevProps.fields[currentProgram]
+      ? prevProps.fields[currentProgram][field]
+        ? prevProps.fields[currentProgram][field]
+        : ''
+      : ''
+    : '';
+
+  if (exist) {
+    if (key) {
+      return typeof exist[key] === 'undefined'
+        ? ''
+        : exist[key];
+    } 
+    return exist;
+    
+  } 
+  return '';  
+};
+
+/**
+ * @deprecated
+ */
+export const getAllFields = () => {
+  const state = getStore().getState();
+  const { fields, currentProgram } = state.argous;
+
+  return fields[currentProgram];
+};
+
+export const clearField = (field) => {
+
+  const state = getStore().getState();
+  const { fields, currentProgram } = state.argous;
+
+  const clonedFields = { ...fields };
+
+  if (clonedFields && clonedFields[currentProgram] && clonedFields[currentProgram][field]) {
+
+    delete clonedFields[currentProgram][field];
+
+    getStore().dispatch(argous.setFields(clonedFields));
+  }
+};
+
+export const clearAllFields = () => {
+  getStore().dispatch(argous.clearAllFields());
+};
+
+/**
+ * @deprecated
+ */
+export const setServerValueToField = async (field) => {
+
+  const state = getStore().getState();
+  const { currentProgram } = state.argous;
+
+  const res = await agGet({ pgCode: currentProgram, field });
+  if (res.pgmOk) {
+
+    let value = res[field];
+
+    try {
+      value = typeof value === 'object'
+        ? value
+        : JSON.parse(value);
+    } catch (err) { }
+
+    setField(field, 'value', value);
+    return res[field];
+  }
+  return '';
+};
+
+/**
+ * @deprecated
+ */
+export const setFieldValueToServer = async (field) => {
+  const state = getStore().getState();
+  const { currentProgram } = state.argous;
+
+  const value = getField(field, 'value');
+
+  const res = await agSet({ [field]: value, pgCode: currentProgram });
+  if (res.pgmOk) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * @deprecated
+ */
+export const fieldChangeListener = (field, fieldListener, prevProps) => {
+  const state = getStore().getState();
+  const { currentProgram, fields } = state.argous;
+
+  if (fieldListener) {
+
+    const fieldAux = fields
+      ? fields[currentProgram]
+        ? fields[currentProgram][field]
+          ? fields[currentProgram][field]
+          : undefined
+        : undefined
+      : undefined;
+
+    const prevFieldAux = prevProps.fields
+      ? prevProps.fields[currentProgram]
+        ? prevProps.fields[currentProgram][field]
+          ? prevProps.fields[currentProgram][field]
+          : undefined
+        : undefined
+      : undefined;
+
+    if (fieldAux !== prevFieldAux) {
+      fieldListener(fieldAux ? fieldAux : {}, prevFieldAux ? prevFieldAux : {});
+    }
+  }
+};
+
+/**
+ * @deprecated
+ */
+export const fieldUpdatesActionHandler = (sendUpdates, receiveUpdates, action, dados, onActionSuccess, onAllUpdated, dataCallback) => {
+
+  let sendUpdatesCount = 0;
+  let receiveUpdatesCount = 0;
+
+  if (sendUpdates.length > 0) {
+
+    sendUpdates.map(f => setFieldValueToServer(f).then(() => {
+
+      if (sendUpdates.length === ++sendUpdatesCount) {
+
+        if (receiveUpdates.length > 0) {
+          if (action) {
+            handleAction(action, dados, onActionSuccess)
+              .then(res => receiveUpdates.map(f => setServerValueToField(f)
+                .then(() => (receiveUpdates.length === ++receiveUpdatesCount) && onAllUpdated && onAllUpdated(dataCallback, res))));
+          } else {
+            receiveUpdates.map(f => setServerValueToField(f)
+              .then(() => (receiveUpdates.length === ++receiveUpdatesCount) && onAllUpdated && onAllUpdated(dataCallback)));
+          }
+
+        } else if (action) {
+          handleAction(action, dados, onActionSuccess)
+            .then(res => onAllUpdated && onAllUpdated(dataCallback, res));
+        } else {
+          onAllUpdated && onAllUpdated(dataCallback);
+        }
+      }
+    }));
+  } else if (action) {
+    handleAction(action, dados, onActionSuccess)
+      .then(res => receiveUpdates.map(f => setServerValueToField(f)
+        .then(() => (receiveUpdates.length === ++receiveUpdatesCount) && onAllUpdated && onAllUpdated(dataCallback, res))));
+  } else {
+    receiveUpdates.map(f => setServerValueToField(f)
+      .then(() => (receiveUpdates.length === ++receiveUpdatesCount) && onAllUpdated && onAllUpdated(dataCallback)));
+  }
+};
+
+/**
+ * @deprecated
+ */
+export const waitFieldsData = (wFields = [], wDatas = [], rejectMilliseconds = 5000, milliseconds = 100) => {
+  return new Promise((resolve, reject) => {
+
+    const lengthWait = wFields.length * wDatas.length;
+    let alreadyHaveLoaded = 0;
+
+    const interval = setInterval(() => {
+      alreadyHaveLoaded = 0;
+
+      for (let field of wFields) {
+
+        const f = getField(field);
+
+        for (let data of wDatas) {
+
+          if (typeof f[data] !== 'undefined') {
+            alreadyHaveLoaded++;
+          }
+
+        }
+      }
+
+      if (lengthWait === alreadyHaveLoaded) {
+        clearInterval(interval);
+        clearTimeout(timeout);
+        resolve();
+      }
+
+    }, milliseconds);
+
+    const timeout = setTimeout(() => {
+      clearInterval(interval);
+      reject();
+    }, rejectMilliseconds);
+
+  });
+};
+
+/**
+ * @deprecated
+ */
+const handleFieldValue = (currentProgram, fields, field, res, defaultValue) => {
+
+  const vlAux = fields[currentProgram]
+    ? fields[currentProgram][field]
+      ? fields[currentProgram][field]
+      : res.pgmOk
+        ? res[field] !== 'null'
+          ? res[field]
+          : undefined
+        : undefined
+    : res.pgmOk
+      ? res[field] !== 'null'
+        ? res[field]
+        : undefined
+      : undefined;
+
+  let value = typeof vlAux !== 'undefined'
+    ? vlAux
+    : typeof defaultValue !== 'undefined'
+      ? defaultValue
+      : '';
+
+  try {
+    value = typeof value === 'object'
+      ? value
+      : JSON.parse(value);
+  } catch (err) { }
+
+  return value;
+};
+
+/**
+ * @deprecated
+ */
+const handleAction = async (ac, dados, onActionSuccess) => {
+
+  const data = {
+    pgCode: getCurrentProgram(),
+    action: ac,
+    dados: dados ? dados : {}
+  };
+
+  const res = await action(data);
+  if (onActionSuccess) {
+    onActionSuccess(res);
+  }
+  return res;
+};

package/lib/fieldsRedux/index.d.ts

@@ -0,0 +1,4 @@
+import createField from './createField';
+import { setAnotherProgramField, getCurrentProgram, initField, setField, getField, getAllFields, clearField, clearAllFields, setServerValueToField, setFieldValueToServer, fieldChangeListener, fieldUpdatesActionHandler, waitFieldsData, getPreviousField, setFieldsByObject, getFieldsByPrefix } from './fieldsRedux';
+import passFields from './passFields';
+export { setAnotherProgramField, passFields, createField, getCurrentProgram, initField, setField, getField, getAllFields, clearField, clearAllFields, setServerValueToField, setFieldValueToServer, fieldChangeListener, fieldUpdatesActionHandler, waitFieldsData, getPreviousField, setFieldsByObject, getFieldsByPrefix };

package/lib/fieldsRedux/index.js

@@ -0,0 +1,5 @@
+import createField from './createField';
+import { setAnotherProgramField, getCurrentProgram, initField, setField, getField, getAllFields, clearField, clearAllFields, setServerValueToField, setFieldValueToServer, fieldChangeListener, fieldUpdatesActionHandler, waitFieldsData, getPreviousField, setFieldsByObject, getFieldsByPrefix } from './fieldsRedux';
+import passFields from './passFields';
+
+export { setAnotherProgramField, passFields, createField, getCurrentProgram, initField, setField, getField, getAllFields, clearField, clearAllFields, setServerValueToField, setFieldValueToServer, fieldChangeListener, fieldUpdatesActionHandler, waitFieldsData, getPreviousField, setFieldsByObject, getFieldsByPrefix };

package/lib/fieldsRedux/passFields.d.ts

@@ -0,0 +1,5 @@
+export default passFields;
+/**
+ * @deprecated
+ */
+declare function passFields(WrappedComponent: any): any;

package/lib/fieldsRedux/passFields.js

@@ -0,0 +1,76 @@
+import { clearField, setField, getField, waitFieldsData, setServerValueToField, setFieldValueToServer, getPreviousField, setFieldsByObject, getFieldsByPrefix } from './fieldsRedux';
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+
+/**
+ * @deprecated
+ * @param {*} WrappedComponent - 
+ * @returns {*} -
+ */
+const passFields = (WrappedComponent) => {
+
+  class HOCComponent extends Component {
+
+    getField = (field, key) => {
+      return getField(field, key);
+    }
+
+    getPreviousField = (p1, p2, p3) => {
+      return getPreviousField(p1, p2, p3);
+    }
+
+    setField = (p1, p2, p3) => {
+      if (typeof p2 === 'object') {
+        return setField(p1, p2);
+      } 
+      return setField(p1, p2, p3);
+      
+    }
+
+    setFieldsByObject = (object, prefix) => {
+      setFieldsByObject(object, prefix);
+    }
+
+    getFieldsByPrefix = (prefix, letPrefix) => {
+      return getFieldsByPrefix(prefix, letPrefix);
+    }
+
+    waitFieldsData = (wFields = [], wDatas = [], rejectMilliseconds = 5000, milliseconds = 100) => {
+      return waitFieldsData(wFields, wDatas, rejectMilliseconds, milliseconds);
+    }
+
+    setServerValueToField = (field) => {
+      return setServerValueToField(field);
+    }
+
+    setFieldValueToServer = (field) => {
+      return setFieldValueToServer(field);
+    }
+
+    clearField = (field) => {
+      clearField(field);
+    }
+
+    render() {
+      return <WrappedComponent
+        getField={this.getField}
+        getPreviousField={this.getPreviousField}
+        setField={this.setField}
+        waitFieldsData={this.waitFieldsData}
+        setServerValueToField={this.setServerValueToField}
+        setFieldValueToServer={this.setFieldValueToServer}
+        clearField={this.clearField}
+        setFieldsByObject={this.setFieldsByObject}
+        getFieldsByPrefix={this.getFieldsByPrefix}
+        {...this.props} />;
+    }
+  }
+
+  const mapStateToProps = (state) => {
+    return { fields: state.argous.fields };
+  };
+
+  return connect(mapStateToProps)(HOCComponent);
+};
+
+export default passFields;

package/lib/reducers/argous.ts

@@ -0,0 +1,103 @@
+import { ActionType } from '../types';
+
+const argous = (state = {
+  usuarioLogado: {},
+  loading: true,
+  processos: [],
+  favorites: [],
+  initialPage: '/',
+  fields: {},
+  block: false,
+  vldPsw: false,
+  sidebar: true
+}, action: ActionType) => {
+  switch (action.type) {
+    case 'setUsuarioLogado':
+      return {
+        ...state,
+        usuarioLogado: action.usuarioLogado
+      };
+    case 'setLoading':
+      return {
+        ...state,
+        loading: action.loading
+      };
+    case 'setProcesso':
+      return {
+        ...state,
+        processos: action.processo
+      };
+    case 'setNotificacao':
+      return {
+        ...state,
+        notificacao: action.notificacao
+      };
+    case 'setInitialPage':
+      return {
+        ...state,
+        initialPage: action.initialPage
+      };
+    case 'setCurrentProgram':
+      return {
+        ...state,
+        currentProgram: action.currentProgram
+      };
+    case 'setCurrentField':
+      return {
+        ...state,
+        fields: state.fields[action.program]
+          ? {
+            ...state.fields,
+            [action.program]: {
+              ...state.fields[action.program],
+              [action.field]: action.value
+            }
+          }
+          : {
+            ...state.fields,
+            [action.program]: {
+              [action.field]: action.value
+            }
+          }
+      };
+    case 'clearAllFields':
+      return {
+        ...state,
+        fields: {}
+      };
+    case 'setFields':
+      return {
+        ...state,
+        fields: action.fields
+      };
+    case 'setFavorites':
+      return {
+        ...state,
+        favorites: action.favorites
+      };
+    case 'setBlockUser':
+      return {
+        ...state,
+        block: action.block
+      };
+    case 'setVldPsw':
+      return {
+        ...state,
+        block: action.vldPsw
+      };
+    case 'setSidebar':
+      return {
+        ...state,
+        sidebar: action.sidebar
+      };
+    case 'setMensagensNaoLidas':
+      return {
+        ...state,
+        mensagensNaoLidas: action.mensagensNaoLidas
+      };
+    default:
+      return state;
+  }
+};
+
+export default argous;

package/lib/reducers/index.ts

@@ -0,0 +1,6 @@
+import argous from './argous';
+import { combineReducers } from 'redux';
+
+const reducers = combineReducers({ argous });
+
+export default reducers;