@uniorganization/uni-lib 4.0.36 → 4.0.37

package/dist/entities/index.d.ts

@@ -90,3 +90,4 @@ export * from './service-center-distance-cache.entity';
 export * from './service-center-geocode-cache.entity';
 export * from './kenko.entity';
 export * from './ticket-service-center-match-process.entity';
+export * from './ticket-service-center-match-loa-pricing.entity';

package/dist/entities/index.js

@@ -106,3 +106,4 @@ __exportStar(require("./service-center-distance-cache.entity"), exports);
 __exportStar(require("./service-center-geocode-cache.entity"), exports);
 __exportStar(require("./kenko.entity"), exports);
 __exportStar(require("./ticket-service-center-match-process.entity"), exports);
+__exportStar(require("./ticket-service-center-match-loa-pricing.entity"), exports);

package/dist/entities/ticket-service-center-match-loa-pricing.entity.d.ts

@@ -0,0 +1,12 @@
+import { Users } from './usr.entity';
+export declare class TicketServiceCenterMatchLoaPricingEntity {
+    id: number;
+    model: string;
+    symptom: string | null;
+    price: number;
+    createdBy?: Users | null;
+    createdById: number | null;
+    createdDate: Date;
+    updatedDate: Date;
+    deletedDate: Date | null;
+}

package/dist/entities/ticket-service-center-match-loa-pricing.entity.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketServiceCenterMatchLoaPricingEntity = void 0;
+const typeorm_1 = require("typeorm");
+const usr_entity_1 = require("./usr.entity");
+let TicketServiceCenterMatchLoaPricingEntity = class TicketServiceCenterMatchLoaPricingEntity {
+};
+exports.TicketServiceCenterMatchLoaPricingEntity = TicketServiceCenterMatchLoaPricingEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)(),
+    __metadata("design:type", Number)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'model', type: 'varchar', nullable: false }),
+    __metadata("design:type", String)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "model", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'symptom', type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "symptom", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'price', type: 'numeric', precision: 10, scale: 2, nullable: false }),
+    __metadata("design:type", Number)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "price", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => usr_entity_1.Users),
+    (0, typeorm_1.JoinColumn)({ name: 'created_by_id' }),
+    __metadata("design:type", usr_entity_1.Users)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "createdBy", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'created_by_id', type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "createdById", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ name: 'created_date', type: 'timestamp' }),
+    __metadata("design:type", Date)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "createdDate", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ name: 'updated_date', type: 'timestamp' }),
+    __metadata("design:type", Date)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "updatedDate", void 0);
+__decorate([
+    (0, typeorm_1.DeleteDateColumn)({ name: 'deleted_date', type: 'timestamp' }),
+    __metadata("design:type", Date)
+], TicketServiceCenterMatchLoaPricingEntity.prototype, "deletedDate", void 0);
+exports.TicketServiceCenterMatchLoaPricingEntity = TicketServiceCenterMatchLoaPricingEntity = __decorate([
+    (0, typeorm_1.Entity)('ticket_service_center_match_loa_pricing', { schema: 'enr' })
+], TicketServiceCenterMatchLoaPricingEntity);

package/dist/modules/google-maps/google-maps.service.d.ts

@@ -1,8 +1,15 @@
-import { DistanceMatrixResponseData, GeocodeResponseData } from '@googlemaps/google-maps-services-js';
+import { GeocodeResponseData } from '@googlemaps/google-maps-services-js';
+import { NormalizedDistanceMatrixResponse } from './google-maps.types';
 export declare class GoogleMapsService {
     private client;
     private readonly logger;
     constructor();
     getGeocoding(address: string): Promise<GeocodeResponseData>;
-    getDistanceMatrix(origin: string, destination: string): Promise<DistanceMatrixResponseData>;
+    getDistanceMatrix(origin: string, destination: string): Promise<NormalizedDistanceMatrixResponse>;
+    private normalizeRouteMatrixResponse;
+    private extractFirstRouteMatrixElement;
+    private extractDurationSeconds;
+    private parseDurationSeconds;
+    private extractRouteStatus;
+    private stringifyHttpError;
 }

package/dist/modules/google-maps/google-maps.service.js

@@ -21,6 +21,7 @@ var GoogleMapsService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleMapsService = void 0;
 const common_1 = require("@nestjs/common");
