@abcagency/hire-control-sdk 1.0.1

package/babel.config.json

@@ -0,0 +1,6 @@
+{
+  "presets": [
+    ["@babel/preset-env", { "modules": false }],
+    "@babel/preset-typescript"
+  ]
+}

package/constants/config.ts

@@ -0,0 +1 @@
+export const API_URL = 'http://localhost:5108';

package/controllers/accountsController.ts

@@ -0,0 +1,54 @@
+import FetchHandler from '../handlers/fetchHandler';
+import ForgotPasswordRequest from '../types/account/forgotPasswordRequest';
+import ResetPasswordWithTokenRequest from '../types/account/resetPasswordWithTokenRequest';
+import ResetPasswordRequest from '../types/account/resetPasswordRequest';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class AccountController {
+  /**
+   * Sends a password reset link to the user's email address.
+   * @param {ForgotPasswordRequest} model - The email of the user.
+   * @returns {Promise<void>} - No return value.
+   */
+  async forgotPassword(model: ForgotPasswordRequest): Promise<void> {
+    try {
+      const response = await fetchHandler.post<ForgotPasswordRequest, void>('/account/forgotPassword', model, false);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Resets the password for a non-authenticated user using a token.
+   * @param {ResetPasswordWithTokenRequest} model - The email, token, and new password.
+   * @returns {Promise<void>} - No return value.
+   */
+  async resetPasswordWithToken(model: ResetPasswordWithTokenRequest): Promise<void> {
+    try {
+      const response = await fetchHandler.post<ResetPasswordWithTokenRequest, void>('/account/resetPasswordWithToken', model, false);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Resets the password for an authenticated user.
+   * @param {ResetPasswordRequest} model - The current and new password.
+   * @param {string | null} authToken - The authorization token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async resetPassword(model: ResetPasswordRequest, authToken: string | null = null): Promise<void> {
+    try {
+      const response = await fetchHandler.post<ResetPasswordRequest, void>('/account/resetPassword', model, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export default new AccountController();

package/controllers/authController.ts

@@ -0,0 +1,159 @@
+import FetchHandler from '../handlers/fetchHandler';
+import ClientLogInRequest from '../types/clientLoginRequest';
+import Credentials from '../types/credentials';
+import RefreshTokenRequest from '../types/refreshTokenRequest';
+import ChangeCompanyRequest from '../types/changeCompanyRequest';
+import AuthResponse from '../types/authResponse';
+import Register from '../types/register';
+import User from '../types/user';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+/**
+ * AuthController class that handles all the authentication API calls.
+ */
+class AuthController {
+  /**
+   * Login using client authentication key.
+   * @param {ClientLogInRequest} clientLogInRequest - The login request object containing the client auth key.
+   * @returns {Promise<any>} - The response from the server.
+   */
+  async login(clientLogInRequest: ClientLogInRequest): Promise<any> {
+    return fetchHandler.post<ClientLogInRequest, any>('/auth/login', clientLogInRequest, false);
+  }
+
+/**
+ * Login for existing users with username and password.
+ * @param {Credentials} credentials - The credentials object containing username and password.
+ * @returns {Promise<any>} - The response containing the authentication token.
+ */
+async nextLogin(credentials: Credentials): Promise<any> {
+  const response = await fetchHandler.post<Credentials, AuthResponse>('/auth/nextLogin', credentials, false);
+
+//   if (response) {
+//     sessionStorage.setItem('token', response.token);
+//     sessionStorage.setItem('refreshToken', response.refreshToken);
+//     sessionStorage.setItem('expiration', response.expiration);
+//   }
+
+  return response;
+}
+
+/**
+ * Refresh the access token using the refresh token.
+ * @param {RefreshTokenRequest} refreshTokenRequest - The refresh token request object containing the refresh token and companyId.
+ * @returns {Promise<any>} - The response with the new token.
+ */
+async refreshToken(refreshTokenRequest: RefreshTokenRequest): Promise<any> {
+  const response = await fetchHandler.post<RefreshTokenRequest, AuthResponse>('/auth/refresh', refreshTokenRequest, false);
+
+  if (response) {
+    sessionStorage.setItem('token', response.token);
+    sessionStorage.setItem('refreshToken', response.refreshToken);
+    sessionStorage.setItem('expiration', response.expiration);
+  }
+
+  return response;
+}
+
+  /**
+   * Change the company for the current authenticated user.
+   * @param {ChangeCompanyRequest} changeCompanyRequest - The request object containing the new company ID.
+   * @returns {Promise<any>} - The response from the server.
+   */
+  async changeCompany(changeCompanyRequest: ChangeCompanyRequest): Promise<any> {
+    return fetchHandler.post<ChangeCompanyRequest, any>('/auth/changeCompany', changeCompanyRequest, true);
+  }
+
+  /**
+   * Register a new user.
+   * @param {Register} register - The register request object containing user details.
+   * @returns {Promise<any>} - The response after registering the user.
+   */
+  async register(register: Register): Promise<any> {
+    return fetchHandler.post<Register, any>('/auth/register', register, false);
+  }
+
+   /**
+   * Fetch the authorized companies for the current user.
+   * @returns {Promise<any>} - The response containing the list of companies.
+   */
+   async getCompanies(): Promise<any> {
+    return fetchHandler.get<any>('/auth/companies', true); // 'true' for authenticated endpoint
+  }
+
+    /**
+   * Get the current company details for the authenticated user.
+   * @returns {Promise<any>} - The response containing the company name and company ID.
+   */
+  async getCompany(): Promise<any> {
+    return fetchHandler.get<any>('/auth/company', true); // 'true' for authenticated endpoint
+  }
+
+    /**
+   * Get the roles for the authenticated user.
+   * @returns {Promise<any>} - The response containing the list of roles.
+   */
+  async getRoles(): Promise<any> {
+    return fetchHandler.get<any>('/auth/roles', true); // 'true' for authenticated endpoint
+  }
+
+/**
+ * Check if the user is authenticated.
+ * @returns {Promise<boolean>} - True if the user is authenticated, false otherwise.
+ */
+async isAuthenticated(): Promise<boolean> {
+  try {
+    const response = await fetchHandler.get<boolean>('/auth/authenticated', true);
+    return response; // Return the boolean response directly from the API
+  } catch (error) {
+    return false; // Return false if there's an error (e.g., unauthorized)
+  }
+}
+
+ /**
+   * Get logged in user.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<User | null>} - The user data or null if not found.
+   */
+  async getUser(authToken: string | null = null): Promise<User | null> {
+    try {
+      const response = await fetchHandler.get<User>(`/auth/user`, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+/**
+ * Logout the authenticated user.
+ * @returns {Promise<any>} - The response from the server.
+ */
+async logout(): Promise<any> {
+  try {
+    const response = await fetchHandler.post<any, any>('/auth/logout', {}, true); // Assuming auth token is handled in fetchHandler
+    // Clear tokens or session storage
+    sessionStorage.removeItem('token');
+    sessionStorage.removeItem('refreshToken');
+    sessionStorage.removeItem('expiration');
+    
+    return response;
+  } catch (error) {
+    throw error;
+  }
+}
+
+  async getPermissions(authToken: string | null = null): Promise<string[]> {
+    try {
+      const response = await fetchHandler.get<string[]>('/auth/permissions', true, authToken); 
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+
+
+export default new AuthController();

package/controllers/clientAuthConfigController.ts

@@ -0,0 +1,69 @@
+import FetchHandler from '../handlers/fetchHandler';
+import ClientAuthConfig from '../types/clientAuthConfig';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class ClientAuthConfigController {
+  /**
+   * Get the client auth configuration by its ID.
+   * @param {string} id - The ID of the client auth configuration.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<ClientAuthConfig | null>} - The client auth configuration or null if not found.
+   */
+  async getClientAuthConfigById(id: string, authToken: string | null = null): Promise<ClientAuthConfig | null> {
+    try {
+      const response = await fetchHandler.get<ClientAuthConfig>(`/clientAuthConfig/${id}`, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get all client auth configurations.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<ClientAuthConfig[] | null>} - The list of client auth configurations or null if not found.
+   */
+  async getAllClientAuthConfigs(authToken: string | null = null): Promise<ClientAuthConfig[] | null> {
+    try {
+      const response = await fetchHandler.get<ClientAuthConfig[]>('/clientAuthConfig', true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Create a new client auth configuration.
+   * @param {ClientAuthConfig} clientAuthConfig - The new client auth configuration to create.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async createClientAuthConfig(clientAuthConfig: ClientAuthConfig, authToken: string | null = null): Promise<void> {
+    return fetchHandler.post<ClientAuthConfig, void>('/clientAuthConfig', clientAuthConfig, true, authToken);
+  }
+
+  /**
+   * Update an existing client auth configuration by its ID.
+   * @param {string} id - The ID of the client auth configuration to update.
+   * @param {ClientAuthConfig} clientAuthConfig - The updated client auth configuration data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateClientAuthConfig(id: string, clientAuthConfig: ClientAuthConfig, authToken: string | null = null): Promise<void> {
+    return fetchHandler.put<ClientAuthConfig, void>(`/clientAuthConfig/${id}`, clientAuthConfig, true, authToken);
+  }
+
+  /**
+   * Delete a client auth configuration by its ID.
+   * @param {string} id - The ID of the client auth configuration to delete.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async deleteClientAuthConfig(id: string, authToken: string | null = null): Promise<void> {
+    return fetchHandler.delete<void>(`/clientAuthConfig/${id}`, true, authToken);
+  }
+}
+
+export default new ClientAuthConfigController();

package/controllers/eventsController.ts

@@ -0,0 +1,58 @@
+import FetchHandler from '../handlers/fetchHandler';
+import Event from '../types/event';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class EventsController {
+  /**
+   * Get all events for the authenticated user’s company.
+   * @returns {Promise<Event[]>} - A list of events.
+   */
+  async getEvents(authToken: string | null = null): Promise<Event[]> {
+    return fetchHandler.get<Event[]>('/events', true, authToken);
+  }
+
+  /**
+   * Get a specific event by ID.
+   * @param {string} id - The event ID.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<Event>} - The event data.
+   */
+  async getEvent(id: string, authToken: string | null = null): Promise<Event> {
+    return fetchHandler.get<Event>(`/events/${id}`, true, authToken);
+  }
+
+  /**
+   * Create a new event (only for SuperAdmin/Admin roles).
+   * @param {Event} Event - The event data to create.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<Event>} - The newly created event data.
+   */
+  async createEvent(Event: any, authToken: string | null = null): Promise<any> {
+    return fetchHandler.post<any, any>('/events', Event, true, authToken);
+  }
+
+  /**
+   * Update an existing event (only for SuperAdmin/Admin roles).
+   * @param {string} id - The event ID to update.
+   * @param {Event} Event - The updated event data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateEvent(id: string, Event: Event, authToken: string | null = null): Promise<void> {
+    return fetchHandler.put<Event, void>(`/events/${id}`, Event, true, authToken);
+  }
+
+  /**
+   * Delete an existing event (only for SuperAdmin/Admin roles).
+   * @param {string} id - The event ID to delete.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async deleteEvent(id: string, authToken: string | null = null): Promise<void> {
+    return fetchHandler.delete(`/events/${id}`, true, authToken);
+  }
+}
+
+export default new EventsController();

package/controllers/listingsController.ts

@@ -0,0 +1,41 @@
+import FetchHandler from '../handlers/fetchHandler';
+import { Listing } from '../types/listing';
+import { API_URL } from '../constants/config';
+import ListingsControllerType from '../types/controllers/listingsControllerType';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class ListingsController implements ListingsControllerType {
+  /**
+   * Get all listings with optional filters.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<Listing[]>} - A list of filtered listings.
+   */
+  async getListings(
+    authToken: string | null = null
+  ): Promise<Listing[]> {
+    try {
+      const response = await fetchHandler.get<Listing[]>('/listings', true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get the details of a specific listing.
+   * @param {number} listingId - The ID of the listing to retrieve.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<Listing | null>} - The listing details or null if not found.
+   */
+  async getListingDetails(listingId: number, authToken: string | null = null): Promise<Listing | null> {
+    try {
+      const response = await fetchHandler.get<Listing>(`/listings/${listingId}`, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export default new ListingsController();

package/controllers/mapConfigController.ts

@@ -0,0 +1,43 @@
+import FetchHandler from '../handlers/fetchHandler';
+import HireControlConfig from '../types/hireControlConfig';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class MapConfigController {
+  /**
+   * Get the map configuration for the current company.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<HireControlConfig | null>} - The map configuration or null if not found.
+   */
+  async getMapConfig(authToken: string | null = null): Promise<HireControlConfig | null> {
+    try {
+      const response = await fetchHandler.get<HireControlConfig>('/mapconfig', true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Update the map configuration for the current company.
+   * @param {HireControlConfig} hireControlConfig - The new map configuration data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateMapConfig(hireControlConfig: HireControlConfig, authToken: string | null = null): Promise<void> {
+    return fetchHandler.put<HireControlConfig, void>('/mapconfig', hireControlConfig, true, authToken);
+  }
+
+  /**
+   * Create a new map configuration for the current company.
+   * @param {HireControlConfig} hireControlConfig - The new map configuration to create.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async createMapConfig(hireControlConfig: HireControlConfig, authToken: string | null = null): Promise<void> {
+    return fetchHandler.post<HireControlConfig, void>('/mapconfig', hireControlConfig, true, authToken);
+  }
+}
+
+export default new MapConfigController();

package/controllers/permissionsController.ts

@@ -0,0 +1,17 @@
+import FetchHandler from '../handlers/fetchHandler';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class PermissionsController {
+  /**
+   * Get all available permissions.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<string[]>} - A list of available permissions.
+   */
+  async getAllPermissions(authToken: string | null = null): Promise<string[]> {
+    return fetchHandler.get<string[]>('/permissions', true, authToken);
+  }
+}
+
+export default new PermissionsController();

package/controllers/rolesController.ts

@@ -0,0 +1,49 @@
+import FetchHandler from '../handlers/fetchHandler';
+import RoleRequest from '../types/role';
+import { API_URL } from '../constants/config';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class RolesController {
+  /**
+   * Get all roles with claims for the authenticated user’s company.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<any[]>} - A list of roles with claims.
+   */
+  async getAllRolesWithClaims(authToken: string | null = null): Promise<any[]> {
+    return fetchHandler.get<any[]>('/roles', true, authToken);
+  }
+
+  /**
+   * Create a new role and optionally assign claims to it.
+   * @param {RoleRequest} roleRequest - The data to create the role.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async addRole(roleRequest: RoleRequest, authToken: string | null = null): Promise<void> {
+    return fetchHandler.post<RoleRequest, void>('/roles', roleRequest, true, authToken);
+  }
+
+  /**
+   * Update an existing role by ID.
+   * @param {string} roleId - The role ID.
+   * @param {RoleRequest} roleRequest - The updated role data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateRole(roleId: string, roleRequest: RoleRequest, authToken: string | null = null): Promise<void> {
+    return fetchHandler.put<RoleRequest, void>(`/roles/${roleId}`, roleRequest, true, authToken);
+  }
+
+  /**
+   * Delete an existing role by ID.
+   * @param {string} roleId - The role ID.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async deleteRole(roleId: string, authToken: string | null = null): Promise<void> {
+    return fetchHandler.delete<void>(`/roles/${roleId}`, true, authToken);
+  }
+}
+
+export default new RolesController();

package/controllers/usersController.ts

@@ -0,0 +1,98 @@
+import FetchHandler from '../handlers/fetchHandler';
+import User from '../types/user';
+import Register from '../types/register';
+import { API_URL } from '../constants/config';
+import  UsersControllerType  from '../types/controllers/usersControllerType';
+
+const fetchHandler = new FetchHandler(API_URL);
+
+class UsersController implements UsersControllerType {
+  /**
+   * Get all users in the system.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<User[]>} - The list of users with roles and permissions.
+   */
+  async getAllUsers(authToken: string | null = null): Promise<User[]> {
+    try {
+      const response = await fetchHandler.get<User[]>('/users', true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get a single user by ID.
+   * @param {string} id - The ID of the user to retrieve.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<User | null>} - The user data or null if not found.
+   */
+  async getUser(id: string, authToken: string | null = null): Promise<User | null> {
+    try {
+      const response = await fetchHandler.get<User>(`/users/${id}`, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Create a new user in the system.
+   * @param {Register} Register - The data for creating a new user.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<User | null>} - The created user data or null if creation fails.
+   */
+  async createUser(Register: Register, authToken: string | null = null): Promise<User | null> {
+    try {
+      const response = await fetchHandler.post<Register, User>('/users', Register, true, authToken);
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing user by ID.
+   * @param {string} id - The ID of the user to update.
+   * @param {Register} Register - The updated user data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateUser(id: string, Register: Register, authToken: string | null = null): Promise<void> {
+    try {
+      await fetchHandler.put<Register, void>(`/users/${id}`, Register, true, authToken);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+    /**
+   * Update a loggedIn user.
+   * @param {Register} Register - The updated user data.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async updateLoggedInUser(Register: Register, authToken: string | null = null): Promise<void> {
+    try {
+      await fetchHandler.put<Register, void>(`/users`, Register, true, authToken);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a user by ID.
+   * @param {string} id - The ID of the user to delete.
+   * @param {string | null} authToken - Optional auth token.
+   * @returns {Promise<void>} - No return value.
+   */
+  async deleteUser(id: string, authToken: string | null = null): Promise<void> {
+    try {
+      await fetchHandler.delete<void>(`/users/${id}`, true, authToken);
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export default new UsersController();

package/dist/constants/config.d.ts

@@ -0,0 +1 @@
+export declare const API_URL = "http://localhost:5108";

package/dist/controllers/accountsController.d.ts

@@ -0,0 +1,26 @@
+import ForgotPasswordRequest from '../types/account/forgotPasswordRequest';
+import ResetPasswordWithTokenRequest from '../types/account/resetPasswordWithTokenRequest';
+import ResetPasswordRequest from '../types/account/resetPasswordRequest';
+declare class AccountController {
+    /**
+     * Sends a password reset link to the user's email address.
+     * @param {ForgotPasswordRequest} model - The email of the user.
+     * @returns {Promise<void>} - No return value.
+     */
+    forgotPassword(model: ForgotPasswordRequest): Promise<void>;
+    /**
+     * Resets the password for a non-authenticated user using a token.
+     * @param {ResetPasswordWithTokenRequest} model - The email, token, and new password.
+     * @returns {Promise<void>} - No return value.
+     */
+    resetPasswordWithToken(model: ResetPasswordWithTokenRequest): Promise<void>;
+    /**
+     * Resets the password for an authenticated user.
+     * @param {ResetPasswordRequest} model - The current and new password.
+     * @param {string | null} authToken - The authorization token.
+     * @returns {Promise<void>} - No return value.
+     */
+    resetPassword(model: ResetPasswordRequest, authToken?: string | null): Promise<void>;
+}
+declare const _default: AccountController;
+export default _default;