@smess/networking 1.0.29 → 1.1.0

package/dist/src/services/store.product.service.js

@@ -0,0 +1,102 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+export class StoreProductProvider {
+    constructor(config, target) {
+        this.config = config;
+        this.target = target;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "featured-product-list":
+                return "/store/featured-product-list";
+            case "featured-product-list-by-store":
+                return "/store/${id}/featured-product-list";
+            case "product-category-list":
+                return "/store/product-category/list";
+            case "product-get-by-id":
+                return "/store/product/${id}";
+            case "product-collection":
+                return "/store/product-collection";
+            case "product-collection-by-store":
+                return "/store/${id}/product-collection";
+            default:
+                return "/store";
+        }
+    }
+    get method() {
+        return "GET";
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, null);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return SmessService.filterHeaders(headers);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class StoreProductService {
+    constructor(config) {
+        this.config = config;
+    }
+    provider(target) {
+        const targetWrapper = new StoreProductProvider(this.config, target);
+        return new SmessService(targetWrapper);
+    }
+    /**
+     * Get featured product list
+     * GET /api/v1/store/featured-product-list
+     */
+    getFeaturedProductList() {
+        return this.provider("featured-product-list").request();
+    }
+    /**
+     * Get featured product list by store
+     * GET /api/v1/store/{id}/featured-product-list
+     */
+    getFeaturedProductListByStore(storeId) {
+        return this.provider("featured-product-list-by-store").request(undefined, undefined, storeId);
+    }
+    /**
+     * Get product category list
+     * GET /api/v1/store/product-category/list
+     */
+    getProductCategoryList() {
+        return this.provider("product-category-list").request();
+    }
+    /**
+     * Get product by ID
+     * GET /api/v1/store/product/{id}
+     */
+    getProductById(productId) {
+        return this.provider("product-get-by-id").request(undefined, undefined, productId);
+    }
+    /**
+     * Get product collection
+     * GET /api/v1/store/product-collection
+     */
+    getProductCollection(payload) {
+        return this.provider("product-collection").request(payload, undefined, undefined);
+    }
+    /**
+     * Get product collection by store
+     * GET /api/v1/store/{id}/product-collection
+     */
+    getProductCollectionByStore(storeId, payload) {
+        return this.provider("product-collection-by-store").request(payload, undefined, storeId);
+    }
+}

package/dist/src/services/store.product.service.test.d.ts

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

package/dist/src/services/store.product.service.test.js

