@dapex-tech/elite-online-services 0.0.0-development

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@dapex-tech/elite-online-services",
+  "version": "0.0.0-development",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "*"
+  ],
+  "peerDependencies": {
+    "socket.io-client": "^4.8.1"
+  },
+  "devDependencies": {
+    "@types/socket.io-client": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dapex-Tech/EliteOnlineServices.git"
+  }
+}

package/services/AdminService.ts

@@ -0,0 +1,122 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AdminDto } from '../models/AdminDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class AdminService {
+    /**
+     * Create a new admin
+     * @param requestBody
+     * @returns any Admin created successfully.
+     * @throws ApiError
+     */
+    public static create(
+        requestBody: AdminDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/admins',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get all admins
+     * @param search
+     * @param orderBy
+     * @param order
+     * @returns any List of admins
+     * @throws ApiError
+     */
+    public static findAll(
+        search: string,
+        orderBy: string,
+        order: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/admins',
+            query: {
+                'search': search,
+                'orderBy': orderBy,
+                'order': order,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get a single admin by ID
+     * @param id
+     * @returns any Admin found
+     * @throws ApiError
+     */
+    public static findOne(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/admins/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Admin not found`,
+            },
+        });
+    }
+    /**
+     * Update an admin by ID
+     * @param id
+     * @param requestBody
+     * @returns any Admin updated successfully.
+     * @throws ApiError
+     */
+    public static update(
+        id: number,
+        requestBody: AdminDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/admins/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Admin not found`,
+            },
+        });
+    }
+    /**
+     * Delete an admin by ID
+     * @param id
+     * @returns any Admin deleted successfully.
+     * @throws ApiError
+     */
+    public static remove(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/admins/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Admin not found`,
+            },
+        });
+    }
+}

package/services/DriversService.ts

@@ -0,0 +1,122 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { DriverDto } from '../models/DriverDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class DriversService {
+    /**
+     * Create a new driver
+     * @param requestBody
+     * @returns any Driver created successfully.
+     * @throws ApiError
+     */
+    public static create(
+        requestBody: DriverDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/drivers',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get all drivers
+     * @param search
+     * @param orderBy
+     * @param order
+     * @returns any List of drivers
+     * @throws ApiError
+     */
+    public static findAll(
+        search: string,
+        orderBy: string,
+        order: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/drivers',
+            query: {
+                'search': search,
+                'orderBy': orderBy,
+                'order': order,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get a single driver by ID
+     * @param id
+     * @returns any Driver found
+     * @throws ApiError
+     */
+    public static findOne(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/drivers/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Driver not found`,
+            },
+        });
+    }
+    /**
+     * Update a driver by ID
+     * @param id
+     * @param requestBody
+     * @returns any Driver updated successfully.
+     * @throws ApiError
+     */
+    public static update(
+        id: number,
+        requestBody: DriverDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/drivers/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Driver not found`,
+            },
+        });
+    }
+    /**
+     * Delete a driver by ID
+     * @param id
+     * @returns any Driver deleted successfully.
+     * @throws ApiError
+     */
+    public static remove(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/drivers/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Driver not found`,
+            },
+        });
+    }
+}

package/services/LoginsService.ts

@@ -0,0 +1,67 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { LoginDto } from '../models/LoginDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class LoginsService {
+    /**
+     * User Login
+     * @param requestBody
+     * @returns any Login successful
+     * @throws ApiError
+     */
+    public static login(
+        requestBody: LoginDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/users/login',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Invalid credentials`,
+            },
+        });
+    }
+    /**
+     * Admin Login
+     * @param requestBody
+     * @returns any Login successful
+     * @throws ApiError
+     */
+    public static login1(
+        requestBody: LoginDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/admins/login',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Invalid credentials`,
+            },
+        });
+    }
+    /**
+     * Driver Login
+     * @param requestBody
+     * @returns any Login successful
+     * @throws ApiError
+     */
+    public static login2(
+        requestBody: LoginDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/drivers/login',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Invalid credentials`,
+            },
+        });
+    }
+}

package/services/MainService.ts

@@ -0,0 +1,19 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class MainService {
+    /**
+     * @returns any
+     * @throws ApiError
+     */
+    public static getHello(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/',
+        });
+    }
+}

package/services/UsersService.ts