+const axios_1 = require("axios");
 const google_maps_services_js_1 = require("@googlemaps/google-maps-services-js");
 let GoogleMapsService = GoogleMapsService_1 = class GoogleMapsService {
     constructor() {
@@ -61,18 +62,36 @@ let GoogleMapsService = GoogleMapsService_1 = class GoogleMapsService {
                 throw new Error('Google Maps API configuration missing');
             }
             try {
-                const response = yield this.client.distancematrix({
-                    params: {
-                        origins: [origin],
-                        destinations: [destination],
-                        key: apiKey,
-                        units: google_maps_services_js_1.UnitSystem.imperial,
+                const requestBody = {
+                    origins: [
+                        {
+                            waypoint: {
+                                address: origin,
+                            },
+                        },
+                    ],
+                    destinations: [
+                        {
+                            waypoint: {
+                                address: destination,
+                            },
+                        },
+                    ],
+                    travelMode: 'DRIVE',
+                    units: 'IMPERIAL',
+                };
+                const response = yield axios_1.default.post('https://routes.googleapis.com/distanceMatrix/v2:computeRouteMatrix', requestBody, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Goog-Api-Key': apiKey,
+                        'X-Goog-FieldMask': 'originIndex,destinationIndex,duration,distanceMeters,status,condition',
                     },
+                    validateStatus: () => true,
                 });
-                if (response.status !== 200) {
-                    throw new Error(`Google Maps API returned status ${response.status}: ${response.data.error_message || ''}`);
+                if (response.status < 200 || response.status >= 300) {
+                    throw new Error(`Google Routes API returned status ${response.status}: ${this.stringifyHttpError(response.data)}`);
                 }
-                return response.data;
+                return this.normalizeRouteMatrixResponse(response.data, origin, destination);
             }
             catch (e) {
                 this.logger.error(`Google Maps API Error: ${e.message}`, e.stack);
@@ -80,6 +99,93 @@ let GoogleMapsService = GoogleMapsService_1 = class GoogleMapsService {
             }
         });
     }
+    normalizeRouteMatrixResponse(data, origin, destination) {
+        var _a;
+        const element = this.extractFirstRouteMatrixElement(data);
+        if (!element) {
+            throw new Error('Google Routes API returned an empty route matrix response');
+        }
+        const distanceMeters = Number((_a = element.distanceMeters) !== null && _a !== void 0 ? _a : 0);
+        const durationSeconds = this.extractDurationSeconds(element.duration);
+        return {
+            origin_addresses: [origin],
+            destination_addresses: [destination],
+            rows: [
+                {
+                    elements: [
+                        {
+                            status: this.extractRouteStatus(element),
+                            distance: {
+                                value: distanceMeters,
+                                text: `${(distanceMeters / 1609.344).toFixed(1)} mi`,
+                            },
+                            duration: {
+                                value: durationSeconds,
+                                text: `${durationSeconds}s`,
+                            },
+                        },
+                    ],
+                },
+            ],
+            routeMatrix: [element],
+        };
+    }
+    extractFirstRouteMatrixElement(data) {
+        var _a, _b, _c, _d;
+        if (Array.isArray(data)) {
+            return (_a = data[0]) !== null && _a !== void 0 ? _a : null;
+        }
+        if (data && typeof data === 'object') {
+            const record = data;
+            if (Array.isArray(record.routeMatrix)) {
+                return (_b = record.routeMatrix[0]) !== null && _b !== void 0 ? _b : null;
+            }
+            if (Array.isArray(record.matrix)) {
+                return (_c = record.matrix[0]) !== null && _c !== void 0 ? _c : null;
+            }
+            if (Array.isArray(record.rows)) {
+                const firstRow = record.rows[0];
+                if (firstRow && Array.isArray(firstRow.elements)) {
+                    return (_d = firstRow.elements[0]) !== null && _d !== void 0 ? _d : null;
+                }
+            }
+        }
+        return null;
+    }
+    extractDurationSeconds(duration) {
+        if (!duration) {
+            return 0;
+        }
+        return this.parseDurationSeconds(duration);
+    }
+    parseDurationSeconds(value) {
+        const match = value.match(/^(-?\d+(?:\.\d+)?)s$/);
+        if (!match) {
+            const fallback = Number(value);
+            return Number.isFinite(fallback) ? Math.max(0, Math.round(fallback)) : 0;
+        }
+        return Math.max(0, Math.round(Number(match[1])));
+    }
+    extractRouteStatus(element) {
+        if (element.status && typeof element.status === 'object') {
+            const status = element.status;
+            if (typeof status.message === 'string' && status.message.trim()) {
+                return status.message;
+            }
+        }
+        if (element.condition && element.condition.trim()) {
+            return element.condition;
+        }
+        return 'OK';
+    }
+    stringifyHttpError(data) {
+        var _a;
+        if (!data || typeof data !== 'object') {
+            return String(data);
+        }
+        const record = data;
+        return ((_a = record.error) === null || _a === void 0 ? void 0 : _a.message) || record.message || JSON.stringify(data);
+    }
 };
 exports.GoogleMapsService = GoogleMapsService;
 exports.GoogleMapsService = GoogleMapsService = GoogleMapsService_1 = __decorate([

package/dist/modules/google-maps/google-maps.types.d.ts

@@ -0,0 +1,75 @@
+export type RouteMatrixElementCondition = 'ROUTE_MATRIX_ELEMENT_CONDITION_UNSPECIFIED' | 'ROUTE_EXISTS' | 'ROUTE_NOT_FOUND';
+export type RouteTravelMode = 'DRIVE' | 'BICYCLE' | 'WALK' | 'TWO_WHEELER' | 'TRANSIT';
+export type RouteUnits = 'METRIC' | 'IMPERIAL';
+export interface GoogleRpcStatus {
+    code: number;
+    message?: string;
+    details?: unknown[];
+}
+export interface ComputeRouteMatrixLatLng {
+    latitude: number;
+    longitude: number;
+}
+export interface ComputeRouteMatrixLocation {
+    latLng: ComputeRouteMatrixLatLng;
+}
+export interface ComputeRouteMatrixWaypoint {
+    address?: string;
+    placeId?: string;
+    location?: ComputeRouteMatrixLocation;
+    via?: boolean;
+    vehicleStopover?: boolean;
+    sideOfRoad?: boolean;
+}
+export interface ComputeRouteMatrixOrigin {
+    waypoint: ComputeRouteMatrixWaypoint;
+    routeModifiers?: Record<string, unknown>;
+}
+export interface ComputeRouteMatrixDestination {
+    waypoint: ComputeRouteMatrixWaypoint;
+}
+export interface ComputeRouteMatrixRequestBody {
+    origins: ComputeRouteMatrixOrigin[];
+    destinations: ComputeRouteMatrixDestination[];
+    travelMode: RouteTravelMode;
+    units?: RouteUnits;
+    routingPreference?: string;
+    departureTime?: string;
+    arrivalTime?: string;
+    languageCode?: string;
+    regionCode?: string;
+    extraComputations?: string[];
+    trafficModel?: string;
+    transitPreferences?: Record<string, unknown>;
+}
+export interface ComputeRouteMatrixElement {
+    originIndex?: number;
+    destinationIndex?: number;
+    status?: GoogleRpcStatus;
+    condition?: RouteMatrixElementCondition;
+    distanceMeters?: number;
+    duration?: string;
+    staticDuration?: string;
+    travelAdvisory?: Record<string, unknown>;
+    fallbackInfo?: Record<string, unknown>;
+}
+export type ComputeRouteMatrixResponse = ComputeRouteMatrixElement[];
+export interface NormalizedDistanceMatrixElement {
+    status: string;
+    distance: {
+        value: number;
+        text: string;
+    };
+    duration: {
+        value: number;
+        text: string;
+    };
+}
+export interface NormalizedDistanceMatrixResponse {
+    origin_addresses: string[];
+    destination_addresses: string[];
+    rows: Array<{
+        elements: NormalizedDistanceMatrixElement[];
+    }>;
+    routeMatrix: ComputeRouteMatrixElement[];
+}

package/dist/modules/google-maps/google-maps.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/index.d.ts

@@ -2,4 +2,5 @@ export * from './common';
 export * from './encryption';
 export * from './google-maps/google-maps.module';
 export * from './google-maps/google-maps.service';
+export * from './google-maps/google-maps.types';
 export * from './file-storage';

package/dist/modules/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./encryption"), exports);
 __exportStar(require("./google-maps/google-maps.module"), exports);
 __exportStar(require("./google-maps/google-maps.service"), exports);
+__exportStar(require("./google-maps/google-maps.types"), exports);
 __exportStar(require("./file-storage"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniorganization/uni-lib",
-  "version": "4.0.36",
+  "version": "4.0.37",
   "description": "UNI Library",
   "author": "Jhomiguel",
   "main": "dist/index.js",