TPEN28 Fix (#300)

* TPEN28 Fix

* Update import28Router.js

* service fix

* function this

* protocol

* Update ProjectFactory.js

* protocol

* co-op fixing

* change variables around page vs canvas

* GET not POST

---------

Co-authored-by: Bryan Haberberger <bryan.j.haberberger@slu.edu>

Author: mepripri

classes/Project/ProjectFactory.js

@@ -340,6 +340,99 @@ export default class ProjectFactory {
     }
   }
 
+  // We might add the Vault here to get the Manifest version 3
+  static transformManifestUrl(url, protocol) {
+      const parsedUrl = new URL(url)
+      parsedUrl.protocol = protocol
+      if (parsedUrl.pathname.endsWith("/manifest.json")) {
+          parsedUrl.pathname = parsedUrl.pathname.replace(/\/manifest\.json$/, "")
+      }
+      parsedUrl.search = "?version=3"
+      return parsedUrl.toString()
+  }
+
+  static async importTPEN28(projectTPEN28Data, projectTPEN3Data, userToken, protocol) {
+    if (!projectTPEN28Data || !projectTPEN3Data) {
+      throw {
+        status: 400,
+        message: "Invalid project data"
+      }
+    }
+
+    const symbols = projectTPEN28Data.projectButtons.map(button => String.fromCharCode(button.key))
+    if (symbols && symbols.length > 0) {
+      const copiedHotkeys = new Hotkeys(projectTPEN3Data._id, symbols)
+      await copiedHotkeys.create()
+    }
+    let projectTools = []
+    try {
+      projectTools = [...projectTPEN28Data.userTool, ...projectTPEN28Data.projectTool]
+    }
+    catch (err) {
+      // Just in case the spread operator didn't end up making an array due to 'undefined' or something weird.
+      projectTools = []
+    }
+    const toolList = projectTPEN3Data.tools.map((tool) => tool.value)
+    const selectedTools = toolList.map((tool) => ({
+        value: tool,
+        state: projectTools.includes(tool),
+    }))
+    const project = new Project(projectTPEN3Data._id)
+    if (selectedTools && selectedTools.length > 0) {
+      await project.updateTools(selectedTools)
+    }
+    const allCanvases = projectTPEN3Data.layers[0].pages.map((page) => page.target)
+    const allPagesIds = projectTPEN3Data.layers[0].pages.map((page) =>page.id.replace(/project\/([a-f0-9]+)/, `project/${projectTPEN3Data._id}`))
+    let manifestUrl = projectTPEN3Data.manifest[0]
+    manifestUrl = this.transformManifestUrl(manifestUrl, protocol)
+    const responseManifest = await fetch(manifestUrl)
+    if (!responseManifest.ok) {
+        throw new Error(`Failed to fetch: ${responseManifest.statusText}`)
+    }
+    
+    const manifestJson = await responseManifest.json()
+    const itemsByPage = {}
+    manifestJson.items.map((item, index) => {
+      const canvasId = item.id
+      if (allCanvases.includes(canvasId)) {
+        const annotations = item.annotations?.flatMap(
+          (annotation) =>
+            annotation.items?.flatMap((innerItems) => ({
+            body: {
+              type: innerItems.body?.type,
+              format: innerItems.body?.format,
+              value: innerItems.body?.value,
+            },
+            motivation: innerItems.motivation,
+            target: innerItems.target,
+            type: innerItems.type,
+            })) || []
+          ) || []
+        itemsByPage[allPagesIds[index]] = annotations
+      }
+    })
+    
+    for (const [endpoint, annotations] of Object.entries(itemsByPage)) {
+        try {
+          const response = await fetch(`${endpoint}/line`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${userToken}`,
+            },
+            body: JSON.stringify(annotations),
+          })
+          if (!response.ok) {
+            throw new Error(`Failed to import annotations: ${response.statusText}`)
+          }
+      } catch (error) {
+        console.error("Error importing annotations:", error)
+      }
+    }
+
+    return projectTPEN3Data
+  }
+
   static async copyProject(projectId, creator) {
     if (!projectId) {
       throw {

project/import28Router.js

@@ -3,6 +3,8 @@ import { respondWithError } from "../utilities/shared.js"
 import cookieParser from "cookie-parser"
 import auth0Middleware from "../auth/index.js"
 import cors from "cors"
+import validateURL from "../utilities/validateURL.js"
+import ProjectFactory from "../classes/Project/ProjectFactory.js"
 
 function patchTokenFromQuery(req, res, next) {
   if (!req.headers.authorization && req.cookies.userToken) {
@@ -79,4 +81,75 @@ router.route("/import28/:uid").get(
     respondWithError(res, 405, "Improper request method. Use GET instead")
 })
 
+router.route("/import28/selectedproject/:selectedProjectId").get(
+    cors(corsOptions),
+    cookieParser(),
+    patchTokenFromQuery,
+    auth0Middleware(),
+    async (req, res) => {
+        const user = req.user
+        const jsessionid = req.cookies?.JSESSIONID
+        const selectedProjectId = req.params?.selectedProjectId
+
+        if (!user) return respondWithError(res, 401, "Unauthenticated request")
+        if (!jsessionid) return respondWithError(res, 400, "Missing jsessionid in query")
+        if (!selectedProjectId) return respondWithError(res, 400, "Missing selectedProjectId in query")
+
+        try {
+            const importResponse = await fetch(
+                `${process.env.TPEN28URL}/TPEN/getProjectTPENServlet?projectID=${selectedProjectId}`,
+                {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        "Cookie": `JSESSIONID=${jsessionid}`
+                    },
+                    credentials: "include"
+                }
+            )
+            .then(resp => {
+                if(!resp.ok) throw resp
+                return resp.json()
+            })
+            .catch(err => {throw err})
+
+            let parsedData = {}
+            parsedData = Object.fromEntries(
+                Object.entries(importResponse).map(([key, value]) => {
+                    try {
+                        return [key, JSON.parse(value)]
+                    } catch {
+                        return [key, value]
+                    }
+                })
+            )
+
+            const manifestURL = `${process.env.TPEN28URL}/TPEN/manifest/${selectedProjectId}`
+            let checkURL = await validateURL(manifestURL)
+            let importData
+            if (!checkURL.valid)
+                return res.status(checkURL.status).json({message: checkURL.message, resolvedPayload: checkURL.resolvedPayload})
+            try {
+                importData = await ProjectFactory.fromManifestURL(manifestURL, user.agent.split('/').pop(), true)
+            } catch (error) {
+                res.status(error.status ?? 500).json({
+                    status: error.status ?? 500,
+                    message: error.message,
+                    data: error.resolvedPayload
+                })
+            }
+
+            await ProjectFactory.importTPEN28(parsedData, importData, req.cookies.userToken, req.protocol)
+            res.status(201).json({
+                message: "Project imported successfully",
+                project: { parsedData, importData }
+            })
+        } catch (error) {
+            return respondWithError(res, error.status ?? 500, error.statusText ?? "Error fetching project data")
+        }
+    }
+).all((req, res) => {
+    respondWithError(res, 405, "Improper request method. Use GET instead")
+})
+
 export default router