argous 1.2.132 → 1.2.136

package/lib/types.d.ts

@@ -0,0 +1,144 @@
+import { BasicModalProps } from './components';
+import { Store } from 'redux';
+
+export type argousConfig = {
+  ssl: boolean,
+  ip: string,
+  ipImagePosts?: string,
+  codigoCliente: string,
+  path?: string
+}
+
+export interface UsuarioLogado {
+  habGrupo?: boolean,
+  habChat?: boolean,
+  habProcesso?: boolean,
+  habFavorito?: boolean,
+  habNotificacao?: boolean,
+  email?: string,
+  funcao?: string,
+  idFornecedorInterno?: number,
+  idUsuario?: number,
+  nome?: string,
+  ramal?: string,
+  publTL?: boolean,
+  imagem?: string,
+  imagemCapa?: string
+}
+
+interface PromiseOptions extends BasicModalProps{
+  resolve: (value: boolean | PromiseLike<boolean>) => void, 
+  reject: (reason?: any) => void
+}
+export interface ArgousSystemType {
+  WSHandler: { onMessage: (params: any) => void },
+  headerState: { value?: 'min' },
+  pessoasChatOpen: { value: boolean },
+  janelaChatOpen?: {
+    idUsuario: number,
+    idSala: number,
+    titulo: string,
+    subtitulo: string,
+    online: boolean,
+    msgsNaoLidas: number
+  },
+  systemTopAlert?: Record<string, any>,
+  openModal?: PromiseOptions,
+  [other: string]: Record<string, any> | undefined
+}
+
+export interface FieldsType {
+  argousSystem: ArgousSystemType,
+  [program: string]: Record<string, any> | undefined
+}
+
+export interface ArgousType {
+  block: boolean,
+  currentProgram: string,
+  favorites: any[],
+  fields: FieldsType,
+  initialPage: string,
+  loading: boolean,
+  processos: any[],
+  sidebar: boolean
+  usuarioLogado: UsuarioLogado,
+  vldPsw: boolean
+}
+export interface StoreState {
+  argous: ArgousType
+}
+
+export type ArgousStore = Store<StoreState, ActionType>
+
+interface setUsuarioLogado {
+  type: 'setUsuarioLogado',
+  usuarioLogado: UsuarioLogado
+} 
+
+interface setLoading {
+  type: 'setLoading',
+  loading: boolean 
+} 
+
+interface setProcesso {
+  type: 'setProcesso',
+  processo: any 
+} 
+
+interface setInitialPage {
+  type: 'setInitialPage',
+  initialPage: string 
+} 
+
+interface setCurrentProgram {
+  type: 'setCurrentProgram',
+  currentProgram: string 
+} 
+
+interface setCurrentField {
+  type: 'setCurrentField',
+  program: string,
+  field: string,
+  value: any   
+} 
+
+interface clearAllFields {
+  type: 'clearAllFields'
+} 
+
+interface setFields {
+  type: 'setFields',
+  fields: any 
+} 
+
+interface setFavorites {
+  type: 'setFavorites',
+  favorites: any[] 
+} 
+
+interface setBlockUser {
+  type: 'setBlockUser',
+  block: boolean 
+} 
+
+interface setNotificacao {
+  type: 'setNotificacao',
+  notificacao: any 
+} 
+
+interface setSidebar {
+  type: 'setSidebar',
+  sidebar: boolean 
+} 
+
+interface setMensagensNaoLidas {
+  type: 'setMensagensNaoLidas',
+  mensagensNaoLidas: number 
+}
+
+interface setVldPsw {
+  type: 'setVldPsw',
+  vldPsw: boolean 
+} 
+
+export type ActionType = setUsuarioLogado|setLoading|setProcesso|setInitialPage|setCurrentProgram|setCurrentField|clearAllFields|setFields|setFavorites|setBlockUser|setNotificacao|setSidebar|setMensagensNaoLidas|setVldPsw

package/lib/utils/api.ts

