Add GetResources and getAllResoureces

Author: miquelgall

README.md

@@ -28,12 +28,16 @@ In order to use this library you need to have access to an Oracle Field Service
 
 `getAllActivities()`: Get ALL existing activities
 
+`searchForActivities(params)` : Search a list of activities based on some input params
+
 `createActivity(activityData)`: Create activity
 
 `deleteActivity(activityId)`: Delete activity
 
 `updateActivity(activityId, activityData)`: Update activity details
 
+`bulkUpdateActivity(data)`: Update a list of activities
+
 `moveActivity(activityId, activityData)`: Move activity
 
 `delayActivity(activityId, activityData)`: Delay activity
@@ -76,6 +80,19 @@ In order to use this library you need to have access to an Oracle Field Service
 
 `getAllUsers()`: Get all users
 
+### Core: Resource Management
+
+`getResources(params?)`: Get existing resources with optional filtering parameters
+
+- `params.canBeTeamHolder` (boolean): Filter resources that can be team holders
+- `params.canParticipateInTeam` (boolean): Filter resources that can participate in teams  
+- `params.expand` (array): Include sub-entities like inventories, workZones, workSkills
+- `params.fields` (array): Specify which resource fields to return
+- `params.limit` (number): Number of items to return (1-100, default 100)
+- `params.offset` (number): Starting record number (default 0)
+
+`getAllResources(params?)`: Get all resources using pagination (excludes limit/offset from params)
+
 ### Core: Plugin Management
 
 `importPlugins(file?, data?)`: Import plugin by path or via an XML string

src/OFS.ts

@@ -17,6 +17,8 @@ import {
     OFSGetActivitiesParams,
     OFSSearchForActivitiesParams,
     OFSBulkUpdateRequest,
+    OFSGetResourcesParams,
+    OFSResourceResponse,
 } from "./model";
 
 export * from "./model";
@@ -604,6 +606,83 @@ export class OFS {
         return this._get(partialURL);
     }
 
+    // Core: Resource Management
+    async getResources(
+        params: OFSGetResourcesParams = {}
+    ): Promise<OFSResourceResponse> {
+        const partialURL = "/rest/ofscCore/v1/resources";
+        const queryParams: any = {};
+        
+        if (params.canBeTeamHolder !== undefined) {
+            queryParams.canBeTeamHolder = params.canBeTeamHolder;
+        }
+        if (params.canParticipateInTeam !== undefined) {
+            queryParams.canParticipateInTeam = params.canParticipateInTeam;
+        }
+        if (params.expand && params.expand.length > 0) {
+            queryParams.expand = params.expand.join(',');
+        }
+        if (params.fields && params.fields.length > 0) {
+            queryParams.fields = params.fields.join(',');
+        }
+        if (params.limit !== undefined) {
+            queryParams.limit = params.limit;
+        }
+        if (params.offset !== undefined) {
+            queryParams.offset = params.offset;
+        }
+
+        return this._get(partialURL, queryParams);
+    }
+
+    /**
+     * Retrieves all resources from the OFS API.
+     * @param params Optional parameters for filtering resources
+     * @returns An object containing all resources.
+     */
+    async getAllResources(params: Omit<OFSGetResourcesParams, 'limit' | 'offset'> = {}) {
+        const partialURL = "/rest/ofscCore/v1/resources";
+        var offset = 0;
+        var limit = 100;
+        var result: any = undefined;
+        var allResults: any = { totalResults: 0, items: [] };
+        
+        const queryParams: any = {};
+        if (params.canBeTeamHolder !== undefined) {
+            queryParams.canBeTeamHolder = params.canBeTeamHolder;
+        }
+        if (params.canParticipateInTeam !== undefined) {
+            queryParams.canParticipateInTeam = params.canParticipateInTeam;
+        }
+        if (params.expand && params.expand.length > 0) {
+            queryParams.expand = params.expand.join(',');
+        }
+        if (params.fields && params.fields.length > 0) {
+            queryParams.fields = params.fields.join(',');
+        }
+
+        do {
+            result = await this._get(partialURL, {
+                ...queryParams,
+                offset: offset,
+                limit: limit,
+            });
+            if (result.status < 400) {
+                if (allResults.totalResults == 0) {
+                    allResults = result.data;
+                } else {
+                    allResults.items = allResults.items.concat(
+                        result.data.items
+                    );
+                }
+                offset += limit;
+            } else {
+                return result;
+            }
+        } while (result.data.items.length == limit);
+        return allResults;
+    }
+
     // Core: Activities Management
     async getActivities(
         params: OFSGetActivitiesParams,

src/model.ts

@@ -246,3 +246,41 @@ export class OFSBulkUpdateRequestParams
         this.inventoryPropertiesUpdateMode = inventoryPropertiesUpdateMode;
     }
 }
