@evershop/evershop 1.0.0-beta

package/src/modules/catalog/pages/frontStore/productView/Options.js

@@ -0,0 +1,96 @@
+/* eslint-disable react/no-array-index-key */
+import PropTypes from 'prop-types';
+import React from 'react';
+import { MultiSelect } from '../../../../../lib/components/form/fields/MultiSelect';
+import { Select } from '../../../../../lib/components/form/fields/Select';
+
+export default function Options({ options = [] }) {
+  if (options.length === 0) { return null; }
+
+  return (
+    <div className="product-single-options mt-4 mb-4">
+      <div className="product-single-options-title mb-2"><strong>Options</strong></div>
+      {options.map((o, i) => {
+        const values = o.values.map((v) => {
+          return {
+            value: v.valueId,
+            text: `${v.value} (+ ${v.extraPrice.text})`
+          };
+        });
+        let FieldComponent = '';
+        switch (o.optionType) {
+          case 'select':
+            FieldComponent = (
+              <Select
+                key={i}
+                name={`product_custom_options[${o.optionId}][]`}
+                options={values}
+                validation_rules={parseInt(o.isRequired, 10) === 1 ? ['notEmpty'] : []}
+                formId="product-form"
+                label={o.optionName}
+              />
+            );
+            break;
+          case 'multiselect':
+            FieldComponent = (
+              <MultiSelect
+                key={i}
+                name={`product_custom_options[${o.optionId}][]`}
+                options={values}
+                validation_rules={parseInt(o.isRequired, 10) === 1 ? ['notEmpty'] : []}
+                formId="product-form"
+                label={o.optionName}
+              />
+            );
+            break;
+          default:
+            FieldComponent = (
+              <Select
+                key={i}
+                name={`product_custom_options[${o.optionId}][]`}
+                options={values}
+                validation_rules={parseInt(o.isRequired, 10) === 1 ? ['notEmpty'] : []}
+                formId="product-form"
+                label={o.optionName}
+              />
+            );
+        }
+        return FieldComponent;
+      })}
+    </div>
+  );
+}
+
+Options.propTypes = {
+  options: PropTypes.arrayOf(PropTypes.shape({
+    optionId: PropTypes.number,
+    isRequired: PropTypes.number,
+    optionName: PropTypes.string,
+    optionType: PropTypes.string
+  })).isRequired
+};
+
+export const layout = {
+  areaId: "productPageMiddleRight",
+  sortOrder: 30
+};
+
+export const query = `
+  query Query {
+    product (id: getContextValue('productId')) {
+      options {
+        optionId
+        isRequired
+        optionName
+        optionType
+        values {
+          valueId
+          value
+          extraPrice {
+            value
+            text
+          }
+        }
+      }
+    }
+  }`;

package/src/modules/catalog/pages/frontStore/productView/Variants.js

