@controleonline/ui-common 1.2.70 → 1.2.75

package/src/api/index.js

@@ -1,11 +1,217 @@
 import myFetch from '@controleonline/ui-common/src/api/fetch';
 import axios from 'axios';
-import { APP_ENV } from '../../../../../config/env';
+import {env as APP_ENV} from '@env';
 import { resolveAppDomain } from '@controleonline/ui-common/src/utils/appDomain';
 import { resolveApiEntryPoint } from '@controleonline/ui-common/src/utils/apiEntryPoint';
-
-const MIME_TYPE = 'application/ld+json';
-
+
+const MIME_TYPE = 'application/ld+json';
+const DOMAIN_QUERY_PARAM_KEYS = new Set(['app-domain', 'appdomain']);
+
+function stripDomainQueryParams(uri) {
+  const value = String(uri || '');
+  const hashIndex = value.indexOf('#');
+  const withoutHash = hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+  const hash = hashIndex >= 0 ? value.slice(hashIndex) : '';
+  const queryIndex = withoutHash.indexOf('?');
+
+  if (queryIndex < 0) {
+    return value;
+  }
+
+  const path = withoutHash.slice(0, queryIndex);
+  const params = new URLSearchParams(withoutHash.slice(queryIndex + 1));
+
+  for (const key of [...params.keys()]) {
+    if (DOMAIN_QUERY_PARAM_KEYS.has(String(key || '').trim().toLowerCase())) {
+      params.delete(key);
+    }
+  }
+
+  const query = params.toString();
+  return `${path}${query ? `?${query}` : ''}${hash}`;
+}
+
+function encodeBasicAuth(user, password) {
+  const credentials = `${String(user || '').trim()}:${String(password || '').trim()}`;
+
+  if (credentials === ':') {
+    return '';
+  }
+
+  if (typeof btoa === 'function') {
+    return btoa(credentials);
+  }
+
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(credentials, 'utf8').toString('base64');
+  }
+
+  return '';
+}
+
+function resolveApiRuntimeConfig(config = {}) {
+  return {
+    apiBaseUrl: String(config.apiBaseUrl || APP_ENV.API_ENTRYPOINT || '').trim(),
+    domain: String(config.domain || APP_ENV.DOMAIN || '').trim(),
+    htaccessUser: String(config.htaccessUser || APP_ENV.HTACCESS_USER || '').trim(),
+    htaccessPassword: String(config.htaccessPassword || APP_ENV.HTACCESS_PASSWORD || '').trim(),
+  };
+}
+
+function buildApiUrl(apiBaseUrl, path) {
+  const apiEntryPoint = resolveApiEntryPoint(apiBaseUrl);
+  const entryPoint = apiEntryPoint + (apiEntryPoint.endsWith('/') ? '' : '/');
+  const rawPath = String(path || '').startsWith('/')
+    ? String(path || '').substring(1)
+    : String(path || '');
+  const normalizedPath = stripDomainQueryParams(rawPath);
+
+  return new URL(normalizedPath, entryPoint).href;
+}
+
+function resolveRequestDevice(masterDevice, device, bodyDeviceId) {
+  if (masterDevice?.id) {
+    return masterDevice;
+  }
+
+  if (device?.id) {
+    return device;
+  }
+
+  return bodyDeviceId ? {id: bodyDeviceId} : null;
+}
+
+async function readSmokeResponseBody(response, responseType) {
+  if (responseType === 'blob') {
+    return await response.blob();
+  }
+
+  if (responseType === 'text') {
+    return await response.text();
+  }
+
+  const text = await response.text();
+
+  if (!text) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    return text;
+  }
+}
+
+function buildSmokeHttpError(response, body) {
+  const message =
+    String(body?.message || body?.error || body || response.statusText || 'Request failed')
+      .trim() || 'Request failed';
+
+  const error = new Error(message);
+  error.code = response.status;
+  error.status = response.status;
+  error.body = body;
+  return error;
+}
+
+async function requestSmoke(path, options = {}, config = {}) {
+  const runtimeConfig = resolveApiRuntimeConfig(config);
+  const url = buildApiUrl(runtimeConfig.apiBaseUrl, path);
+  const headers = new Headers(options.headers || undefined);
+  const accept =
+    options.responseType === 'blob' || options.responseType === 'text'
+      ? '*/*'
+      : MIME_TYPE;
+
+  if (accept !== '' && !headers.has('Accept')) {
+    headers.set('Accept', accept);
+  }
+
+  if (options.responseType !== 'blob' && !headers.has('Content-Type')) {
+    headers.set('Content-Type', MIME_TYPE);
+  }
+
+  const sessionToken = await api.getToken();
+
+  if (sessionToken && !headers.has('API-TOKEN')) {
+    headers.set('API-TOKEN', sessionToken);
+  }
+
+  const basicAuth = encodeBasicAuth(runtimeConfig.htaccessUser, runtimeConfig.htaccessPassword);
+  if (basicAuth !== '' && !headers.has('Authorization')) {
+    headers.set('Authorization', `Basic ${basicAuth}`);
+  }
+
+  const appDomain = resolveAppDomain(runtimeConfig.domain);
+  if (appDomain !== '' && !headers.has('App-Domain')) {
+    headers.set('App-Domain', appDomain);
+  }
+
+  let body = options.body;
+  const hasBody =
+    body !== undefined &&
+    body !== null &&
+    options.method !== 'GET' &&
+    options.method !== 'HEAD';
+
+  if (hasBody && typeof body !== 'string' && !(body instanceof FormData) && !(body instanceof Blob)) {
+    body = JSON.stringify(body);
+  }
+
+  if (options.params) {
+    const params = api.serialize(options.params);
+    if (params.length > 0) {
+      const urlObject = new URL(url);
+      urlObject.search = params.join('&');
+      return requestSmokeUrl(urlObject.toString(), {
+        ...options,
+        body,
+        headers,
+      });
+    }
+  }
+
+  return requestSmokeUrl(url, {
+    ...options,
+    body,
+    headers,
+  });
+}
+
+async function requestSmokeUrl(url, options) {
+  const response = await fetch(url, options);
+
+  if (options.responseType === 'blob') {
+    if (!response.ok) {
+      throw buildSmokeHttpError(response, await response.text().catch(() => ''));
+    }
+
+    return await response.blob();
+  }
+
+  const responseBody = await readSmokeResponseBody(response, options.responseType);
+
+  if (!response.ok) {
+    throw buildSmokeHttpError(response, responseBody);
+  }
+
+  if (
+    responseBody &&
+    typeof responseBody === 'object' &&
+    (responseBody['@type'] === 'Error' ||
+      responseBody['@type'] === 'ConstraintViolationList')
+  ) {
+    throw buildSmokeHttpError(response, responseBody);
+  }
+
+  if (options.responseType === 'text') {
+    return typeof responseBody === 'string' ? responseBody : '';
+  }
+
+  return responseBody;
+}
+
 export const api = {
   device: JSON.parse(localStorage.getItem('device') || '{}'),
   masterDevice: JSON.parse(localStorage.getItem('master-device') || '{}'),
@@ -17,19 +223,25 @@ export const api = {
     const apiEntryPoint = resolveApiEntryPoint(APP_ENV.API_ENTRYPOINT);
     const entryPoint = apiEntryPoint + (apiEntryPoint.endsWith("/") ? "" : "/");
     const url = new URL(uri.startsWith('/') ? uri.substring(1) : uri, entryPoint).href;
+    const basicAuth = encodeBasicAuth(APP_ENV.HTACCESS_USER, APP_ENV.HTACCESS_PASSWORD);
+    const headers = {
+      'API-TOKEN': token,
+      'App-Domain': appDomain,
+      'Accept': '*/*',
+      // IMPORTANTE: Deixe vazio para o Axios/Browser definir o boundary do multipart
+    };
+
+    if (basicAuth !== '') {
+      headers.Authorization = `Basic ${basicAuth}`;
+    }
 
     return axios.post(url, formData, {
-      headers: {
-        'API-TOKEN': token,
-        'App-Domain': appDomain,
-        'Accept': '*/*',
-        // IMPORTANTE: Deixe vazio para o Axios/Browser definir o boundary do multipart
-      }
-    });
-  },
-  fetch: async function (uri, options = {}) {
-    if (typeof options.headers === 'undefined')
-      Object.assign(options, { headers: new Headers() });
+      headers,
+    });
+  },
+  fetch: async function (uri, options = {}) {
+    if (typeof options.headers === 'undefined')
+      Object.assign(options, { headers: new Headers() });
 
     // Always refresh device from localStorage in case it was set after module load
     try {
@@ -45,14 +257,19 @@ export const api = {
     } catch (e) {
       this.masterDevice = {};
     }
-
-    let token = await this.getToken();
-    if (token) options.headers.set('API-TOKEN', token);
-
-    let bodyDeviceId = null;
-    if (options.body) {
-      if (typeof options.body === 'object') {
-        bodyDeviceId = options.body.device || null;
+
+    let token = await this.getToken();
+    if (token) options.headers.set('API-TOKEN', token);
+
+    const basicAuth = encodeBasicAuth(APP_ENV.HTACCESS_USER, APP_ENV.HTACCESS_PASSWORD);
+    if (basicAuth !== '' && !options.headers.has('Authorization')) {
+      options.headers.set('Authorization', `Basic ${basicAuth}`);
+    }
+
+    let bodyDeviceId = null;
+    if (options.body) {
+      if (typeof options.body === 'object') {
+        bodyDeviceId = options.body.device || null;
       } else if (typeof options.body === 'string') {
         try {
           const parsedBody = JSON.parse(options.body);
@@ -63,21 +280,36 @@ export const api = {
       }
     }
 
-    const headerDeviceId =
-      this.masterDevice?.id || this.device?.id || bodyDeviceId;
-    if (headerDeviceId) options.headers.set('DEVICE', headerDeviceId);
+    const requestDevice = resolveRequestDevice(
+      this.masterDevice,
+      this.device,
+      bodyDeviceId,
+    );
+
+    if (requestDevice?.id) {
+      options.headers.set('DEVICE', requestDevice.id);
+
+      const requestDeviceType = String(requestDevice.type || '')
+        .trim()
+        .toUpperCase();
+      if (requestDeviceType !== '') {
+        options.headers.set('DEVICE-TYPE', requestDeviceType);
+      }
+    }
     if (options.responseType != 'text') {
       options.headers.set('Content-Type', MIME_TYPE);
       options.headers.set('Accept', MIME_TYPE);
     }
     options.headers.set('App-Domain', resolveAppDomain(APP_ENV.DOMAIN));
-
-    if (options.body && typeof options.body != 'string') {
-      options.body = JSON.stringify(options.body);
-    }
-    if (options.params) {
-      uri = this.buildQueryString(uri, options);
-    }
+
+    if (options.body && typeof options.body != 'string') {
+      options.body = JSON.stringify(options.body);
+    }
+    uri = stripDomainQueryParams(uri);
+
+    if (options.params) {
+      uri = this.buildQueryString(uri, options);
+    }
     return myFetch(uri, options).catch(e => {
       throw e;
     });
@@ -100,13 +332,18 @@ export const api = {
 
     return session?.token || session?.api_key;
   },
-  serialize(obj, prefix = '') {
-    const pairs = [];
-
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        const value = obj[key];
-        let fullKey = prefix ? `${prefix}.${key}` : key; // Usa ponto para objetos
+  serialize(obj, prefix = '') {
+    const pairs = [];
+
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const normalizedKey = String(key || '').trim().toLowerCase();
+        if (DOMAIN_QUERY_PARAM_KEYS.has(normalizedKey)) {
+          continue;
+        }
+
+        const value = obj[key];
+        let fullKey = prefix ? `${prefix}.${key}` : key; // Usa ponto para objetos
 
         if (value === null || value === undefined) {
           pairs.push(`${fullKey}=`);
@@ -135,21 +372,54 @@ export const api = {
     return pairs;
   },
 
-  buildQueryString(uri, options) {
-    if (options.params) {
-      const params = this.serialize(options.params);
-      uri = `${uri}?${params.join('&')}`;
-    }
-    return uri;
-  },
-  post: async function (uri, body = {}) {
-    const options = {
-      method: 'POST',
-      body: body,
-    };
-    return await this.fetch(uri, options);
-  },
-  execute: function (params) {
-    return axios(params);
-  },
-};
+  buildQueryString(uri, options) {
+    const safeUri = stripDomainQueryParams(uri);
+
+    if (options.params) {
+      const params = this.serialize(options.params);
+      if (params.length === 0) {
+        return safeUri;
+      }
+
+      const hashIndex = safeUri.indexOf('#');
+      const withoutHash = hashIndex >= 0 ? safeUri.slice(0, hashIndex) : safeUri;
+      const hash = hashIndex >= 0 ? safeUri.slice(hashIndex) : '';
+      const separator = withoutHash.includes('?') ? '&' : '?';
+
+      return `${withoutHash}${separator}${params.join('&')}${hash}`;
+    }
+
+    return safeUri;
+  },
+  post: async function (uri, body = {}) {
+    const options = {
+      method: 'POST',
+      body: body,
+    };
+    return await this.fetch(uri, options);
+  },
+  loadSmokeIndex: async function (config = {}) {
+    return await requestSmoke('/tests', {}, config);
+  },
+  loadArtifactBlob: async function (config = {}, artifact) {
+    if (!artifact || typeof artifact !== 'object') {
+      throw new Error('Artefato inválido.');
+    }
+
+    if (!artifact.url) {
+      throw new Error('Artefato inválido.');
+    }
+
+    return await requestSmoke(artifact.url, {
+      responseType: 'blob',
+    }, config);
+  },
+  triggerSmokeRun: async function (config = {}) {
+    return await requestSmoke('/tests/run', {
+      method: 'POST',
+    }, config);
+  },
+  execute: function (params) {
+    return axios(params);
+  },
+};

package/src/react/components/AddImportModal.js

@@ -1,108 +1,68 @@
-import React, { useState } from 'react';
-import {
-    View,
-    Text,
-    TouchableOpacity,
-    ScrollView,
-    ActivityIndicator,
-    Platform,
-} from 'react-native';
-
-import Icon from 'react-native-vector-icons/MaterialIcons';
-import * as DocumentPicker from 'expo-document-picker';
+import React from 'react';
+import {
+    View,
+    Text,
+    TouchableOpacity,
+    ScrollView,
+    ActivityIndicator,
+} from 'react-native';
+
+import Icon from 'react-native-vector-icons/MaterialIcons';
 import { useStore } from '@store';
-import AnimatedModal from '@controleonline/ui-crm/src/react/components/AnimatedModal';
-import { api } from '@controleonline/ui-common/src/api';
+import AnimatedModal from './AnimatedModal';
 import { useMessage } from '@controleonline/ui-common/src/react/components/MessageService';
+import DefaultUpload from '@controleonline/ui-default/src/react/components/upload/DefaultUpload';
 import styles from './AddImportModal.styles';
-
-const AddImportModal = ({ visible, onClose, onSuccess, context = {} }) => {
-    const { showError, showSuccess } = useMessage();
-    const peopleStore = useStore('people');
-    const getters = peopleStore.getters;
-    const { currentCompany } = getters;
-
-    const [file, setFile] = useState(null);
-    const [loading, setLoading] = useState(false);
+
+const AddImportModal = ({ visible, onClose, onSuccess, context = {} }) => {
+    const { showError, showSuccess } = useMessage();
+    const peopleStore = useStore('people');
+    const importsStore = useStore('imports');
+    const themeStore = useStore('theme');
+    const getters = peopleStore.getters;
+    const { currentCompany } = getters;
+    const importActions = importsStore.actions || {};
+    const themeColors = themeStore?.getters?.colors || {};
+    const buttonPalette = {
+        buttonBackground: themeColors.buttonBackground,
+        buttonBorder: themeColors.buttonBorder,
+        buttonText: themeColors.buttonText,
+        buttonIcon: themeColors.buttonIcon || themeColors.buttonText,
+    };
+
     const modalTitle = global.t?.t('imports', 'title', 'new_import');
     const csvLabel = global.t?.t('imports', 'label', 'csv_file');
     const selectFileLabel = global.t?.t('imports', 'button', 'select_file');
     const cancelLabel = global.t?.t('imports', 'button', 'cancel');
-    const importLabel = global.t?.t('imports', 'button', 'import');
     const csvOnlyLabel = global.t?.t('imports', 'message', 'only_csv_files_are_allowed');
-    const pickFileErrorLabel = global.t?.t('imports', 'error', 'error_selecting_file');
     const importSuccessLabel = global.t?.t('imports', 'success', 'import_sent_successfully');
     const importErrorLabel = global.t?.t('imports', 'error', 'error_sending_import');
-    const missingFileLabel = global.t?.t('imports', 'error', 'select_a_csv_file');
-
-    const handlePickFile = async () => {
-        try {
-            const result = await DocumentPicker.getDocumentAsync({
-                type: 'text/csv',
-                copyToCacheDirectory: true,
-                multiple: false,
-            });
-
-            if (result.canceled) return;
-
-            const pickedFile = result.assets[0];
-
-            if (!pickedFile.name?.toLowerCase().endsWith('.csv')) {
-                showError(csvOnlyLabel);
-                return;
-            }
-
-            setFile(pickedFile);
-        } catch {
-            showError(pickFileErrorLabel);
-        }
-    };
 
-    const handleSave = async () => {
-        if (!file) {
-            showError(missingFileLabel);
-            return;
+    const handleUploadImportFile = async ({ file }) => {
+        if (!file?.name?.toLowerCase().endsWith('.csv')) {
+            throw new Error(csvOnlyLabel);
         }
-
-        setLoading(true);
-
-        try {
-            const formData = new FormData();
-            formData.append('importType', context.context);
-
-
-            formData.append('people', String(currentCompany.id));
-
-
-            if (Platform.OS === 'web') {
-                const response = await fetch(file.uri);
-                const blob = await response.blob();
-                formData.append('file', blob, file.name || 'import.csv');
-            } else {
-                formData.append('file', {
-                    uri: file.uri,
-                    name: file.name || 'import.csv',
-                    type: file.mimeType || 'text/csv',
-                });
-            }
 
-            await api.upload('/imports/upload', formData);
+        try {
+            await importActions.uploadImportFile({
+                file,
+                importType: context.context,
+                peopleId: currentCompany.id,
+            });
             showSuccess(importSuccessLabel);
             if (onSuccess) onSuccess();
             handleClose();
+            return file;
         } catch {
-            showError(importErrorLabel);
-        } finally {
-            setLoading(false);
+            throw new Error(importErrorLabel);
         }
-    };
-
-    const handleClose = () => {
-        setFile(null);
-        onClose();
-    };
-
-    return (
+    };
+
+    const handleClose = () => {
+        onClose();
+    };
+
+    return (
         <AnimatedModal
             visible={visible}
             onRequestClose={handleClose}
@@ -118,15 +78,50 @@ const AddImportModal = ({ visible, onClose, onSuccess, context = {} }) => {
 
                 <ScrollView style={styles.content}>
                     <Text style={styles.label}>{csvLabel}</Text>
-                    <TouchableOpacity
-                        onPress={handlePickFile}
-                        style={styles.filePicker}
-                    >
-                        <Text numberOfLines={1} style={styles.fileName}>
-                            {file ? file.name : selectFileLabel}
-                        </Text>
-                        <Icon name="upload-file" size={22} color={file ? "#007bff" : "#666"} />
-                    </TouchableOpacity>
+                    <DefaultUpload
+                        relationStoreName="imports"
+                        relationField="import"
+                        relationResource="imports"
+                        entityId={context.context || 'import'}
+                        companyId={currentCompany.id}
+                        context={`imports-${context.context || 'default'}`}
+                        libraryContexts={[`imports-${context.context || 'default'}`]}
+                        acceptedTypes="text/csv,.csv"
+                        fileType=""
+                        title={csvLabel}
+                        triggerLabel={selectFileLabel}
+                        managerTitle={modalTitle}
+                        searchPlaceholder={selectFileLabel}
+                        uploadButtonLabel={selectFileLabel}
+                        emptyAttachmentLabel=""
+                        emptyLibraryLabel={selectFileLabel}
+                        showInlineContent={false}
+                        uploadResultAlreadyAttached
+                        requireEntity={false}
+                        onUploadFile={handleUploadImportFile}
+                        renderTrigger={({openManager, uploading}) => (
+                            <TouchableOpacity
+                                onPress={openManager}
+                                disabled={uploading}
+                                style={[
+                                    styles.filePicker,
+                                    {
+                                        backgroundColor: buttonPalette.buttonBackground,
+                                        borderColor: buttonPalette.buttonBorder,
+                                    },
+                                ]}
+                            >
+                                <Text numberOfLines={1} style={[styles.fileName, { color: buttonPalette.buttonText }]}>
+                                    {selectFileLabel}
+                                </Text>
+                                {uploading ? (
+                                    <ActivityIndicator color={buttonPalette.buttonIcon} />
+                                ) : (
+                                    <Icon name="upload-file" size={22} color={buttonPalette.buttonIcon} />
+                                )}
+                            </TouchableOpacity>
+                        )}
+                    />
                     <Text style={styles.helperText}>
                         {csvOnlyLabel}
                     </Text>
@@ -136,22 +131,11 @@ const AddImportModal = ({ visible, onClose, onSuccess, context = {} }) => {
                     <TouchableOpacity onPress={handleClose} style={styles.secondaryButton}>
                         <Text>{cancelLabel}</Text>
                     </TouchableOpacity>
-
-                    <TouchableOpacity
-                        onPress={handleSave}
-                        disabled={loading}
-                        style={[
-                            styles.primaryButton,
-                            loading && styles.primaryButtonDisabled,
-                        ]}
-                    >
-                        {loading ? <ActivityIndicator color="#fff" /> : <Text style={styles.primaryButtonText}>{importLabel}</Text>}
-                    </TouchableOpacity>
                 </View>
             </View>
-        </AnimatedModal>
-    );
-};
-
+        </AnimatedModal>
+    );
+};
+
 export default AddImportModal;
 // TODO(store-first): quando este arquivo for mexido, mover a leitura para stores e evitar chamadas HTTP diretas quando o store ja resolver isso.