@smess/networking 1.0.16 → 1.0.19

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

@@ -0,0 +1,402 @@
+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("getStoreList", () => {
+        it("should get store list successfully", async () => {
+            const response = { data: [{ id: "1", name: "Store 1" }] };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getStoreList().toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("getStoreInformation", () => {
+        it("should get store information successfully", async () => {
+            const storeId = "store-123";
+            const response = { data: { id: storeId, name: "Store 1" } };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.getStoreInformation(storeId).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);
+        });
+    });
+    describe("updateProductBatch", () => {
+        it("should update product batch successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                products: [{ id: "1", price: 100 }],
+            };
+            const response = { data: { updated: 1 } };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updateProductBatch(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("updateCustomerBatch", () => {
+        it("should update customer batch successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                customers: [{ id: "1", status: "active" }],
+            };
+            const response = { data: { updated: 1 } };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updateCustomerBatch(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("updateCartBatch", () => {
+        it("should update cart batch successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                orders: [{ id: "1", status: "completed" }],
+            };
+            const response = { data: { updated: 1 } };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updateCartBatch(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+    describe("updateOrderItemBatch", () => {
+        it("should update order item batch successfully", async () => {
+            const storeId = "store-123";
+            const payload = {
+                items: [{ id: "1", quantity: 5 }],
+            };
+            const response = { data: { updated: 1 } };
+            jest.spyOn(service, "provider").mockReturnValue({
+                request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+            });
+            const result = await service.updateOrderItemBatch(storeId, payload).toPromise();
+            expect(result?.hasSuccess).toBe(true);
+            expect(result?.response).toEqual(response);
+        });
+    });
+});

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

@@ -53,6 +53,7 @@ export interface FeaturedProductData {
 export declare class StoreService {
     private readonly config;
     private readonly $authToken;
+    readonly $selectedStoreId: BehaviorSubject<string | null>;
     private readonly cacheService;
     private readonly storeListCache;
     private readonly productCollectionCache;
@@ -60,6 +61,14 @@ export declare class StoreService {
     private readonly featuredProductCache;
     constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
     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>>;

package/dist/services/store.service.js

@@ -1,6 +1,6 @@
 import { NetworkingUIEventWrapped, } from "../types/types";
 import { Accept, SMESSHeader, SmessService } from "./smess.service";
-import { from, of } from "rxjs";
+import { BehaviorSubject, from, of } from "rxjs";
 import { map, switchMap, catchError } from "rxjs/operators";
 import { GenericIndexedDBService } from "./cache.service";
 export class StoreProvider {
@@ -56,6 +56,7 @@ export class StoreService {
     constructor(config, $authToken) {
         this.config = config;
         this.$authToken = $authToken;
+        this.$selectedStoreId = new BehaviorSubject(null);
         // Initialize cache services for different data types
         this.cacheService = new GenericIndexedDBService("StoreCache", "id, timestamp", (data) => data, (data) => data);
         this.storeListCache = new GenericIndexedDBService("StoreListCache", "timestamp", (data) => data, (data) => data);
@@ -67,6 +68,18 @@ export class StoreService {
         const targetWrapper = new StoreProvider(this.config, target, this.$authToken);
         return new SmessService(targetWrapper);
     }
+    /**
+     * Set the selected store ID
+     */
+    setSelectedStoreId(storeId) {
+        this.$selectedStoreId.next(storeId);
+    }
+    /**
+     * Get the current selected store ID
+     */
+    get currentSelectedStoreId() {
+        return this.$selectedStoreId.value;
+    }
     get(id) {
         return from(this.cacheService.getOne(id)).pipe(switchMap((cachedData) => {
             if (cachedData && this.isCacheValid(cachedData.timestamp)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.16",
+  "version": "1.0.19",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",