@@ -0,0 +1,143 @@
+/* eslint-disable no-restricted-syntax */
+import React from 'react';
+import PubSub from 'pubsub-js';
+import { FORM_VALIDATED } from '../../../../../lib/util/events';
+import './Variants.scss';
+
+function isSelected(attributeCode, optionId, currentFilters = {}) {
+  return (
+    currentFilters[attributeCode] !== undefined
+    && parseInt(currentFilters[attributeCode], 10) === parseInt(optionId, 10)
+  );
+}
+
+function isAvailable(attributeCode, optionId, variants, currentFilters = {}) {
+  return true; // TODO: Complete me
+}
+
+export default function Variants({ product: { variantGroup: vs }, pageInfo: { url } }) {
+  const attributes = vs ? vs.variantAttributes : [];
+  const variants = vs ? vs.items : [];
+  const [error, setError] = React.useState(null);
+  const currentProductUrl = url;
+  const getCurrentSelection = () => {
+    const currentSelection = {};
+    const url = new URL(currentProductUrl);
+    const params = new URLSearchParams(url.search);
+    for (const [key, value] of params.entries()) {
+      // Check if the key is a variant attribute
+      if (attributes.find((a) => a.attributeCode === key)) {
+        currentSelection[key] = value;
+      }
+    }
+
+    return currentSelection;
+  }
+  const variantFilters = getCurrentSelection();
+
+  const validate = (formId, errors) => {
+    if (formId !== 'productForm') { return true; }
+
+    let flag = true;
+    attributes.forEach((a) => {
+      if (variantFilters[a.attributeCode] === undefined) { flag = false; }
+    });
+    if (flag === false) {
+      // eslint-disable-next-line no-param-reassign
+      errors.variants = 'Missing variant';
+      setError('Please select variant option');
+      return false;
+    } else {
+      return true;
+    }
+  };
+
+  React.useEffect(() => {
+    const token = PubSub.subscribe(FORM_VALIDATED, (message, data) => {
+      validate(data.formId, data.errors);
+    });
+
+    return function cleanup() {
+      PubSub.unsubscribe(token);
+    };
+  }, []);
+
+  const getUrl = (attributeCode, optionId) => {
+    const url = new URL(currentProductUrl);
+    if (!Object.keys(variantFilters).includes(attributeCode)
+      || parseInt(variantFilters[attributeCode], 10) !== parseInt(optionId, 10)) {
+      url.searchParams.set(attributeCode, optionId);
+    } else {
+      url.searchParams.delete(attributeCode);
+    }
+
+    return url;
+  };
+
+  return (
+    <div className="variant variant-container grid grid-cols-1 gap-1 mt-2">
+      {attributes.map((a, i) => {
+        const options = a.options.filter(
+          (v, j, s) => s.findIndex((o) => o.optionId === v.optionId) === j
+        );
+        return (
+          <div key={a.attributeCode}>
+            <input name={`variant_options[${i}][attribute_id]`} type="hidden" value={a.attributeId} />
+            <input name={`variant_options[${i}][optionId]`} type="hidden" value={variantFilters[a.attributeCode] ? variantFilters[a.attributeCode] : ''} />
+            <div className="mb-05 text-textSubdued uppercase"><span>{a.attribute_name}</span></div>
+            <ul className="variant-option-list flex justify-start">
+              {options.map((o) => {
+                let className = 'mr-05';
+                if (isSelected(a.attributeCode, o.optionId, variantFilters)) {
+                  className = 'selected mr-05';
+                }
+                if (isAvailable(a.attributeCode, o.optionId, variants, variantFilters)) {
+                  return (
+                    <li key={o.optionId} className={className}>
+                      <a href={getUrl(a.attributeCode, o.optionId)}>{o.optionText}</a>
+                    </li>
+                  );
+                } else {
+                  return <li key={o.optionId} className="un-available mr-05"><span>{o.optionText}</span></li>;
+                }
+              })}
+            </ul>
+          </div>
+        );
+      })}
+      {error && <div className="variant-validate error text-critical">{error}</div>}
+    </div>
+  );
+}
+
+export const layout = {
+  areaId: "productPageMiddleRight",
+  sortOrder: 40
+}
+
+export const query = `
+query Query {
+  pageInfo {
+    url
+  }
+  product(id: getContextValue('productId')) {
+    variantGroup {
+      variantAttributes {
+        attributeId
+        attributeCode
+        attributeName
+        options {
+          optionId
+          optionText
+        }
+      }
+      items {
+        attributes {
+          attributeCode
+          optionId
+        }
+      }
+    }
+  }
+}
+`

package/src/modules/catalog/pages/frontStore/productView/Variants.scss

@@ -0,0 +1,22 @@
+.variant-option-list {
+    li {
+        border: 1px solid var(--divider);
+        border-radius: 2px;
+        background-color: #fff;
+        font-size: 12px;
+        a,span {
+            padding: 1rem 1.5rem;
+            display: block;
+            text-align: center;
+        }
+        &.selected {
+            background-color: var(--success);
+            border-color: var(--success);
+            color: #fff;
+        }
+        &.un-available {
+            background-color: var(--border);
+            color: #fff;
+        }
+    }
+}

