ofsc-utility-browser 1.0.22 → 1.0.24

package/dist/activities/index.d.ts

@@ -12,7 +12,7 @@
  * @returns {Promise<any[]>} A promise which resolves to an array of activity objects.
  * @throws {Error} If the date format is invalid or if the resources parameter is missing.
  */
-export declare function getAllActivities(clientId: string, clientSecret: string, instanceUrl: string, resources: string, dateFrom: string, dateTo: string, q?: string, fields?: string, includeNonScheduled?: boolean): Promise<any[]>;
+export declare function getAllActivities(clientId: string, clientSecret: string, instanceUrl: string, resources: string, dateFrom: string, dateTo: string, q?: string, fields?: string, includeNonScheduled?: boolean, includeChildren?: "none" | "all" | "immediate"): Promise<any[]>;
 export declare function getActivitybyId(clientId: string, clientSecret: string, instanceUrl: string, activityId: number, token?: string): Promise<{
     token: string;
     data: any;

package/dist/activities/index.js

@@ -16,7 +16,7 @@ const isValidDate = (date) => /^\d{4}-\d{2}-\d{2}$/.test(date);
  * @returns {Promise<any[]>} A promise which resolves to an array of activity objects.
  * @throws {Error} If the date format is invalid or if the resources parameter is missing.
  */
-export async function getAllActivities(clientId, clientSecret, instanceUrl, resources, dateFrom, dateTo, q, fields, includeNonScheduled = false) {
+export async function getAllActivities(clientId, clientSecret, instanceUrl, resources, dateFrom, dateTo, q, fields, includeNonScheduled = false, includeChildren = "none") {
     // Validate date inputs
     if (!isValidDate(dateFrom) || !isValidDate(dateTo)) {
         throw new Error(`❌ Invalid date format. Expected YYYY-MM-DD.`);
@@ -34,6 +34,8 @@ export async function getAllActivities(clientId, clientSecret, instanceUrl, reso
         });
         if (q)
             params.append("q", q);
+        if (includeChildren)
+            params.append("includeChildren", includeChildren);
         if (resources)
             params.append("resources", resources);
         if (fields)

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 import * as Activity from "./activities";
 import * as DailyExtract from "./dailyExtract";
 import * as GPS from "./gps";
+import * as MetaData from "./metadata";
 import * as OauthTokenService from "./oauthTokenService";
 import * as Resources from "./resources";
 import * as Users from "./users";
 import * as Utilities from "./utilities";
-export { Activity, DailyExtract, GPS, OauthTokenService, Resources, Users, Utilities };
+export { Activity, DailyExtract, GPS, MetaData, OauthTokenService, Resources, Users, Utilities };
 export * from "./types";
 declare const _default: {
     Activity: typeof Activity;
@@ -16,5 +17,6 @@ declare const _default: {
     Users: typeof Users;
     DailyExtract: typeof DailyExtract;
     GPS: typeof GPS;
+    MetaData: typeof MetaData;
 };
 export default _default;

package/dist/index.js

@@ -1,13 +1,14 @@
 import * as Activity from "./activities";
 import * as DailyExtract from "./dailyExtract";
 import * as GPS from "./gps";
+import * as MetaData from "./metadata";
 import * as OauthTokenService from "./oauthTokenService";
 import * as Resources from "./resources";
 import * as Users from "./users";
 import * as Utilities from "./utilities";
 import { downloadCSV } from "./utilities";
 // Export grouped namespaces
-export { Activity, DailyExtract, GPS, OauthTokenService, Resources, Users, Utilities };
+export { Activity, DailyExtract, GPS, MetaData, OauthTokenService, Resources, Users, Utilities };
 // Export types
 export * from "./types";
 // Default export (for convenience)
@@ -19,5 +20,6 @@ export default {
     downloadCSV,
     Users,
     DailyExtract,
-    GPS
+    GPS,
+    MetaData
 };

package/dist/metadata/activityType.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Fetches all proeprties from the OFSC instance.
+ *
+ * @param {string} clientId - The OFSC client ID.
+ * @param {string} clientSecret - The OFSC client secret.
+ * @param {string} instanceUrl - The OFSC instance URL.
+ * @param {string} [initialToken] - The OAuth token to use. If not provided, a new token will be fetched.
+ *
+ * @returns {Promise<any[]>} A promise which resolves to an array of resource objects.
+ */
+export declare function ActivityType(clientId: string, clientSecret: string, instanceUrl: string, initialToken?: string): Promise<any[]>;
+type TimeSlot = {
+    label: string;
+};
+type Translation = {
+    language: string;
+    name: string;
+    languageISO: string;
+};
+type ActivityType = {
+    label: string;
+    name: string;
+    active: boolean;
+    groupLabel: string;
+    defaultDuration: number;
+    timeSlots?: TimeSlot[];
+    colors?: Record<string, string>;
+    features?: Record<string, boolean>;
+    translations?: Translation[];
+};
+type CompareError = {
+    label: string;
+    field?: string;
+    message: string;
+    env1Value?: any;
+    env2Value?: any;
+    env1Instance?: string;
+    env2Instance?: string;
+};
+export declare function deepCompareActivityTypes(env1: ActivityType[], env2: ActivityType[], e1Instance: string, e2Instance: string): CompareError[];
+export {};

package/dist/metadata/activityType.js

@@ -0,0 +1,227 @@
+import { fetchWithRetry } from "../utilities";
+/**
+ * Fetches all proeprties from the OFSC instance.
+ *
+ * @param {string} clientId - The OFSC client ID.
+ * @param {string} clientSecret - The OFSC client secret.
+ * @param {string} instanceUrl - The OFSC instance URL.
+ * @param {string} [initialToken] - The OAuth token to use. If not provided, a new token will be fetched.
+ *
+ * @returns {Promise<any[]>} A promise which resolves to an array of resource objects.
+ */
+export async function ActivityType(clientId, clientSecret, instanceUrl, initialToken = "") {
+    /**
+     * The number of API calls made so far.
+     * Used to determine if we should wait 10 seconds to avoid server rate limits.
+     */
+    let apiCallCount = 0;
+    /**
+     * The number of API calls after which we should wait 10 seconds.
+     */
+    const WAIT_AFTER_CALLS = 20;
+    /**
+     * The delay in milliseconds to wait after reaching the API call limit.
+     */
+    const DELAY_MS = 10000; // 10 seconds
+    /**
+     * Sleeps for the given amount of milliseconds.
+     *
+     * @param {number} ms - The amount of milliseconds to sleep.
+     * @returns {Promise<void>} A promise which resolves when the sleep is over.
+     */
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    /**
+     * Fetches resources from the OFSC instance.
+     *
+     * @param {number} offset - The offset from which to fetch resources.
+     * @param {string} token - The OAuth token to use.
+     * @returns {Promise<Response[]>} A promise which resolves to an array of resource responses.
+     */
+    const ActivityType = async (offset, token) => {
+        apiCallCount++;
+        // Wait 10 seconds after 20 API calls to avoid server rate limits.
+        if (apiCallCount % WAIT_AFTER_CALLS === 0) {
+            console.warn(` Waiting 10 seconds after ${apiCallCount} API calls to avoid server rate limits.`);
+            await sleep(DELAY_MS);
+        }
+        const url = `https://${instanceUrl}.fs.ocs.oraclecloud.com/rest/ofscMetadata/v1/activityTypes?offset=${offset}&limit=100`;
+        const res = await fetchWithRetry(url, clientId, clientSecret, instanceUrl, token);
+        const { items, totalResults } = res.data;
+        const totalFetched = items.length;
+        console.log(`Received ${totalFetched} items (Total: ${offset + totalFetched})`);
+        if (offset + totalFetched >= totalResults) {
+            return items;
+        }
+        const nextItems = await ActivityType(offset + totalFetched, res.token);
+        return [...items, ...nextItems];
+    };
+    return ActivityType(0, initialToken);
+}
+export function deepCompareActivityTypes(env1, env2, e1Instance, e2Instance) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const errors = [];
+    const env2Map = new Map(env2.map(e => [e.label, e]));
+    const env1Map = new Map(env1.map(e => [e.label, e]));
+    for (const a1 of env1) {
+        const a2 = env2Map.get(a1.label);
+        if (!a2) {
+            errors.push({
+                label: a1.label,
+                message: "Missing in env2",
+                env1Value: a1,
+                env1Instance: e1Instance,
+                env2Instance: e2Instance
+            });
+            continue;
+        }
+        // ---- primitive fields ----
+        const fields = [
+            "name",
+            "active",
+            "groupLabel",
+            "defaultDuration"
+        ];
+        for (const field of fields) {
+            if (a1[field] !== a2[field]) {
+                errors.push({
+                    label: a1.label,
+                    field: String(field),
+                    message: `${field} mismatch`,
+                    env1Value: a1[field],
+                    env2Value: a2[field],
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        // ---- timeSlots ----
+        const ts1 = (_a = a1.timeSlots) !== null && _a !== void 0 ? _a : [];
+        const ts2 = (_b = a2.timeSlots) !== null && _b !== void 0 ? _b : [];
+        const ts2Set = new Set(ts2.map(t => t.label));
+        const ts1Set = new Set(ts1.map(t => t.label));
+        for (const t of ts1) {
+            if (!ts2Set.has(t.label)) {
+                errors.push({
+                    label: a1.label,
+                    field: "timeSlots",
+                    message: `Missing timeslot in env2 (${t.label})`,
+                    env1Value: t.label,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        for (const t of ts2) {
+            if (!ts1Set.has(t.label)) {
+                errors.push({
+                    label: a1.label,
+                    field: "timeSlots",
+                    message: `Missing timeslot in env1 (${t.label})`,
+                    env2Value: t.label,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        // ---- colors ----
+        const c1 = (_c = a1.colors) !== null && _c !== void 0 ? _c : {};
+        const c2 = (_d = a2.colors) !== null && _d !== void 0 ? _d : {};
+        const allColorKeys = new Set([...Object.keys(c1), ...Object.keys(c2)]);
+        for (const key of allColorKeys) {
+            if (c1[key] !== c2[key]) {
+                errors.push({
+                    label: a1.label,
+                    field: `colors.${key}`,
+                    message: "Color mismatch",
+                    env1Value: c1[key],
+                    env2Value: c2[key],
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        // ---- features ----
+        const f1 = (_e = a1.features) !== null && _e !== void 0 ? _e : {};
+        const f2 = (_f = a2.features) !== null && _f !== void 0 ? _f : {};
+        const allFeatureKeys = new Set([...Object.keys(f1), ...Object.keys(f2)]);
+        for (const key of allFeatureKeys) {
+            if (f1[key] !== f2[key]) {
+                errors.push({
+                    label: a1.label,
+                    field: `features.${key}`,
+                    message: "Feature mismatch",
+                    env1Value: f1[key],
+                    env2Value: f2[key],
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        // ---- translations ----
+        const t1 = (_g = a1.translations) !== null && _g !== void 0 ? _g : [];
+        const t2 = (_h = a2.translations) !== null && _h !== void 0 ? _h : [];
+        const t2Map = new Map(t2.map(t => [t.languageISO, t]));
+        const t1Set = new Set(t1.map(t => t.languageISO));
+        for (const tr1 of t1) {
+            const tr2 = t2Map.get(tr1.languageISO);
+            if (!tr2) {
+                errors.push({
+                    label: a1.label,
+                    field: "translations",
+                    message: `Missing translation in env2 (${tr1.languageISO})`,
+                    env1Value: tr1,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+                continue;
+            }
+            if (tr1.name !== tr2.name) {
+                errors.push({
+                    label: a1.label,
+                    field: `translations.name[${tr1.languageISO}]`,
+                    message: "Translation name mismatch",
+                    env1Value: tr1.name,
+                    env2Value: tr2.name,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+            if (tr1.language !== tr2.language) {
+                errors.push({
+                    label: a1.label,
+                    field: `translations.language[${tr1.languageISO}]`,
+                    message: "Translation language mismatch",
+                    env1Value: tr1.language,
+                    env2Value: tr2.language,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        for (const tr2 of t2) {
+            if (!t1Set.has(tr2.languageISO)) {
+                errors.push({
+                    label: a1.label,
+                    field: "translations",
+                    message: `Missing translation in env1 (${tr2.languageISO})`,
+                    env2Value: tr2,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+    }
+    // ---- missing in env1 ----
+    for (const a2 of env2) {
+        if (!env1Map.has(a2.label)) {
+            errors.push({
+                label: a2.label,
+                message: "Missing in env1",
+                env2Value: a2,
+                env1Instance: e1Instance,
+                env2Instance: e2Instance
+            });
+        }
+    }
+    return errors;
+}

package/dist/metadata/activityTypeGroup.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fetches all proeprties from the OFSC instance.
+ *
+ * @param {string} clientId - The OFSC client ID.
+ * @param {string} clientSecret - The OFSC client secret.
+ * @param {string} instanceUrl - The OFSC instance URL.
+ * @param {string} [initialToken] - The OAuth token to use. If not provided, a new token will be fetched.
+ *
+ * @returns {Promise<any[]>} A promise which resolves to an array of resource objects.
+ */
+export declare function ActivityTypeGroups(clientId: string, clientSecret: string, instanceUrl: string, initialToken?: string): Promise<any[]>;
+type ActivityType = {
+    label: string;
+};
+type Translation = {
+    language: string;
+    name: string;
+    languageISO: string;
+};
+type ActivityGroup = {
+    label: string;
+    name: string;
+    activityTypes?: ActivityType[];
+    translations?: Translation[];
+    links?: any[];
+};
+type CompareError = {
+    label: string;
+    field?: string;
+    message: string;
+    env1Value?: any;
+    env2Value?: any;
+    env1Instance?: string;
+    env2Instance?: string;
+};
+export declare function deepCompareActivityGroups(env1: ActivityGroup[], env2: ActivityGroup[], e1Instance: string, e2Instance: string): CompareError[];
+export {};

package/dist/metadata/activityTypeGroup.js

@@ -0,0 +1,186 @@
+import { fetchWithRetry } from "../utilities";
+/**
+ * Fetches all proeprties from the OFSC instance.
+ *
+ * @param {string} clientId - The OFSC client ID.
+ * @param {string} clientSecret - The OFSC client secret.
+ * @param {string} instanceUrl - The OFSC instance URL.
+ * @param {string} [initialToken] - The OAuth token to use. If not provided, a new token will be fetched.
+ *
+ * @returns {Promise<any[]>} A promise which resolves to an array of resource objects.
+ */
+export async function ActivityTypeGroups(clientId, clientSecret, instanceUrl, initialToken = "") {
+    /**
+     * The number of API calls made so far.
+     * Used to determine if we should wait 10 seconds to avoid server rate limits.
+     */
+    let apiCallCount = 0;
+    /**
+     * The number of API calls after which we should wait 10 seconds.
+     */
+    const WAIT_AFTER_CALLS = 20;
+    /**
+     * The delay in milliseconds to wait after reaching the API call limit.
+     */
+    const DELAY_MS = 10000; // 10 seconds
+    /**
+     * Sleeps for the given amount of milliseconds.
+     *
+     * @param {number} ms - The amount of milliseconds to sleep.
+     * @returns {Promise<void>} A promise which resolves when the sleep is over.
+     */
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    /**
+     * Fetches resources from the OFSC instance.
+     *
+     * @param {number} offset - The offset from which to fetch resources.
+     * @param {string} token - The OAuth token to use.
+     * @returns {Promise<Response[]>} A promise which resolves to an array of resource responses.
+     */
+    const ActivityTypeGroups = async (offset, token) => {
+        apiCallCount++;
+        // Wait 10 seconds after 20 API calls to avoid server rate limits.
+        if (apiCallCount % WAIT_AFTER_CALLS === 0) {
+            console.warn(` Waiting 10 seconds after ${apiCallCount} API calls to avoid server rate limits.`);
+            await sleep(DELAY_MS);
+        }
+        const url = `https://${instanceUrl}.fs.ocs.oraclecloud.com/rest/ofscMetadata/v1/activityTypeGroups?offset=${offset}&limit=100`;
+        const res = await fetchWithRetry(url, clientId, clientSecret, instanceUrl, token);
+        const { items, totalResults } = res.data;
+        const totalFetched = items.length;
+        console.log(`Received ${totalFetched} items (Total: ${offset + totalFetched})`);
+        if (offset + totalFetched >= totalResults) {
+            return items;
+        }
+        const nextItems = await ActivityTypeGroups(offset + totalFetched, res.token);
+        return [...items, ...nextItems];
+    };
+    return ActivityTypeGroups(0, initialToken);
+}
+export function deepCompareActivityGroups(env1, env2, e1Instance, e2Instance) {
+    var _a, _b, _c, _d;
+    const errors = [];
+    const env2Map = new Map(env2.map(e => [e.label, e]));
+    const env1Map = new Map(env1.map(e => [e.label, e]));
+    // --- Compare env1 against env2 ---
+    for (const g1 of env1) {
+        const g2 = env2Map.get(g1.label);
+        if (!g2) {
+            errors.push({
+                label: g1.label,
+                message: "Missing in env2",
+                env1Value: g1,
+                env1Instance: e1Instance,
+                env2Instance: e2Instance
+            });
+            continue;
+        }
+        // ---- name ----
+        if (g1.name !== g2.name) {
+            errors.push({
+                label: g1.label,
+                field: "name",
+                message: "Name mismatch",
+                env1Value: g1.name,
+                env2Value: g2.name,
+                env1Instance: e1Instance,
+                env2Instance: e2Instance
+            });
+        }
+        // ---- activityTypes ----
+        const a1 = (_a = g1.activityTypes) !== null && _a !== void 0 ? _a : [];
+        const a2 = (_b = g2.activityTypes) !== null && _b !== void 0 ? _b : [];
+        const a2Map = new Map(a2.map(a => [a.label, a]));
+        const a1Set = new Set(a1.map(a => a.label));
+        for (const at1 of a1) {
+            if (!a2Map.has(at1.label)) {
+                errors.push({
+                    label: g1.label,
+                    field: "activityTypes",
+                    message: `ActivityType missing in env2 (${at1.label})`,
+                    env1Value: at1.label,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        for (const at2 of a2) {
+            if (!a1Set.has(at2.label)) {
+                errors.push({
+                    label: g1.label,
+                    field: "activityTypes",
+                    message: `ActivityType missing in env1 (${at2.label})`,
+                    env2Value: at2.label,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        // ---- translations ----
+        const t1 = (_c = g1.translations) !== null && _c !== void 0 ? _c : [];
+        const t2 = (_d = g2.translations) !== null && _d !== void 0 ? _d : [];
+        const t2Map = new Map(t2.map(t => [t.languageISO, t]));
+        const t1Set = new Set(t1.map(t => t.languageISO));
+        for (const tr1 of t1) {
+            const tr2 = t2Map.get(tr1.languageISO);
+            if (!tr2) {
+                errors.push({
+                    label: g1.label,
+                    field: "translations",
+                    message: `Translation missing in env2 (${tr1.languageISO})`,
+                    env1Value: tr1,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+                continue;
+            }
+            if (tr1.name !== tr2.name) {
+                errors.push({
+                    label: g1.label,
+                    field: `translation.name[${tr1.languageISO}]`,
+                    message: "Translation name mismatch",
+                    env1Value: tr1.name,
+                    env2Value: tr2.name,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+            if (tr1.language !== tr2.language) {
+                errors.push({
+                    label: g1.label,
+                    field: `translation.language[${tr1.languageISO}]`,
+                    message: "Translation language mismatch",
+                    env1Value: tr1.language,
+                    env2Value: tr2.language,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+        for (const tr2 of t2) {
+            if (!t1Set.has(tr2.languageISO)) {
+                errors.push({
+                    label: g1.label,
+                    field: "translations",
+                    message: `Translation missing in env1 (${tr2.languageISO})`,
+                    env2Value: tr2,
+                    env1Instance: e1Instance,
+                    env2Instance: e2Instance
+                });
+            }
+        }
+    }
+    // --- Missing in env1 ---
+    for (const g2 of env2) {
+        if (!env1Map.has(g2.label)) {
+            errors.push({
+                label: g2.label,
+                message: "Missing in env1",
+                env2Value: g2,
+                env1Instance: e1Instance,
+                env2Instance: e2Instance
+            });
+        }
+    }
+    return errors;
+}

package/dist/metadata/index.d.ts

@@ -0,0 +1,37 @@
+export * from "./activityType";
+export * from "./activityTypeGroup";
+export * from "./resourceTypes";
+/**
+ * Fetches all proeprties from the OFSC instance.
+ *
+ * @param {string} clientId - The OFSC client ID.
+ * @param {string} clientSecret - The OFSC client secret.
+ * @param {string} instanceUrl - The OFSC instance URL.
+ * @param {string} [initialToken] - The OAuth token to use. If not provided, a new token will be fetched.
+ *
+ * @returns {Promise<any[]>} A promise which resolves to an array of resource objects.
+ */
+export declare function AllProperties(clientId: string, clientSecret: string, instanceUrl: string, initialToken?: string): Promise<any[]>;
+type Translation = {
+    language: string;
+    name: string;
+    languageISO: string;
+};
+type FieldDefinition = {
+    label: string;
+    name: string;
+    type: string;
+    entity: string;
+    gui: string;
+    translations: Translation[];
+};
+type CompareError = {
+    label: string;
+    field?: string;
+    message: string;
+    env1Value?: any;
+    env2Value?: any;
+    env1Instance?: string;
+    env2Instance?: string;
+};
+export declare function compareProperties(propEnv1: FieldDefinition[], propEnv2: FieldDefinition[], e1Instance: string, e2Instance: string): Promise<CompareError[]>;