closer-cli 0.0.4 → 0.4.0

package/csv/users.csv

@@ -0,0 +1,8 @@
+UserCode,Name,Email,Password,GroupCodes,MacroFilterCodes,CanSendOrder,CanCloseOrder,SharingUsers,Role
+MR,Mario Rossi,mario.rossicloser.sale,projectx,AI|WA,SS2020|FW2020|SS2021,TRUE,TRUE,EZ|EF|NR|FP|NDR|FC,
+EZ,Enrico Zeffiro,enrico.zeffiro@h-farm.com,projectx,AI|WA,SS2020|FW2020|SS2021,TRUE,TRUE,MR|EF|NR|FP|NDR|FC,
+EF,Emanuele Fornaro,emanuele.fornaro@h-farm.com,projectx,AI|WA,SS2020|FW2020,TRUE,TRUE,MR|EZ|NR|FP|NDR|FC,
+NR,Nicole Raffino,nicole.raffino@h-farm.com,projectx,AI,SS2020|FW2020,TRUE,TRUE,MR|EZ|EF|FP|NDR|FC,ADMIN
+FP,Francesco Pasqua,francesco.pasqua@h-farm.com,projectx,AI,SS2020|FW2020,TRUE,TRUE,MR|EZ|EF|NR|NDR|FC,ADMIN
+NDR,Nicola Dei Rossi,nicola.deirossih-farm.com,projectx,AI,FW2020,TRUE,TRUE,MR|EZ|EF|NR|FP|FC,
+FC,Fabio Carraro,fabio.carraro@h-farm.com,projectx,AI,SS2020|FW2020,TRUE,TRUE,MR|EZ|EF|NR|FP|NDR,

package/helpers.js