package/src/modules/catalog/pages/frontStore/productView/index.js

@@ -0,0 +1,100 @@
+const { select, node } = require('@evershop/mysql-query-builder');
+const { pool } = require('../../../../../lib/mysql/connection');
+const { get } = require('../../../../../lib/util/get');
+const { getConfig } = require('../../../../../lib/util/getConfig');
+const { setContextValue } = require('../../../../graphql/services/contextHelper');
+
+module.exports = async (request, response, stack, next) => {
+  try {
+    const query = select();
+    query.from('product')
+      .leftJoin('product_description')
+      .on('product.`product_id`', '=', 'product_description.`product_description_product_id`');
+    query.where('status', '=', 1);
+    query.andWhere('product_description.`url_key`', '=', request.params.url_key);
+    const product = await query.load(pool);
+
+    if (product === null) {
+      response.status(404);
+      next();
+    } else {
+      const queries = request.query;
+      if (!get(product, 'variant_group_id') || Object.values(queries).length === 0) {
+        setContextValue(request, 'productId', product.product_id);
+        setContextValue(request, 'pageInfo', {
+          title: product.meta_title || product.name,
+          description: product.meta_description || product.short_description
+        });
+      } else {
+        const group = await select()
+          .from('variant_group')
+          .select('attribute_one')
+          .select('attribute_two')
+          .select('attribute_three')
+          .select('attribute_four')
+          .select('attribute_five')
+          .where('variant_group_id', '=', product.variant_group_id)
+          .load(pool);
+
+        const attributes = await select()
+          .from('attribute')
+          .where('attribute_id', 'IN', Object.values(group).filter((v) => v != null))
+          .and('attribute_code', 'IN', Object.keys(queries))
+          .execute(pool);
+
+        if (attributes.length > 0) {
+          const vsQuery = select().from('product', 'p')
+            .select('p.`product_id`')
+            .select('a.`attribute_id`')
+            .select('a.`option_id`')
+            .select('COUNT(p.`product_id`)', 'count');
+          vsQuery.innerJoin('product_attribute_value_index', 'a')
+            .on('p.product_id', '=', 'a.`product_id`');
+          vsQuery.where('p.variant_group_id', '=', product.variant_group_id)
+            .and('p.status', '=', 1);
+
+          if (getConfig('catalog.showOutOfStockProduct') === false) {
+            vsQuery.andWhere('p.manage_stock', '=', '0')
+              .addNode(
+                node('OR').addLeaf('AND', 'p.qty', '>', 0).addLeaf('AND', 'p.stock_availability', '=', 1)
+              );
+          }
+          vsQuery.andWhere('a.attribute_id', 'IN', attributes.map((a) => a.attribute_id))
+            .and('a.option_id', 'IN', attributes.map((a) => queries[a.attribute_code]));
+          vsQuery.groupBy('p.`product_id`');
+          vsQuery.having('count', '>=', attributes.length);
+          const variants = await vsQuery.execute(pool);
+
+          if (variants.length > 0) {
+            const query = select();
+            query.from('product')
+              .leftJoin('product_description')
+              .on('product.`product_id`', '=', 'product_description.`product_description_product_id`');
+            query.where('product_id', '=', variants[0].product_id);
+            const pv = await query.load(pool);
+            setContextValue(request, 'productId', pv.product_id);
+            setContextValue(request, 'pageInfo', {
+              title: pv.meta_title || pv.name,
+              description: pv.meta_description || pv.short_description
+            });
+          } else {
+            setContextValue(request, 'productId', product.product_id);
+            setContextValue(request, 'pageInfo', {
+              title: product.meta_title || product.name,
+              description: product.meta_description || product.short_description
+            });
+          }
+        } else {
+          setContextValue(request, 'productId', product.product_id);
+          setContextValue(request, 'pageInfo', {
+            title: product.meta_title || product.name,
+            description: product.meta_description || product.short_description
+          });
+        }
+      }
+      next();
+    }
+  } catch (e) {
+    next(e);
+  }
+};

