@mixd-id/web-scaffold 0.1.230406001

package/src/utils/helpers.js

@@ -0,0 +1,185 @@
+const md5 = require("md5");
+const fs = require("fs");
+
+
+const ceil = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.ceil(n) / p
+}
+
+const floor = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.floor(n) / p
+}
+
+const ftWildcard = (key) => {
+  const term = key.replace(/[\-\+\<\>\@\(\)\~]/, ' ', 'gi')
+
+  const searchTerms = []
+  term.split(' ').forEach((txt) => {
+    if(txt.length >= 3){
+      searchTerms.push(`+${txt}*`)
+    }
+  })
+  return searchTerms.join(' ')
+}
+
+const moveFile = function(oldPath, newPath, callback) {
+
+  fs.rename(oldPath, newPath, function (err) {
+    if (err) {
+      if (err.code === 'EXDEV') {
+        copy();
+      } else {
+        callback(err);
+      }
+      return;
+    }
+    callback();
+  });
+
+  function copy() {
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+
+    readStream.on('error', callback);
+    writeStream.on('error', callback);
+
+    readStream.on('close', function () {
+      fs.unlink(oldPath, callback);
+    });
+
+    readStream.pipe(writeStream);
+  }
+}
+
+const round = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.round(n) / p
+}
+
+const sanitizeMobileNumber = (mobileNumber) => {
+  if(typeof mobileNumber !== 'string') return mobileNumber
+
+  if(mobileNumber.length > 0){
+    mobileNumber = mobileNumber.replace(/[\- ]/g, '')
+    if(mobileNumber.substring(0, 1) === '0') mobileNumber = '+62' + mobileNumber.substring(1)
+    if(mobileNumber.substring(0, 1) !== '+'){
+      if(mobileNumber.substring(0, 2) === '62')
+        mobileNumber = '+' + mobileNumber
+      else
+        mobileNumber = '+62' + mobileNumber
+    }
+    if(mobileNumber.length > 0){
+      mobileNumber = mobileNumber[0] + mobileNumber.slice(1).replace(/\D/g, '')
+    }
+  }
+
+  return mobileNumber
+}
+
+const saveBase64 = async(data, dir = '/storage/files/images') => {
+  if(data.indexOf(',') >= 0){
+    data = data.substring(data.indexOf(',') + 1)
+  }
+  const buffer = Buffer.from(data, 'base64');
+  return await saveBuffer(buffer, dir)
+}
+
+const saveBuffer = async(buffer, dir = '/storage/files/images') => {
+
+  const { fileTypeFromBuffer } = await import('file-type')
+
+  const type = await fileTypeFromBuffer(buffer)
+
+  const storagePath = process.env.ROOT_PATH + (dir)
+  const ext = type && type.ext ? '.' + type.ext : ''
+  const filename = md5(buffer) + ext
+  const to = storagePath + '/' + filename
+
+  fs.writeFileSync(to, buffer)
+
+  return filename
+}
+
+const saveFromUrl = async(url, dir = '/storage/files/images') => {
+
+  const res = await axios({
+    method: 'GET',
+    url,
+    responseType: 'arraybuffer',
+  })
+  const buffer = Buffer.from(res.data)
+  return await saveBuffer(buffer, dir)
+}
+
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+const strSlug = (title, separator) => {
+  if (typeof separator == 'undefined') separator = '-';
+
+  // Convert all dashes/underscores into separator
+  var flip = separator === '-' ? '_' : '-';
+  title = title.replace(flip, separator);
+
+  // Remove all characters that are not the separator, letters, numbers, or whitespace.
+  title = title.toLowerCase()
+      .replace(new RegExp('[^a-z0-9' + separator + '\\s]', 'g'), '');
+
+  // Replace all separator characters and whitespace by a single separator
+  title = title.replace(new RegExp('[' + separator + '\\s]+', 'g'), separator);
+
+  return title.replace(new RegExp('^[' + separator + '\\s]+|[' + separator + '\\s]+$', 'g'),'');
+}
+
+const strVars = (text, vars) => {
+
+  (text.match(/\{.*?(?=\})\}/gi) ?? []).forEach((match) => {
+    const key = match.substring(1, match.length - 1)
+    const value = vars[key] ?? ''
+    text = text.replace(match, value)
+  })
+
+  return text
+}
+
+const writeStorage = (path, content, append = false) => {
+
+  if(path.startsWith('/')) path = path.substring(1)
+
+  if(append){
+    fs.appendFileSync(process.env.ROOT_PATH + `/storage/${path}`, content)
+  }
+  else{
+    fs.writeFileSync(process.env.ROOT_PATH + `/storage/${path}`, content)
+  }
+}
+
+const bufferToStream = (buffer) => {
+  const { Duplex } = require('stream')
+  let stream = new Duplex()
+  stream.push(buffer)
+  stream.push(null)
+  return stream
+}
+
+
+module.exports = {
+  ceil,
+  floor,
+  ftWildcard,
+  moveFile,
+  round,
+  sanitizeMobileNumber,
+  saveBase64,
+  saveBuffer,
+  saveFromUrl,
+  sleep,
+  strSlug,
+  strVars,
+  writeStorage,
+  bufferToStream
+}

