lamp-core-lst 2025.11.1-3.basic

package/src/service/Fetch.ts

@@ -0,0 +1,187 @@
+import { jwtVerify } from "jose"
+import { CredentialService } from "./Credential.service"
+import LAMP from ".."
+/**
+ *
+ */
+export type Configuration = {
+  /**
+   *
+   */
+  base: string
+
+  /**
+   *
+   */
+  authorization?: string
+
+  /**
+   *
+   */
+  headers?: { [header: string]: string }
+
+  token?: string
+  accessToken?: string
+  refreshToken?: string
+
+  jwt_secret?: string
+}
+
+const userTokenKey = "tokenInfo"
+
+//If refresh token expired, then logout from app
+const handleSessionExpiry = async () => {
+  localStorage.removeItem(userTokenKey)
+  localStorage.setItem("verified", JSON.stringify({ value: false }))
+  sessionStorage.setItem("LAMP._auth", JSON.stringify({ id: null, password: null, serverAddress: null }))
+  // alert("Your session expired, Please login again.")
+  // window.location.href = "/#/?expired=true"
+}
+
+//If access Token expired then call api for renewing the tokens
+const handleRenewToken = async (refreshToken: string, base: string) => {
+  try {
+    const credService = new CredentialService()
+    const res = await credService.renewToken(refreshToken, base)
+
+    const accessToken = res?.data?.access_token
+
+    if (accessToken) {
+      sessionStorage.setItem(
+        userTokenKey,
+        JSON.stringify({ accessToken: res?.data?.access_token, refreshToken: res?.data?.refresh_token })
+      )
+    }
+    return accessToken
+  } catch (error) {
+    console.log(error)
+  }
+}
+
+async function _fetch<ResultType>(
+  method: string,
+  route: string,
+  configuration?: Configuration,
+  body?: any
+): Promise<ResultType> {
+  if (!configuration) throw new Error("Cannot make HTTP request due to invalid configuration.")
+  let authorization
+
+  const userTokenFromLocalStore: any = JSON.parse(sessionStorage.getItem("tokenInfo"))
+  if (userTokenFromLocalStore?.accessToken) {
+    authorization = `Bearer ${
+      configuration.accessToken ? configuration.accessToken : userTokenFromLocalStore?.accessToken
+    }`
+  }
+
+  try {
+    var response = await fetch(`${configuration.base}${route}`, {
+      method: method,
+      headers: new Headers(
+        typeof authorization !== "undefined" && !!authorization
+          ? {
+              "Content-Type": "application/json",
+              Accept: "application/json",
+              ...(configuration!.headers || {}),
+              Authorization: authorization,
+            }
+          : ({
+              "Content-Type": "application/json",
+              Accept: "application/json",
+              ...(configuration!.headers || {}),
+            } as any)
+      ),
+      credentials: "include",
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    })
+    if (!response.ok) {
+      console.warn(`HTTP error ${response.status}`)
+    }
+
+    const result = await response.json().catch(() => {
+      throw new Error("Invalid JSON response")
+    })
+
+    // Handle invalid token
+    if (result?.error === "401.invalid-token" || result?.message === "401.invalid-token") {
+      if (!route.includes("renewToken")) {
+        try {
+          const refreshToken = configuration.refreshToken ?? userTokenFromLocalStore?.refreshToken
+          if (!refreshToken) {
+            handleSessionExpiry()
+            return { data: [], error: "401.invalid-token" } as unknown as ResultType
+          }
+          const token = await handleRenewToken(refreshToken, configuration.base)
+          if (token) {
+            configuration.authorization = token
+            // retry the same request
+            switch (method) {
+              case "post":
+                return await Fetch.post(route, body, configuration)
+                break
+              case "get":
+                return await Fetch.get(route, configuration)
+                break
+              case "put":
+                return await Fetch.put(route, body, configuration)
+                break
+              case "delete":
+                return await Fetch.delete(route, configuration)
+                break
+              case "patch":
+                return await Fetch.patch(route, body, configuration)
+                break
+            }
+          } else {
+            handleSessionExpiry()
+            return { data: [], error: "401.invalid-token" } as any
+          }
+        } catch (tokenError) {
+          console.error("Token renewal failed:", tokenError)
+          handleSessionExpiry()
+          return { data: [], error: "401.invalid-token" } as unknown as ResultType
+        }
+      } else {
+        handleSessionExpiry()
+        return { data: [], error: "401.invalid-token" } as unknown as ResultType
+      }
+    }
+    return result
+  } catch (error) {
+    const message = (error as any)?.message || String(error)
+    console.error("Fetch failed:", message)
+    return { data: [], error: message || "Unknown error" } as unknown as ResultType
+  }
+}
+
+export class Fetch {
+  public static async get<ResultType>(route: string, configuration?: Configuration): Promise<ResultType> {
+    return await _fetch("get", route, configuration)
+  }
+  public static async post<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType> {
+    return await _fetch("post", route, configuration, body)
+  }
+  public static async put<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType> {
+    return await _fetch("put", route, configuration, body)
+  }
+  public static async patch<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType> {
+    return await _fetch("patch", route, configuration, body)
+  }
+  public static async delete<ResultType>(
+    route: string,
+    configuration?: Configuration,
+    body?: any
+  ): Promise<ResultType> {
+    return await _fetch("delete", route, configuration, body)
+  }
+}
+
+// export async function verifyToken(token: string, secretKey: string) {
+//   try {
+//     const secret_Key = new TextEncoder().encode(this.configuration.jwt_secret);
+//     const decoded = jwtVerify(token, secret_Key);
+//     return decoded;
+//   } catch (error) {
+//     throw new Error('Invalid token');
+//   }
+// }