package/src/modules/catalog/pages/frontStore/productView/route

@@ -0,0 +1,2 @@
+GET
+/product/:url_key

package/src/modules/catalog/services/getFilterableAttributes.js

@@ -0,0 +1,64 @@
+const { select } = require("@evershop/mysql-query-builder");
+const { pool } = require("../../../lib/mysql/connection");
+const { getProductsBaseQuery } = require("./getProductsBaseQuery");
+
+module.exports.getFilterableAttributes = async (categoryId) => {
+  const productsQuery = await getProductsBaseQuery(categoryId);
+  productsQuery.select('product.`product_id`');
+  // Get the list of productIds before applying pagination, sorting...etc
+  // Base on this list, we will find all attribute,
+  // category and price can be appeared in the filter table
+  const allIds = (await productsQuery.execute(pool)).map((row) => row.product_id);
+
+  // Filterable attributes
+  const query = select('attribute.`attribute_name`', 'attribute_name')
+    .select('attribute.`type`', 'type')
+    .select('attribute.`is_filterable`', 'is_filterable')
+    .select('product_attribute_value_index.`attribute_id`', 'attribute_id')
+    .select('attribute.`attribute_code`', 'attribute_code')
+    .select('product_attribute_value_index.`option_id`', 'option_id')
+    .select('product_attribute_value_index.`option_text`', 'option_text')
+    .from('attribute');
+  query.innerJoin('product_attribute_value_index')
+    .on('attribute.`attribute_id`', '=', 'product_attribute_value_index.`attribute_id`');
+
+  query.where('product_attribute_value_index.`product_id`', 'IN', allIds)
+    .and('type', 'IN', ['select', 'multiselect'])
+    .and('is_filterable', '=', 1);
+
+  const attributeData = await query.execute(pool);
+
+  const attributes = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < attributeData.length; i++) {
+    const index = attributes.findIndex((a) => a.attributeCode === attributeData[i].attribute_code);
+    if (index === -1) {
+      attributes.push({
+        attributeName: attributeData[i].attribute_name,
+        attributeId: attributeData[i].attribute_id,
+        attributeCode: attributeData[i].attribute_code,
+        options: [
+          {
+            optionId: attributeData[i].option_id,
+            optionText: attributeData[i].option_text,
+          }
+        ]
+      });
+    } else {
+      const idx = attributes[index].options.findIndex(
+        (o) => parseInt(o.optionId, 10) === parseInt(attributeData[i].option_id, 10)
+      );
+      if (idx === -1) {
+        attributes[index].options = attributes[index].options.concat({
+          optionId: attributeData[i].option_id,
+          optionText: attributeData[i].option_text,
+        });
+      } else {
+        // eslint-disable-next-line no-plusplus
+        attributes[index].options[idx].productCount++;
+      }
+    }
+  }
+
+  return attributes;
+}

package/src/modules/catalog/services/getPriceRange.js

@@ -0,0 +1,20 @@
+const { select } = require("@evershop/mysql-query-builder");
+const { pool } = require("../../../lib/mysql/connection");
+const { getProductsBaseQuery } = require("./getProductsBaseQuery");
+
+module.exports.getPriceRange = async function getPriceRange(categoryId) {
+  const productsQuery = await getProductsBaseQuery(categoryId);
+  productsQuery.select('product.`product_id`');
+  // Get the list of productIds before applying pagination, sorting...etc
+  // Base on this list, we will find all attribute,
+  // category and price can be appeared in the filter table
+  const allIds = (await productsQuery.execute(pool)).map((row) => row.product_id);
+  const priceRange = await select()
+    .select('MIN(price)', 'min')
+    .select('MAX(price)', 'max')
+    .from('product')
+    .where('product_id', 'IN', allIds)
+    .execute(pool);
+
+  return priceRange[0];
+}

package/src/modules/catalog/services/getProductsBaseQuery.js

