@unchainedshop/plugins 1.1.3 → 1.1.4

package/src/pricing/product-price-round.ts

@@ -0,0 +1,78 @@
+import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
+import { ProductPricingAdapter } from '@unchainedshop/core-products';
+
+const roundToNext = (value, precision) =>
+  value % precision === precision / 2
+    ? value + precision / 2
+    : value + (precision - (value % precision));
+
+// String is referencing to a currency
+interface PriceRoundSettings {
+  configurations: Record<string, number>;
+  defaultPrecision: number;
+  skip: Array<string>;
+}
+
+const ProductPriceRoundSettings: PriceRoundSettings = {
+  configurations: {},
+  defaultPrecision: 50,
+  skip: [],
+};
+
+export const configureProductPriceRounding = ({
+  configurations,
+  defaultPrecision,
+  skip,
+}: PriceRoundSettings) => {
+  if (defaultPrecision) ProductPriceRoundSettings.defaultPrecision = defaultPrecision;
+  if (configurations) ProductPriceRoundSettings.configurations = configurations;
+  if (skip?.length) ProductPriceRoundSettings.skip = skip;
+};
+
+export const ProductPriceRound: IProductPricingAdapter & {
+  configure: (params: PriceRoundSettings) => void;
+} = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.price-round',
+  version: '1.0',
+  label: 'Round product price to the next precision number',
+  orderIndex: 2,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  configure: configureProductPriceRounding,
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        const { currency, quantity } = params.context;
+        const { configurations, skip, defaultPrecision } = ProductPriceRoundSettings;
+        const { calculation = [] } = params.calculationSheet;
+
+        if (skip?.indexOf(currency) !== -1) return pricingAdapter.calculate();
+
+        const roundPrecision = configurations?.[currency] || defaultPrecision;
+
+        if (calculation?.length && roundPrecision) {
+          const [productPrice] = calculation;
+          pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+          pricingAdapter.resultSheet().addItem({
+            amount: roundToNext(productPrice.amount, roundPrecision) * quantity,
+            isTaxable: productPrice.isTaxable,
+            isNetPrice: productPrice.isNetPrice,
+            meta: { adapter: ProductPriceRound.key },
+          });
+        }
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};

package/src/pricing/product-swiss-tax.ts