package/src/service/Participant.service.ts

@@ -0,0 +1,217 @@
+import { Fetch, Configuration } from "./Fetch"
+import { Identifier } from "../model/Type"
+import { Participant } from "../model/Participant"
+import { Demo } from "./Demo"
+import jsonata from "jsonata"
+
+export class ParticipantService {
+  public configuration?: Configuration
+
+  /**
+   * Get the set of all participants.
+   */
+  public async all(transform?: string): Promise<Participant[]> {
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+
+      let output = Demo.Participant?.map(x => Object.assign(new Participant(), x))
+      output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+      return Promise.resolve(output)
+    }
+    return (await Fetch.get<{ data: any[] }>(`/participant`, this.configuration)).data?.map(x =>
+      Object.assign(new Participant(), x)
+    )
+  }
+
+  /**
+   * Get the set of all participants under a single researcher.
+   * @param researcherId
+   */
+  public async allByResearcher(researcherId: Identifier, transform?: string): Promise<Participant[]> {
+    if (researcherId === null || researcherId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling participantAllByResearcher.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (researcherId === "me") researcherId = credential.length > 0 ? credential[0]["origin"] : researcherId
+
+      if (Demo.Researcher.filter(x => x["id"] === researcherId).length > 0) {
+        let output = Demo.Participant.filter(x =>
+          Demo.Study.filter(y => y["#parent"] === researcherId)
+            ?.map(y => y["id"])
+            .includes(x["#parent"])
+        )?.map(x => Object.assign(new Participant(), x))
+        output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+        return Promise.resolve(output)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return (
+      await Fetch.get<{ data: any[] }>(`/researcher/${researcherId}/participant`, this.configuration)
+    ).data?.map(x => Object.assign(new Participant(), x))
+  }
+
+  /**
+   * Get the set of all participants in a single study.
+   * @param studyId
+   */
+  public async allByStudy(studyId: Identifier, transform?: string): Promise<Participant[]> {
+    if (studyId === null || studyId === undefined)
+      throw new Error("Required parameter studyId was null or undefined when calling participantAllByStudy.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (studyId === "me") studyId = credential.length > 0 ? credential[0]["origin"] : studyId
+
+      if (Demo.Study.filter(x => x["id"] === studyId).length > 0) {
+        let output = Demo.Participant.filter(x => x["#parent"] === studyId)?.map(x =>
+          Object.assign(new Participant(), x)
+        )
+        output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+        return Promise.resolve(output)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return (await Fetch.get<{ data: any[] }>(`/study/${studyId}/participant`, this.configuration)).data?.map(x =>
+      Object.assign(new Participant(), x)
+    )
+  }
+
+  /**
+   * Create a new Participant for the given Study.
+   * @param studyId
+   * @param participant
+   */
+  public async create(studyId: Identifier, participant: Participant): Promise<Identifier> {
+    if (studyId === null || studyId === undefined)
+      throw new Error("Required parameter studyId was null or undefined when calling participantCreate.")
+    if (participant === null || participant === undefined)
+      throw new Error("Required parameter participant was null or undefined when calling participantCreate.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (studyId === "me") studyId = credential.length > 0 ? credential[0]["origin"] : studyId
+
+      if (Demo.Study.filter(x => x["id"] === studyId).length > 0) {
+        let data = {
+          "#type": "Participant",
+          "#parent": studyId,
+          id:
+            "U" +
+            Math.random()
+              .toString()
+              .substring(2, 11),
+          language: "en",
+          theme: "#359FFE",
+          emergency_contact: null,
+          helpline: null
+        }
+        Demo.Participant.push(data)
+        return Promise.resolve({ data: data["id"] } as any)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return await Fetch.post(`/study/${studyId}/participant`, participant, this.configuration)
+  }
+
+  /**
+   * Delete a participant AND all owned data or event streams.
+   * @param participantId
+   */
+  public async delete(participantId: Identifier): Promise<Identifier> {
+    if (participantId === null || participantId === undefined)
+      throw new Error("Required parameter participantId was null or undefined when calling participantDelete.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (participantId === "me") participantId = credential.length > 0 ? credential[0]["origin"] : participantId
+
+      let idx = Demo.Participant.findIndex(x => x["id"] === participantId)
+      if (idx >= 0) {
+        Demo.Participant.splice(idx, 1)
+        Demo.ActivityEvent = Demo.ActivityEvent.filter(x => x["#parent"] !== participantId)
+        Demo.SensorEvent = Demo.SensorEvent.filter(x => x["#parent"] !== participantId)
+        Demo.Credential = Demo.Credential.filter(x => x["#parent"] !== participantId)
+        Demo.Tags = Demo.Tags.filter(x => x["#parent"] !== participantId && x["target"] !== participantId)
+        return Promise.resolve({} as any)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return await Fetch.delete(`/participant/${participantId}`, this.configuration)
+  }
+
+  /**
+   * Update a Participant's settings.
+   * @param participantId
+   * @param participant
+   */
+  public async update(participantId: Identifier, participant: Participant): Promise<Identifier> {
+    if (participantId === null || participantId === undefined)
+      throw new Error("Required parameter participantId was null or undefined when calling participantUpdate.")
+    if (participant === null || participant === undefined)
+      throw new Error("Required parameter participant was null or undefined when calling participantUpdate.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (participantId === "me") participantId = credential.length > 0 ? credential[0]["origin"] : participantId
+
+      if (Demo.Participant.filter(x => x["id"] === participantId).length > 0) {
+        return Promise.resolve({ error: "500.demo-restriction" } as any)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return await Fetch.put(`/participant/${participantId}`, participant, this.configuration)
+  }
+
+  /**
+   * Get a single participant, by identifier.
+   * @param participantId
+   */
+  public async view(participantId: Identifier, transform?: string): Promise<Participant> {
+    if (participantId === null || participantId === undefined)
+      throw new Error("Required parameter participantId was null or undefined when calling participantView.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter(x => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (participantId === "me") participantId = credential.length > 0 ? credential[0]["origin"] : participantId
+
+      let data = Demo.Participant.filter(x => x["id"] === participantId)?.map(x => Object.assign(new Participant(), x))
+      if (data.length > 0) {
+        let output = data[0]
+        output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+        return Promise.resolve(output)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return (await Fetch.get<{ data: any[] }>(`/participant/${participantId}`, this.configuration)).data?.map(x =>
+      Object.assign(new Participant(), x)
+    )[0]
+  }
+}

package/src/service/Researcher.service.ts

@@ -0,0 +1,147 @@
+import { Fetch, Configuration } from "./Fetch"
+import { Identifier } from "../model/Type"
+import { Researcher } from "../model/Researcher"
+import { Demo } from "./Demo"
+import jsonata from "jsonata"
+
+export class ResearcherService {
+  public configuration?: Configuration
+
+  /**
+   * Get the set of all researchers.
+   */
+  public async all(transform?: string): Promise<Researcher[]> {
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter((x) => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+
+      let output = Demo.Researcher?.map((x) => Object.assign(new Researcher(), x))
+      output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+      return Promise.resolve(output)
+    }
+    return (await Fetch.get<{ data: any[] }>(`/researcher`, this.configuration))?.data?.map((x) =>
+      Object.assign(new Researcher(), x)
+    )
+  }
+
+  /**
+   * Create a new Researcher.
+   * @param researcher
+   */
+  public async create(researcher: Researcher): Promise<Identifier> {
+    if (researcher === null || researcher === undefined)
+      throw new Error("Required parameter researcher was null or undefined when calling researcherCreate.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    return await Fetch.post(`/researcher`, researcher, this.configuration)
+  }
+
+  /**
+   * Delete a researcher.
+   * @param researcherId
+   */
+  public async delete(researcherId: Identifier): Promise<Identifier> {
+    if (researcherId === null || researcherId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling researcherDelete.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    return await Fetch.delete(`/researcher/${researcherId}`, this.configuration)
+  }
+
+  /**
+   * Update a Researcher's settings.
+   * @param researcherId
+   * @param body
+   */
+  public async update(researcherId: Identifier, researcher: Researcher): Promise<Identifier> {
+    if (researcherId === null || researcherId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling researcherUpdate.")
+    if (researcher === null || researcher === undefined)
+      throw new Error("Required parameter researcher was null or undefined when calling researcherUpdate.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    return await Fetch.put(`/researcher/${researcherId}`, researcher, this.configuration)
+  }
+
+  /**
+   * Get a single researcher, by identifier.
+   * @param researcherId
+   */
+  public async view(researcherId: Identifier, transform?: string): Promise<Researcher> {
+    if (researcherId === null || researcherId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling researcherView.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter((x) => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+      if (researcherId === "me") researcherId = credential.length > 0 ? credential[0]["origin"] : researcherId
+
+      let data = Demo.Researcher.filter((x) => x["id"] === researcherId)?.map((x) => Object.assign(new Researcher(), x))
+
+      if (data.length > 0) {
+        let output = data[0]
+        output = typeof transform === "string" ? jsonata(transform).evaluate(output) : output
+        return Promise.resolve(output)
+      } else {
+        return Promise.resolve({ error: "404.not-found" } as any)
+      }
+    }
+    return (await Fetch.get<{ data: any[] }>(`/researcher/${researcherId}`, this.configuration))?.data?.map((x) =>
+      Object.assign(new Researcher(), x)
+    )[0]
+  }
+
+  public async usersList(id: string, filters: any): Promise<any> {
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter((x) => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+
+      let output = Demo.Researcher?.map((x) => Object.assign(new Researcher(), x))
+      return Promise.resolve(output)
+    }
+    const result = await Fetch.post(`/researcher/${id}/users`, filters, this.configuration) as any
+    return result?.data
+  }
+
+  public async activitiesList(id: string, filters: any): Promise<any> {
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter((x) => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+
+      let output = Demo.Researcher?.map((x) => Object.assign(new Researcher(), x))
+      return Promise.resolve(output)
+    }
+    const result = await Fetch.post(`/researcher/activities/${id}`, filters, this.configuration) as any
+    return result?.data
+  }
+  public async sensorsList(id: string, filters: any): Promise<any> {
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      let auth = (this.configuration.authorization || ":").split(":")
+      let credential = Demo.Credential.filter((x) => x["access_key"] === auth[0] && x["secret_key"] === auth[1])
+      if (credential.length === 0) return Promise.resolve({ error: "403.invalid-credentials" } as any)
+
+      let output = Demo.Researcher?.map((x) => Object.assign(new Researcher(), x))
+      return Promise.resolve(output)
+    }
+    const result = await Fetch.post(`/researcher/sensors/${id}`, filters, this.configuration) as any
+    return result?.data
+  }
+}

package/src/service/ResearcherSettings.service.ts

@@ -0,0 +1,62 @@
+import { Fetch, Configuration } from "./Fetch"
+import { Identifier } from "../model/Type"
+import { ResearcherBanner, ResearcherSettings } from "../model/ResearcherSettings"
+
+export class ResearcherSettingsService {
+  public configuration?: Configuration
+
+  /**
+   * Create Researcher Settings.
+   * @param researcherId
+   */
+  public async createResearcherSettings(
+    researcherId: Identifier,
+    researcherData: any,
+    choice?: any
+  ): Promise<Identifier> {
+    if (researcherId === null || researcherId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling researcherSettingsCreate.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    const res: any = await Fetch.post(
+      `/researcherSettings/${researcherId}?choice=${choice}`,
+      researcherData,
+      this.configuration
+    )
+    return res
+  }
+
+  /**
+   * Get Researcher Settings.
+   * @param researcherId
+   */
+  public async getResearcherSettings(type: string, id: Identifier): Promise<any> {
+    if (id === null || id === undefined)
+      throw new Error("Required parameter id was null or undefined when calling researcherSettingsGet.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    const result = (await Fetch.get(`/researcherSettings/${type}/${id}`, this.configuration)) as ResearcherBanner
+    return result.data
+  }
+
+  public async getResearcherSettingsforParticipant(participantId: Identifier): Promise<any> {
+    if (participantId === null || participantId === undefined)
+      throw new Error("Required parameter researcherId was null or undefined when calling researcherSettingsGet.")
+
+    if (this.configuration.base === "https://demo.lamp.digital") {
+      // DEMO
+      return Promise.resolve({ error: "500.demo-restriction" } as any)
+    }
+    const result = (await Fetch.get(
+      `/participant/researcherSettings/${participantId}`,
+      this.configuration
+    )) as ResearcherBanner
+    return result.data
+  }
+}