@@ -0,0 +1,20 @@
+const { select } = require("@evershop/mysql-query-builder");
+const { pool } = require("../../../lib/mysql/connection");
+
+module.exports.getProductsBaseQuery = async (categoryId) => {
+  const query = select()
+    .from('product');
+  query.leftJoin('product_description')
+    .on('product_description.`product_description_product_id`', '=', 'product.`product_id`');
+  query.where(
+    'product.`product_id`',
+    'IN',
+    (await select('product_id')
+      .from('product_category')
+      .where('category_id', '=', categoryId)
+      .execute(pool)).map((row) => row.product_id)
+  );
+  query.andWhere('product.`status`', '=', 1);
+
+  return query;
+};

package/src/modules/catalog/services/getProductsQuery.js

@@ -0,0 +1,46 @@
+const { select } = require("@evershop/mysql-query-builder");
+const { pool } = require("../../../lib/mysql/connection");
+const { getProductsBaseQuery } = require("./getProductsBaseQuery");
+
+module.exports.getProductsQuery = async function getProductsQuery(categoryId) {
+  // Visibility filter
+  // Get the products query
+  const query = await getProductsBaseQuery(categoryId);
+
+  // Visibility. For variant group
+  const copy = query.clone();
+  // Get all group that have at lease 1 item visibile
+  const visibleGroups = (await select('variant_group_id')
+    .from('variant_group')
+    .where('visibility', '=', 1)
+    .execute(pool)).map((v) => v.variant_group_id);
+
+  if (visibleGroups) {
+    // Get all invisible variants from current query
+    copy.select('SUM(product.`visibility`)', 'sumv')
+      .select('product_id')
+      .andWhere('product.variant_group_id', 'IN', visibleGroups);
+    copy.groupBy('product.variant_group_id')
+      .having('sumv', '=', 0);
+
+    const invisibleIds = (await copy.execute(pool)).map((v) => v.product_id);
+    if (invisibleIds.length > 0) {
+      const n = node('AND');
+      n.addLeaf('AND', 'product.`product_id`', 'IN', invisibleIds)
+        .addNode(
+          node('OR')
+            .addLeaf('OR', 'product.`visibility`', '<>', 0)
+            .addLeaf('OR', 'product.`visibility`', 'IS', null)
+        );
+      query.getWhere().addNode(n);
+    } else {
+      query.andWhere('product.`visibility`', '<>', 0)
+        .or('product.`visibility`', 'IS', null);
+    }
+  } else {
+    query.andWhere('product.`visibility`', '<>', 0)
+      .or('product.`visibility`', 'IS', null);
+  }
+
+  return query;
+}

package/src/modules/catalog/services/productsFilter.js

@@ -0,0 +1,16 @@
+const { getFilterableAttributes } = require('./getFilterableAttributes');
+const { getPriceRange } = require('./getPriceRange');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+/**
+ *  This function takes a list of product ID
+ * and get all attribute, category and price can be used in filter table
+ * @param {Array[Number]} productIds
+ */
+exports.productsFilters = async function productsFilters(productIds = []) {
+  return {
+    price: getPriceRange(productIds),
+    attributes: getFilterableAttributes(productIds)
+  };
+};

package/src/modules/catalog/tests/intergration/productView.test.js

@@ -0,0 +1,23 @@
+describe('Product page is rendered correctly', () => {
+  it('It should returns 404 when the product is not existed', () => {
+    cy.request({
+      url: "/product/123456789",
+      failOnStatusCode: false
+    })
+      .should(response => {
+        expect(response.status).to.eq(404);
+        expect(response.body).to.contains('Not found');
+      });
+  });
+
+  it('It should return 404 when the product is disabled', () => {
+    cy.request({
+      url: "/product/product-name",
+      failOnStatusCode: false
+    })
+      .should(response => {
+        expect(response.status).to.eq(404);
+        expect(response.body).to.contains('Not found');
+      });
+  });
+})