+
+export interface OFSGetResourcesParams {
+    canBeTeamHolder?: boolean;
+    canParticipateInTeam?: boolean;
+    expand?: string[];
+    fields?: string[];
+    limit?: number;
+    offset?: number;
+}
+
+export interface OFSResource {
+    resourceId: string;
+    name: string;
+    status: string;
+    resourceType: string;
+    email?: string;
+    phone?: string;
+    language?: string;
+    timeZone?: string;
+}
+
+export interface OFSResourceListResponse {
+    totalResults: number;
+    limit: number;
+    offset: number;
+    items: OFSResource[];
+    links?: any;
+}
+
+export class OFSResourceResponse extends OFSResponse {
+    data: OFSResourceListResponse = {
+        totalResults: 0,
+        limit: 100,
+        offset: 0,
+        items: [],
+        links: undefined,
+    };
+}

test/general/base.test.ts

@@ -116,3 +116,66 @@ test("Get all Users", async () => {
     expect(result.items.length).toEqual(result.totalResults);
     expect(result.items[0].login).toBe("admin");
 });
+
+test("Get Resources No offset", async () => {
+    var result = await myProxy.getResources();
+    expect(result.status).toBe(200);
+    expect(result.data.totalResults).toBeGreaterThan(0);
+    expect(result.data.items.length).toBeGreaterThan(0);
+    expect(result.data.limit).toBe(100);
+    expect(result.data.offset).toBe(0);
+    expect(result.data.items[0]).toHaveProperty("resourceId");
+    expect(result.data.items[0]).toHaveProperty("name");
+    expect(result.data.items[0]).toHaveProperty("status");
+    expect(result.data.items[0]).toHaveProperty("resourceType");
+});
+
+test("Get Resources with limit", async () => {
+    var result = await myProxy.getResources({ limit: 5 });
+    expect(result.status).toBe(200);
+    expect(result.data.totalResults).toBeGreaterThan(0);
+    expect(result.data.items.length).toBeLessThanOrEqual(5);
+    expect(result.data.limit).toBe(5);
+    expect(result.data.offset).toBe(0);
+});
+
+test("Get Resources with offset and limit", async () => {
+    var result = await myProxy.getResources({ offset: 2, limit: 3 });
+    expect(result.status).toBe(200);
+    expect(result.data.totalResults).toBeGreaterThan(0);
+    expect(result.data.items.length).toBeLessThanOrEqual(3);
+    expect(result.data.limit).toBe(3);
+    expect(result.data.offset).toBe(2);
+});
+
+test("Get Resources with canBeTeamHolder filter", async () => {
+    var result = await myProxy.getResources({ canBeTeamHolder: true });
+    expect(result.status).toBe(200);
+    expect(result.data.totalResults).toBeGreaterThanOrEqual(0);
+    if (result.data.items.length > 0) {
+        expect(result.data.items[0]).toHaveProperty("resourceId");
+        expect(result.data.items[0]).toHaveProperty("name");
+    }
+});
+
+test("Get Resources with fields filter", async () => {
+    var result = await myProxy.getResources({ fields: ["resourceId", "name", "status"] });
+    expect(result.status).toBe(200);
+    expect(result.data.totalResults).toBeGreaterThan(0);
+    expect(result.data.items.length).toBeGreaterThan(0);
+    expect(result.data.items[0]).toHaveProperty("resourceId");
+    expect(result.data.items[0]).toHaveProperty("name");
+    expect(result.data.items[0]).toHaveProperty("status");
+});
+
+test("Get all Resources", async () => {
+    var result = await myProxy.getAllResources();
+    expect(result.totalResults).toBeGreaterThan(0);
+    expect(result.items.length).toEqual(result.totalResults);
+    if (result.items.length > 0) {
+        expect(result.items[0]).toHaveProperty("resourceId");
+        expect(result.items[0]).toHaveProperty("name");
+        expect(result.items[0]).toHaveProperty("status");
+        expect(result.items[0]).toHaveProperty("resourceType");
+    }
+});