@evershop/evershop 1.0.0-beta

package/src/modules/catalog/api/admin/productBulkEnable/[context]multerNone[auth].js

@@ -0,0 +1,7 @@
+const multer = require('multer');
+
+const upload = multer();
+
+module.exports = (request, response, stack, next) => {
+  upload.none()(request, response, next);
+};

package/src/modules/catalog/api/admin/productBulkEnable/enableProducts.js

@@ -0,0 +1,24 @@
+const { update } = require('@evershop/mysql-query-builder');
+const { getConnection } = require('../../../../../lib/mysql/connection');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, stack, next) => {
+  const connection = await getConnection();
+  try {
+    const productIds = request.body.ids;
+    await update('product')
+      .given({ status: 1 })
+      .where('product_id', 'IN', productIds.split(','))
+      .execute(connection);
+    response.json({
+      data: {},
+      success: true
+    });
+  } catch (e) {
+    response.json({
+      data: {},
+      message: e.message,
+      success: false
+    });
+  }
+};

package/src/modules/catalog/api/admin/productBulkEnable/route

@@ -0,0 +1,2 @@
+GET,POST
+/product/bulkEnable

package/src/modules/catalog/api/admin/productSavePost/[context]multerNone[auth].js

@@ -0,0 +1,7 @@
+const multer = require('multer');
+
+const upload = multer();
+
+module.exports = (request, response, stack, next) => {
+  upload.none()(request, response, next);
+};

package/src/modules/catalog/api/admin/productSavePost/[createProduct,updateProduct]saveAttributes[finish].js

@@ -0,0 +1,79 @@
+/* eslint-disable no-loop-func */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+const {
+  insert, select, update, insertOnUpdate, del
+} = require('@evershop/mysql-query-builder');
+const { get } = require('../../../../../lib/util/get');
+
+module.exports = async (request, response, stack) => {
+  const promises = [stack.createProduct, stack.updateProduct];
+  const results = await Promise.all(promises);
+  let productId;
+  if (request.body.product_id) {
+    productId = request.body.product_id;
+  } else {
+    productId = results[0].insertId;
+  }
+  const connection = await stack.getConnection;
+  const attributes = get(request, 'body.attributes', {});
+
+  for (const code in attributes) {
+    const attr = await select().from('attribute').where('attribute_code', '=', code).load(connection);
+    if (!attr) { return; }
+
+    if (attr.type === 'textarea' || attr.type === 'text') {
+      const flag = await select('attribute_id')
+        .from('product_attribute_value_index')
+        .where('product_id', '=', productId)
+        .and('attribute_id', '=', attr.attribute_id)
+        .load(connection);
+
+      if (flag) {
+        await update('product_attribute_value_index')
+          .given({ option_text: attributes[code].trim() })
+          .where('product_id', '=', productId)
+          .and('attribute_id', '=', attr.attribute_id)
+          .execute(connection);
+      } else {
+        await insert('product_attribute_value_index')
+          .prime('product_id', productId)
+          .prime('attribute_id', attr.attribute_id)
+          .prime('option_text', attributes[code].trim())
+          .execute(connection);
+      }
+    } else if (attr.type === 'multiselect') {
+      await Promise.all(attributes[code].map(() => (async () => {
+        const option = await select().from('attribute_option').where('attribute_option_id', '=', parseInt(attributes[code], 10)).load(connection);
+        if (option === null) { return; }
+        await insertOnUpdate('product_attribute_value_index')
+          .prime('option_id', option.attribute_option_id)
+          .prime('product_id', productId)
+          .prime('attribute_id', attr.attribute_id)
+          .prime('option_text', option.option_text)
+          .execute(connection);
+      })()));
+    } else if (attr.type === 'select') {
+      const option = await select().from('attribute_option').where('attribute_option_id', '=', parseInt(attributes[code], 10)).load(connection);
+      // eslint-disable-next-line no-continue
+      if (option === false) { continue; }
+      // Delete old option if any
+      await del('product_attribute_value_index')
+        .where('attribute_id', '=', attr.attribute_id)
+        .and('product_id', '=', productId)
+        .execute(connection);
+      // Insert new option
+      await insertOnUpdate('product_attribute_value_index')
+        .prime('option_id', option.attribute_option_id)
+        .prime('product_id', productId)
+        .prime('attribute_id', attr.attribute_id)
+        .prime('option_text', option.option_text)
+        .execute(connection);
+    } else {
+      await insertOnUpdate('product_attribute_value_index')
+        .prime('option_text', attributes[code])
+        .execute(connection);
+    }
+  }
+};

