@unchainedshop/plugins 4.7.2 → 4.8.0

package/lib/pricing/product-price-rateconversion.js

@@ -0,0 +1,53 @@
+import { ProductPricingDirector, ProductPricingAdapter, } from '@unchainedshop/core';
+export const ProductPriceRateConversion = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.rate-conversion',
+    version: '1.0.0',
+    label: 'Generic rate conversion plugin that converts between rates if entry in DB exists.',
+    orderIndex: 10,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const { modules } = params.context;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { product, countryCode, quantity, currencyCode: targetCurrency } = params.context;
+                const { calculation = [] } = params.calculationSheet;
+                if (calculation?.length) {
+                    return pricingAdapter.calculate();
+                }
+                const productPrice = await modules.products.prices.price(product, {
+                    countryCode,
+                    quantity,
+                });
+                if (!productPrice) {
+                    return pricingAdapter.calculate();
+                }
+                const fromCurrencyObj = await modules.currencies.findCurrency({
+                    isoCode: productPrice.currencyCode,
+                });
+                const targetCurrencyObj = await modules.currencies.findCurrency({
+                    isoCode: targetCurrency,
+                });
+                if (!targetCurrencyObj?.isActive || !fromCurrencyObj?.isActive)
+                    return pricingAdapter.calculate();
+                const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
+                if (rateData && rateData.rate > 0) {
+                    const convertedAmount = Math.round(productPrice.amount * rateData.rate);
+                    pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+                    pricingAdapter.resultSheet().addItem({
+                        amount: convertedAmount * quantity,
+                        isTaxable: Boolean(productPrice?.isTaxable),
+                        isNetPrice: Boolean(productPrice?.isNetPrice),
+                        meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
+                    });
+                }
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductPriceRateConversion);

package/lib/pricing/product-round.d.ts

@@ -0,0 +1,10 @@
+import { type IProductPricingAdapter } from '@unchainedshop/core';
+interface PriceRoundSettings {
+    defaultPrecision: number;
+    roundTo: (value: number, precision: number, currencyCode: string) => number;
+}
+export declare const ProductRound: IProductPricingAdapter & {
+    configure: (params: PriceRoundSettings) => void;
+    settings: PriceRoundSettings;
+};
+export {};

package/lib/pricing/product-round.js

@@ -0,0 +1,44 @@
+import { ProductPricingAdapter, ProductPricingDirector, } from '@unchainedshop/core';
+export const ProductRound = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-round',
+    version: '1.0.0',
+    label: 'Round product price',
+    orderIndex: 90,
+    isActivatedFor: () => {
+        return true;
+    },
+    settings: {
+        defaultPrecision: 5,
+        roundTo: (value, precision) => Math.round(value / precision) * precision,
+    },
+    configure({ defaultPrecision, roundTo }) {
+        if (defaultPrecision)
+            this.settings.defaultPrecision = defaultPrecision;
+        if (roundTo)
+            this.settings.roundTo = roundTo;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { currencyCode } = params.context;
+                const { defaultPrecision, roundTo } = ProductRound.settings;
+                const { calculation = [] } = params.calculationSheet;
+                if (calculation?.length) {
+                    pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
+                    calculation.forEach((item) => {
+                        const newAmount = roundTo(item.amount, defaultPrecision, currencyCode);
+                        pricingAdapter.resultSheet().calculation.push({
+                            ...item,
+                            amount: newAmount,
+                        });
+                    });
+                }
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductRound);

package/lib/pricing/product-swiss-tax.d.ts

@@ -0,0 +1,2 @@
+import { type IProductPricingAdapter } from '@unchainedshop/core';
+export declare const ProductSwissTax: IProductPricingAdapter;

package/lib/pricing/product-swiss-tax.js