package/src/modules/checkout/api/admin/bestsellers/loadData.js

@@ -0,0 +1,30 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { pool } = require('../../../../../lib/mysql/connection');
+const { buildUrl } = require('../../../../../lib/router/buildUrl');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, delegate, next) => {
+  const query = select();
+  query.from('product').leftJoin('product_description').on('product.`product_id`', '=', 'product_description.`product_description_product_id`');
+  query.leftJoin('order_item').on('product.`product_id`', '=', 'order_item.`product_id`');
+  query.select('product.`product_id`', 'product_id')
+    .select('order_item.`product_id`')
+    .select('image')
+    .select('name')
+    .select('price')
+    .select('SUM(order_item.`qty`)', 'qty')
+    .select('SUM(order_item.`product_id`)', 'sum')
+    .where('order_item_id', 'IS NOT', null);
+  query.groupBy('order_item.`product_id`')
+    .orderBy('qty', 'DESC')
+    .limit(0, 5);
+  const results = await query.execute(pool);
+
+  response.json(results.map((p) => {
+    const product = { ...p, editUrl: buildUrl('productEdit', { id: parseInt(p.product_id, 10) }) };
+    if (p.image) {
+      product.imageUrl = buildUrl('adminStaticAsset', [p.image]);
+    }
+    return product;
+  }));
+};

package/src/modules/checkout/api/admin/bestsellers/route

@@ -0,0 +1,2 @@
+POST
+/lifetimesales

package/src/modules/checkout/api/admin/createShipment/[context]borderParser[auth].js

@@ -0,0 +1,5 @@
+const bodyParser = require('body-parser');
+
+module.exports = (request, response, stack, next) => {
+  bodyParser.json({ inflate: false })(request, response, next);
+}

package/src/modules/checkout/api/admin/createShipment/createShipment.js

@@ -0,0 +1,68 @@
+const {
+  rollback, insert, commit, select, update, startTransaction
+} = require('@evershop/mysql-query-builder');
+const config = require('config');
+const { getConnection } = require('../../../../../lib/mysql/connection');
+const { get } = require('../../../../../lib/util/get');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, stack, next) => {
+  const connection = await getConnection();
+  await startTransaction(connection);
+  const { orderId } = request.params;
+  const carrierName = get(request, 'body.carrier_name');
+  const trackingNumber = get(request, 'body.tracking_number');
+  try {
+    const order = await select()
+      .from('order')
+      .where('uuid', '=', orderId)
+      .load(connection);
+
+    if (!order) {
+      throw new Error('Requested order does not exist');
+    }
+    const shipment = await select()
+      .from('shipment')
+      .where('shipment_order_id', '=', order.order_id)
+      .load(connection);
+
+    if (shipment) {
+      throw new Error('Order was fullfilled');
+    }
+    await insert('shipment')
+      .given({
+        shipment_order_id: order.order_id,
+        carrier_name: carrierName,
+        tracking_number: trackingNumber
+      })
+      .execute(connection);
+    /* Update Shipment status to fullfilled */
+    const shipmentStatus = config.get('order.shipmentStatus');
+    if (shipmentStatus.find((s) => s.code === 'fullfilled')) {
+      await update('order')
+        .given({ shipment_status: 'fullfilled' })
+        .where('order_id', '=', order.order_id)
+        .execute(connection);
+    }
+    /* Add an activity log message */
+    // TODO: This will be improved. It should be treated as a side effect and move to somewhere else
+    await insert('order_activity').given({
+      order_activity_order_id: order.order_id,
+      comment: 'Fullfilled items',
+      customer_notified: 0
+    }).execute(connection);
+
+    await commit(connection);
+    response.json({
+      data: {},
+      success: true
+    });
+  } catch (e) {
+    await rollback(connection);
+    response.json({
+      data: {},
+      message: e.message,
+      success: false
+    });
+  }
+};

package/src/modules/checkout/api/admin/createShipment/route

@@ -0,0 +1,2 @@
+POST
+/fullfill/:orderId