@@ -0,0 +1,706 @@
+/* eslint-disable no-console */
+/* eslint-disable no-param-reassign */
+/* eslint-disable implicit-arrow-linebreak */
+const fs = require('fs')
+const path = require('path')
+const WebSocket = require('ws')
+const chalk = require('chalk')
+const es = require('event-stream')
+const parse = require('csv-parse/lib/sync')
+const stringify = require('csv-stringify/lib/sync')
+const got = require('got')
+const { createWriteStream } = require('fs')
+
+exports.createSocketConnection = (endpoint, adminSecret) => {
+  const protocol = endpoint.includes('localhost') ? 'ws' : 'wss'
+  const socket = new WebSocket(`${protocol}://${endpoint}/import`, {
+    headers: { 'x-closer-admin-secret': adminSecret }
+  })
+
+  return socket
+}
+
+exports.ALLOWED_CSV_FILES = {
+  product: 'products.csv',
+  price: 'prices.csv',
+  group: 'groups.csv',
+  lookup: 'lookups.csv',
+  user: 'users.csv',
+  customer: 'customers.csv',
+  label: 'labels.csv',
+  filterPosition: 'filterPosition.csv',
+  fieldConfiguration: 'fieldConfigurations.csv',
+  userCustomer: 'userCustomers.csv'
+}
+
+exports.getCsvFilesFromDir = dir =>
+  fs.readdirSync(dir).filter(file => path.extname(file).toLowerCase() === '.csv')
+
+exports.getGoogleSheetCsvUrl = (docId, sheet) =>
+  `https://docs.google.com/spreadsheets/d/${docId}/gviz/tq?tqx=out:csv&sheet=${sheet}`
+
+exports.importCsvFromFile = (file, csvType, outputDir, spinner, ws, delimiter = ',') =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    const hrstart = process.hrtime()
+
+    let readStream = null
+
+    const errorCsvFile = path.resolve(outputDir, `${csvType}_errors.csv`)
+    const errorFileStream = fs.createWriteStream(errorCsvFile)
+
+    const skippedCsvFile = path.resolve(outputDir, `${csvType}_skipped.csv`)
+    const skippedFileStream = fs.createWriteStream(skippedCsvFile)
+
+    const filename = path.basename(file)
+    const dirname = path.dirname(errorCsvFile)
+    if (!fs.existsSync(dirname)) {
+      fs.mkdirSync(dirname, { recursive: true })
+    }
+
+    let header = ''
+    let lineNumber = 0
+    let countImported = 0
+    let countFailed = 0
+    let countSkipped = 0
+
+    spinner.start('Loading...')
+
+    const importRowSuccess = () => {
+      countImported += 1
+
+      spinner.text = this.printImportProcessResult({
+        countImported,
+        countFailed,
+        countSkipped,
+        executionTime: this.getExecutionTime(hrstart),
+        name: filename
+      })
+
+      readStream.resume()
+    }
+
+    const importRowError = csvRow => {
+      countFailed += 1
+
+      spinner.text = this.printImportProcessResult({
+        countImported,
+        countFailed,
+        countSkipped,
+        executionTime: this.getExecutionTime(hrstart),
+        name: filename
+      })
+
+      errorFileStream.write(
+        stringify([csvRow], {
+          header: countFailed === 1,
+          quoted: true,
+          delimiter: ';'
+        })
+      )
+
+      readStream.resume()
+    }
+
+    const importFatal = errorMessage => {
+      spinner.fail(
+        this.printImportProcessResult({
+          countImported,
+          countFailed,
+          countSkipped,
+          executionTime: this.getExecutionTime(hrstart),
+          name: filename,
+          fatalError: errorMessage
+        })
+      )
+
+      resolve({
+        csvType,
+        countImported,
+        countFailed,
+        countSkipped,
+        executionTime: this.getExecutionTime(hrstart),
+        inputFile: file,
+        fatalError: `FATAL: ${errorMessage}`
+      })
+
+      readStream.destroy()
+      errorFileStream.end()
+      skippedFileStream.end()
+    }
+
+    const importSuccess = () => {
+      if (countFailed > 0 || countSkipped > 0) {
+        spinner.warn()
+      } else {
+        spinner.succeed()
+      }
+
+      errorFileStream.end()
+      skippedFileStream.end()
+
+      resolve({
+        csvType,
+        countImported,
+        countFailed,
+        countSkipped,
+        executionTime: this.getExecutionTime(hrstart),
+        inputFile: file
+      })
+    }
+
+    socket.on('open', () => {
+      readStream = fs
+        .createReadStream(file)
+        .pipe(es.split())
+        .pipe(
+          es.mapSync(line => {
+            readStream.pause()
+
+            if (lineNumber === 0) {
+              header = line
+              readStream.resume()
+            } else {
+              try {
+                const rows = parse(`${header}\n${line}`, {
+                  columns: true,
+                  skip_empty_lines: true,
+                  skipLinesWithEmptyValues: true,
+                  delimiter
+                })
+
+                if (rows.length > 0) {
+                  const packet = {
+                    csvRow: rows[0],
+                    csvType,
+                    lineNumber,
+                    type: 'importCsvRow'
+                  }
+                  socket.send(JSON.stringify(packet))
+                } else {
+                  readStream.resume()
+                }
+              } catch (e) {
+                countSkipped += 1
+                skippedFileStream.write(`${line},${e.message}`)
+                readStream.resume()
+              }
+            }
+
+            lineNumber += 1
+          })
+        )
+        .on('error', e => importFatal(e.message))
+        .on('end', importSuccess)
+    })
+
+    socket.on('message', packet => {
+      const { type, payload } = JSON.parse(packet)
+
+      switch (type) {
+        case 'importRowSuccess':
+          importRowSuccess()
+          break
+        case 'importRowError':
+          importRowError(payload.csvRow)
+          break
+        case 'importRowFatal':
+          importFatal(payload.error)
+          break
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      importFatal(e.message)
+    })
+  })
+
+exports.validateCsvFromFile = (file, csvType, ws, delimiter = ',') =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    const hrstart = process.hrtime()
+
+    let readStream = null
+
+    let header = ''
+    let lineNumber = 0
+    const filename = path.basename(file)
+
+    socket.on('open', () => {
+      readStream = fs
+        .createReadStream(file)
+        .pipe(es.split())
+        .pipe(
+          es.mapSync(line => {
+            readStream.pause()
+
+            if (lineNumber === 0) {
+              header = line
+              readStream.resume()
+            }
+
+            if (lineNumber === 1) {
+              const rows = parse(`${header}\n${line}`, {
+                columns: true,
+                skip_empty_lines: true,
+                skipLinesWithEmptyValues: true,
+                delimiter
+              })
+
+              const packet = {
+                csvColumns: Object.keys(rows[0]),
+                csvType,
+                type: 'validateCsvHeaderRequest'
+              }
+
+              socket.send(JSON.stringify(packet))
+              readStream.destroy()
+            }
+
+            lineNumber += 1
+          })
+        )
+        .on('error', e => {
+          resolve({
+            csvType,
+            executionTime: this.getExecutionTime(hrstart),
+            inputFile: filename,
+            error: e.message
+          })
+        })
+    })
+
+    socket.on('message', packet => {
+      const { type, payload } = JSON.parse(packet)
+      switch (type) {
+        case 'validateCsvHeaderResponse': {
+          const result = {
+            csvType,
+            executionTime: this.getExecutionTime(hrstart),
+            inputFile: filename
+          }
+
+          if (payload.error) {
+            result.error = payload.error
+          }
+
+          resolve(result)
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({
+        csvType,
+        executionTime: this.getExecutionTime(hrstart),
+        inputFile: file,
+        error: e.message
+      })
+    })
+  })
+
+exports.importCsvFromUrl = async (url, csvType, outputDir, spinner, ws) => {
+  spinner.start('Downloading file...')
+  const downloadedFile = await this.download(url, outputDir, `${csvType}.csv`)
+  spinner.succeed('Downloaded file')
+  return this.importCsvFromFile(downloadedFile, csvType, outputDir, spinner, ws)
+}
+
+exports.getExecutionTime = start => {
+  const hrend = process.hrtime(start)
+  return ((hrend[0] * 1e9 + hrend[1]) / 1e9).toFixed(1)
+}
+
+exports.printValidationProcessHeader = () => {
+  console.log('\n=== Validation Process Result ===\n')
+}
+
+exports.printImportProcessHeader = () => {
+  console.log('\n=== Import Process Result ===\n')
+}
+
+exports.printValidationProcessResult = ({
+  inputFile,
+  error
+  // eslint-disable-next-line consistent-return
+}) => {
+  let message = ''
+  const filename = path.basename(inputFile)
+
+  if (error) {
+    message = `[${chalk.red(filename)}] not valid ${chalk.gray(`[${error}]`)}`
+  } else {
+    message = `[${chalk.green(filename)}] valid`
+  }
+
+  console.log(message)
+}
+
+exports.printImportProcessResult = ({
+  countImported,
+  countFailed,
+  countSkipped,
+  executionTime,
+  name,
+  fatalError
+  // eslint-disable-next-line consistent-return
+}) => {
+  let message = ''
+
+  if (fatalError) {
+    message = `[${chalk.red(name)}] ${chalk.red(fatalError)}`
+    return message
+  }
+
+  message = `[${this.colorByResult(
+    name,
+    countImported,
+    countFailed,
+    countSkipped
+  )}] imported ${this.colorGreaterThanZero(countImported, 'green')} items`
+
+  if (countFailed) {
+    message += `, failed ${this.colorGreaterThanZero(countFailed, 'red')} items`
+  }
+
+  if (countSkipped) {
+    message += `, skipped ${this.colorGreaterThanZero(countSkipped, 'red')} items`
+  }
+
+  message += ` ${chalk.gray(`[${executionTime}s]`)}`
+
+  return message
+}
+
+exports.colorByResult = (value, countImported, countFailed, countSkipped) => {
+  let color = 'green'
+
+  if (countImported > 0 && (countFailed > 0 || countSkipped > 0)) {
+    color = 'yellow'
+  }
+
+  if (countImported === 0 && (countFailed > 0 || countSkipped > 0)) {
+    color = 'red'
+  }
+
+  return chalk[color](value)
+}
+
+exports.colorGreaterThanZero = (value, color) => {
+  if (value > 0) {
+    return chalk[color](value)
+  }
+
+  return value
+}
+
+exports.refreshOrders = (spinner, ws) =>
+  new Promise(resolve => {
+    const hrstart = process.hrtime()
+
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Refreshing draft orders...')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'refreshDraftOrdersRequest' }))
+    })
+
+    socket.on('message', packet => {
+      const { type, payload } = JSON.parse(packet)
+      switch (type) {
+        case 'refreshDraftOrdersResponse': {
+          spinner.text = this.printRefreshedOrders({
+            ...payload,
+            executionTime: this.getExecutionTime(hrstart)
+          })
+          spinner.succeed()
+          resolve({
+            totalCount: payload.totalCount,
+            refreshed: payload.refreshed,
+            errored: payload.errored,
+            executionTime: this.getExecutionTime(hrstart)
+          })
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+// eslint-disable-next-line consistent-return
+exports.printRefreshedOrders = ({ refreshed, errored, executionTime }) => {
+  let message = ''
+
+  const stringRefreshed = this.colorGreaterThanZero(refreshed.length, 'green')
+  const stringErrored = this.colorGreaterThanZero(errored.length, 'red')
+
+  message += `Refreshed ${stringRefreshed} orders (draft)`
+
+  if (errored.length) {
+    message += `, refresh failed for ${stringErrored} orders.`
+  }
+
+  message += ` ${chalk.gray(`[${executionTime}s]`)}`
+
+  return message
+}
+
+exports.truncateTablesByCsvTypes = (csvTypes, spinner, ws) =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Deleting database records...')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'truncateTablesByCsvTypesRequest', csvTypes }))
+    })
+
+    socket.on('message', packet => {
+      const { type } = JSON.parse(packet)
+      switch (type) {
+        case 'truncateTablesByCsvTypesResponse': {
+          spinner.succeed('Database records deleted (soft)')
+          resolve()
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+exports.download = async (url, destPath, fileName) =>
+  new Promise((resolve, reject) => {
+    const filePath = path.resolve(destPath, fileName)
+
+    const dirname = path.dirname(filePath)
+    if (!fs.existsSync(dirname)) {
+      fs.mkdirSync(dirname, { recursive: true })
+    }
+
+    const downloadStream = got.stream(url)
+    const fileWriterStream = createWriteStream(filePath)
+
+    downloadStream
+      // .on('downloadProgress', ({ transferred, total, percent }) => {
+      //   const percentage = Math.round(percent * 100)
+      //   console.error(`progress: ${transferred}/${total} (${percentage}%)`)
+      // })
+      .on('error', reject)
+
+    fileWriterStream.on('error', reject).on('finish', () => {
+      resolve(filePath)
+    })
+
+    downloadStream.pipe(fileWriterStream)
+  })
+
+exports.callBeforeDataImportProcess = (spinner, ws) =>
+  new Promise((resolve, reject) => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Executing tasks before start...')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'callBeforeDataImportProcessRequest' }))
+    })
+
+    socket.on('message', packet => {
+      const { type, payload } = JSON.parse(packet)
+      switch (type) {
+        case 'callBeforeDataImportProcessResponse': {
+          if (payload.error) {
+            spinner.fail(payload.error)
+            reject()
+          } else {
+            spinner.succeed('Tasks executed before start')
+            resolve()
+          }
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+exports.callAfterDataImportProcess = (spinner, ws, report) =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Executing tasks after the end process...')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'callAfterDataImportProcessRequest', payload: report }))
+    })
+
+    socket.on('message', packet => {
+      const { type } = JSON.parse(packet)
+      switch (type) {
+        case 'callAfterDataImportProcessResponse': {
+          spinner.succeed('Tasks executed after the end process')
+          resolve()
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+exports.callAfterMediaImportProcess = (spinner, ws, report) =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Executing tasks after the end process...')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'callAfterMediaImportProcessRequest', payload: report }))
+    })
+
+    socket.on('message', packet => {
+      const { type } = JSON.parse(packet)
+      switch (type) {
+        case 'callAfterMediaImportProcessResponse': {
+          spinner.succeed('Tasks executed after the end process')
+          resolve()
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+exports.importMedia = (reprocess, spinner, ws) =>
+  new Promise(resolve => {
+    const hrstart = process.hrtime()
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    let countAssetImported = 0
+    let countAssetSkipped = 0
+    let countAssetFailed = 0
+    let countProductAssetImported = 0
+
+    const updateSpinnerText = () => {
+      spinner.text = this.printImportProcessResult({
+        countImported: countAssetImported,
+        countSkipped: countAssetSkipped,
+        countFailed: countAssetFailed,
+        executionTime: this.getExecutionTime(hrstart),
+        name: 'Asset'
+      })
+    }
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'import.images', payload: { reprocess } }))
+    })
+
+    socket.on('message', packet => {
+      const { type, payload } = JSON.parse(packet)
+
+      switch (type) {
+        case 'import.images.start':
+          spinner.start('[Asset] Importing Assets...')
+          break
+        case 'import.images.imageAsset.success':
+          countAssetImported += 1
+          updateSpinnerText()
+          break
+        case 'import.images.imageAsset.skipped':
+          countAssetSkipped += 1
+          updateSpinnerText()
+          break
+        case 'import.images.imageAsset.failed':
+          countAssetFailed += 1
+          updateSpinnerText()
+          break
+        case 'import.images.productAssets.start':
+          countProductAssetImported = payload.count
+          spinner.succeed()
+          spinner.start(`[ProductAsset] Importing ${countProductAssetImported} Product Assets...`)
+          break
+        case 'import.images.productAssets.end':
+          spinner.succeed(
+            this.printImportProcessResult({
+              countImported: payload.count,
+              countFailed: 0,
+              executionTime: this.getExecutionTime(hrstart),
+              name: 'ProductAsset'
+            })
+          )
+          break
+        case 'import.images.end':
+          resolve({
+            countAssetImported,
+            countAssetSkipped,
+            countAssetFailed,
+            countProductAssetImported
+          })
+          break
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })
+
+exports.flushMedia = (spinner, ws) =>
+  new Promise(resolve => {
+    const socket = this.createSocketConnection(ws.endpoint, ws.adminSecret)
+
+    spinner.start('Flushing... ')
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({ type: 'flush.media.request' }))
+    })
+
+    socket.on('message', packet => {
+      const { type } = JSON.parse(packet)
+      switch (type) {
+        case 'flush.media.response': {
+          spinner.succeed('Flushing completed')
+          resolve()
+          break
+        }
+        default:
+          break
+      }
+    })
+
+    socket.on('error', e => {
+      resolve({ error: e.message })
+    })
+  })