package/src/modules/catalog/api/admin/productSavePost/[createProduct,updateProduct]saveCategories[finish].js

@@ -0,0 +1,32 @@
+/* eslint-disable no-loop-func */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+const {
+  insert, del
+} = require('@evershop/mysql-query-builder');
+const { get } = require('../../../../../lib/util/get');
+
+module.exports = async (request, response, delegate) => {
+  const promises = [delegate.createProduct, delegate.updateProduct];
+  const results = await Promise.all(promises);
+  let productId;
+  if (request.body.product_id) {
+    productId = request.body.product_id;
+  } else {
+    productId = results[0].insertId;
+  }
+  const connection = await delegate.getConnection;
+  const categories = get(request, 'body.categories', []);
+  console.log(categories)
+  // Delete all
+  await del('product_category').where('product_id', '=', productId).execute(connection, false);
+  // Add new 
+  for (let i = 0; i < categories.length; i++) {
+    if (categories[i]) {
+      await insert('product_category')
+        .given({ product_id: productId, category_id: categories[i] })
+        .execute(connection, false);
+    }
+  }
+};

package/src/modules/catalog/api/admin/productSavePost/[createProduct,updateProduct]saveImages[finish].js

@@ -0,0 +1,126 @@
+const { insert, del, update } = require('@evershop/mysql-query-builder');
+const sharp = require('sharp');
+const config = require('config');
+const path = require('path');
+const { get } = require('../../../../../lib/util/get');
+const { CONSTANTS } = require('../../../../../lib/helpers');
+const { existsSync } = require('fs');
+
+module.exports = async (request, response, stack) => {
+  let gallery = get(request, 'body.productMainImages', []);
+
+  // Wait for product saving to be completed
+  const promises = [stack.createProduct, stack.updateProduct];
+  const results = await Promise.all(promises);
+
+  let productId = results[0] ? results[0].insertId : results[1];
+  const connection = await stack.getConnection;
+  // eslint-disable-next-line no-useless-catch
+  try {
+    // Delete all old images
+    await del('product_image')
+      .where('product_image_product_id', '=', productId)
+      .execute(connection);
+    gallery = gallery.filter((image) => {
+      const mediaPath = path.join(CONSTANTS.MEDIAPATH, image);
+      return image && existsSync(mediaPath);
+    });
+
+    if (gallery.length > 0) {
+      const mainImage = gallery.shift();
+      const mediaPath = path.join(CONSTANTS.MEDIAPATH, mainImage);
+      const ext = path.extname(path.resolve(CONSTANTS.MEDIAPATH, mainImage));
+      // Generate thumbnail
+      if (existsSync(mediaPath)) {
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.thumbnail.width'),
+            config.get('catalog.product.image.thumbnail.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-thumb${ext}`
+          ));
+
+        // Generate listing
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.listing.width'),
+            config.get('catalog.product.image.listing.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-list${ext}`
+          ));
+
+        // Generate single
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.single.width'),
+            config.get('catalog.product.image.single.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-single${ext}`
+          ));
+      }
+
+      await update('product')
+        .given({ image: mainImage })
+        .where('product_id', '=', productId)
+        .execute(connection);
+    }
+
+    await Promise.all(gallery.map((f) => (async () => {
+      const mediaPath = path.join(CONSTANTS.MEDIAPATH, f);
+      const ext = path.extname(path.resolve(CONSTANTS.MEDIAPATH, f));
+      if (existsSync(mediaPath)) {
+        // Generate thumbnail
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.thumbnail.width'),
+            config.get('catalog.product.image.thumbnail.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-thumb${ext}`
+          ));
+
+        // Generate listing
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.listing.width'),
+            config.get('catalog.product.image.listing.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-list${ext}`
+          ));
+
+        // Generate single
+        await sharp(mediaPath)
+          .resize(
+            config.get('catalog.product.image.single.width'),
+            config.get('catalog.product.image.single.height'),
+            { fit: 'inside' }
+          )
+          .toFile(mediaPath.replace(
+            ext,
+            `-single${ext}`
+          ));
+      }
+      await insert('product_image')
+        .given({ image: f })
+        .prime('product_image_product_id', productId)
+        .execute(connection);
+    })()));
+  } catch (e) {
+    // TODO: Log an error here
+    throw e;
+  }
+};

