@doctocar/tooling 0.3.1-16 → 0.3.1-17

package/dist/firebase/firestore/utils/order/__tests__/buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails.service.test.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const pricing_1 = require("../../../../../pricing");
+const enums_2 = require("../../../enums");
+const services_1 = require("../../services");
+const stubs_1 = require("../../stubs");
+const buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1 = require("../buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails.utils");
+jest.mock("../../services", () => {
+    return {
+        ...jest.requireActual("../../services"),
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrow: jest.fn(),
+    };
+});
+describe("buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails", () => {
+    let getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock;
+    let getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn;
+    let professionalUserPublicDocument;
+    let professionalServiceTypes;
+    let customerVehicleType;
+    let countryServicesPublicConfig;
+    beforeEach(() => {
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock =
+            services_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow;
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.MOTORCYCLE,
+        };
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn);
+        professionalUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)();
+        professionalServiceTypes = [
+            enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            enums_2.ServicesTypes.INTERIOR_CLEANING,
+            enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        ];
+        customerVehicleType = enums_2.VehicleTypes.CITY_CAR;
+        countryServicesPublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+            [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [],
+            }),
+            [enums_2.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [],
+            }),
+            [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                ],
+            }),
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should map a single service type to pricing line and detail", () => {
+        professionalServiceTypes = [enums_2.ServicesTypes.EXTERIOR_CLEANING];
+        const pricingAndDuration = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.MOTORCYCLE,
+        };
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn =
+            pricingAndDuration;
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn);
+        const result = (0, buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails)({
+            professionalServiceTypes,
+            professionalUserPublicDocument,
+            customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
+            professionalUserPublicDocument,
+            professionalServiceType: professionalServiceTypes[0],
+            vehicleType: customerVehicleType,
+        });
+        expect(result.professionalServicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderProfessionalServicesDetails).toEqual([
+            {
+                id: `professionalServiceDetails0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+            },
+        ]);
+    });
+    it("should map multiple service types and subservices correctly", () => {
+        const result = (0, buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails)({
+            professionalServiceTypes,
+            professionalUserPublicDocument,
+            customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(3);
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(1, {
+            professionalUserPublicDocument,
+            professionalServiceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            vehicleType: customerVehicleType,
+        });
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(2, {
+            professionalUserPublicDocument,
+            professionalServiceType: enums_2.ServicesTypes.INTERIOR_CLEANING,
+            vehicleType: customerVehicleType,
+        });
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(3, {
+            professionalUserPublicDocument,
+            professionalServiceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+            vehicleType: customerVehicleType,
+        });
+        expect(result.professionalServicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+            {
+                id: `pricingLine1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+            {
+                id: `pricingLine2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderProfessionalServicesDetails).toEqual([
+            {
+                id: `professionalServiceDetails0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                scheduledAt: undefined,
+            },
+            {
+                id: `professionalServiceDetails1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.INTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+            },
+            {
+                id: `professionalServiceDetails2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                pricingLineId: `pricingLine2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                photosStoragePaths: {
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                isSubservice: true,
+            },
+        ]);
+    });
+    it("Should add to orderProfessionalSubServicesDetails if is a subservice", () => {
+        professionalServiceTypes = [
+            enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        ];
+        const pricingAndDuration = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.SEDAN,
+        };
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn =
+            pricingAndDuration;
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowReturn);
+        const result = (0, buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails)({
+            professionalServiceTypes,
+            professionalUserPublicDocument,
+            customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
+            professionalUserPublicDocument,
+            professionalServiceType: professionalServiceTypes[0],
+            vehicleType: customerVehicleType,
+        });
+        expect(result.professionalServicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderProfessionalServicesDetails).toEqual([
+            {
+                id: `professionalServiceDetails0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                photosStoragePaths: {
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                isSubservice: true,
+            },
+        ]);
+    });
+    it("should throw if getActiveProfessionalServicePricingAndDurationForVehicleOrThrow throws", () => {
+        getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock.mockImplementationOnce(() => {
+            throw new Error("Service pricing not found");
+        });
+        expect(() => (0, buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails)({
+            professionalServiceTypes,
+            professionalUserPublicDocument,
+            customerVehicleType,
+            countryServicesPublicConfig,
+        })).toThrow("Service pricing not found");
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+    });
+    it("should throw if a professional service type is not in country config", () => {
+        professionalServiceTypes = [
+            enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            enums_2.ServicesTypes.INTERIOR_CLEANING,
+            enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        ];
+        countryServicesPublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+            [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)(),
+            [enums_2.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)(),
+            [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: undefined,
+        });
+        expect(() => (0, buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails_utils_1.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails)({
+            professionalServiceTypes,
+            professionalUserPublicDocument,
+            customerVehicleType,
+            countryServicesPublicConfig,
+        })).toThrow(`Professional service type ${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT} is not available in the country configuration.`);
+        expect(getActiveProfessionalServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/firebase/firestore/utils/order/__tests__/buildOrderServicePreTaxLinesAndProfessionalServicesDetails.test.d.ts

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

package/dist/firebase/firestore/utils/order/__tests__/buildOrderServicePreTaxLinesAndProfessionalServicesDetails.test.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const pricing_1 = require("../../../../../pricing");
+const enums_2 = require("../../../enums");
+const services_1 = require("../../services");
+const stubs_1 = require("../../stubs");
+const buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1 = require("../buildOrderServicePreTaxLinesAndProfessionalServicesDetails");
+jest.mock("../../services", () => {
+    return {
+        ...jest.requireActual("../../services"),
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow: jest.fn(),
+    };
+});
+describe("buildOrderServicePreTaxLinesAndProfessionalServicesDetails", () => {
+    let getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock;
+    let getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn;
+    let professionalUserPublicDocument;
+    let serviceTypes;
+    let customerVehicleType;
+    let countryServicesPublicConfig;
+    beforeEach(() => {
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock =
+            services_1.getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow;
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.MOTORCYCLE,
+        };
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn);
+        professionalUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)();
+        serviceTypes = [
+            enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            enums_2.ServicesTypes.INTERIOR_CLEANING,
+            enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        ];
+        customerVehicleType = enums_2.VehicleTypes.CITY_CAR;
+        countryServicesPublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+            [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [],
+            }),
+            [enums_2.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [],
+            }),
+            [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                ],
+            }),
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should map a single service type to pricing line and detail", () => {
+        serviceTypes = [enums_2.ServicesTypes.EXTERIOR_CLEANING];
+        const pricingAndDuration = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.MOTORCYCLE,
+        };
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn =
+            pricingAndDuration;
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn);
+        const result = (0, buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1.buildOrderServicePreTaxLinesAndProfessionalServicesDetails)({
+            serviceTypes,
+            professionalUserPublicDocument,
+            vehicleType: customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
+            professionalUserPublicDocument,
+            serviceType: serviceTypes[0],
+            vehicleType: customerVehicleType,
+        });
+        expect(result.servicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderServicesDetails).toEqual([
+            {
+                id: `orderServiceDetails0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+            },
+        ]);
+    });
+    it("should map multiple service types and subservices correctly", () => {
+        const result = (0, buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1.buildOrderServicePreTaxLinesAndProfessionalServicesDetails)({
+            serviceTypes,
+            professionalUserPublicDocument,
+            vehicleType: customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(3);
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(1, {
+            professionalUserPublicDocument,
+            serviceType: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            vehicleType: customerVehicleType,
+        });
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(2, {
+            professionalUserPublicDocument,
+            serviceType: enums_2.ServicesTypes.INTERIOR_CLEANING,
+            vehicleType: customerVehicleType,
+        });
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenNthCalledWith(3, {
+            professionalUserPublicDocument,
+            serviceType: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+            vehicleType: customerVehicleType,
+        });
+        expect(result.servicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+            {
+                id: `pricingLine1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+            {
+                id: `pricingLine2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderServicesDetails).toEqual([
+            {
+                id: `orderServiceDetails0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.EXTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                scheduledAt: undefined,
+            },
+            {
+                id: `orderServiceDetails1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                pricingLineId: `pricingLine1-${enums_2.ServicesTypes.INTERIOR_CLEANING}`,
+                type: enums_2.ServicesTypes.INTERIOR_CLEANING,
+                photosStoragePaths: {
+                    [enums_2.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+            },
+            {
+                id: `orderServiceDetails2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                pricingLineId: `pricingLine2-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                photosStoragePaths: {
+                    [enums_2.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                isSubservice: true,
+            },
+        ]);
+    });
+    it("Should add to orderProfessionalSubServicesDetails if is a subservice", () => {
+        serviceTypes = [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT];
+        const pricingAndDuration = {
+            pricePreTaxInCents: 2500,
+            durationInMinutes: 45,
+            currency: enums_1.SupportedIsoCurrency.EUR,
+            isActive: true,
+            type: enums_2.VehicleTypes.SEDAN,
+        };
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn =
+            pricingAndDuration;
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock.mockReturnValue(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowReturn);
+        const result = (0, buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1.buildOrderServicePreTaxLinesAndProfessionalServicesDetails)({
+            serviceTypes,
+            professionalUserPublicDocument,
+            vehicleType: customerVehicleType,
+            countryServicesPublicConfig,
+        });
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledWith({
+            professionalUserPublicDocument,
+            serviceType: serviceTypes[0],
+            vehicleType: customerVehicleType,
+        });
+        expect(result.servicesPreTaxLines).toEqual([
+            {
+                id: `pricingLine0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                amountPreTaxInCents: 2500,
+                category: pricing_1.PricingLineCategories.SERVICE,
+                currency: enums_1.SupportedIsoCurrency.EUR,
+            },
+        ]);
+        expect(result.orderServicesDetails).toEqual([
+            {
+                id: `orderServiceDetails0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                pricingLineId: `pricingLine0-${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT}`,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                photosStoragePaths: {
+                    [enums_2.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                    [enums_2.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+                },
+                durationInMinutes: 45,
+                isSubservice: true,
+            },
+        ]);
+    });
+    it("should throw if getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow throws", () => {
+        getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock.mockImplementationOnce(() => {
+            throw new Error("Service pricing not found");
+        });
+        expect(() => (0, buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1.buildOrderServicePreTaxLinesAndProfessionalServicesDetails)({
+            serviceTypes,
+            professionalUserPublicDocument,
+            vehicleType: customerVehicleType,
+            countryServicesPublicConfig,
+        })).toThrow("Service pricing not found");
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(1);
+    });
+    it("should throw if a professional service type is not in country config", () => {
+        serviceTypes = [
+            enums_2.ServicesTypes.EXTERIOR_CLEANING,
+            enums_2.ServicesTypes.INTERIOR_CLEANING,
+            enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        ];
+        countryServicesPublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+            [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)(),
+            [enums_2.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)(),
+            [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: undefined,
+        });
+        expect(() => (0, buildOrderServicePreTaxLinesAndProfessionalServicesDetails_1.buildOrderServicePreTaxLinesAndProfessionalServicesDetails)({
+            serviceTypes,
+            professionalUserPublicDocument,
+            vehicleType: customerVehicleType,
+            countryServicesPublicConfig,
+        })).toThrow(`Service type ${enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT} is not available in the country configuration.`);
+        expect(getActiveServiceProviderServicePricingAndDurationForVehicleOrThrowMock).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/firebase/firestore/utils/order/__tests__/getOrderCustomerAndProfessionalIds.test.d.ts

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

package/dist/firebase/firestore/utils/order/__tests__/getOrderCustomerAndProfessionalIds.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stubs_1 = require("../../stubs");
+const getOrderCustomerAndProfessionalIds_1 = require("../getOrderCustomerAndProfessionalIds");
+describe("getOrderCustomerAndProfessionalIds", () => {
+    let orderDocument;
+    beforeEach(() => {
+        orderDocument = (0, stubs_1.firestoreOrderDocumentStub)({
+            customerDetails: {
+                firestoreId: "customer-123",
+            },
+            professionalDetails: {
+                firestoreId: "professional-456",
+            },
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should return correct customerId and professionalId", () => {
+        const result = (0, getOrderCustomerAndProfessionalIds_1.getOrderCustomerAndProfessionalIds)({ orderDocument });
+        expect(result).toEqual({
+            customerId: "customer-123",
+            professionalId: "professional-456",
+        });
+    });
+});

package/dist/firebase/firestore/utils/order/buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails.utils.d.ts

@@ -0,0 +1,2 @@
+import type { BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsProps, BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsReturn } from "./types";
+export declare function buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails({ countryServicesPublicConfig, professionalServiceTypes, professionalUserPublicDocument, customerVehicleType, }: BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsProps): BuildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetailsReturn;

package/dist/firebase/firestore/utils/order/buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails.utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails = buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails;
+const pricing_1 = require("../../../../pricing");
+const enums_1 = require("../../enums");
+const services_1 = require("../services");
+function buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails({ countryServicesPublicConfig, professionalServiceTypes, professionalUserPublicDocument, customerVehicleType, }) {
+    const professionalServicesPreTaxLines = [];
+    const orderProfessionalServicesDetails = [];
+    professionalServiceTypes.forEach((professionalServiceType, index) => {
+        if (!countryServicesPublicConfig[professionalServiceType]) {
+            throw new Error(`Professional service type ${professionalServiceType} is not available in the country configuration.`);
+        }
+        const pricingAndDurationForVehicle = (0, services_1.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow)({
+            professionalUserPublicDocument,
+            professionalServiceType,
+            vehicleType: customerVehicleType,
+        });
+        const pricingLineId = `pricingLine${index}-${professionalServiceType}`;
+        const professionalServiceDetailsId = `professionalServiceDetails${index}-${professionalServiceType}`;
+        const pricingPreTaxLine = {
+            id: pricingLineId,
+            amountPreTaxInCents: pricingAndDurationForVehicle.pricePreTaxInCents,
+            category: pricing_1.PricingLineCategories.SERVICE,
+            currency: pricingAndDurationForVehicle.currency,
+        };
+        professionalServicesPreTaxLines.push(pricingPreTaxLine);
+        const orderProfessionalServiceDetail = {
+            id: professionalServiceDetailsId,
+            pricingLineId: pricingLineId,
+            type: professionalServiceType,
+            photosStoragePaths: {
+                [enums_1.OrderProfessionalServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                [enums_1.OrderProfessionalServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+            },
+            durationInMinutes: pricingAndDurationForVehicle.durationInMinutes,
+        };
+        if (countryServicesPublicConfig[professionalServiceType].parentsServices &&
+            countryServicesPublicConfig[professionalServiceType].parentsServices
+                .length > 0) {
+            orderProfessionalServiceDetail.isSubservice = true;
+        }
+        orderProfessionalServicesDetails.push(orderProfessionalServiceDetail);
+    });
+    return {
+        professionalServicesPreTaxLines,
+        orderProfessionalServicesDetails,
+    };
+}

package/dist/firebase/firestore/utils/order/buildOrderServicePreTaxLinesAndProfessionalServicesDetails.d.ts

@@ -0,0 +1,2 @@
+import type { BuildOrderServicePreTaxLinesAndServicesDetailsProps, BuildOrderServicePreTaxLinesAndServicesDetailsReturn } from "./types";
+export declare function buildOrderServicePreTaxLinesAndProfessionalServicesDetails({ countryServicesPublicConfig, serviceTypes, professionalUserPublicDocument, vehicleType, }: BuildOrderServicePreTaxLinesAndServicesDetailsProps): BuildOrderServicePreTaxLinesAndServicesDetailsReturn;

package/dist/firebase/firestore/utils/order/buildOrderServicePreTaxLinesAndProfessionalServicesDetails.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOrderServicePreTaxLinesAndProfessionalServicesDetails = buildOrderServicePreTaxLinesAndProfessionalServicesDetails;
+const pricing_1 = require("../../../../pricing");
+const enums_1 = require("../../enums");
+const services_1 = require("../services");
+function buildOrderServicePreTaxLinesAndProfessionalServicesDetails({ countryServicesPublicConfig, serviceTypes, professionalUserPublicDocument, vehicleType, }) {
+    const servicesPreTaxLines = [];
+    const orderServicesDetails = [];
+    serviceTypes.forEach((serviceType, index) => {
+        if (!countryServicesPublicConfig[serviceType]) {
+            throw new Error(`Service type ${serviceType} is not available in the country configuration.`);
+        }
+        const pricingAndDurationForVehicle = (0, services_1.getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow)({
+            professionalUserPublicDocument,
+            serviceType,
+            vehicleType,
+        });
+        const pricingLineId = `pricingLine${index}-${serviceType}`;
+        const serviceDetailsId = `orderServiceDetails${index}-${serviceType}`;
+        const pricingPreTaxLine = {
+            id: pricingLineId,
+            amountPreTaxInCents: pricingAndDurationForVehicle.pricePreTaxInCents,
+            category: pricing_1.PricingLineCategories.SERVICE,
+            currency: pricingAndDurationForVehicle.currency,
+        };
+        servicesPreTaxLines.push(pricingPreTaxLine);
+        const orderServiceDetail = {
+            id: serviceDetailsId,
+            pricingLineId: pricingLineId,
+            type: serviceType,
+            photosStoragePaths: {
+                [enums_1.OrderServiceDetailsPhotoContext.BEFORE_SERVICE]: [],
+                [enums_1.OrderServiceDetailsPhotoContext.AFTER_SERVICE]: [],
+            },
+            durationInMinutes: pricingAndDurationForVehicle.durationInMinutes,
+        };
+        if (countryServicesPublicConfig[serviceType].parentsServices &&
+            countryServicesPublicConfig[serviceType].parentsServices.length > 0) {
+            orderServiceDetail.isSubservice = true;
+        }
+        orderServicesDetails.push(orderServiceDetail);
+    });
+    return {
+        servicesPreTaxLines,
+        orderServicesDetails,
+    };
+}

package/dist/firebase/firestore/utils/order/getOrderCustomerAndProfessionalIds.d.ts

@@ -0,0 +1,2 @@
+import type { GetOrderCustomerAndProfessionalIdsParams, GetOrderCustomerAndProfessionalIdsResult } from "./types";
+export declare function getOrderCustomerAndProfessionalIds({ orderDocument, }: GetOrderCustomerAndProfessionalIdsParams): GetOrderCustomerAndProfessionalIdsResult;