soyba-lib 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soyba-lib",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "main": "src/index.js",
   "type": "module",
   "description": "Thư viện YBA (Sổ Y Bạ) - Truy vấn lịch sử khám bệnh",

package/src/index.js

@@ -1,13 +1,12 @@
 // lib/soyba/src/index.js
 import axios from 'axios';
 import { parseStringPromise } from 'xml2js';
-import zlib from 'zlib';
 
 class YBAClient {
   constructor(options = {}) {
     this.baseUrl = options.baseUrl || process.env.API_SOYBA;
     this.apiKey = options.apiKey || process.env.API_KEY;
-    this.timeout = options.timeout || 15000;
+    this.timeout = options.timeout || 30000;
     this.logger = options.logger || console;
     
     if (!this.baseUrl) {
@@ -22,92 +21,105 @@ class YBAClient {
   }
 
   _isBase64(str) {
-    if (typeof str !== 'string') return false;
+    if (typeof str !== 'string' || str.length === 0) return false;
     
+    // Remove whitespace and check format
     const cleaned = str.replace(/\s+/g, '');
     if (!/^[A-Za-z0-9+/=_-]+$/.test(cleaned)) return false;
+    
+    // Check if it's a valid base64
     try {
-      const buf = Buffer.from(cleaned, 'base64');
-      return buf && buf.length > 0;
+      const decoded = Buffer.from(cleaned, 'base64').toString('utf8');
+      // Check if it looks like XML
+      return decoded.includes('<') && decoded.includes('>');
     } catch {
       return false;
     }
   }
 
-  async _decodeFileContent(base64Str) {
-    const buf = Buffer.from(base64Str.replace(/\r|\n/g, ''), 'base64');
-    let xmlStr = null;
-
+  async _decodeBase64ToXml(base64Str) {
     try {
-      xmlStr = zlib.gunzipSync(buf).toString('utf8');
-    } catch {
-      xmlStr = buf.toString('utf8');
+      const cleaned = base64Str.replace(/\s+/g, '');
+      const xmlStr = Buffer.from(cleaned, 'base64').toString('utf8');
+      
+      // Parse XML to JSON
+      const json = await parseStringPromise(xmlStr, { 
+        explicitArray: false, 
+        mergeAttrs: true,
+        trim: true 
+      });
+      
+      return { xml: xmlStr, json };
+    } catch (error) {
+      this.logger.warn('Failed to decode base64 XML', { error: error.message });
+      return { xml: null, json: null };
     }
+  }
 
-    let json = null;
+  async _fetchAndParseXmlFromUrl(url) {
     try {
-      json = await parseStringPromise(xmlStr, { explicitArray: false, mergeAttrs: true });
-    } catch {
-      // XML parsing failed
+      this.logger.debug('Fetching XML from URL', { url });
+      
+      const response = await axios.get(url, {
+        timeout: this.timeout,
+        responseType: 'text'
+      });
+      
+      // Parse XML to JSON
+      const json = await parseStringPromise(response.data, { 
+        explicitArray: false, 
+        mergeAttrs: true,
+        trim: true 
+      });
+      
+      return { xml: response.data, json };
+    } catch (error) {
+      this.logger.warn('Failed to fetch/parse XML from URL', { url, error: error.message });
+      return { xml: null, json: null };
     }
-
-    return { xml: xmlStr, json };
   }
 
-  async _decodeAndParseFiles(obj) {
-    const results = [];
-    const self = this;
+  async _processNestedXmlFiles(obj) {
+    if (!obj || typeof obj !== 'object') return obj;
 
-    async function traverse(node) {
-      if (!node || typeof node !== 'object') return;
+    // Process arrays
+    if (Array.isArray(obj)) {
+      const processed = [];
+      for (const item of obj) {
+        processed.push(await this._processNestedXmlFiles(item));
+      }
+      return processed;
+    }
 
-      if (node.FILEHOSO) {
-        const files = Array.isArray(node.FILEHOSO) ? node.FILEHOSO : [node.FILEHOSO];
-        const newFiles = [];
-        for (const file of files) {
-          if (file && file.NOIDUNGFILE && file.LOAIHOSO && self._isBase64(file.NOIDUNGFILE)) {
-            try {
-              const decoded = await self._decodeFileContent(file.NOIDUNGFILE);
-              const minimal = {
-                LOAIHOSO: file.LOAIHOSO,
-                NOIDUNGFILE_JSON: decoded.json
-              };
-              results.push(minimal);
-              newFiles.push(minimal);
-              self.logger.debug('Decoded FILEHOSO and injected minimal file', { LOAIHOSO: file.LOAIHOSO });
-            } catch (e) {
-              self.logger.warn('Failed to decode FILEHOSO', { LOAIHOSO: file.LOAIHOSO, error: e.message });
-            }
+    // Process objects
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === 'FILEHOSO' && Array.isArray(value)) {
+        // Process FILEHOSO array - decode NOIDUNGFILE in each item
+        const processedFiles = [];
+        for (const file of value) {
+          if (file && file.NOIDUNGFILE && this._isBase64(file.NOIDUNGFILE)) {
+            this.logger.debug('Decoding XML file', { LOAIHOSO: file.LOAIHOSO });
+            const decoded = await this._decodeBase64ToXml(file.NOIDUNGFILE);
+            processedFiles.push({
+              ...file,
+              NOIDUNGFILE: decoded.json || decoded.xml || file.NOIDUNGFILE,
+              NOIDUNGFILE_RAW: decoded.xml
+            });
           } else {
-            self.logger.debug('Skipping non-base64 or missing FILEHOSO', { maybeFile: file && file.LOAIHOSO });
+            processedFiles.push(file);
           }
         }
-
-        // Replace FILEHOSO with decoded files
-        node.FILEHOSO = Array.isArray(node.FILEHOSO) ? newFiles : (newFiles[0] || undefined);
+        result[key] = processedFiles;
+      } else if (typeof value === 'object') {
+        result[key] = await this._processNestedXmlFiles(value);
+      } else {
+        result[key] = value;
       }
-
-      for (const key of Object.keys(node)) {
-        if (typeof node[key] === 'object') await traverse(node[key]);
-      }
-    }
-
-    await traverse(obj);
-    this.logger.debug('Total decoded FILEHOSO', { count: results.length });
-    return results;
-  }
-
-  async _parseRawXml(xmlStr) {
-    try {
-      const json = await parseStringPromise(xmlStr, { explicitArray: false, mergeAttrs: true });
-      return json;
-    } catch (e) {
-      this.logger.warn('Failed to parse raw XML', { error: e.message });
-      return null;
     }
+    return result;
   }
 
-  // Copy exact logic from soyba.service.js getLichSuKham
   async getLichSuKham(cccd, token) {
     const correlationId = `soyba_hist_${Date.now()}_${Math.random().toString(36).slice(2,9)}`;
     
@@ -123,18 +135,23 @@ class YBAClient {
 
     try {
       this.logger.debug('SOYBA getLichSuKham request', { correlationId, url, params: { cccd } });
-      const resp = await axios.get(url, { headers, params: { cccd }, timeout: this.timeout });
-      this.logger.debug('SOYBA getLichSuKham response', { correlationId, data: resp.data });
-      return { status: resp.status, data: resp.data };
-    } catch (err) {
-      this.logger.error('SOYBA getLichSuKham failed', { correlationId, error: err.message, stack: err.stack, url, params: { cccd } });
-      const status = err.response?.status || 500;
-      const data = err.response?.data || { error: 'SOYBA request failed' };
+      const response = await axios.get(url, { headers, params: { cccd }, timeout: this.timeout });
+      this.logger.debug('SOYBA getLichSuKham response', { correlationId, status: response.status });
+      
+      return { status: response.status, data: response.data };
+    } catch (error) {
+      this.logger.error('SOYBA getLichSuKham failed', { 
+        correlationId, 
+        error: error.message, 
+        status: error.response?.status 
+      });
+      
+      const status = error.response?.status || 500;
+      const data = error.response?.data || { error: 'SOYBA request failed' };
       return { status, data };
     }
   }
 
-  // Copy exact logic from soyba.service.js getChiTietLichSu
   async getChiTietLichSu(cccd, ma_lk, token) {
     const correlationId = `soyba_detail_${Date.now()}_${Math.random().toString(36).slice(2,9)}`;
     
@@ -150,29 +167,57 @@ class YBAClient {
 
     try {
       this.logger.debug('SOYBA getChiTietLichSu request', { correlationId, url, params: { cccd, ma_lk } });
-      const resp = await axios.get(url, { headers, params: { cccd, ma_lk }, timeout: this.timeout });
-      this.logger.debug('YBA raw response', { correlationId, data: resp.data });
-
-      // Parse XML string if needed
-      let rootObj = resp.data;
-      if (typeof resp.data === 'string') {
-        const parsed = await this._parseRawXml(resp.data);
-        if (parsed) rootObj = parsed;
-      }
-
-      // Decode FILEHOSO files
-      const decodedFiles = await this._decodeAndParseFiles(rootObj);
-
-      if (decodedFiles.length > 0) {
-        // Return exactly like service gốc
-        return { status: resp.status, data: { original: rootObj } };
+      const response = await axios.get(url, { headers, params: { cccd, ma_lk }, timeout: this.timeout });
+      
+      this.logger.debug('YBA raw response received', { correlationId, dataLength: JSON.stringify(response.data).length });
+      
+      let processedData = response.data;
+      
+      // Handle different response formats
+      if (Array.isArray(processedData)) {
+        // Process each item in array
+        const processedArray = [];
+        for (const item of processedData) {
+          if (item.Url && item.ContentType === 'text/xml') {
+            // New format: fetch XML from URL
+            this.logger.debug('Fetching XML from URL', { Url: item.Url });
+            const xmlResult = await this._fetchAndParseXmlFromUrl(item.Url);
+            if (xmlResult.json) {
+              // Process nested XML files in the fetched content
+              const processedXml = await this._processNestedXmlFiles(xmlResult.json);
+              processedArray.push({
+                ...item,
+                NOIDUNGFILE: processedXml,
+                NOIDUNGFILE_RAW: xmlResult.xml
+              });
+            } else {
+              processedArray.push(item);
+            }
+          } else {
+            // Process existing NOIDUNGFILE if present
+            const processedItem = await this._processNestedXmlFiles(item);
+            processedArray.push(processedItem);
+          }
+        }
+        processedData = processedArray;
+      } else if (processedData && typeof processedData === 'object') {
+        // Single object - process nested files
+        processedData = await this._processNestedXmlFiles(processedData);
       }
-
-      // No decoded files - return parsed object or fallback
-      return { status: resp.status, data: rootObj || [] };
-    } catch (err) {
-      this.logger.error('SOYBA getChiTietLichSu failed', { correlationId, error: err.message, stack: err.stack, url, params: { cccd, ma_lk } });
-      const status = err.response?.status || 500;
+      
+      this.logger.debug('YBA processing completed', { correlationId });
+      return { status: response.status, data: processedData };
+      
+    } catch (error) {
+      this.logger.error('SOYBA getChiTietLichSu failed', { 
+        correlationId, 
+        error: error.message,
+        status: error.response?.status,
+        url, 
+        params: { cccd, ma_lk } 
+      });
+      
+      const status = error.response?.status || 500;
       return { status, data: [] };
     }
   }