package/src/modules/catalog/api/admin/productSavePost/[createProduct,updateProduct]saveOptions[finish].js

@@ -0,0 +1,94 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-await-in-loop */
+const {
+  insert, del, select, update
+} = require('@evershop/mysql-query-builder');
+const { merge } = require('../../../../../lib/util/merge');
+
+async function saveOptionValues(optionId, values, connection) {
+  if (!values || values === 0) {
+    await del('product_custom_option_value').where('option_id', '=', optionId).execute(connection);
+    return;
+  }
+
+  // Delete all old option values
+  await del('product_custom_option_value')
+    .where('option_id', '=', optionId)
+    .andWhere('product_custom_option_value_id', 'NOT IN', Object.keys(values))
+    .execute(connection);
+  // Get all remaining option values for comparison
+  const optionValues = await select('product_custom_option_value_id')
+    .from('product_custom_option_value')
+    .where('option_id', '=', optionId).execute(connection);
+
+  for (const id in values) {
+    if (optionValues.find(
+      (v) => parseInt(v.product_custom_option_value_id, 10) === parseInt(id, 10)
+    )) {
+      await update('product_custom_option_value')
+        .given(merge(values[id], { sort_order: 0 }))
+        .where('product_custom_option_value_id', '=', id)
+        .execute(connection);
+    } else {
+      await insert('product_custom_option_value')
+        .given(merge(values[id], { sort_order: 0 }))
+        .prime('option_id', optionId)
+        .execute(connection);
+    }
+  }
+}
+
+module.exports = async (request, response, stack) => {
+  const promises = [stack.createProduct, stack.updateProduct];
+  const results = await Promise.all(promises);
+  let productId;
+  if (request.body.product_id) {
+    productId = request.body.product_id;
+  } else {
+    productId = results[0].insertId;
+  }
+  const connection = await stack.getConnection;
+  if (!request.body.options) {
+    // Clean all options
+    await del('product_custom_option').where('product_custom_option_product_id', '=', productId).execute(connection);
+    return;
+  }
+  // Delete all old options
+  await del('product_custom_option')
+    .where('product_custom_option_product_id', '=', productId)
+    .and('product_custom_option_id', 'NOT IN', Object.keys(request.body.options)).execute(connection);
+
+  // Get all remaining options for comparison
+  const options = await select('product_custom_option_id').from('product_custom_option').where('product_custom_option_product_id', '=', productId).execute(connection);
+  // eslint-disable-next-line no-restricted-syntax
+  // eslint-disable-next-line guard-for-in
+  for (const id in request.body.options) {
+    let option;
+    if (options.find((o) => parseInt(o.product_custom_option_id, 10) === parseInt(id, 10))) {
+      option = await update('product_custom_option')
+        .given(
+          {
+            ...request.body.options[id],
+            is_required: request.body.options[id].is_required || 0
+          }
+        )
+        .where('product_custom_option_id', '=', id)
+        .execute(connection);
+    } else {
+      option = await insert('product_custom_option')
+        .given(
+          {
+            ...request.body.options[id],
+            is_required: request.body.options[id].is_required || 0
+          }
+        )
+        .prime('product_custom_option_product_id', productId)
+        .execute(connection);
+    }
+    await saveOptionValues(
+      parseInt(option.insertId || id, 10),
+      request.body.options[id].values || [],
+      connection
+    );
+  }
+};

package/src/modules/catalog/api/admin/productSavePost/[createProduct,updateProduct]saveVariants[finish].js

