@smess/networking 1.0.28 → 1.0.30

package/dist/src/services/customer.service.test.js

@@ -0,0 +1,430 @@
+import { CustomerService, } from "./customer.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("CustomerService", () => {
+    const config = {
+        baseUrl: "https://api.example.com",
+        isProd: false,
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new CustomerService(config, $authToken);
+    });
+    it("register success", async () => {
+        const payload = {
+            email: "test@example.com",
+            password: "pass",
+        };
+        const response = {
+            data: { id: 1, email: "test@example.com" },
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.register(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("register error", async () => {
+        const payload = {
+            email: "test@example.com",
+            password: "pass",
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.register(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getProfile success", async () => {
+        const response = {
+            data: { id: 1, email: "test@example.com" },
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getProfile().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getProfile error", async () => {
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.getProfile().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("updateProfile success", async () => {
+        const payload = {
+            name: "Test",
+            address: "123 Main St",
+            postal_code: "12345",
+            city: "City",
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        const response = { data: { id: 1, name: "Test" } };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.updateProfile(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("updateProfile error", async () => {
+        const payload = {
+            name: "Test",
+            address: "123 Main St",
+            postal_code: "12345",
+            city: "City",
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.updateProfile(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getCartCollection success", async () => {
+        const cartItem = {
+            id: "45bfb315-bc60-11f0-90ea-0242ac120004",
+            productId: "352235aa-a6bc-11f0-a3ef-0242ac120004",
+            productName: "GARAM MASALA 100G",
+            quantity: 2,
+            unit: "piece",
+            unitPrice: 1.55,
+            subtotal: 3.1,
+            total: 3.1,
+            picture: "https://s3.smeservices.cloud/grandparismarche-fr/2025-04/3276650136216.png",
+        };
+        const cartSummary = {
+            cartId: "45acc017-bc60-11f0-90ea-0242ac120004",
+            reference: "ORD-A121C9-220935",
+            dateCreated: "2025-11-08 05:03:32",
+            dateModified: "2025-11-08 16:08:55",
+            discountTotal: 0,
+            discountTax: 0,
+            shippingTotal: 0,
+            shippingTax: 0,
+            cartTax: 0,
+            total: 13.95,
+            totalTax: 0,
+            customerId: "244cac49-d014-11ef-8404-0242ac120003",
+            billingInformation: null,
+            shippingInformation: {
+                email: "john.doe@example.com",
+                phoneNumber: "+1-555-123-4567",
+                street: "123 Main Street",
+                city: "san_francisco",
+                postalCode: "94105",
+                state: "ca",
+                country: "us",
+            },
+            status: "confirmed",
+            paymentMethod: "bank_transfer",
+            deliveryType: "pickup",
+            transactionId: null,
+            customerIpAddress: "172.18.0.1",
+            customerUserAgent: "IntelliJ HTTP Client/PhpStorm 2024.3.6",
+            customerNote: null,
+            cartHash: "a121c980b381419d8341556b1f90445c05cbfa4605d6257330df605d20de2c87",
+            cartItems: [cartItem],
+            paymentUrl: null,
+            store: null,
+        };
+        const data = {
+            links: {
+                first: "/api/v1/store/cart/collection?per_page=24&page=1",
+                last: "/api/v1/store/cart/collection?per_page=24&page=1",
+            },
+            items: [cartSummary],
+            count: 1,
+            total: 1,
+            page: 1,
+            totalPage: 1,
+            perPage: 24,
+            metadata: [],
+        };
+        const response = {
+            data,
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+            status: "confirmed",
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getCartCollection error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCartCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("getCustomerProductCollection success", async () => {
+        const product = {
+            id: "504e061d-a6bc-11f0-a3ef-0242ac120004",
+            barcode: "8935063610908",
+            expiryDate: null,
+            name: "AUBERGINE MARINE PIMENTEE NGOC LIEN 400G",
+            category: "CONSERVE",
+            subCategory: null,
+            vatInPercent: 5.5,
+            unit: "piece",
+            volume: null,
+            quantity: 1,
+            unitWeight: null,
+            articleWeight: null,
+            tareWeight: null,
+            supplier: "TCHEQUE",
+            supplierCode: null,
+            supplierItemName: null,
+            picture: "https://s3.smeservices.cloud/grandparismarche-fr/2025-04/8935063610908.png",
+            slug: "aubergine-marine-pimentee-ngoc-lien-400g-8935063610908",
+            internalCode: "5215",
+            htmlDescription: null,
+            inventory: true,
+            quantityInStock: 9,
+            minimumStockQuantity: 0,
+            pricePurchase: 3.25,
+            priceToSell: 3.25,
+            discountInPercent: 0,
+            priceAfterDiscount: 0,
+            priceByWeight: false,
+        };
+        const item = {
+            customerId: "c0e25a90-bc54-11f0-90ea-0242ac120004",
+            productId: "504e061d-a6bc-11f0-a3ef-0242ac120004",
+            category: "New Cate",
+            notes: "Customer note for this favorite product",
+            createdAt: "2025-11-08 03:45:51",
+            updatedAt: "2025-11-08 03:45:51",
+            product,
+        };
+        const productCollectionData = {
+            links: {
+                first: "/api/v1/store/customer-product/collection?per_page=24&page=1",
+                last: "/api/v1/store/customer-product/collection?per_page=24&page=1",
+            },
+            items: [item],
+            count: 1,
+            total: 1,
+            page: 1,
+            totalPage: 1,
+            perPage: 24,
+            metadata: [],
+        };
+        const response = {
+            data: productCollectionData,
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCustomerProductCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("getCustomerProductCollection error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const query = {
+            page: 1,
+            per_page: 24,
+        };
+        const result = await service.getCustomerProductCollection(query).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(query);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("createCustomerProduct success", async () => {
+        const product = {
+            id: "504e061d-a6bc-11f0-a3ef-0242ac120004",
+            barcode: "8935063610908",
+            expiryDate: null,
+            name: "AUBERGINE MARINE PIMENTEE NGOC LIEN 400G",
+            category: "CONSERVE",
+            subCategory: null,
+            vatInPercent: 5.5,
+            unit: "piece",
+            volume: null,
+            quantity: 1,
+            unitWeight: null,
+            articleWeight: null,
+            tareWeight: null,
+            supplier: "TCHEQUE",
+            supplierCode: null,
+            supplierItemName: null,
+            picture: "https://s3.smeservices.cloud/grandparismarche-fr/2025-04/8935063610908.png",
+            slug: "aubergine-marine-pimentee-ngoc-lien-400g-8935063610908",
+            internalCode: "5215",
+            htmlDescription: null,
+            inventory: true,
+            quantityInStock: 9,
+            minimumStockQuantity: 0,
+            pricePurchase: 3.25,
+            priceToSell: 3.25,
+            discountInPercent: 0,
+            priceAfterDiscount: 0,
+            priceByWeight: false,
+        };
+        const response = {
+            data: {
+                customerId: "c0e25a90-bc54-11f0-90ea-0242ac120004",
+                productId: "504e061d-a6bc-11f0-a3ef-0242ac120004",
+                category: "New Cate",
+                notes: "Customer note for this favorite product",
+                createdAt: "2025-11-08 03:45:51",
+                updatedAt: "2025-11-09 16:34:39",
+                product,
+            },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Customer note for this favorite product",
+            category: "New Cate",
+        };
+        const result = await service.createCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("createCustomerProduct error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            notes: "Customer note for this favorite product",
+        };
+        const result = await service.createCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("removeCustomerProduct success", async () => {
+        const response = {
+            data: {
+                message: "Favorite removed successfully",
+            },
+        };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+        };
+        const result = await service.removeCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("removeCustomerProduct error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+        };
+        const result = await service.removeCustomerProduct(payload).toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it("updateCustomerProductCategory success", async () => {
+        const response = { data: true };
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            old_category: "Standard",
+            category: "Preferred",
+        };
+        const result = await service
+            .updateCustomerProductCategory(payload)
+            .toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it("updateCustomerProductCategory error", async () => {
+        const requestMock = jest
+            .fn()
+            .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())));
+        jest.spyOn(service, "provider").mockReturnValue({
+            request: requestMock,
+        });
+        const payload = {
+            product_id: "product-123",
+            old_category: "Standard",
+            category: "Preferred",
+        };
+        const result = await service
+            .updateCustomerProductCategory(payload)
+            .toPromise();
+        expect(requestMock).toHaveBeenCalledWith(payload);
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

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

@@ -0,0 +1,73 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export type EmployeeTarget = "get-profile" | "cart-client-collection" | "cart-bulk-action";
+export interface EmployeeCartCollectionQuery {
+    page?: number;
+    per_page?: number;
+    status?: string;
+    search?: string;
+    sort_by?: string;
+    sort_order?: "asc" | "desc";
+}
+export interface EmployeeCartBulkActionRequest {
+    create?: Array<{
+        cart_id?: string;
+        status?: string;
+        customer_note?: string;
+        customer_id?: string;
+        payment_method?: string;
+        delivery_type?: string;
+        items?: Array<{
+            product_id: string;
+            quantity: number;
+            custom_price?: number;
+            [key: string]: unknown;
+        }>;
+        billing_information?: Record<string, unknown>;
+        shipping_information?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    update?: Array<{
+        cart_id: string;
+        status?: string;
+        customer_note?: string;
+        customer_id?: string;
+        payment_method?: string;
+        delivery_type?: string;
+        items?: Array<{
+            product_id: string;
+            quantity: number;
+            custom_price?: number;
+            [key: string]: unknown;
+        }>;
+        billing_information?: Record<string, unknown>;
+        shipping_information?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    delete?: Array<{
+        cart_id: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+export declare class EmployeeProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: EmployeeTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class EmployeeService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: EmployeeTarget): SmessService<EmployeeProvider>;
+    getProfile(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getCartCollection(query?: EmployeeCartCollectionQuery): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    bulkCartAction(payload: EmployeeCartBulkActionRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

package/dist/src/services/employee.service.js

@@ -0,0 +1,74 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { withAuthReset } from "./utils/withAuthReset";
+export class EmployeeProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version
+            ? `${this.config.baseUrl}/${this.config.version}`
+            : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case "get-profile":
+                return "/authentication/get-profile";
+            case "cart-client-collection":
+                return "/store/cart/client/collection";
+            case "cart-bulk-action":
+                return "/store/cart/bulk-action";
+            default:
+                return "/authentication/not-found";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case "get-profile":
+            case "cart-client-collection":
+                return "GET";
+            case "cart-bulk-action":
+                return "POST";
+            default:
+                return "GET";
+        }
+    }
+    get headers() {
+        const headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        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 EmployeeService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new EmployeeProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    getProfile() {
+        return withAuthReset(this.provider("get-profile").request(), this.$authToken);
+    }
+    getCartCollection(query) {
+        return withAuthReset(this.provider("cart-client-collection").request(query), this.$authToken);
+    }
+    bulkCartAction(payload) {
+        return withAuthReset(this.provider("cart-bulk-action").request(payload), this.$authToken);
+    }
+}

package/dist/src/services/employee.service.test.d.ts

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