@@ -0,0 +1,76 @@
+import { ProductPricingDirector, ProductPricingAdapter, ProductPricingRowCategory, } from '@unchainedshop/core';
+import { resolveTaxCategoryFromDeliveryProvider, resolveTaxCategoryFromProduct, SwissTaxCategories, } from "./tax/ch.js";
+import isDeliveryAddressInCountry from "./utils/isDeliveryAddressInCountry.js";
+export const ProductSwissTax = {
+    ...ProductPricingAdapter,
+    key: 'shop.unchained.pricing.product-swiss-tax',
+    version: '1.0.0',
+    label: 'Apply Swiss Tax on Product',
+    orderIndex: 80,
+    isActivatedFor: () => {
+        return true;
+    },
+    actions: (params) => {
+        const pricingAdapter = ProductPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const orderDelivery = context.order?.deliveryId
+                    ? await context.modules.orders.deliveries.findDelivery({
+                        orderDeliveryId: context.order?.deliveryId,
+                    })
+                    : null;
+                if (!isDeliveryAddressInCountry({
+                    ...context,
+                    orderDelivery,
+                }, ['CH', 'LI'])) {
+                    return pricingAdapter.calculate();
+                }
+                let taxCategory = resolveTaxCategoryFromProduct(context.product);
+                if (!taxCategory) {
+                    const provider = orderDelivery?.deliveryProviderId
+                        ? await context.modules.delivery.findProvider({
+                            deliveryProviderId: orderDelivery?.deliveryProviderId,
+                        })
+                        : null;
+                    if (provider)
+                        taxCategory = resolveTaxCategoryFromDeliveryProvider(provider);
+                }
+                if (!taxCategory)
+                    taxCategory = SwissTaxCategories.DEFAULT;
+                const taxRate = taxCategory.rate(context.order?.ordered);
+                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,
+                            baseCategory: ProductPricingRowCategory.Item,
+                            meta: { adapter: ProductSwissTax.key },
+                        });
+                    }
+                    else {
+                        const taxAmount = row.amount * taxRate;
+                        pricingAdapter.resultSheet().addTax({
+                            amount: taxAmount,
+                            rate: taxRate,
+                            baseCategory: ProductPricingRowCategory.Item,
+                            meta: { adapter: ProductSwissTax.key },
+                        });
+                    }
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+ProductPricingDirector.registerAdapter(ProductSwissTax);

package/lib/quotations/manual.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/quotations/manual.js