@@ -0,0 +1,273 @@
+/* eslint-disable no-lone-blocks */
+const {
+  insert, select, update, insertOnUpdate, del
+} = require('@evershop/mysql-query-builder');
+const sharp = require('sharp');
+const { CONSTANTS } = require('../../../../../lib/helpers');
+const { get } = require('../../../../../lib/util/get');
+const path = require('path');
+const config = require('config');
+const { existsSync } = require('fs');
+
+module.exports = async (request, response, stack) => {
+  // Wait for product table to be updated. get productId
+  const promises = [stack.createProduct, stack.updateProduct];
+  const results = await Promise.all(promises);
+  let productId;
+  if (request.body.product_id) {
+    productId = request.body.product_id;
+  } else {
+    productId = results[0].insertId;
+  }
+  const connection = await stack.getConnection;
+
+  const product = await select().from('product').where('product_id', '=', productId).load(connection);
+
+  // If "variant_group" is not available, do nothing
+  if (request.body.variant_group === undefined) { return; }
+
+  // No variants
+  if (
+    request.body.variant_group.variants === undefined
+    || request.body.variant_group.variants.length === 0
+  ) {
+    // Remove variant group ID from main product if any
+    // Update visibility
+    await update('product')
+      .prime('variant_group_id', null)
+      .prime('visibility', 1)
+      .where('product_id', '=', productId)
+      .execute(connection);
+    return;
+  }
+
+  // Make sure variant attribute are "select" attribute
+  if (
+    !request.body.variant_group.variant_group_attributes
+    || Object.keys(request.body.variant_group.variant_group_attributes).length === 0
+  ) { return; }
+
+  const attributes = await select()
+    .from('attribute')
+    .where('attribute_id', 'IN', request.body.variant_group.variant_group_attributes)
+    .andWhere('type', '=', 'select')
+    .execute(connection);
+
+  if (attributes.length < request.body.variant_group.variant_group_attributes.length) { return; }
+
+  // If variant attributes are not assigned to current product attribute group. We do it now
+  await Promise.all(attributes.map((a) => (async () => {
+    await insertOnUpdate('attribute_group_link')
+      .prime('attribute_id', a.attribute_id)
+      .prime('group_id', parseInt(request.body.group_id, 10))
+      .execute(connection);
+  })()));
+
+  // Maximum 5 attributes
+  await del('variant_group').where('variant_group_id', '=', parseInt(`0${product.variant_group_id}`, 10)).execute(connection);
+  const variantId = get(await insert('variant_group')
+    .given({
+      attribute_group_id: parseInt(request.body.group_id, 10),
+      attribute_one: attributes[0].attribute_id,
+      attribute_two: get(attributes[1], 'attribute_id'),
+      attribute_three: get(attributes[2], 'attribute_id'),
+      attribute_four: get(attributes[3], 'attribute_id'),
+      attribute_five: get(attributes[4], 'attribute_id')
+    })
+    .execute(connection), 'insertId');
+
+  await update('product')
+    .prime('variant_group_id', variantId)
+    .where('product_id', '=', productId)
+    .execute(connection);
+
+  // Validate and save variants
+  const { variants } = request.body.variant_group;
+  // console.log(variants);
+  await Promise.all(Object.keys(variants).map((k) => (async () => {
+    {
+      const v = variants[k];
+      // If this is the current SKU
+      if (v.sku === product.sku) {
+
+      } else {
+        const options = await Promise.all(v.attributes.map((a) => (async () => await select()
+          .from('attribute_option')
+          .where('attribute_id', '=', a.attribute)
+          .andWhere('attribute_option_id', '=', a.value)
+          .load(connection))()));
+        if (v.sku && options.find((o) => o === null) === undefined) {
+          await saveVariant(
+            productId,
+            v.productId,
+            v.sku,
+            parseFloat(`0${v.price}`),
+            parseInt(`0${v.qty}`, 10),
+            v.visibility,
+            options.map((o) => ({
+              ...o, option_id: o.attribute_option_id, option_text: o.option_text
+            })),
+            request.body[k] || [],
+            connection
+          );
+        }
+      }
+    }
+  })()));
+};
+
+async function saveVariant(mainProductId, variantProductId, variantSku, variantPrice, variantQty, variantVisibility, variantAttributes, variantImages = [], connection) {
+  // Copy master information
+  let productId;
+  if (variantProductId) {
+    productId = variantProductId;
+    await update('product')
+      .given(await select().from('product').where('product_id', '=', mainProductId).load(connection))
+      .prime('sku', variantSku)
+      .prime('price', variantPrice)
+      .prime('qty', variantQty)
+      .prime('image', null)
+      .prime('visibility', variantVisibility)
+      .where('product_id', '=', variantProductId)
+      .execute(connection);
+  } else {
+    productId = get(await insertOnUpdate('product')
+      .given(await select().from('product').where('product_id', '=', mainProductId).load(connection))
+      .prime('sku', variantSku)
+      .prime('price', variantPrice)
+      .prime('qty', variantQty)
+      .prime('image', null)
+      .prime('visibility', variantVisibility)
+      .execute(connection), 'insertId');
+  }
+
+  // Copy description
+  await insertOnUpdate('product_description')
+    .given(await select().from('product_description').where('product_description_product_id', '=', mainProductId).load(connection))
+    .prime('product_description_product_id', productId)
+    .execute(connection);
+
+  // Save image gallery
+  if (variantImages.length > 0) {
+    const mainImage = variantImages.shift();
+    const mediaPath = path.join(CONSTANTS.MEDIAPATH, mainImage);
+    const ext = path.extname(path.resolve(CONSTANTS.MEDIAPATH, mainImage));
+    if (existsSync(mediaPath)) {
+      // Generate thumbnail
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.thumbnail.width'),
+          config.get('catalog.product.image.thumbnail.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-thumb${ext}`
+        ));
+
+      // Generate listing
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.listing.width'),
+          config.get('catalog.product.image.listing.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-list${ext}`
+        ));
+
+      // Generate single
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.single.width'),
+          config.get('catalog.product.image.single.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-single${ext}`
+        ));
+    }
+    await update('product')
+      .given({ image: mainImage })
+      .where('product_id', '=', productId)
+      .execute(connection);
+  }
+
+  // Delete all old images
+  await del('product_image')
+    .where('product_image_product_id', '=', productId)
+    .execute(connection);
+
+  // Save new images
+  await Promise.all(variantImages.map((f) => (async () => {
+    const mediaPath = path.join(CONSTANTS.MEDIAPATH, f);
+    const ext = path.extname(path.resolve(CONSTANTS.MEDIAPATH, f));
+
+    if (existsSync(mediaPath)) {
+      // Generate thumbnail
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.thumbnail.width'),
+          config.get('catalog.product.image.thumbnail.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-thumb${ext}`
+        ));
+
+      // Generate listing
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.listing.width'),
+          config.get('catalog.product.image.listing.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-list${ext}`
+        ));
+
+      // Generate single
+      await sharp(mediaPath)
+        .resize(
+          config.get('catalog.product.image.single.width'),
+          config.get('catalog.product.image.single.height'),
+          { fit: 'inside' }
+        )
+        .toFile(mediaPath.replace(
+          ext,
+          `-single${ext}`
+        ));
+    }
+    await insert('product_image')
+      .given({ image: f })
+      .prime('product_image_product_id', productId)
+      .execute(connection);
+  })()));
+
+  // Copy attribute
+  const attributes = await select()
+    .from('product_attribute_value_index')
+    .where('product_id', '=', mainProductId)
+    .execute(connection);
+
+  await Promise.all(attributes.map((a) => (async () => {
+    {
+      const va = variantAttributes.find((va) => parseInt(va.attribute_id) === parseInt(a.attribute_id));
+      if (va) {
+        await insertOnUpdate('product_attribute_value_index')
+          .given(va)
+          .prime('product_id', productId)
+          .execute(connection);
+      } else {
+        await insertOnUpdate('product_attribute_value_index')
+          .given(a)
+          .prime('product_id', productId)
+          .execute(connection);
+      }
+    }
+  })()));
+}

package/src/modules/catalog/api/admin/productSavePost/[getConnection]createProduct[finish].js

@@ -0,0 +1,13 @@
+const { insert } = require('@evershop/mysql-query-builder');
+
+module.exports = async (request, response, stack) => {
+  if (request.body.product_id) { return null; }
+
+  const connection = await stack.getConnection;
+  const result = await insert('product').given(request.body).execute(connection);
+  await insert('product_description')
+    .given(request.body)
+    .prime('product_description_product_id', result.insertId).execute(connection);
+
+  return result;
+};

package/src/modules/catalog/api/admin/productSavePost/[getConnection]updateProduct[finish].js

@@ -0,0 +1,15 @@
+const { update } = require('@evershop/mysql-query-builder');
+
+module.exports = async (request, response, stack) => {
+  if (!request.body.product_id) { return null; }
+
+  const connection = await stack.getConnection;
+  await update('product').given(request.body)
+    .where('product_id', '=', request.body.product_id)
+    .execute(connection);
+  await update('product_description')
+    .given(request.body).where('product_description_product_id', '=', request.body.product_id)
+    .execute(connection);
+
+  return request.body.product_id;
+};