@esolve/ng-esolve-connect 0.20.9 → 0.21.2

package/fesm2020/esolve-ng-esolve-connect.mjs

@@ -319,12 +319,185 @@ class EsolveResult {
     }
 }
 
+class EsolveMultipleSelectFilter {
+    constructor(field, options) {
+        this.field = field;
+        this.type = 'multiple';
+        this.options = [];
+        if (options) {
+            this.options = options;
+        }
+    }
+    setValue(values) {
+        this.values = values;
+    }
+    toHttpParams(http_params) {
+        if (!this.values) {
+            throw new Error('No values set');
+        }
+        const base_property = `filter[${this.field}]`;
+        const type_property = base_property + '[type]';
+        const values_property = base_property + '[values][]';
+        const params = {
+            [type_property]: this.type,
+            [values_property]: this.values,
+        };
+        if (http_params) {
+            return http_params.appendAll(params);
+        }
+        return params;
+    }
+}
+
+class EsolveRangeFilter {
+    constructor(field, min = 0, max = 0) {
+        this.field = field;
+        this.type = 'range';
+        this.min = 0;
+        this.max = 0;
+        this.options = {
+            min: 0,
+            max: 0,
+        };
+        this.options.min = min;
+        this.options.max = max;
+        if ((max > 0) && (min > max)) {
+            this.options.min = max;
+            this.options.max = min;
+        }
+    }
+    setValue(min, max) {
+        this.min = min;
+        this.max = max;
+        if ((max > 0) && (min > max)) {
+            this.min = max;
+            this.max = min;
+        }
+    }
+    toHttpParams(http_params) {
+        if (this.min <= 0 && this.max <= 0) {
+            throw new Error('No values set');
+        }
+        const base_property = `filter[${this.field}]`;
+        const type_property = base_property + '[type]';
+        const min_property = base_property + '[min]';
+        const max_property = base_property + '[max]';
+        const params = {
+            [type_property]: this.type,
+            [min_property]: this.min,
+            [max_property]: this.max,
+        };
+        if (http_params) {
+            return http_params.appendAll(params);
+        }
+        return params;
+    }
+}
+
+class EsolveSingleSelectFilter {
+    constructor(field, options_or_value) {
+        this.field = field;
+        this.type = 'single';
+        this.options = [];
+        if (Array.isArray(options_or_value)) {
+            this.options = options_or_value;
+        }
+        else {
+            this.setValue(options_or_value);
+        }
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    toHttpParams(http_params) {
+        if (!this.value) {
+            throw new Error('No values set');
+        }
+        const base_property = `filter[${this.field}]`;
+        const type_property = base_property + '[type]';
+        const values_property = base_property + '[value]';
+        const params = {
+            [type_property]: this.type,
+            [values_property]: this.value,
+        };
+        if (http_params) {
+            return http_params.appendAll(params);
+        }
+        return params;
+    }
+}
+
+// Classes
+
+// Interfaces
+
+// Types
+
+var EsolveFilterFactory;
+(function (EsolveFilterFactory) {
+    function createRangeWithValue(field, min = 0, max = 0) {
+        const filter = new EsolveRangeFilter(field);
+        filter.setValue(min, max);
+        return filter;
+    }
+    EsolveFilterFactory.createRangeWithValue = createRangeWithValue;
+    function createSingleSelectWithValue(field, value) {
+        const filter = new EsolveSingleSelectFilter(field, value);
+        return filter;
+    }
+    EsolveFilterFactory.createSingleSelectWithValue = createSingleSelectWithValue;
+    function createMultipleSelectWithValue(field, value) {
+        const filter = new EsolveMultipleSelectFilter(field);
+        filter.setValue(value);
+        return filter;
+    }
+    EsolveFilterFactory.createMultipleSelectWithValue = createMultipleSelectWithValue;
+    function covertFromObj(obj) {
+        const filters = [];
+        for (const field in obj) {
+            const value = obj[field];
+            let filter = null;
+            if (Array.isArray(value)) {
+                filter = createMultipleSelectWithValue(field, value);
+            }
+            else if (typeof value === 'object') {
+                filter = createRangeWithValue(field, value.min, value.max);
+            }
+            else {
+                filter = createSingleSelectWithValue(field, value);
+            }
+            if (filter) {
+                filters.push(filter);
+            }
+        }
+        return filters;
+    }
+    EsolveFilterFactory.covertFromObj = covertFromObj;
+    function convertToHttpParams(filters, http_params) {
+        if (http_params) {
+            for (const filter of filters) {
+                http_params = filter.toHttpParams(http_params);
+            }
+            return http_params;
+        }
+        let params = {};
+        for (const filter of filters) {
+            params = {
+                ...params,
+                ...filter.toHttpParams(),
+            };
+        }
+        return params;
+    }
+    EsolveFilterFactory.convertToHttpParams = convertToHttpParams;
+})(EsolveFilterFactory || (EsolveFilterFactory = {}));
+
 class EsolveResponseResult {
     constructor(response) {
         this.success_log = [];
         this.error_log = [];
-        this.error_log.push(...response.log.filter(log_item => log_item.type === 'error'));
-        this.success_log.push(...response.log.filter(log_item => log_item.type === 'success'));
+        this.error_log.push(...response.log.filter((log_item) => log_item.type === 'error'));
+        this.success_log.push(...response.log.filter((log_item) => log_item.type === 'success'));
     }
 }
 
@@ -360,11 +533,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                 }]
         }], ctorParameters: function () { return []; } });
 