@@ -0,0 +1,20 @@
+import { QuotationDirector, QuotationAdapter } from '@unchainedshop/core';
+const ManualOffering = {
+    ...QuotationAdapter,
+    key: 'shop.unchained.quotations.manual',
+    version: '1.0.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/lib/warehousing/eth-minter.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/warehousing/eth-minter.js

@@ -0,0 +1,120 @@
+import { WarehousingError, WarehousingDirector, WarehousingAdapter, } from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { ProductContractStandard, ProductType } from '@unchainedshop/core-products';
+import { systemLocale } from '@unchainedshop/utils';
+import { generateDbObjectId } from '@unchainedshop/mongodb';
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:eth-minter');
+const ETHMinter = {
+    ...WarehousingAdapter,
+    key: 'shop.unchained.warehousing.infinite-minter',
+    version: '1.0',
+    label: 'Infinite Minter',
+    orderIndex: 0,
+    initialConfiguration: [{ key: 'chainId', value: '0' }],
+    typeSupported: (type) => {
+        return type === WarehousingProviderType.VIRTUAL;
+    },
+    actions: (configuration, context) => {
+        const { MINTER_TOKEN_OFFSET = '0', ROOT_URL = 'http://localhost:4010' } = process.env;
+        const { product, orderPosition, token, modules, locale } = context;
+        const { contractAddress, contractStandard, tokenId, supply, ercMetadataProperties } = product?.tokenization || {};
+        const getTokensCreated = async () => {
+            const existingTokens = await modules.warehousing.findTokens(contractStandard === ProductContractStandard.ERC721
+                ? { contractAddress: contractStandard }
+                : {
+                    contractAddress: contractStandard,
+                    tokenSerialNumber: tokenId,
+                });
+            const tokensCreated = existingTokens.reduce((acc, curToken) => {
+                return acc + curToken.quantity;
+            }, 0);
+            return tokensCreated;
+        };
+        return {
+            ...WarehousingAdapter.actions(configuration, context),
+            isActive() {
+                return product?.type === ProductType.TOKENIZED_PRODUCT;
+            },
+            configurationError() {
+                if (contractStandard === 'ERC1155' && !tokenId) {
+                    logger.error(`Token ID is required for ERC1155 contract standard (productId: ${product._id})`);
+                    return WarehousingError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            stock: async () => {
+                const tokensCreated = await getTokensCreated();
+                return supply ? supply - tokensCreated : 0;
+            },
+            tokenize: async () => {
+                const chainId = configuration.find(({ key }) => key === 'chainId')?.value || undefined;
+                const meta = { contractStandard };
+                const tokensCreated = await getTokensCreated();
+                if (!orderPosition) {
+                    throw new Error('Order position not found in context');
+                }
+                if (contractStandard === 'ERC721') {
+                    const items = new Array(orderPosition.quantity).fill(null).map((_, i) => ({
+                        _id: generateDbObjectId(),
+                        tokenSerialNumber: Number(parseInt(MINTER_TOKEN_OFFSET, 10) + tokensCreated + (i + 1)).toString(),
+                        contractAddress,
+                        quantity: 1,
+                        chainId,
+                        meta,
+                    }));
+                    return items;
+                }
+                return [
+                    {
+                        _id: generateDbObjectId(),
+                        tokenSerialNumber: tokenId,
+                        contractAddress,
+                        quantity: orderPosition.quantity,
+                        chainId,
+                        meta,
+                    },
+                ];
+            },
+            tokenMetadata: async (tokenSerialNumber) => {
+                if (!product) {
+                    throw new Error('Product not found in context');
+                }
+                const allLanguages = await modules.languages.findLanguages({
+                    includeInactive: false,
+                });
+                const [firstMedia] = await modules.products.media.findProductMedias({
+                    productId: product._id,
+                    limit: 1,
+                });
+                const file = firstMedia && (await modules.files.findFile({ fileId: firstMedia.mediaId }));
+                const fileAdapter = file && getFileAdapter();
+                const signedUrl = await fileAdapter?.createDownloadURL(file);
+                const url = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
+                const text = await modules.products.texts.findLocalizedText({
+                    productId: product._id,
+                    locale: locale || systemLocale,
+                });
+                const name = `${text.title} #${tokenSerialNumber}`;
+                const isDefaultLanguageActive = locale ? locale.language === systemLocale.language : true;
+                const localization = isDefaultLanguageActive
+                    ? {
+                        uri: `${ROOT_URL}/erc-metadata/${product._id}/${locale}/${tokenId}.json`,
+                        default: systemLocale.language,
+                        locales: allLanguages.map((lang) => lang.isoCode),
+                    }
+                    : undefined;
+                return {
+                    name,
+                    description: text.description,
+                    image: url,
+                    properties: ercMetadataProperties,
+                    localization,
+                    ...(token?.meta || {}),
+                };
+            },
+        };
+    },
+};
+WarehousingDirector.registerAdapter(ETHMinter);

package/lib/warehousing/store.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/warehousing/store.js

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

package/lib/worker/budgetsms.d.ts

@@ -0,0 +1,9 @@
+export declare function checkBudgetSmsCredentials(): Promise<{
+    success: boolean;
+    credit: number;
+    error?: undefined;
+} | {
+    error: any;
+    success?: undefined;
+    credit?: undefined;
+}>;

package/lib/worker/budgetsms.js

@@ -0,0 +1,169 @@
+import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+const { BUDGETSMS_USERNAME, BUDGETSMS_USERID, BUDGETSMS_HANDLE } = process.env;
+const BudgetSMSWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.budgetsms',
+    label: 'Send Messages through BudgetSMS',
+    version: '1.0.0',
+    type: 'BUDGETSMS',
+    doWork: async ({ from, to, text, test = false, customid, price = false, mccmnc = false, credit = false, ...params }) => {
+        try {
+            if (!BUDGETSMS_USERNAME || !BUDGETSMS_USERID || !BUDGETSMS_HANDLE) {
+                throw new Error('Missing BudgetSMS credentials. Please set BUDGETSMS_USERNAME, BUDGETSMS_USERID, and BUDGETSMS_HANDLE');
+            }
+            const username = BUDGETSMS_USERNAME.trim();
+            const userid = BUDGETSMS_USERID.trim();
+            const handle = BUDGETSMS_HANDLE.trim();
+            if (!/^\d+$/.test(userid)) {
+                throw new Error('BUDGETSMS_USERID must be numeric only. Found: ' + userid);
+            }
+            const url = test ? 'https://api.budgetsms.net/testsms/' : 'https://api.budgetsms.net/sendsms/';
+            const formattedTo = to.replace(/^\+|^00/, '').replace(/[\s-]/g, '');
+            const queryParams = new URLSearchParams({
+                username: username,
+                userid: userid,
+                handle: handle,
+                msg: text || '',
+                from: from || '',
+                to: formattedTo,
+                ...(customid && { customid }),
+                ...(!test && price && { price: '1' }),
+                ...(!test && mccmnc && { mccmnc: '1' }),
+                ...(!test && credit && { credit: '1' }),
+                ...params,
+            });
+            const fullUrl = `${url}?${queryParams.toString()}`;
+            const response = await fetch(fullUrl, {
+                method: 'GET',
+                headers: {
+                    Accept: 'text/plain',
+                    'User-Agent': 'Unchained/BudgetSMS-Plugin',
+                },
+            });
+            const responseText = await response.text().then((text) => text.trim());
+            if (responseText.startsWith('OK')) {
+                const parts = responseText.split(' ');
+                const result = {
+                    sms_id: parts[1] || null,
+                    status: test ? 'test_successful' : 'sent',
+                    test_mode: test,
+                };
+                if (test) {
+                    result.message = 'Test SMS validated successfully (no credit deducted)';
+                }
+                else {
+                    let index = 2;
+                    if (price && parts[index] && parts[index + 1]) {
+                        result.price = parseFloat(parts[index]);
+                        result.parts = parseInt(parts[index + 1]);
+                        index += 2;
+                    }
+                    if (mccmnc && parts[index]) {
+                        result.mccmnc = parts[index];
+                        index += 1;
+                    }
+                    if (credit && parts[index]) {
+                        result.remaining_credit = parseFloat(parts[index]);
+                    }
+                }
+                return {
+                    success: true,
+                    result,
+                    error: null,
+                };
+            }
+            if (responseText.startsWith('ERR')) {
+                const parts = responseText.split(' ');
+                const errorCode = parts[1] || 'UNKNOWN';
+                const errorMessages = {
+                    '1001': 'Authentication failed OR insufficient credit (BudgetSMS returns 1001 for both)',
+                    '1002': 'Account not active',
+                    '1003': 'Insufficient credit',
+                    '1004': 'No access to this API',
+                    '1005': 'No handle provided',
+                    '1006': 'No UserID provided',
+                    '1007': 'No Username provided',
+                    '2001': 'SMS message text is empty',
+                    '2002': 'SMS numeric senderid can be max. 16 numbers',
+                    '2003': 'SMS alphanumeric sender can be max. 11 characters',
+                    '2004': 'SMS senderid is empty or invalid',
+                    '2005': 'Destination number is too short',
+                    '2006': 'Destination is not numeric',
+                    '2007': 'Destination is empty',
+                    '2008': 'SMS text is not OK (check encoding?)',
+                    '2009': 'Parameter issue',
+                    '2010': 'Destination number is invalidly formatted',
+                    '2011': 'Destination is invalid',
+                    '2012': 'SMS message text is too long',
+                    '2013': 'SMS message is invalid',
+                    '2014': 'SMS CustomID is used before',
+                    '2015': 'Charset problem',
+                    '2016': 'Invalid UTF-8 encoding',
+                    '3001': 'No route to destination',
+                    '3002': 'No routes are setup',
+                    '3003': 'Invalid destination',
+                    '4001': 'System error, related to customid',
+                    '4002': 'System error, temporary issue',
+                };
+                let message = errorMessages[errorCode] || `Unknown error code: ${errorCode}`;
+                if (errorCode === '1001') {
+                    message += '. Note: Check your account balance - BudgetSMS may return 1001 when credit is 0.';
+                }
+                return {
+                    success: false,
+                    error: {
+                        name: 'BUDGETSMS_ERROR',
+                        code: errorCode,
+                        message,
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    name: 'BUDGETSMS_ERROR',
+                    message: 'Unexpected response format from BudgetSMS API',
+                    response: responseText,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+WorkerDirector.registerAdapter(BudgetSMSWorker);
+export async function checkBudgetSmsCredentials() {
+    const url = 'https://api.budgetsms.net/checkcredit/';
+    const username = process.env.BUDGETSMS_USERNAME?.trim();
+    const userid = process.env.BUDGETSMS_USERID?.trim();
+    const handle = process.env.BUDGETSMS_HANDLE?.trim();
+    if (!username || !userid || !handle) {
+        return { error: 'Missing credentials' };
+    }
+    if (!/^\d+$/.test(userid)) {
+        return { error: 'UserID must be numeric only' };
+    }
+    const queryParams = new URLSearchParams({ username, userid, handle });
+    try {
+        const response = await fetch(`${url}?${queryParams.toString()}`, { method: 'GET' });
+        const text = await response.text();
+        if (text.startsWith('OK')) {
+            const credit = parseFloat(text.split(' ')[1]) || 0;
+            return { success: true, credit };
+        }
+        else {
+            return { error: text };
+        }
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+}

package/lib/worker/bulk-export.d.ts

@@ -0,0 +1,2 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BulkExportWorker: IWorkerAdapter<any, any>;

package/lib/worker/bulk-export.js

@@ -0,0 +1,64 @@
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+const isSupportedLocale = (locale) => {
+    try {
+        const dtf = new Intl.DateTimeFormat(locale);
+        const resolved = dtf.resolvedOptions().locale;
+        return resolved.toLowerCase() === locale.toLowerCase();
+    }
+    catch (e) {
+        console.error(e);
+        return false;
+    }
+};
+const createLanguageDialectList = (languages, countries) => {
+    const result = new Set();
+    (languages || []).forEach(({ isoCode: baseIsoCode }) => {
+        result.add(baseIsoCode);
+        (countries || []).forEach(({ isoCode: countryIsoCode }) => {
+            const dialectIsoCode = [baseIsoCode, countryIsoCode.toUpperCase()].join('-');
+            if (isSupportedLocale(dialectIsoCode))
+                result.add(dialectIsoCode);
+        });
+    });
+    return Array.from(result);
+};
+const logger = createLogger('unchained:bulk-export');
+export const BulkExportWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.bulk-export',
+    label: 'Bulk Export',
+    version: '2.1.0',
+    type: 'BULK_EXPORT',
+    maxParallelAllocations: 1,
+    doWork: async (payload, unchainedAPI) => {
+        try {
+            const { modules } = unchainedAPI;
+            const languages = await modules.languages.findLanguages({ includeInactive: false });
+            const countries = await modules.countries.findCountries({ includeInactive: false });
+            const bulkExporter = unchainedAPI.bulkExporter.createBulkExporter({ entity: payload.type });
+            await bulkExporter.validate(payload);
+            const locales = createLanguageDialectList(languages, countries);
+            const [result, error] = await bulkExporter.execute(payload, locales, unchainedAPI);
+            if (error) {
+                return {
+                    success: false,
+                    result: result,
+                    error,
+                };
+            }
+            return {
+                success: true,
+                result,
+            };
+        }
+        catch (err) {
+            logger.error(err);
+            return {
+                success: false,
+                error: { name: err.name, message: err.message, stack: err.stack },
+            };
+        }
+    },
+};
+WorkerDirector.registerAdapter(BulkExportWorker);

package/lib/worker/bulk-import.d.ts

@@ -0,0 +1,2 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BulkImportWorker: IWorkerAdapter<any, Record<string, any>>;