@@ -0,0 +1,153 @@
+import { getConfig } from './config';
+import { getStore } from './store';
+import { action, agGet, agSet } from '../api';
+import { setAnotherProgramField } from '../fieldsRedux';
+
+const getCurrentProgram = async (n = 0) => {
+  const state = getStore().getState();
+  const { currentProgram } = state.argous;
+  if (!currentProgram) {
+    return new Promise((resolve, reject) => {
+      if (n >= 10) reject(console.error('getServerValue, setServerValue ou serverAction chamado antes do mount do Programa. Use programDidMount().'));
+      setTimeout(async () => {
+        resolve(await getCurrentProgram(n++));
+      }, 100);
+    });
+  }
+  return currentProgram;
+};
+
+/**
+ * @deprecated
+ */
+export const getServerValue = async (field:string): Promise<any> => {
+  const currentProgram = await getCurrentProgram();
+
+  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) { }
+    return value;
+  }
+  return '';
+};
+
+/**
+ * @deprecated
+ * 
+ * @param {string} field - String
+ * @param {any} value - Valor
+ * 
+ * @returns {Promise<any>} retorno 
+ */
+export const setServerValue = async (field:string, value:any): Promise<any> => {
+  const currentProgram = await getCurrentProgram();
+
+  const res = await agSet({ pgCode: currentProgram, [field]: value });
+  return !!res.pgmOk;
+};
+
+let debuging = false;
+
+export const enableDebugger = () => {
+  debuging = true;
+};
+
+export const serverAction = async (metodo:string, dados = {}, pgCode?:string|boolean, tratarErro?:string|boolean) => {
+
+  const code = typeof pgCode === 'string' ? pgCode : typeof tratarErro === 'string' ? tratarErro : undefined;
+  const tErro = typeof tratarErro === 'boolean' ? tratarErro : typeof pgCode === 'boolean' ? pgCode : false;
+
+  const currentProgram = code || await getCurrentProgram();
+
+  const data = {
+    pgCode: currentProgram,
+    action: metodo,
+    dados
+  };
+
+  const res = await action(data);
+  if (debuging && process.env.NODE_ENV !== 'production') {
+    console.log('-------- Server Action ---------');
+    console.log('pgCode: ', currentProgram);
+    console.log('action: ', metodo);
+    console.log('dados: ', dados);
+    console.log('res: ', res);
+    if (res.dsErro) console.error(res.dsErro);
+    console.log('--------------------------------');
+  }
+  if (res.dsErro && tErro) setError(res.dsErro);
+  if (res.chTkn) document.cookie = `lt=${res.chTkn};path=/;SameSite=Lax;${getConfig().ssl ? 'secure' : ''}`;
+  if (res.blkTkn) {
+    setInfo(res.blkTkn, 'Justificativa de Bloqueio', 0);
+    window.localStorage.setItem('blkUs', JSON.stringify(getStore().getState().argous.usuarioLogado));
+    getStore().dispatch({ type: 'setUsuarioLogado', usuarioLogado: {} });
+    document.cookie = `lt=;path=/;SameSite=Lax;${getConfig().ssl ? 'secure' : ''}`;
+    getStore().dispatch({ type: 'setBlockUser', block: true });
+  }
+  if (res.vldPsw) getStore().dispatch({ type: 'setVldPsw', vldPsw: true });
+  return res;
+};
+
+export function setAlert(mensagem: string, type: 'error' | 'success' | 'info' | 'warning', title: string, time = 5000) {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { mensagem, type, title, time }, 'argousSystem');
+  }, 0);
+}
+
+export function setError(mensagem:string, title = 'Erro') {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { mensagem, type: 'error', title }, 'argousSystem');
+  }, 0);
+}
+
+export function setSuccess(mensagem:string, title:string, time = 5000) {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { mensagem, type: 'success', title, time }, 'argousSystem');
+  }, 0);
+}
+
+export function setInfo(mensagem:string, title:string, time = 5000) {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { mensagem, type: 'info', title, time }, 'argousSystem');
+  }, 0);
+}
+
+export function setWarning(mensagem:string, title:string, time = 5000) {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { mensagem, type: 'warning', title, time }, 'argousSystem');
+  }, 0);
+}
+
+export function sendNotification({ id, mensagem, title, type, link, dsLabel }:{ id:string|number, mensagem:string, title:string, type:string, link:string, dsLabel:string }) {
+  setTimeout(() => {
+    setAnotherProgramField('systemTopAlert', { type: 'notification', id, mensagem, title, link, dsLabel, icon: type }, 'argousSystem');
+  }, 0);
+}
+
+const getUrlVars = () => {
+  var vars:any = {};
+  window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, (_, key, value):string => {
+    vars[key] = value;
+    return '';
+  });
+  return vars;
+};
+
+const deleteURLParameters = () => {
+  let params = window.location.href;
+  let pos = params.indexOf('?');
+  if (pos > 0) params = params.substring(0, pos); 
+  window.history.replaceState('object or string', 'Title', params);
+};
+
+export const getUrlParameters = async (pgCode?:string) => {
+  const urlPrms = getUrlVars();
+  if (urlPrms.ctrl) {
+    deleteURLParameters();
+    return await serverAction('getURLParameters', { ctrl: urlPrms.ctrl }, pgCode, true);
+  }
+};