-class EsolveHttpError {
-    constructor(type, message, error_code) {
+class EsolveHttpError extends Error {
+    constructor(type, code, message, ...params) {
+        // Pass remaining arguments (including vendor specific ones) to parent constructor
+        super(...[message, ...params]);
+        this.http_error = true;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, EsolveHttpError);
+        }
+        this.name = 'EsolveHttpError';
         this.type = type;
-        this.message = message;
-        this.error_code = error_code;
+        this.error_code = code;
     }
 }
 
@@ -374,7 +554,7 @@ class EsolveErrorHandlerService {
         throw new EsolveHttpError('error', message, code);
     }
     emitError(code, message) {
-        return throwError(new EsolveHttpError('error', message, code));
+        return throwError(() => new EsolveHttpError('error', message, code));
     }
     handleHttpPostError(service_type, errorRes) {
         if (!(errorRes instanceof HttpErrorResponse) &&
@@ -384,7 +564,7 @@ class EsolveErrorHandlerService {
                 ('transaction_type' in errorRes) &&
                 ('status' in errorRes) &&
                 ('log' in errorRes))) {
-            return throwError(this.parsePostErrors(errorRes));
+            return throwError(() => this.parsePostErrors(errorRes));
         }
         return this.handleHttpError(service_type, errorRes);
     }
@@ -396,32 +576,32 @@ class EsolveErrorHandlerService {
                 ('message' in errorRes) &&
                 ('code' in errorRes)));
         if (is_not_base) {
-            return throwError(this.parseDeleteError(errorRes));
+            return throwError(() => this.parseDeleteError(errorRes));
         }
         return this.handleHttpError(service_type, errorRes);
     }