@@ -0,0 +1,123 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { UserDto } from '../models/UserDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class UsersService {
+    /**
+     * Create a new user
+     * @param requestBody
+     * @returns any User created successfully.
+     * @throws ApiError
+     */
+    public static create(
+        requestBody: UserDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid data.`,
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get all users
+     * @param search
+     * @param orderBy
+     * @param order
+     * @returns any List of users.
+     * @throws ApiError
+     */
+    public static findAll(
+        search: string,
+        orderBy: string,
+        order: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users',
+            query: {
+                'search': search,
+                'orderBy': orderBy,
+                'order': order,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get a user by ID
+     * @param id
+     * @returns any User found.
+     * @throws ApiError
+     */
+    public static findOne(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `User not found.`,
+            },
+        });
+    }
+    /**
+     * Update a user by ID
+     * @param id
+     * @param requestBody
+     * @returns any User updated successfully.
+     * @throws ApiError
+     */
+    public static update(
+        id: number,
+        requestBody: UserDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/users/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `User not found.`,
+            },
+        });
+    }
+    /**
+     * Delete a user by ID
+     * @param id
+     * @returns any User deleted successfully.
+     * @throws ApiError
+     */
+    public static remove(
+        id: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/users/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `User not found.`,
+            },
+        });
+    }
+}

package/services/index.ts

@@ -0,0 +1,5 @@
+export * from './AdminService';
+export * from './DriversService';
+export * from './LoginsService';
+export * from './MainService';
+export * from './UsersService';

package/socketService.ts

@@ -0,0 +1,105 @@
+import { io, Socket } from 'socket.io-client';
+import { DriverLocationMap, DriverLocationWithClientID } from './types';
+
+export class SocketService {
+  private socket: Socket;
+
+  /*
+  constructor(baseUrl: string) {
+    this.socket = io(baseUrl, { transports: ['websocket'] });
+  }
+  */
+
+  constructor(baseUrl: string, token?: string) {
+    this.socket = io(baseUrl, {
+      transports: ['websocket'],
+      auth: token ? { token } : undefined, // ✅ send token if available
+    });
+  }
+
+  connect() {
+    this.socket.connect();
+  }
+
+  disconnect() {
+    this.socket.disconnect();
+  }
+
+  isConnected(): boolean {
+    return this.socket.connected;
+  }
+
+  isActive(): boolean {
+    return this.socket.active;
+  }
+
+  on<T = any>(event: string, cb: (data: T) => void) {
+    this.socket.on(event, cb);
+  }
+
+  off(event: string, cb?: (...args: any[]) => void) {
+    if (cb) {
+      this.socket.off(event, cb);
+    } else {
+      this.socket.removeAllListeners(event);
+    }
+  }
+
+  emit<T = any>(event: string, data: T) {
+    this.socket.emit(event, data);
+  }
+
+  // Métodos personalizados
+  sendMessage(message: string) {
+    this.emit('message', { text: message });
+  }
+
+  onMessageReceived(cb: (data: { text: string }) => void) {
+    this.on('messageReceived', cb);
+  }
+
+  offMessageReceived(cb: (data: { text: string }) => void) {
+    this.off('messageReceived', cb);
+  }
+
+  updateLocation(data: DriverLocationWithClientID) {
+    this.emit('updateLocation', { ...data });
+  }
+
+  onLocationUpdated(cb: (data: DriverLocationMap) => void) {
+    this.on('locationUpdated', cb);
+  }
+
+  offLocationUpdated(cb: (data: DriverLocationMap) => void) {
+    this.off('locationUpdated', cb);
+  }
+
+  onAllLocations(cb: (data: DriverLocationMap) => void) {
+    this.on('allLocations', cb);
+  }
+
+  offAllLocations(cb: (data: DriverLocationMap) => void) {
+    this.off('allLocations', cb);
+  }
+
+  sendHeartbeat(clientID: string) {
+    this.emit('heartbeat', { clientID });
+  }
+
+  onHeartbeatReceived(cb: (data: { clientID: string; timestamp: number }) => void) {
+    this.on('heartbeatReceived', cb);
+  }
+
+  offHeartbeatReceived(cb: (data: { clientID: string; timestamp: number }) => void) {
+    this.off('heartbeatReceived', cb);
+  }
+
+  onAllHeartbeats(cb: (data: { [clientID: string]: number }) => void) {
+    this.on('allHeartbeats', cb);
+  }
+
+  offAllHeartbeats(cb: (data: { [clientID: string]: number }) => void) {
+    this.off('allHeartbeats', cb);
+  }
+
+}

package/types/driver-location.entity.ts

@@ -0,0 +1,13 @@
+export interface DriverLocation {
+  lat: number;
+  lng: number;
+  at?: Date;
+}
+
+export interface DriverLocationWithClientID extends DriverLocation {
+  clientID: string;
+}
+
+export interface DriverLocationMap {
+  [clientID: string]: DriverLocation;
+}

package/types/index.ts

@@ -0,0 +1,2 @@
+export * from './driver-location.entity';
+export * from './user.entity';

package/types/user.entity.ts

@@ -0,0 +1,5 @@
+export class User {
+  id: number;
+  name: string;
+  email: string;
+}