package/lib/utils/config.ts

@@ -0,0 +1,12 @@
+import { argousConfig } from '../types';
+
+let config: argousConfig;
+
+export function setConfig(providedConfig: argousConfig, callback?: () => any) {
+  config = providedConfig;
+  callback && callback();
+}
+
+export function getConfig() {
+  return config;
+}

package/lib/utils/date.ts

@@ -0,0 +1,63 @@
+import { addExtraZero } from '.';
+
+export const getMonthName = (nr: number) => {
+  switch (nr) {
+    case 0: return 'Janeiro';
+    case 1: return 'Fevereiro';
+    case 2: return 'Março';
+    case 3: return 'Abril';
+    case 4: return 'Maio';
+    case 5: return 'Junho';
+    case 6: return 'Julho';
+    case 7: return 'Agosto';
+    case 8: return 'Setembro';
+    case 9: return 'Outubro';
+    case 10: return 'Novembro';
+    case 11: return 'Dezembro';
+    default: return '';
+  }
+};
+
+export const getDayName = (day: number) => {
+  switch (day) {
+    case 1: return 'Segunda';
+    case 2: return 'Terça';
+    case 3: return 'Quarta';
+    case 4: return 'Quinta';
+    case 5: return 'Sexta';
+    case 6: return 'Sábado';
+    default: return 'Domingo';
+  }
+};
+
+export const convertMinutesToHour = (minutes: number) => {
+  const dtAux = new Date(0, 0, 0, 0, 0, 0, 0);
+  dtAux.setMinutes(minutes);
+
+  return `${addExtraZero(dtAux.getHours())}:${addExtraZero(dtAux.getMinutes())}`;
+};
+
+export const sqlDateToReadableDate = (sqlDate: string) => {
+
+  const readableDate = { date: '', hour: '' };
+
+  if (sqlDate.length > 10) {
+    const date = sqlDate.slice(0, 10).split('-');
+
+    readableDate.date = `${date[2]}/${date[1]}/${date[0]}`;
+
+    if (sqlDate.indexOf(' ') > -1) {
+      const hour = sqlDate.split(' ')[1].split(':');
+
+      readableDate.hour = `${hour[0]}:${hour[1]}`;
+    }
+  }
+
+  return readableDate;
+};
+
+export const fixInvalidDate = (date: string) => {
+  if (!date || typeof date !== 'string') return date;
+  const splitDate = date.split(' ');
+  return `${splitDate[0]} ${splitDate[1].split(':').map(t => addExtraZero(t)).join(':')}`;
+};

package/lib/utils/index.ts