package/src/utils/helpers.mjs

@@ -0,0 +1,197 @@
+
+const csvToArray = (str, delimiter = null) => {
+
+  if(!delimiter){
+    delimiter = str.indexOf(';') >= 0 ? ';' : ','
+  }
+
+  str = str.trim()
+
+  const headers = str.slice(0, str.indexOf("\n")).split(delimiter);
+
+  const rows = str.slice(str.indexOf("\n") + 1).split("\n");
+
+  const arr = rows.map(function (row) {
+    const values = row.split(delimiter);
+    let el = {}
+    if(values.length === headers.length){
+      el = headers.reduce(function (object, header, index) {
+        object[header] = values[index];
+        return object;
+      }, {});
+    }
+    return el;
+  })
+    .filter((_) => Object.keys(_).length > 0);
+
+  return arr;
+}
+
+const downsizeImage = async (url, targetWidth, imageType, quality, opt = {}) => {
+
+  let defaultImageType = 'image/jpeg'
+
+  if(url instanceof File){
+
+    defaultImageType = url.type
+
+    await (new Promise((resolve, reject) => {
+      var reader = new FileReader();
+      reader.addEventListener('load', () => {
+        url = reader.result
+        resolve()
+      }, false)
+      reader.addEventListener('error', (e) => {
+        reject(e)
+      })
+      reader.readAsDataURL(url);
+    }))
+  }
+
+  return new Promise((resolve, reject) => {
+
+    const image = new Image()
+    image.addEventListener('load', () => {
+
+      const canvasWidth = image.width > targetWidth ? targetWidth : image.width
+      const canvasHeight = Math.round((image.height / image.width) * canvasWidth)
+
+      const canvas = document.createElement('canvas');
+      canvas.width = canvasWidth;
+      canvas.height = canvasHeight;
+
+      if(opt.constraint){
+        if(canvasWidth / canvasHeight !== opt.constraint)
+          reject(new Error('Image constraint error'))
+      }
+
+      const ctx = canvas.getContext("2d");
+      ctx.drawImage(image, 0, 0, canvasWidth, canvasHeight);
+
+      canvas.toBlob((blob) => {
+        resolve(blob)
+      }, imageType ?? defaultImageType, quality ?? .8)
+    })
+    image.addEventListener('error', (e) => {
+      reject(e)
+    })
+    image.src = url
+  })
+}
+
+const parseBoolean = function(exp){
+  return [ 'true', 1, true ].includes(typeof exp === 'string' ?
+      exp.toLowerCase() : exp)
+}
+
+const strVars = function(text, vars){
+
+  (text.match(/\{.*?(?=\})\}/gi) ?? []).forEach((match) => {
+    const key = match.substring(1, match.length - 1)
+    const value = vars[key] ?? ''
+    text = text.replace(match, value)
+  })
+
+  return text
+}
+
+let _QS
+const urlQuery = function(){
+
+  if(!_QS){
+    _QS = new Proxy(new URLSearchParams(window.location.search), {
+      get: (searchParams, prop) => searchParams.get(prop),
+    });
+  }
+
+  return _QS
+}
+
+const getQueryString = function(key){
+  urlQuery()
+
+  if(typeof key === 'string'){
+    return _QS[key]
+  }
+  else if(Array.isArray(key)){
+    return key.map((k) => {
+      return _QS[k]
+    })
+  }
+}
+
+let __uid = new Date().getTime()
+const uid = function(prefix){
+  return (prefix ?? '') + __uid++;
+}
+
+export {
+  downsizeImage,
+  uid,
+  observeInit,
+  csvToArray,
+  parseBoolean,
+  urlQuery,
+  getQueryString
+}
+
+function observeInit(){
+
+  const intersectionObserver = new IntersectionObserver(
+      onIntersection,
+      {
+        rootMargin: '50px 50px 50px 50px',
+        threshold: 0.01,
+      }
+  )
+
+  function onIntersection(entries, observer) {
+
+    entries.forEach((entry) => {
+      if (entry.intersectionRatio === 0) {
+        return;
+      }
+
+      const item = entry.target
+      const key = item.__observeKey
+      const { type, callback } = observeCols[key]
+
+      if(typeof callback === 'function')
+        callback.apply(item)
+
+      if(type === 'once'){
+        observer.unobserve(item)
+        delete observeCols[key]
+      }
+    })
+  }
+
+  const observeCols = {}
+
+  const once = function(el, callback)
+  {
+    if(typeof el.__observeKey !== 'undefined') return
+
+    intersectionObserver.observe(el)
+
+    const key = 'observe-' + uid()
+    observeCols[key] = { type:'once', callback }
+    el.__observeKey = key
+  }
+
+  const always = function(el, callback)
+  {
+    if(typeof el.__observeKey !== 'undefined') return
+
+    intersectionObserver.observe(el)
+
+    const key = 'observe-' + uid()
+    observeCols[key] = { type:'one', callback }
+    el.__observeKey = key
+  }
+
+  return {
+    once,
+    always
+  }
+}