@@ -0,0 +1,117 @@
+import moment from 'moment';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+import {
+  IProductPricingAdapter,
+  ProductPricingAdapterContext,
+} from '@unchainedshop/types/products.pricing';
+
+// https://www.ch.ch/de/mehrwertsteuersatz-schweiz/
+export const SwissTaxCategories = {
+  DEFAULT: {
+    rate: (date) => {
+      const referenceDate = moment(date);
+      if (referenceDate.isBefore('2018-01-01')) {
+        return 0.08;
+      }
+      return 0.077;
+    },
+  },
+  REDUCED: {
+    tag: 'swiss-tax-category:reduced',
+    rate: () => {
+      return 0.025;
+    },
+  },
+  SPECIAL: {
+    tag: 'swiss-tax-category:special',
+    rate: () => {
+      return 0.037;
+    },
+  },
+};
+
+const getTaxRate = (context: ProductPricingAdapterContext) => {
+  const date = context.order && context.order.ordered ? new Date(context.order.ordered) : new Date();
+  const { product } = context;
+
+  if (product.tags?.includes(SwissTaxCategories.REDUCED.tag)) {
+    return SwissTaxCategories.REDUCED.rate();
+  }
+  if (product.tags?.includes(SwissTaxCategories.SPECIAL.tag)) {
+    return SwissTaxCategories.SPECIAL.rate();
+  }
+  return SwissTaxCategories.DEFAULT.rate(date);
+};
+
+const isDeliveryAddressInSwitzerland = async ({ order, country, modules }) => {
+  let countryCode = country?.toUpperCase().trim();
+
+  if (order) {
+    const orderDelivery = await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    });
+    const address = orderDelivery?.context?.address || order.billingAddress;
+
+    if (address?.countryCode > '') {
+      countryCode = address.countryCode?.toUpperCase().trim();
+    }
+  }
+
+  return countryCode === 'CH' || countryCode === 'LI';
+};
+
+const ProductSwissTax: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.product-swiss-tax',
+  version: '1.0',
+  label: 'Apply Swiss Tax on Product',
+  orderIndex: 20,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+    const { context } = params;
+    return {
+      ...pricingAdapter,
+
+      calculate: async () => {
+        if (!(await isDeliveryAddressInSwitzerland(context))) {
+          return pricingAdapter.calculate();
+        }
+        const taxRate = getTaxRate(context);
+        ProductPricingAdapter.log(`ProductSwissTax -> Tax Multiplicator: ${taxRate}`);
+        params.calculationSheet.filterBy({ isTaxable: true }).forEach(({ isNetPrice, ...row }) => {
+          if (!isNetPrice) {
+            const taxAmount = row.amount - row.amount / (1 + taxRate);
+            pricingAdapter.resultSheet().calculation.push({
+              ...row,
+              amount: -taxAmount,
+              isTaxable: false,
+              isNetPrice: false,
+              meta: { adapter: ProductSwissTax.key },
+            });
+            pricingAdapter.resultSheet().addTax({
+              amount: taxAmount,
+              rate: taxRate,
+              meta: { adapter: ProductSwissTax.key },
+            });
+          } else {
+            const taxAmount = row.amount * taxRate;
+            pricingAdapter.resultSheet().addTax({
+              amount: taxAmount,
+              rate: taxRate,
+              meta: { adapter: ProductSwissTax.key },
+            });
+          }
+        });
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductSwissTax);

package/src/pricing/utils/cache.js

@@ -0,0 +1,32 @@
+import 'abort-controller/polyfill';
+import LRUCache from 'lru-cache';
+
+class Cache {
+  constructor(ttlSeconds = 60) {
+    this.cache = new LRUCache({
+      max: 500,
+      ttl: ttlSeconds * 1000,
+    });
+  }
+
+  get(key, currentFuntion) {
+    const value = this.cache.get(key);
+    if (value) {
+      return Promise.resolve(value);
+    }
+    return currentFuntion().then((result) => {
+      this.cache.set(key, result);
+      return result;
+    });
+  }
+
+  del(keys) {
+    this.cache.del(keys);
+  }
+
+  flushAll() {
+    this.cache.reset();
+  }
+}
+
+export default Cache;

package/src/quotations/manual.ts

@@ -0,0 +1,27 @@
+import { IQuotationAdapter } from '@unchainedshop/types/quotations';
+import { QuotationDirector, QuotationAdapter } from '@unchainedshop/core-quotations';
+
+const ManualOffering: IQuotationAdapter = {
+  ...QuotationAdapter,
+
+  key: 'shop.unchained.quotations.manual',
+  version: '1.0',
+  label: 'Manual Offerings',
+  orderIndex: 0,
+
+  isActivatedFor: () => true,
+
+  actions: (params) => {
+    return {
+      ...QuotationAdapter.actions(params),
+
+      quote: async () => {
+        return {
+          expires: new Date(new Date().getTime() + 3600 * 1000),
+        };
+      },
+    };
+  },
+};
+
+QuotationDirector.registerAdapter(ManualOffering);

package/src/warehousing/google-sheets.ts

@@ -0,0 +1,165 @@
+import {
+  WarehousingDirector,
+  WarehousingAdapter,
+  WarehousingProviderType,
+} from '@unchainedshop/core-warehousing';
+import Sheets from 'node-sheets';
+import { log, LogLevel } from '@unchainedshop/logger';
+import 'abort-controller/polyfill';
+import LRU from 'lru-cache';
+import { IWarehousingAdapter } from '@unchainedshop/types/warehousing';
+
+const { NODE_ENV, GOOGLE_SHEETS_ID, GOOGLE_SHEETS_PRIVATE_KEY_DATA } = process.env;
+
+const ttl = NODE_ENV === 'production' ? 1000 * 60 * 60 : 0; // 1 hour or 1 second
+
+const downloadSpreadsheet = async () => {
+  if (!GOOGLE_SHEETS_PRIVATE_KEY_DATA || !GOOGLE_SHEETS_ID) return null;
+  try {
+    // https://docs.google.com/spreadsheets/d/GOOGLE_SHEETS_ID/edit?usp=sharing
+    const gs = new Sheets(GOOGLE_SHEETS_ID);
+    const authData = JSON.parse(GOOGLE_SHEETS_PRIVATE_KEY_DATA);
+    await gs.authorizeJWT(authData);
+    const delivery = await gs.tables('delivery!A:ZZZ');
+    const inventory = await gs.tables('inventory!A:ZZZ');
+    log(`GoogleSheet: Updated cache with TTL: ${ttl}`, {
+      level: LogLevel.Verbose,
+    });
+    return {
+      delivery,
+      inventory,
+    };
+  } catch (err) {
+    log(err, { level: LogLevel.Error });
+    throw err;
+  }
+};
+
+const updateGoogleCache = async (cache) => {
+  try {
+    const sheet = await downloadSpreadsheet();
+    if (sheet) {
+      cache.set('tables', sheet);
+      return sheet;
+    }
+  } catch (e) {
+    log(e, { level: LogLevel.Error });
+  }
+  return null;
+};
+
+const googleCache = new LRU({
+  max: 500,
+  ttl, // 1 second in dev
+  allowStale: true,
+  dispose: () => {
+    updateGoogleCache(googleCache);
+  },
+});
+
+updateGoogleCache(googleCache);
+
+const getRows = async (name: string) => {
+  const cachedTables = googleCache.get('tables');
+  let tables = cachedTables;
+  if (!cachedTables) {
+    tables = await updateGoogleCache(googleCache);
+  }
+  if (!tables || !tables[name] || !tables[name].rows) return [];
+  return tables[name].rows;
+};
+
+const getRemoteTime = async (sku: string, quantity: number, selector: string) => {
+  const rows = await getRows('delivery');
+  const resolvedRow = rows.reduce((result, row) => {
+    const parsedQuantity = parseInt(row.Quantity.value, 10);
+    const parsedSKU = row.SKU.value.toUpperCase();
+    if (parsedSKU === sku && parsedQuantity <= quantity) {
+      return row;
+    }
+    return result;
+  }, null);
+  if (!resolvedRow) return null;
+  const time = parseInt(resolvedRow[selector].value, 10) || 0;
+  log(`GoogleSheet: Resolve Time ${selector} (${quantity}) for ${sku}: ${time}`, {
+    level: LogLevel.Verbose,
+  });
+  return time;
+};
+
+const getRemoteInventory = async (sku: string) => {
+  const rows = await getRows('inventory');
+  const resolvedRow = [].concat(rows).reduce((result, row) => {
+    if (result || !row) return result;
+    const parsedSKU = row.SKU.value.toUpperCase();
+    if (parsedSKU === sku) {
+      return row;
+    }
+    return result;
+  }, null);
+  if (!resolvedRow) return null;
+  const amount = parseInt(resolvedRow.Stock.value, 10) || 0;
+  log(`GoogleSheet: Resolve Inventory for ${sku}: ${amount}`, {
+    level: LogLevel.Verbose,
+  });
+  return amount;
+};
+
+const GoogleSheets: IWarehousingAdapter = {
+  ...WarehousingAdapter,
+
+  key: 'shop.unchained.warehousing.google-sheets',
+  version: '1.0',
+  label: 'Google Sheets',
+  orderIndex: 0,
+
+  typeSupported: (type) => {
+    return type === WarehousingProviderType.PHYSICAL;
+  },
+
+  initialConfiguration: [
+    {
+      key: 'sheetId',
+      value: null,
+    },
+  ],
+
+  actions: (_, context) => {
+    return {
+      isActive: () => {
+        return true;
+      },
+
+      configurationError: () => {
+        return null;
+      },
+
+      stock: async () => {
+        const { sku } = context.product.warehousing || {};
+        return getRemoteInventory(sku);
+      },
+
+      productionTime: async (quantity: number) => {
+        const { sku } = context.product.warehousing || {};
+        if (!sku) return null;
+        const selector = 'WAREHOUSE_HOURS';
+        const timeInHours = await getRemoteTime(sku.toUpperCase(), quantity, selector);
+        if (!timeInHours) return null;
+        return timeInHours * 60 * 60 * 1000;
+      },
+
+      commissioningTime: async (quantity) => {
+        const { product, deliveryProvider } = context;
+        const { sku } = product.warehousing || {};
+        if (!sku) return null;
+        const { type } = deliveryProvider;
+        const selector = `DELIVERY_HOURS:${type}`;
+        const timeInHours = await getRemoteTime(sku.toUpperCase(), quantity, selector);
+        if (!timeInHours) return null;
+        return timeInHours * 60 * 60 * 1000;
+      },
+    };
+  },
+};
+
+WarehousingDirector.registerAdapter(GoogleSheets);

package/src/warehousing/store.ts

@@ -0,0 +1,47 @@
+import {
+  WarehousingDirector,
+  WarehousingAdapter,
+  WarehousingProviderType,
+} from '@unchainedshop/core-warehousing';
+import { IWarehousingAdapter } from '@unchainedshop/types/warehousing';
+
+const Store: IWarehousingAdapter = {
+  ...WarehousingAdapter,
+
+  key: 'shop.unchained.warehousing.store',
+  version: '1.0',
+  label: 'Store',
+  orderIndex: 0,
+
+  initialConfiguration: [{ key: 'name', value: 'Flagship Store' }],
+
+  typeSupported: (type) => {
+    return type === WarehousingProviderType.PHYSICAL;
+  },
+
+  actions: () => {
+    return {
+      isActive: async () => {
+        return true;
+      },
+
+      configurationError: async () => {
+        return null;
+      },
+
+      stock: async () => {
+        return 99999;
+      },
+
+      productionTime: async () => {
+        return 0;
+      },
+
+      commissioningTime: async () => {
+        return 0;
+      },
+    };
+  },
+};
+
+WarehousingDirector.registerAdapter(Store);

package/src/worker/BulkImportWorker.ts

@@ -1,6 +1,6 @@
 import { IWorkerAdapter } from '@unchainedshop/types/worker';
 import { WorkerDirector } from '@unchainedshop/core-worker';
-import { createLogger } from '@unchainedshop/logger';
+import { createLogger, LogLevel } from '@unchainedshop/logger';
 import { BaseAdapter } from '@unchainedshop/utils';
 import fs from 'fs';
 import JSONStream from 'JSONStream';
@@ -9,7 +9,7 @@ import { EventIterator } from 'event-iterator';
 const logger = createLogger('unchained:platform:bulk-import');
 
 const streamPayloadToBulkImporter = async (bulkImporter, createReadStream) => {
-  logger.profile(`parseAsync`, { level: 'verbose' });
+  logger.profile(`parseAsync`, { level: LogLevel.Verbose, message: 'parseAsync' });
 
   const eventIterator = new EventIterator(
     (queue) => {
@@ -37,7 +37,7 @@ const streamPayloadToBulkImporter = async (bulkImporter, createReadStream) => {
     await bulkImporter.prepare(event);
   }
 
-  logger.profile(`parseAsync`, { level: 'verbose' });
+  logger.profile(`parseAsync`, { level: LogLevel.Verbose, message: 'parseAsync' });
 };
 
 export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {

package/src/worker/GenerateOrderWorker.ts

@@ -7,7 +7,7 @@ import {
   EnrollmentDirector,
   enrollmentsSettings,
   EnrollmentStatus,
-} from 'meteor/unchained:core-enrollments';
+} from '@unchainedshop/core-enrollments';
 import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core-worker';
 
 const generateOrder = async (

package/src/worker/email.ts

@@ -1,10 +1,57 @@
 import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
 import { createLogger } from '@unchainedshop/logger';
-import { Email } from 'meteor/email';
 import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import open from 'open';
 
 const logger = createLogger('unchained:plugins:worker:email');
 
+const checkEmailInterceptionEnabled = () => {
+  return process.env.NODE_ENV !== 'production' && !process.env.UNCHAINED_DISABLE_EMAIL_INTERCEPTION;
+};
+
+function writeFile(filename, data, done) {
+  fs.mkdtemp(path.join(os.tmpdir(), 'email-'), (err1, folder) => {
+    if (err1) return done(err1);
+    const temporaryFolderPath = `${folder}/${filename}`;
+    return fs.writeFile(temporaryFolderPath, data, (err2) => {
+      if (err2) return done(err2);
+      return done(null, temporaryFolderPath);
+    });
+  });
+}
+
+const openInBrowser = (options) => {
+  const filename = `${Date.now()}.html`;
+  const content = `
+    <b>From:&nbsp</b>${options.from}<br/>
+    <b>To:&nbsp;</b>${options.to}<br/>
+    <b>Cc:&nbsp;</b>${options.cc}<br/>
+    <b>Bcc:&nbsp;</b>${options.bcc}<br/>
+    <b>Reply-To:&nbsp;</b>${options.replyTo}<br/>
+    <br/>
+    <b>subject:&nbsp;</b>${options.subject}<br/>
+    <b>attachments:&nbsp;</b>${(options.attachments || [])
+      .map(({ filename: attachmentFilename, path: attachmentPath }) => {
+        const absoluteFilePath = path.join(process.cwd(), attachmentPath);
+        return `<a href="${absoluteFilePath}">${attachmentFilename}</a>`;
+      })
+      .join(',&nbsp;')}<br/>
+    <hr/>
+    ${(options.html || options.text).replace(/(\r\n|\n|\r)/gm, '<br/>')}
+    `;
+  writeFile(filename, content, (err, filePath) => {
+    if (err) {
+      logger.error(err);
+      return;
+    }
+    logger.verbose('unchained:platform -> Mailman detected an outgoing email');
+    open(filePath);
+  });
+};
+
 const EmailWorkerPlugin: IWorkerAdapter<
   {
     from?: string;
@@ -36,13 +83,18 @@ const EmailWorkerPlugin: IWorkerAdapter<
     }
 
     try {
-      // https://docs.meteor.com/api/email.html#Email-send
-      const result = Email.send({
+      const sendMailOptions = {
         from,
         to,
         subject,
         ...rest,
-      });
+      };
+      if (checkEmailInterceptionEnabled()) {
+        openInBrowser(sendMailOptions);
+        return { success: true, result: { intercepted: true } };
+      }
+      const transporter = nodemailer.createTransport(process.env.MAIL_URL);
+      const result = await transporter.sendMail(sendMailOptions);
       return { success: true, result };
     } catch (err) {
       return {