@@ -0,0 +1,319 @@
+import { StoreProductService, } from "./store.product.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of } from "rxjs";
+describe("StoreProductService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    beforeEach(() => {
+        service = new StoreProductService(config);
+    });
+    describe("getFeaturedProductList", () => {
+        it("should get featured product list successfully", async () => {
+            const response = {
+                data: [
+                    {
+                        id: "1",
+                        name: "Product 1",
+                        barcode: "123",
+                        category: "CONGELE",
+                        vatInPercent: 5.5,
+                        unit: "piece",
+                        quantity: 1,
+                        picture: "image.png",
+                        slug: "product-1",
+                        internalCode: "001",
+                        inventory: true,
+                        quantityInStock: 10,
+                        minimumStockQuantity: 5,
+                        pricePurchase: 10,
+                        priceToSell: 15,
+                        discountInPercent: 0,
+                        priceAfterDiscount: 0,
+                        expiryDate: null,
+                        subCategory: null,
+                        volume: null,
+                        unitWeight: null,
+                        articleWeight: null,
+                        tareWeight: null,
+                        supplier: null,
+                        supplierCode: null,
+                        supplierItemName: null,
+                        htmlDescription: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getFeaturedProductList().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should handle error", async () => {
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+            });
+            const result = await service.getFeaturedProductList().toPromise();
+            expect(result?.hasFailed).toBe(true);
+        });
+    });
+    describe("getFeaturedProductListByStore", () => {
+        it("should get featured product list by store successfully", async () => {
+            const storeId = "store-123";
+            const response = {
+                data: [
+                    {
+                        id: "1",
+                        name: "Product 1",
+                        barcode: "123",
+                        category: "CONGELE",
+                        vatInPercent: 5.5,
+                        unit: "piece",
+                        quantity: 1,
+                        picture: "image.png",
+                        slug: "product-1",
+                        internalCode: "001",
+                        inventory: true,
+                        quantityInStock: 10,
+                        minimumStockQuantity: 5,
+                        pricePurchase: 10,
+                        priceToSell: 15,
+                        discountInPercent: 0,
+                        priceAfterDiscount: 0,
+                        expiryDate: null,
+                        subCategory: null,
+                        volume: null,
+                        unitWeight: null,
+                        articleWeight: null,
+                        tareWeight: null,
+                        supplier: null,
+                        supplierCode: null,
+                        supplierItemName: null,
+                        htmlDescription: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getFeaturedProductListByStore(storeId).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCategoryList", () => {
+        it("should get product category list successfully", async () => {
+            const response = {
+                data: [
+                    {
+                        name: "BOISSON",
+                        numberOfProducts: 443,
+                        image: null,
+                    },
+                    {
+                        name: "CONGELE",
+                        numberOfProducts: 324,
+                        image: null,
+                    },
+                ],
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCategoryList().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductById", () => {
+        it("should get product by id successfully", async () => {
+            const productId = "product-123";
+            const response = {
+                data: {
+                    id: productId,
+                    name: "Product 1",
+                    barcode: "123",
+                    category: "CONGELE",
+                    vatInPercent: 5.5,
+                    unit: "piece",
+                    quantity: 1,
+                    picture: "image.png",
+                    slug: "product-1",
+                    internalCode: "001",
+                    inventory: true,
+                    quantityInStock: 10,
+                    minimumStockQuantity: 5,
+                    pricePurchase: 10,
+                    priceToSell: 15,
+                    discountInPercent: 0,
+                    priceAfterDiscount: 0,
+                    expiryDate: null,
+                    subCategory: null,
+                    volume: null,
+                    unitWeight: null,
+                    articleWeight: null,
+                    tareWeight: null,
+                    supplier: null,
+                    supplierCode: null,
+                    supplierItemName: null,
+                    htmlDescription: null,
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductById(productId).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCollection", () => {
+        it("should get product collection successfully", async () => {
+            const payload = {
+                page: 1,
+                per_page: 10,
+                search: "test",
+            };
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=10&page=1",
+                        last: "/api/v1/store/product-collection?per_page=10&page=5",
+                        next: "/api/v1/store/product-collection?per_page=10&page=2",
+                    },
+                    items: [
+                        {
+                            id: "1",
+                            name: "Product 1",
+                            barcode: "123",
+                            category: "CONGELE",
+                            vatInPercent: 5.5,
+                            unit: "piece",
+                            quantity: 1,
+                            picture: "image.png",
+                            slug: "product-1",
+                            internalCode: "001",
+                            inventory: true,
+                            quantityInStock: 10,
+                            minimumStockQuantity: 5,
+                            pricePurchase: 10,
+                            priceToSell: 15,
+                            discountInPercent: 0,
+                            priceAfterDiscount: 0,
+                            expiryDate: null,
+                            subCategory: null,
+                            volume: null,
+                            unitWeight: null,
+                            articleWeight: null,
+                            tareWeight: null,
+                            supplier: null,
+                            supplierCode: null,
+                            supplierItemName: null,
+                            htmlDescription: null,
+                        },
+                    ],
+                    count: 10,
+                    total: 50,
+                    page: 1,
+                    totalPage: 5,
+                    perPage: 10,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollection(payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+        it("should get product collection without payload", async () => {
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=24&page=1",
+                        last: "/api/v1/store/product-collection?per_page=24&page=1",
+                    },
+                    items: [],
+                    count: 0,
+                    total: 0,
+                    page: 1,
+                    totalPage: 1,
+                    perPage: 24,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollection().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getProductCollectionByStore", () => {
+        it("should get product collection by store successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                page: 1,
+                per_page: 10,
+            };
+            const response = {
+                data: {
+                    links: {
+                        first: "/api/v1/store/product-collection?per_page=10&page=1",
+                        last: "/api/v1/store/product-collection?per_page=10&page=1",
+                    },
+                    items: [
+                        {
+                            id: "1",
+                            name: "Product 1",
+                            barcode: "123",
+                            category: "CONGELE",
+                            vatInPercent: 5.5,
+                            unit: "piece",
+                            quantity: 1,
+                            picture: "image.png",
+                            slug: "product-1",
+                            internalCode: "001",
+                            inventory: true,
+                            quantityInStock: 10,
+                            minimumStockQuantity: 5,
+                            pricePurchase: 10,
+                            priceToSell: 15,
+                            discountInPercent: 0,
+                            priceAfterDiscount: 0,
+                            expiryDate: null,
+                            subCategory: null,
+                            volume: null,
+                            unitWeight: null,
+                            articleWeight: null,
+                            tareWeight: null,
+                            supplier: null,
+                            supplierCode: null,
+                            supplierItemName: null,
+                            htmlDescription: null,
+                        },
+                    ],
+                    count: 1,
+                    total: 1,
+                    page: 1,
+                    totalPage: 1,
+                    perPage: 10,
+                    metadata: [],
+                },
+            };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getProductCollectionByStore(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});

package/dist/src/services/store.service.d.ts

@@ -0,0 +1,79 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type StoreTarget = "store-get" | "store-list" | "store-product-category-list" | "store-product-collection" | "store-featured-product-list";
+export interface ProductCollectionRequest {
+    page?: number;
+    per_page?: number;
+    search?: string;
+    sort_by?: string;
+    category?: string;
+    min_price?: number;
+    max_price?: number;
+    only_discounted?: boolean;
+    unit?: string;
+    supplier?: string;
+    has_offer?: boolean;
+}
+export declare class StoreProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: StoreTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface StoreData {
+    id: string;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface StoreListData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCollectionData {
+    storeId: string;
+    request: ProductCollectionRequest;
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface ProductCategoryData {
+    data: HttpResponse;
+    timestamp: number;
+}
+export interface FeaturedProductData {
+    storeId: string;
+    data: HttpResponse;
+    timestamp: number;
+}
+export declare class StoreService {
+    private readonly config;
+    readonly $selectedStoreId: BehaviorSubject<string | null>;
+    private readonly cacheService;
+    private readonly storeListCache;
+    private readonly productCollectionCache;
+    private readonly productCategoryCache;
+    private readonly featuredProductCache;
+    constructor(config: NetworkingConfig);
+    provider(target: StoreTarget): SmessService<StoreProvider>;
+    /**
+     * Set the selected store ID
+     */
+    setSelectedStoreId(storeId: string | null): void;
+    /**
+     * Get the current selected store ID
+     */
+    get currentSelectedStoreId(): string | null;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCategoryList(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    productCollection(id: string, payload: ProductCollectionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    featuredProductList(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    clearCache(): Promise<void>;
+    clearStoreCache(id: string): Promise<void>;
+    clearProductCollectionCache(id: string): Promise<void>;
+    private isCacheValid;
+}