package/src/utils/importer.js

@@ -0,0 +1,156 @@
+const md5 = require("md5");
+const fs = require("fs");
+const AdmZip = require("adm-zip");
+const glob = require("glob");
+const Exceljs = require("exceljs")
+const { saveBuffer } = require('./helpers.js')
+
+const analyseRequest = async(req) => {
+
+  const file = req.files[0]
+  const ext = file.originalname.split('.').slice(-1).pop()
+
+  let folderName = md5('motor-import-analyse' + new Date().getTime())
+  let xlsxFileType, xlsxFile
+
+  fs.mkdirSync(process.env.ROOT_PATH + '/storage/files/temp/' + folderName)
+
+  if(ext === 'zip'){
+
+    const zip = new AdmZip(file.buffer)
+    zip.extractAllTo(process.env.ROOT_PATH + '/storage/files/temp/' + folderName, true)
+
+    const res = glob.sync(process.env.ROOT_PATH + '/storage/files/temp/' + folderName + '/**/*(*.xlsx|*.csv)')
+
+    if(res.length < 1)
+      throw new Error('Invalid file')
+    else if(res.length > 1)
+      throw new Error('Invalid file')
+    else{
+      xlsxFile = res[0]
+      xlsxFileType = xlsxFile.split('.').slice(-1).pop()
+    }
+  }
+
+  else{
+    xlsxFileType = ext
+    const filename = await saveBuffer(file.buffer, '/storage/files/temp/' + folderName)
+    xlsxFile = process.env.ROOT_PATH + '/storage/files/temp/' + folderName + '/' + filename
+  }
+
+
+  const workbook = new Exceljs.Workbook();
+  switch(xlsxFileType){
+
+    case 'xlsx':
+      await workbook.xlsx.readFile(xlsxFile)
+      break
+
+    case 'csv':
+      await workbook.csv.readFile(xlsxFile, {
+        parserOptions: {
+          delimiter: ';'
+        }
+      });
+      break
+  }
+
+  if(workbook.worksheets.length > 1)
+    throw new Error('Number of sheet allowed within file is 1')
+  else if(workbook.worksheets.length < 1)
+    throw new Error('Unable to read worksheet')
+
+  const worksheet = workbook.worksheets[0]
+
+  const columns = []
+  const header = worksheet.getRow(1)
+  if(!header)
+    throw new Error('Invalid file')
+  header.eachCell((cell) => {
+    columns.push(cell.value)
+  })
+
+  return {
+    columns,
+    folderName,
+    xlsxFileType,
+    xlsxFile
+  }
+}
+
+const importRequest = async(req) => {
+
+  const { columns, folderName, xlsxFileType, xlsxFile, keys } = req.body
+
+  keys.forEach((key) => {
+    if (key.required && !key.value)
+      throw new Error({name: ['Kolom ' + key.text + ' harus diisi']})
+  })
+
+  const rows = []
+  const cols = {}
+  const workbook = new Exceljs.Workbook();
+  switch(xlsxFileType){
+
+    case 'xlsx':
+      await workbook.xlsx.readFile(xlsxFile)
+      break
+
+    case 'csv':
+      await workbook.csv.readFile(xlsxFile, {
+        parserOptions: {
+          delimiter: ';'
+        }
+      });
+      break
+  }
+
+  const worksheet = workbook.worksheets[0]
+  worksheet.eachRow((row, index) => {
+    if(index === 1){
+      row.eachCell((cell, index) => {
+
+        let mapped = false
+        keys.forEach((key) => {
+          if(key.value === cell.value){
+            cols[key.key] = index
+            mapped = true
+          }
+        })
+
+        if(!mapped){
+          cols[cell.value] = index
+        }
+      })
+    }
+    else{
+      const obj = {}
+
+      for(let key in cols){
+        const cell = row.getCell(cols[key])
+        obj[key] = cell.formulaType === 1 ? cell.result : cell.value
+      }
+
+      rows.push(obj)
+    }
+  })
+
+  //console.log(JSON.stringify(rows, null, 2))
+
+  const images = glob.sync(process.env.ROOT_PATH + '/storage/files/temp/' + folderName +
+      '/**/*(*.jpg|*.jpeg|*.png|*.webp)')
+
+  return {
+    ...req.body,
+    rows,
+    images,
+    columns,
+    keys
+  }
+}
+
+
+module.exports = {
+  analyseRequest,
+  importRequest
+}