@@ -0,0 +1,314 @@
+import { getStore } from './store';
+import { getFileFromLink, headers } from '../api';
+import { ModalProviderContext } from '../components/ConfirmModal/ModalProvider';
+import { setAnotherProgramField, setField } from '../fieldsRedux';
+import { ActionType, ArgousType } from '../types';
+import { useTheme } from '@material-ui/core';
+import * as colors from '@material-ui/core/colors';
+import { ChartOptions } from 'chart.js';
+// import { BasicModal } from '../components';
+import { BasicModalProps } from 'lib/components';
+import React, { useRef, useEffect, useContext, useState } from 'react';
+
+export const widthToCenterVertically = (content:number) => {
+
+  const B = document.body;
+  const H = document.documentElement;
+
+  // if (typeof document.height !== 'undefined') {
+  //   height = document.height;
+  // } else {
+  const height = Math.max(B.scrollHeight, B.offsetHeight, H.clientHeight, H.scrollHeight, H.offsetHeight);
+  // }
+
+  return (height - content) / 2;
+};
+
+export const getCookie = (cName: string) => {
+  if (document.cookie.length > 0) {
+    let cStart = document.cookie.indexOf(cName + '=');
+    if (cStart !== -1) {
+      cStart = cStart + cName.length + 1;
+      let cEnd = document.cookie.indexOf(';', cStart);
+      if (cEnd === -1) {
+        cEnd = document.cookie.length;
+      }
+      return unescape(document.cookie.substring(cStart, cEnd));
+    }
+  }
+  return '';
+};
+
+export const addExtraZero = (vl:number|string) => {
+  return vl < 10
+    ? `0${typeof vl === 'string' ? parseInt(vl) : vl}`
+    : vl;
+};
+
+export const formataNome = (value:string) => {
+  if (value) {
+    let nome = value.toLowerCase().split(' ');
+    for (let i = 0; i < nome.length; i++)
+      nome[i] = nome[i].charAt(0).toUpperCase() + nome[i].substring(1);
+    return nome.join(' ');
+  }
+  return '';
+};
+
+export function downloadBase64(base64: string, fileName: string, fileExtension: string) {
+  let element = document.createElement('a');
+  element.setAttribute('href', base64);
+  element.setAttribute('download', fileExtension ? `${fileName}.${fileExtension}` : fileName);
+  element.style.display = 'none';
+  document.body.appendChild(element);
+  element.click();
+  document.body.removeChild(element);
+}
+
+/**
+ * Função faz o download de qualquer url
+ * 
+ * @param {string} url - Url a ser baixada
+ * @param {string} fileName - Nome do arquivo baixado
+ * @param {string=} fileExtension - Extenção do arquivo baixado
+ * 
+ * @returns {void}
+ */
+export async function downloadFromUrl(url: string, fileName: string, fileExtension?: string): Promise<void> {
+  const blob = await (await fetch(url, { method: 'GET', headers: headers() })).blob();
+  const urlCreator = URL || window.URL || window.webkitURL; 
+  const tag = document.createElement('a');
+  tag.href = urlCreator.createObjectURL(blob);
+  tag.download = fileExtension ? `${fileName}.${fileExtension}` : fileName;
+  tag.style.display = 'none';
+  document.body.appendChild(tag);
+  tag.click();
+  document.body.removeChild(tag);
+}
+
+export const printPdf = async (URL = '') => {
+  const url = await getFileFromLink({ URL });
+
+  const iframe = document.createElement('iframe');
+  document.body.appendChild(iframe);
+  
+  iframe.style.display = 'none';
+  iframe.onload = () => iframe.contentWindow?.print();
+  
+  if (iframe.contentWindow) iframe.contentWindow.onafterprint = () => document.removeChild(iframe);
+  
+  iframe.src = url;
+};
+
+export const getRandomColor = () => {
+  let letters = '0123456789ABCDEF';
+  let color = '#';
+  for (let i = 0; i < 6; i++)
+    color += letters[Math.floor(Math.random() * 16)];
+  return color;
+};
+
+interface RNG {
+  state:any;
+  m:number;
+  a:number;
+  c:number;
+}
+
+class RNG { //pseudo random
+  constructor(seed:number) {
+  // LCG using GCC's constants
+    this.m = 0x80000000; // 2**31;
+    this.a = 1103515245;
+    this.c = 12345;
+
+    this.state = seed ? seed : Math.floor(Math.random() * (this.m - 1));
+  }
+  nextInt() {
+    this.state = (this.a * this.state + this.c) % this.m;
+    return this.state;
+  }
+  nextFloat() {
+    return this.nextInt() / (this.m - 1);
+  }
+  nextRange(start: number, end: number) {
+    var rangeSize = end - start;
+    var randomUnder1 = this.nextInt() / this.m;
+    return start + Math.floor(randomUnder1 * rangeSize);
+  }
+  choice(array:any) {
+    return array[this.nextRange(0, array.length)];
+  }
+}
+
+export const getInitials = (nome = '') => `${nome.split(' ')[0].substring(0, 1).toUpperCase()}${nome.split(' ')[nome.split(' ').length - 1].substring(0, 1).toUpperCase()}`;
+
+export const getNumeroFromInitials = (initials: string, length: number) => Math.ceil(new RNG((initials.charCodeAt(0) + initials.charCodeAt(1) - 130) * length / 5).nextFloat() * 10) - 1;
+
+export const usePrevious = (value:any) => {
+  const ref = useRef();
+  useEffect(() => {
+    ref.current = value; 
+  });
+  return ref.current;
+};
+
+/**
+ * Igual o useEffect, mas não ativa quando o componente monta
+ * 
+ * @param {React.EffectCallback} effect - Função imperativa que pode retornar uma função de limpeza
+ * @param {React.DependencyList} dependencies - Dependencias que quando atualizadas rodarão o efeito
+ * 
+ * @returns {void} Sem retorno
+ */
+export function useUpdateEffect(effect: React.EffectCallback, dependencies: React.DependencyList): void {
+  const isInitialMount = useRef(true);
+  useEffect(() => {
+    if (isInitialMount.current) isInitialMount.current = false;
+    else effect();    
+  }, dependencies);
+}
+
+export function formataDinheiro(n: number) {
+  if (n >= 0) return new Intl.NumberFormat('pt-BR', { minimumFractionDigits: 2 }).format(n);
+  return `(${new Intl.NumberFormat('pt-BR', { minimumFractionDigits: 2 }).format(Math.abs(n))})`;
+}
+
+export const sanitizaHTML = (html = '') => html?.replace(/(<script>)|(<\/script>)|(\bon[^ ]*=('|"))/gi, '') || '';
+
+
+/**
+ * Format bytes as human-readable text.
+ * 
+ * @param {number} bytes - Number of bytes.
+ * @param {boolean} si - True to use metric (SI) units, aka powers of 1000. False to use binary (IEC) units, aka powers of 1024.
+ * @param {number} dp - Number of decimal places to display.
+ * 
+ * @returns {string} Formatted string.
+ */
+export const humanFileSize = (bytes: number, si: boolean = true, dp: number = 2): string => {
+  const thresh = si ? 1000 : 1024;
+                                
+  if (Math.abs(bytes) < thresh) return `${bytes} B`; 
+
+  const units = si 
+    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] 
+    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+  let u = -1;
+  const r = 10 ** dp;
+
+  do {
+    bytes /= thresh;
+    ++u;
+  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+
+  return `${bytes.toFixed(dp)} ${units[u]}`;
+};
+
+const chaves = Object.keys(colors).filter(i => i !== 'common');
+
+export const randomColor = (): string => {
+  const color = colors[chaves[Math.floor(chaves.length * Math.random())]];
+  const chavesCor = Object.keys(color);
+  return color[chavesCor[Math.floor(chavesCor.length * Math.random())]];
+};
+
+/**
+ * Hook para padronizar o tema dos gráficos
+ * 
+ * @param {ChartOptions} props - Props customizados
+ * @returns {ChartOptions} - retorno com tema ajustado
+ */
+export const useGraph = ({ 
+  title, legend: { labels, ...legend } = {}, 
+  plugins: { datalabels, ...plugins } = {}, 
+  scales: { 
+    yAxes: [{ ticks: yticks = {}, gridLines: ygridLines = {}, ...yAxes } = {}, ...y] = [], 
+    xAxes: [{ ticks: xticks = {}, gridLines: xgridLines = {}, ...xAxes } = {}, ...x] = [], 
+    ...scales 
+  } = {}, 
+  ...props 
+}: ChartOptions = {}): ChartOptions => {
+  const theme = useTheme();
+  return { 
+    title: { fontColor: theme.palette.text.primary, fontSize: theme.typography.fontSize, ...title },
+    legend: { position: 'bottom', labels: { fontColor: theme.palette.text.primary, ...labels }, ...legend },
+    plugins: { datalabels: {
+      align: 'end', anchor: 'end',
+      color: theme.palette.text.secondary,
+      textShadowColor: theme.palette.background.default, textShadowBlur: 3, ...datalabels
+    }, ...plugins }, 
+    scales: {
+      yAxes: [{         
+        ticks: { fontColor: theme.palette.text.secondary, ...yticks }, 
+        gridLines: { color: theme.palette.divider, zeroLineColor: theme.palette.divider, ...ygridLines },
+        ...yAxes
+      }, ...y],
+      xAxes: [{ 
+        ticks: { fontColor: theme.palette.text.secondary, ...xticks }, 
+        gridLines: { color: theme.palette.divider, zeroLineColor: theme.palette.divider, ...xgridLines },
+        ...xAxes
+      }, ...x],
+      ...scales
+    }, ...props 
+  };
+};
+
+export const useModal = () => {
+  const createModal = useContext(ModalProviderContext);
+  return createModal;
+};
+
+// Nao funciona... talvez com redux funcione, q nem a parte de erros
+// export const confirm = ({ title = '', description = '' }) => {
+//   const { createModal } = useModal()
+//   return createModal(BasicModal)({ title, description })
+// } 
+
+export const useStore = (): ArgousType => {
+  return getStore().getState().argous || {};
+};
+
+export const reduxDispatch = (action: ActionType) => {
+  getStore().dispatch(action);
+};
+
+export const formataTelefone = (value: string) => {
+  if (!value) return value; 
+  const currentValue = value.replace(/[^\d]/g, '');
+  const cvLength = currentValue.length; 
+  if (cvLength < 3) return currentValue; 
+  if (cvLength < 7) return `(${currentValue.slice(0, 2)}) ${currentValue.slice(2)}`; 
+  if (cvLength < 11) return `(${currentValue.slice(0, 2)}) ${currentValue.slice(2, 6)}-${currentValue.slice(6)}`; 
+  return `(${currentValue.slice(0, 2)}) ${currentValue.slice(2, 7)}-${currentValue.slice(7, 11)}`; 
+};
+
+export const useWebSocket = () => {
+  const [value, setValue] = useState({});
+
+  useEffect(() => {
+    setField('WSHandler', { onMessage: setValue });
+  }, []);
+
+  return value;
+};
+
+export const formataCpf = (value: string) => value?.replace(/[^\d]/, '').replace(/^(.{3})(.{3})(.{3})(.{2})$/, '$1.$2.$3-$4');
+
+export const copyToClipboard = (text: string) => {
+  if (navigator.clipboard) navigator.clipboard.writeText(text);
+  else {
+    const textField = document.createElement('input');
+    textField.setAttribute('value', text);
+    document.body.appendChild(textField);
+    textField.focus();
+    textField.select();
+    textField.setSelectionRange(0, 99999);
+    document.execCommand('copy');
+    textField.remove();
+  }
+};
+
+export const confirm = (props: BasicModalProps | string) => new Promise<boolean>((resolve, reject) => {
+  setAnotherProgramField('openModal', { value: Object.assign({ resolve, reject, okLabel: 'Confirmar', cancelLabel: 'Cancelar', title: 'Confirmar?' }, typeof props === 'string' ? { description: props } : props) }, 'argousSystem');
+});