kitchen-simulator 5.0.0-test.5 → 5.0.0-test.7

package/src/utils/helper.js

@@ -0,0 +1,431 @@
+import { HDRCubeTextureLoader } from 'three/examples/jsm/loaders/HDRCubeTextureLoader.js';
+import {
+  DECIMAL_PLACES_2,
+  HDR_URLS,
+  ANIMATE_OBJECT_OPEN_DOOR_ROTATION_UNIT,
+  ANIMATE_STEP_MAX,
+  MODE_ELEVATION_VIEW
+} from '../../src/constants';
+import * as Three from 'three';
+import { returnReplaceableDeepSearchType } from './../components/viewer2d/utils';
+import convert from 'convert-units';
+import { formatNumber } from './math';
+
+const AWS = require('aws-sdk');
+
+const s3 = new AWS.S3({
+  accessKeyId: process.env.REACT_APP_AWS_ID,
+  secretAccessKey: process.env.REACT_APP_AWS_SECRET
+});
+
+const s3ParseUrl = url => {
+  var _decodedUrl = decodeURIComponent(url);
+
+  var _result = null;
+
+  // http://s3.amazonaws.com/bucket/key1/key2
+  var match = decodedUrl.match(
+    /^https?:\/\/s3.amazonaws.com\/([^\/]+)\/?(.*?)$/
+  );
+  if (_match) {
+    _result = {
+      bucket: _match[1],
+      key: _match[2],
+      region: ''
+    };
+  }
+
+  // http://s3-aws-region.amazonaws.com/bucket/key1/key2
+  match = decodedUrl.match(
+    /^https?:\/\/s3-([^.]+).amazonaws.com\/([^\/]+)\/?(.*?)$/
+  );
+  if (_match) {
+    _result = {
+      bucket: _match[2],
+      key: _match[3],
+      region: _match[1]
+    };
+  }
+
+  // http://bucket.s3.amazonaws.com/key1/key2
+  match = decodedUrl.match(/^https?:\/\/([^.]+).s3.amazonaws.com\/?(.*?)$/);
+  if (_match) {
+    _result = {
+      bucket: _match[1],
+      key: _match[2],
+      region: ''
+    };
+  }
+
+  // http://bucket.s3-aws-region.amazonaws.com/key1/key2 or,
+  // http://bucket.s3.aws-region.amazonaws.com/key1/key2
+  match = decodedUrl.match(
+    /^https?:\/\/([^.]+).(?:s3-|s3\.)([^.]+).amazonaws.com\/?(.*?)$/
+  );
+  if (_match) {
+    _result = {
+      bucket: _match[1],
+      key: _match[3],
+      region: _match[2]
+    };
+  }
+
+  return _result;
+};
+
+export const textureCube = new HDRCubeTextureLoader()
+  .setPath('/catalog/envMap/')
+  .load(HDR_URLS, function () {
+    textureCube.magFilter = Three.LinearFilter;
+    textureCube.needsUpdate = true;
+  });
+
+export const getSignedUrl = url => {
+  if (!url) return url;
+  let signedUrl = url;
+  try {
+    const { bucket, key } = s3ParseUrl(url);
+    signedUrl = s3.getSignedUrl('getObject', {
+      Bucket: bucket,
+      Key: key,
+      ResponseCacheControl: 'no-cache'
+    });
+  } catch (e) {
+    signedUrl = url;
+  }
+  return signedUrl;
+};
+
+export const base64Decode = targetStr => {
+  if (!targetStr) return null;
+  try {
+    // If URL-encoded, decode first
+    const base64Str = targetStr.includes('%')
+      ? decodeURIComponent(targetStr)
+      : targetStr;
+    const binaryStr = atob(base64Str);
+    // Convert binary string to UTF-8 string
+    return decodeURIComponent(
+      binaryStr
+        .split('')
+        .map(char => `%${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+        .join('')
+    );
+  } catch (e) {
+    console.log('Invalid Base64 or UTF-8 string: ', e);
+    return null;
+  }
+};
+
+export const refineProductForSummaryPdf = (
+  refinedProductList,
+  catalog,
+  categoryData,
+  itemSKU,
+  suffix,
+  item,
+  product,
+  measurementUnit,
+  count
+) => {
+  let review;
+  let doorColor = item.doorStyle;
+  if (doorColor.size) {
+    doorColor = doorColor.toJS();
+  }
+  let doorStyleName = doorColor?.name;
+  if (catalog !== undefined) {
+    if (!doorColor?.install) {
+      categoryData.data.doorStyles.items.forEach(category => {
+        category.items.forEach(element => {
+          if (element.items.filter(it => it.id === doorColor?.id)) {
+            doorColor = { ...doorColor, install: category.name };
+          }
+        });
+      });
+    }
+
+    review = catalog.elements[item.type];
+    if (!review) {
+      review = catalog.elements[returnReplaceableDeepSearchType(item.type)];
+    }
+
+    if (doorColor?.install?.toLowerCase() === 'pre-assembled') {
+      itemSKU += '-assembled';
+    } else {
+      itemSKU += '-rta';
+    }
+
+    const refinedData = {
+      thumbnail: review.img,
+      sku: itemSKU,
+      sizeInfo: {
+        width:
+          Math.round(
+            convert(review.info.sizeinfo.width)
+              .from('in')
+              .to(measurementUnit._unit) * 100
+          ) / 100,
+        depth:
+          Math.round(
+            convert(review.info.sizeinfo.depth)
+              .from('in')
+              .to(measurementUnit._unit) * 100
+          ) / 100,
+        height:
+          Math.round(
+            convert(review.info.sizeinfo.height)
+              .from('in')
+              .to(measurementUnit._unit) * 100
+          ) / 100,
+        _unit: measurementUnit._unit
+      },
+      doorstyle: doorStyleName,
+      installation: suffix,
+      subTotal:
+        product && product.discounted_price
+          ? product && Number(product.discounted_price * (count || 1))
+          : 0
+    };
+
+    let index = (refinedProductList || []).findIndex(
+      row => row.sku === itemSKU
+    );
+    if (index !== -1) {
+      refinedProductList[index] = refinedData;
+    } else {
+      refinedProductList.push(refinedData);
+    }
+  }
+};
+
+export const refineMoldingForSummaryPdf = (
+  refinedProductList,
+  molding,
+  product,
+  newSKU
+) => {
+  if (molding) {
+    let review = {
+      img: molding.thumbnail,
+      name: molding.name,
+      count: molding.count
+    };
+
+    const subTotalPrice =
+      product && product.discounted_price
+        ? formatNumber(
+            product.discounted_price * review.count,
+            DECIMAL_PLACES_2
+          )
+        : 0;
+    const refinedData = {
+      id: newSKU,
+      thumbnail: review.img,
+      sku: review.name,
+      sizeInfo: null,
+      subTotal: Number(subTotalPrice)
+    };
+
+    let index = (refinedProductList || []).findIndex(row => row.sku === newSKU);
+    if (index !== -1) {
+      refinedProductList[index] = refinedData;
+    } else {
+      refinedProductList.push(refinedData);
+    }
+  }
+};
+
+export function applyEdges(object) {
+  if (object && object.isMesh && !(object instanceof Three.LineSegments)) {
+    let parent = object.parent;
+    if (!isEmpty(parent)) {
+      if (
+        object.name.match('interior_drawer') ||
+        object.name.match('interior') ||
+        object.name.match('soul')
+      ) {
+        parent.remove(object);
+      } else {
+        // Create a replacement
+        const edges = new Three.EdgesGeometry(object.geometry, 10);
+        const lineMaterial = new Three.LineBasicMaterial({
+          color: 0x000000,
+          depthTest: true,
+          depthFunc: Three.LessEqualDepth,
+          depthWrite: false
+        });
+        const line = new Three.LineSegments(edges, lineMaterial);
+        line.position.copy(object.position);
+        line.scale.copy(object.scale);
+        line.rotation.copy(object.rotation);
+        line.name = object.name;
+
+        // Replace in parent
+        parent.remove(object);
+        parent.add(line);
+      }
+    }
+  }
+}
+
+export function replaceMeshesWithLineSegments(object) {
+  if (object && object.children.length > 0) {
+    for (let i = object.children.length - 1; i >= 0; i--) {
+      const child = object.children[i];
+      // Recursively process children first
+      replaceMeshesWithLineSegments(child);
+    }
+  } else {
+    //
+    // Check if the child is a THREE.Mesh
+    applyEdges(object);
+  }
+}
+
+export const isEmpty = value =>
+  value === undefined ||
+  value === null ||
+  (typeof value === 'array' && value.length === 0) ||
+  (typeof value === 'object' && Object.keys(value).length === 0) ||
+  (typeof value === 'string' && value.trim().length === 0);
+
+// animate the Opening or Closing Door action
+export const animateDoor = (
+  offsetData,
+  doorObj,
+  open_doors,
+  item,
+  isCorner,
+  mode
+) => {
+  let offset = new Three.Vector3(offsetData.x, offsetData.y, offsetData?.z);
+  doorObj.translateOnAxis(offset, 1);
+  let rotation =
+    doorObj.name.match(/\d_(door[^LR1-9]*)(_[LR])?(_[1-9])?$/)[2] === '_L'
+      ? -ANIMATE_OBJECT_OPEN_DOOR_ROTATION_UNIT
+      : ANIMATE_OBJECT_OPEN_DOOR_ROTATION_UNIT;
+  let isflip = item.properties.flip_doorhandle;
+  rotation = isflip ? -rotation : rotation;
+  if (isCorner == 1) {
+    if (!doorObj.name.includes('base_end')) {
+      rotation *= 2;
+    }
+    let tmp = doorObj.children[0].children.filter(item => {
+      return item.children.length != 0;
+    });
+    if (tmp.length != 0) {
+      rotation = open_doors ? -rotation : rotation;
+    } else {
+      rotation = open_doors ? rotation : -rotation;
+    }
+  } else {
+    rotation = open_doors ? rotation : -rotation;
+  }
+  if (mode === 'Opened2D') rotation *= ANIMATE_STEP_MAX; // Check whether the object's door is opened in 2D.
+  doorObj.rotateY(rotation);
+  doorObj.translateOnAxis(offset, -1);
+};
+
+// Opening or Closing the drawer action
+export const translateDrawer = (item, drawerObj, open_doors, mode) => {
+  let animate_translate_unit =
+    ((convert(item.properties.depth._length)
+      .from(item.properties.depth._unit)
+      .to('cm') *
+      (1 / 2)) /
+      ANIMATE_STEP_MAX) *
+    0.01;
+  // Check whether the object's drawer is opened in 2D.
+  if (mode === 'Opened2D') animate_translate_unit *= ANIMATE_STEP_MAX;
+  drawerObj.translateZ(
+    open_doors ? -animate_translate_unit : animate_translate_unit
+  );
+};
+
+export const getPath = () => {
+  return window.location.pathname;
+};
+
+export const getPathInfo = num => {
+  const paths = window.location.pathname.split('/');
+  if (paths.length >= num + 1) {
+    return paths[num];
+  } else {
+    return paths[num - 1 >= 0 ? num - 1 : 0];
+  }
+};
+
+// determine if elevation mode or not
+export function isElevationView(mode) {
+  if (mode === MODE_ELEVATION_VIEW) return true;
+  else return false;
+}
+
+// calculate camera rect in elevation mode
+/**
+ *
+ * @param {number} width width of elevation view - canvas
+ * @param {number} height height of elevation view - canvas
+ * @param {number} ceilHeight ceiling Height
+ * @param {number} lineLength wall's length
+ * @returns {object}
+ */
+
+//** elevation view (canvas) **//
+
+//// h /////////////////////// width //////////////////////// h ////
+//// e //// **c***************lineLength*************c** //// e ////
+//// i //// **e                                      e** //// i ////
+//// g //// **i                                      i** //// g ////
+//// h //// **l***************lineLength*************l** //// h ////
+//// t /////////////////////// width //////////////////////// t ////
+export function handleCamRect(width, height, ceilHeight, lineLength) {
+  let scale = Math.min((width * 0.6) / lineLength, (height * 0.6) / ceilHeight); // scale is min value
+  let cameraRect = {
+    width: width / scale,
+    height: height / scale
+  };
+
+  return cameraRect;
+}
+
+/**
+ *
+ * @param {*} layer
+ * @param {*} ceilHeight
+ * @param {*} ceilUnit
+ * @returns true ceilingHeight is bigger than totalHeight(item's height + altitude), otherwise false
+ */
+export function isCeilLimitation(layer, ceilHeight, ceilUnit) {
+  let items = layer.getIn(['layers', layer.selectedLayer, 'items']);
+  return items.some(item => {
+    let height = item.properties.getIn(['height', '_length']);
+    let heightUnit = item.properties.getIn(['height', '_unit']);
+    let altitude = item.properties.getIn(['altitude', '_length']);
+    let altitudeUnit = item.properties.getIn(['altitude', '_unit']);
+    let totalHeight =
+      convert(height).from(heightUnit).to(ceilUnit._unit) +
+      convert(altitude).from(altitudeUnit).to(ceilUnit._unit);
+    return totalHeight > ceilHeight;
+  });
+}
+
+export function isValidNumber(n) {
+  return !isNaN(n) && isFinite(n);
+}
+
+export function toPlainObject(maybeImmutable) {
+  if (maybeImmutable && typeof maybeImmutable.toJS === 'function') {
+    return maybeImmutable.toJS();
+  }
+  return maybeImmutable; // already a plain JS object
+}
+
+export function isImmutable(maybeImmutable) {
+  return !!(maybeImmutable && typeof maybeImmutable.toJS === 'function');
+}
+
+export function debugUtil() {
+  return new Date();
+}

package/src/utils/history.js

@@ -0,0 +1,37 @@
+import { Map } from 'immutable';
+import diff from 'immutablediff';
+import patch from 'immutablepatch';
+
+export const historyPush = (historyStructure, item) => {
+  if (historyStructure.last) {
+    if (historyStructure.last.hashCode() !== item.hashCode()) {
+      let toPush = new Map({
+        time: Date.now(),
+        diff: diff(historyStructure.last, item)
+      });
+
+      historyStructure = historyStructure
+        .set('last', item)
+        .set('list', historyStructure.list.push(toPush));
+    }
+  } else {
+    historyStructure = historyStructure.set('last', item);
+  }
+  return historyStructure;
+};
+
+export const historyPop = historyStructure => {
+  if (historyStructure.last) {
+    if (historyStructure.list.size) {
+      let last = historyStructure.first;
+      for (let x = 0; x < historyStructure.list.size - 1; x++) {
+        last = patch(last, historyStructure.list.get(x).get('diff'));
+      }
+
+      historyStructure = historyStructure
+        .set('last', last)
+        .set('list', historyStructure.list.pop());
+    }
+  }
+  return historyStructure;
+};

package/src/utils/id-broker.js

@@ -0,0 +1,9 @@
+let shortid = require('shortid');
+
+export class IDBroker {
+  static acquireID() {
+    return shortid.generate();
+  }
+}
+
+export default IDBroker;

package/src/utils/logger.js

@@ -0,0 +1,8 @@
+export function LogLine(state, layerID, lineID) {
+  let layer = state.getIn(['scene', 'layers', layerID]);
+  let line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
+  let vertex0 = layer.vertices.get(line.vertices.get(0));
+  let vertex1 = layer.vertices.get(line.vertices.get(1));
+  console.log('updateDrawingLine: vertex0', vertex0.x, vertex0.y);
+  console.log('updateDrawingLine: vertex1', vertex1.x, vertex1.y);
+}

package/src/utils/math.js

@@ -0,0 +1,51 @@
+/** @description Return float fixed to desired precision
+ *  @param {number} num Float to fix
+ *  @param {number} precision Desired precision, or 6 if not specified
+ *  @return {number}
+ */
+export function toFixedFloat(num, precision = 6) {
+  if (num && precision) {
+    return parseFloat(parseFloat(num).toFixed(precision));
+  }
+  return 0;
+}
+
+/** @description Return absolute value of a number
+ *  @param {number} n Number of wich get value without sign
+ *  @return {number}
+ */
+export const fAbs = n => {
+  return Math.abs(n);
+  // let x = n;
+  // x < 0 && (x = ~x + 1);
+  // return x;
+};
+
+/** @description Multiply two matrices
+ *  @param {Array} m1 Matrix 1
+ *  @param {Array} m2 Matrix 2
+ *  @return {Array}
+ */
+export const multiplyMatrices = (m1, m2) => {
+  let result = [];
+  for (let i = 0; i < m1.length; i++) {
+    result[i] = [];
+    for (let j = 0; j < m2[0].length; j++) {
+      let sum = 0;
+      for (let k = 0; k < m1[0].length; k++) {
+        sum += m1[i][k] * m2[k][j];
+      }
+      result[i][j] = sum;
+    }
+  }
+  return result;
+};
+
+export const formatNumber = (value, digits) => {
+  if (value == null || isNaN(Number(value))) return value; // guard for null/undefined/non-numeric
+  return Number(value).toFixed(digits);
+};
+
+export const isNonZeroText = text => {
+  return parseFloat(text) !== 0;
+};