-    handleHttpError(service_type, errorRes) {
-        if (errorRes instanceof HttpErrorResponse) {
-            if (errorRes.status === 500) {
-                const server_error = errorRes.error;
+    handleHttpError(service_type, error_response) {
+        if (error_response instanceof HttpErrorResponse) {
+            if (error_response.status === 500) {
+                const server_error = error_response.error;
                 if (('service_type' in server_error) &&
                     (server_error.service_type === service_type)) {
-                    return throwError(this.parseException(server_error));
+                    return throwError(() => this.parseException(server_error));
                 }
             }
         }
         else {
-            if (('service_type' in errorRes) &&
-                (errorRes.service_type === service_type)) {
-                if (errorRes.type === 'exception') {
-                    return throwError(this.parseException(errorRes));
+            if (('service_type' in error_response) &&
+                (error_response.service_type === service_type)) {
+                if (error_response.type === 'exception') {
+                    return throwError(() => this.parseException(error_response));
                 }
-                else if (errorRes.type === 'error') {
-                    return throwError(this.parseResponseError(errorRes));
+                else if (error_response.type === 'error') {
+                    return throwError(() => this.parseResponseError(error_response));
                 }
             }
         }
-        return throwError(errorRes);
+        return throwError(() => error_response);
     }
     parseException(exception) {
         const error = new EsolveHttpError('exception', exception.message || 'Unknown exception has occurred', exception.additional_data.exception_type || 'unknown');
@@ -432,17 +612,18 @@ class EsolveErrorHandlerService {
         return error;
     }
     parsePostErrors(response) {
-        const error = new EsolveHttpError('error', 'Unknown error has occurred', 'unknown');
+        let error_code = 'unknown';
+        let message = 'Unknown error has occurred';
         if ((response.status.state === 'none') && (response.log.length > 0)) {
-            error.error_code = 'no_response';
-            error.message = 'Response was provided';
+            error_code = 'no_response';
+            message = 'Response was provided';
         }
         else if (response.status.state === 'error') {
             const login_error_log = response.log[0];
-            error.error_code = login_error_log.message_code;
-            error.message = login_error_log.message;
+            error_code = login_error_log.message_code;
+            message = login_error_log.message;
         }
-        return error;
+        return new EsolveHttpError('error', error_code, message);
     }
     parseDeleteError(result) {
         return new EsolveHttpError('error', result.message, result.code);
@@ -745,6 +926,26 @@ class EsolveCategoryTreeService {
             return this.processTree(response.records);
         }));
     }
+    /**
+     * Retrieve the special tree structure for a specific special from the eSolve
+     * instance and converts it into the correct format
+     *
+     * @param special_id Id of to special to get tree for
+     *
+     * @returns Observable containing special tree data
+     */
+    getSpecialTree(special_id) {
+        let params = new HttpParams();
+        params = params.set('special_id', special_id);
+        return this.http
+            .get(`${this.config.api_url}/get-special-tree.php`, { params })
+            .pipe(map((response) => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            return this.processTree(response.records);
+        }));
+    }
     /**
      * Retrieve the details of a category tree item from the eSolve instance and
      * converts it to the correct format.
@@ -790,7 +991,7 @@ class EsolveCategoryTreeService {
                 return this.processTreeItem(response.records[0]);
             }));
         }
-        return throwError('Invalid options');
+        return throwError(() => 'Invalid options');
     }
     /**
      * Processes the eSolve tree records and converts them into the correct format.
@@ -1143,7 +1344,9 @@ class EsolveTagsService {
      */
     getTags(options) {
         const params = this.parseOptions(options);
-        return this.http.get(`${this.config.api_url}/get-tags.php`, { params }).pipe(map(response => {
+        return this.http
+            .get(`${this.config.api_url}/get-tags.php`, { params })
+            .pipe(map((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1232,7 +1435,9 @@ class EsolveTopicService {
         if (topic_id_list.length > 0) {
             params = params.append('topic_id', topic_id_list.join(','));
         }
-        return this.http.get(`${this.config.api_url}/get-topics.php`, { params }).pipe(map(response => {
+        return this.http
+            .get(`${this.config.api_url}/get-topics.php`, { params })
+            .pipe(map((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -1859,9 +2064,10 @@ class EsolveLocationsService {
      * Set the addresses_id to 0 and the gps coordinates in order to retrieve the locations list when the address isn't
      * yet saved.
      *
-     * @param addresses_id if supplied, the address will be looked up and the latitude and longitude on the address will be used.
+     * @param addresses_id if supplied, the latitude and longitude on the address will be used.
      * @param latitude if supplied and address_id > 0, the value is ignored.
      * @param longitude if supplied and address_id > 0, the value is ignored.
+     *
      * @returns An `Observable` with an array of stock locations
      */
     getStockLocationsGeo(addresses_id = 0, latitude = 0, longitude = 0) {
@@ -2116,7 +2322,7 @@ class EsolveAccountService {
             }));
         }
         catch (error) {
-            return throwError(error);
+            return throwError(() => error);
         }
     }
     deleteAddress(id) {
@@ -2254,7 +2460,7 @@ class EsolveAccountService {
             }));
         }
         catch (error) {
-            return throwError(error);
+            return throwError(() => error);
         }
     }
     getTransaction(id) {
@@ -2277,7 +2483,7 @@ class EsolveAccountService {
             }));
         }
         catch (error) {
-            return throwError(error);
+            return throwError(() => error);
         }
     }
     processUserAccount(record) {
@@ -2749,10 +2955,12 @@ class EsolveStockBadge {
 class EsolveStockPrice {
     /**
      * Create stock price instance
+     *
      * @param base_price Price without tax
      * @param base_price_with_tax Price with tax
      * @param sell_price Price without tax and with discounts applied if applicable
      * @param sell_price_with_tax Price with tax and with discounts applied if applicable
+     * @param taxed Whether tax has been applied
      */
     constructor(
     /**
@@ -2770,7 +2978,7 @@ class EsolveStockPrice {
     /**
      * Price with tax and with discounts applied if applicable
      */
-    sell_price_with_tax = 0) {
+    sell_price_with_tax = 0, taxed) {
         this.base_price = base_price;
         this.base_price_with_tax = base_price_with_tax;
         this.sell_price = sell_price;
@@ -2783,6 +2991,7 @@ class EsolveStockPrice {
             this.sell_price = this.base_price;
             this.sell_price_with_tax = this.base_price_with_tax;
         }
+        this.taxed = taxed ?? this.base_price !== this.base_price_with_tax;
     }
 }
 
@@ -3000,7 +3209,7 @@ class EsolveStockItemBase {
             seo_title = record.seo_page_title ?? '';
             seo_keywords = record.seo_keywords ?? '';
         }
-        this.price = new EsolveStockPrice(base_price, base_price_with_tax, sell_price, sell_price_with_tax);
+        this.price = new EsolveStockPrice(base_price, base_price_with_tax, sell_price, sell_price_with_tax, record.vat_item);
         if (seo_title.trim() === '') {
             seo_title = this.name;
         }
@@ -3225,7 +3434,7 @@ class EsolveStockService {
                 code,
             },
         });
-        return this.getStockRecords(params).pipe(map(response => {
+        return this.getStockRecords(params).pipe(map((response) => {
             if ((response.records === undefined) ||
                 (response.records.length <= 0)) {
                 throw response;
@@ -3245,7 +3454,7 @@ class EsolveStockService {
                 sef_name,
             },
         });
-        return this.getStockRecords(params).pipe(map(response => {
+        return this.getStockRecords(params).pipe(map((response) => {
             if ((response.records === undefined) ||
                 (response.records.length <= 0)) {
                 throw response;
@@ -3300,23 +3509,26 @@ class EsolveStockService {
         if (options.specials_id) {
             params = params.set('specials_id', options.specials_id);
         }
-        if (options.tag_id_list) {
-            if (options.tag_id_list.length > 0) {
-                params = params.set('tag_id', options.tag_id_list.join(','));
-            }
+        if (options.tag_id_list && options.tag_id_list.length > 0) {
+            params = params.set('tag_id', options.tag_id_list.join(','));
+        }
+        if (options.topic_id_list && options.topic_id_list.length > 0) {
+            params = params.set('topic_id', options.topic_id_list.join(','));
         }
-        if (options.topic_id_list) {
-            if (options.topic_id_list.length > 0) {
-                params = params.set('topic_id', options.topic_id_list.join(','));
+        if (options.filters) {
+            let filters = options.filters;
+            if (!Array.isArray(filters)) {
+                filters = EsolveFilterFactory.covertFromObj(filters);
             }
+            params = EsolveFilterFactory.convertToHttpParams(filters, params);
         }
-        return this.getStockRecords(params).pipe(map(response => {
+        return this.getStockRecords(params).pipe(map((response) => {
             if ((response.records === undefined) ||
                 (response.records.length <= 0)) {
                 throw response;
             }
             const stockItems = [];
-            response.records.forEach(stockRecord => {
+            response.records.forEach((stockRecord) => {
                 stockItems.push(this.processStockItem(stockRecord));
             });
             return new EsolveStockItemList(stockItems, +response.additional_data.total_records, options.page ?? 0);
@@ -3430,6 +3642,41 @@ class EsolveStockService {
             return collection;
         }));
     }
+    getStockFilters(options) {
+        let params = new HttpParams({
+            fromObject: {
+                category_id: options.category_id ?? '',
+                subcategory_id: options.subcategory_id ?? 0,
+                ranges_id: options.ranges_id ?? 0,
+                manufacturers_id: options.manufacturers_id ?? 0,
+                fields: options.fields.join(','),
+            },
+        });
+        return this.http
+            .get(`${this.config.api_url}/get-item-filters.php`, { params })
+            .pipe(map((response) => {
+            if (response.records === undefined) {
+                throw response;
+            }
+            const filters = [];
+            for (const record of response.records) {
+                let filter = null;
+                if (record.type === 'range') {
+                    filter = new EsolveRangeFilter(record.field, +record.min, +record.max);
+                }
+                else if (record.type === 'single') {
+                    filter = new EsolveSingleSelectFilter(record.field, record.values);
+                }
+                else if (record.type === 'multiple') {
+                    filter = new EsolveMultipleSelectFilter(record.field, record.values);
+                }
+                if (filter) {
+                    filters.push(filter);
+                }
+            }
+            return filters;
+        }));
+    }
     /**
      * Processes the eSolve stock item record and converts it to an object.
      *
@@ -3820,7 +4067,7 @@ class EsolveCartService {
             responseType: 'json',
             observe: 'body',
         })
-            .pipe(map(response => {
+            .pipe(map((response) => {
             if (response.responses === undefined) {
                 throw response;
             }
@@ -4378,7 +4625,9 @@ class EsolveShippingService {
                 params = params.set('location_id', options.location_id);
             }
         }
-        return this.http.get(`${this.config.api_url}/get-shipping-methods.php`, { params }).pipe(map(response => {
+        return this.http
+            .get(`${this.config.api_url}/get-shipping-methods.php`, { params })
+            .pipe(map((response) => {
             if (response.records === undefined) {
                 throw response;
             }
@@ -4422,7 +4671,7 @@ class EsolveShippingService {
             }));
         }
         catch (err) {
-            return throwError(err);
+            return throwError(() => err);
         }
     }
     /**
@@ -4515,5 +4764,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ESOLVE_CONNECT_CONFIG, EsolveAccountService, EsolveAdditionalStockImage, EsolveAddress, EsolveAddressResult, EsolveAsset, EsolveAssetsService, EsolveAuthService, EsolveBankingDetails, EsolveBanner, EsolveBannerImage, EsolveBannerImageHotspot, EsolveBannerService, EsolveCartItem, EsolveCartService, EsolveCartStockItem, EsolveCartTotals, EsolveCategoryTreeItem, EsolveCategoryTreeService, EsolveChangePasswordResult, EsolveCheckoutResult, EsolveColour, EsolveCookieService, EsolveEnquiryResult, EsolveEnquiryService, EsolveErrorHandlerService, EsolveGeocodeAddressResult, EsolveGeocodeCoordsResult, EsolveGeocodeResult, EsolveGeocoderService, EsolveHttpError, EsolveLinkedAsset, EsolveLinkedStockItem, EsolveList, EsolveLocation, EsolveLocationAddress, EsolveLocationContactInfo, EsolveLocationPOBoxAddress, EsolveLocationTradingDay, EsolveLocationTradingTimes, EsolveLocationsService, EsolveManufacturer, EsolveManufacturersService, EsolveMediaStockItem, EsolveMenuItem, EsolveMenuService, EsolveNewsArticle, EsolveNewsArticleAuthor, EsolveNewsArticleList, EsolveNewsGroup, EsolveNewsService, EsolvePaymentMethod, EsolvePaymentResult, EsolvePaymentService, EsolveRange, EsolveRangesService, EsolveRecipeStockItem, EsolveRegistrationResult, EsolveResetPasswordResult, EsolveResponseHandlerService, EsolveResponseResult, EsolveResult, EsolveSeoInfo, EsolveSeoService, EsolveSession, EsolveSessionService, EsolveShippingCost, EsolveShippingMethod, EsolveShippingService, EsolveShippingTotals, EsolveSpecial, EsolveSpecialDates, EsolveSpecialImage, EsolveSpecialImageCollection, EsolveSpecialsService, EsolveStockBadge, EsolveStockGroup, EsolveStockGroupItem, EsolveStockImage, EsolveStockImageCollection, EsolveStockItem, EsolveStockItemBase, EsolveStockItemList, EsolveStockLeadTimes, EsolveStockPrice, EsolveStockService, EsolveTag, EsolveTagsService, EsolveTopic, EsolveTopicService, EsolveTransaction, EsolveTransactionAddress, EsolveTransactionClient, EsolveTransactionItem, EsolveTransactionItemPrice, EsolveTransactionList, EsolveTransactionLocation, EsolveTransactionPaymentMethod, EsolveTransactionShippingMethod, EsolveTransactionUser, EsolveUserAccount, EsolveUserAccountBusiness, EsolveUserAccountContact, EsolveUserAccountResult, EsolveVaultItem, EsolveVaultItemResult, NgEsolveConnectModule };
+export { ESOLVE_CONNECT_CONFIG, EsolveAccountService, EsolveAdditionalStockImage, EsolveAddress, EsolveAddressResult, EsolveAsset, EsolveAssetsService, EsolveAuthService, EsolveBankingDetails, EsolveBanner, EsolveBannerImage, EsolveBannerImageHotspot, EsolveBannerService, EsolveCartItem, EsolveCartService, EsolveCartStockItem, EsolveCartTotals, EsolveCategoryTreeItem, EsolveCategoryTreeService, EsolveChangePasswordResult, EsolveCheckoutResult, EsolveColour, EsolveCookieService, EsolveEmptyCartResult, EsolveEnquiryResult, EsolveEnquiryService, EsolveErrorHandlerService, EsolveFilterFactory, EsolveGeocodeAddressResult, EsolveGeocodeCoordsResult, EsolveGeocodeResult, EsolveGeocoderService, EsolveHttpError, EsolveLinkedAsset, EsolveLinkedStockItem, EsolveList, EsolveLocation, EsolveLocationAddress, EsolveLocationContactInfo, EsolveLocationPOBoxAddress, EsolveLocationTradingDay, EsolveLocationTradingTimes, EsolveLocationsService, EsolveManufacturer, EsolveManufacturersService, EsolveMediaStockItem, EsolveMenuItem, EsolveMenuService, EsolveMultipleSelectFilter, EsolveNewsArticle, EsolveNewsArticleAuthor, EsolveNewsArticleList, EsolveNewsGroup, EsolveNewsService, EsolvePaymentMethod, EsolvePaymentResult, EsolvePaymentService, EsolveRange, EsolveRangeFilter, EsolveRangesService, EsolveRecipeStockItem, EsolveRegistrationResult, EsolveResetPasswordResult, EsolveResponseHandlerService, EsolveResponseResult, EsolveResult, EsolveSeoInfo, EsolveSeoService, EsolveSession, EsolveSessionService, EsolveShippingCost, EsolveShippingMethod, EsolveShippingService, EsolveShippingTotals, EsolveSingleSelectFilter, EsolveSpecial, EsolveSpecialDates, EsolveSpecialImage, EsolveSpecialImageCollection, EsolveSpecialsService, EsolveStockBadge, EsolveStockGroup, EsolveStockGroupItem, EsolveStockImage, EsolveStockImageCollection, EsolveStockItem, EsolveStockItemBase, EsolveStockItemList, EsolveStockLeadTimes, EsolveStockPrice, EsolveStockService, EsolveTag, EsolveTagsService, EsolveTopic, EsolveTopicService, EsolveTransaction, EsolveTransactionAddress, EsolveTransactionClient, EsolveTransactionItem, EsolveTransactionItemPrice, EsolveTransactionList, EsolveTransactionLocation, EsolveTransactionPaymentMethod, EsolveTransactionShippingMethod, EsolveTransactionUser, EsolveUserAccount, EsolveUserAccountBusiness, EsolveUserAccountContact, EsolveUserAccountResult, EsolveVaultItem, EsolveVaultItemResult, NgEsolveConnectModule };
 //# sourceMappingURL=esolve-ng-esolve-connect.mjs.map