curtain-web-api 1.0.75 → 1.0.77

package/build/classes/curtain-api.d.ts

@@ -11,6 +11,8 @@ export interface SiteProperties {
     jwt_refresh_token_lifetime_days: number;
     jwt_remember_me_access_token_lifetime_days: number;
     jwt_remember_me_refresh_token_lifetime_days: number;
+    umami_website_id?: string;
+    umami_url?: string;
 }
 export interface CurtainChunkedUploadStatus {
     id: string;
@@ -121,6 +123,30 @@ export interface AddCurtainToCollection {
     curtain_id?: number;
     link_id?: string;
 }
+export interface DataCiteAlternateIdentifier {
+    alternateIdentifier: string;
+    alternateIdentifierType: string;
+}
+export interface DataCiteCollectionMetadata {
+    collection_id: number;
+    collection_name: string;
+    collection_description: string;
+    main_session: {
+        curtain_id: number | null;
+        link_id: string | null;
+    };
+    sessions: Array<{
+        curtain_id: number;
+        link_id: string;
+        data_url: string;
+    }>;
+}
+export interface ParsedDataCiteData {
+    mainSessionUrl?: string;
+    alternativeSessionUrls: string[];
+    collectionMetadataUrl?: string;
+    collectionMetadata?: DataCiteCollectionMetadata;
+}
 export declare class CurtainWebAPI {
     loginURL: string;
     logoutURL: string;
@@ -152,7 +178,7 @@ export declare class CurtainWebAPI {
     addOwner(linkId: string, owner: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     removeOwner(linkId: string, owner: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getCurtainLinks(username: string, sessionDescription?: string, offset?: number, sessionType?: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
-    getSiteProperties(): Promise<import("axios").AxiosResponse<SiteProperties, any, {}>>;
+    getSiteProperties(appType?: string): Promise<import("axios").AxiosResponse<SiteProperties, any, {}>>;
     saveDataFilterList(name: string, data: string, category?: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getDataFilterListByID(id: number, limit?: number): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getDataFilterList(title?: string, searchTerm?: string, category?: string, limit?: number, offset?: number): Promise<import("axios").AxiosResponse<any, any, {}>>;
@@ -182,6 +208,12 @@ export declare class CurtainWebAPI {
     }, any, {}>>;
     updateDataCite(id: number, data: any): Promise<import("axios").AxiosResponse<any, any, {}>>;
     deleteDataCite(id: number): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    parseDataCiteAlternateIdentifiers(alternateIdentifiers: DataCiteAlternateIdentifier[]): Promise<ParsedDataCiteData>;
+    loadDataCiteSession(url: string): Promise<any>;
+    loadAllDataCiteSessions(parsedData: ParsedDataCiteData): Promise<{
+        main?: any;
+        alternatives: any[];
+    }>;
     changeDataCiteStatus(id: number, status: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     lockDataCite(id: number, lock: boolean): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getKinaseLibraryProxy(sequence: string): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/build/classes/curtain-api.js

@@ -414,10 +414,14 @@ export class CurtainWebAPI {
             return response;
         });
     }
-    getSiteProperties() {
+    getSiteProperties(appType) {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";
-        return this.axiosInstance.get(this.baseURL + "site-properties/", { headers: headers, responseType: "json" });
+        let params = new URLSearchParams();
+        if (appType) {
+            params.append("app", appType);
+        }
+        return this.axiosInstance.get(this.baseURL + "site-properties/", { headers: headers, params: params, responseType: "json" });
     }
     saveDataFilterList(name, data, category = "") {
         let headers = new AxiosHeaders();
@@ -623,6 +627,62 @@ export class CurtainWebAPI {
         headers["Accept"] = "application/json";
         return this.axiosInstance.delete(this.baseURL + "datacite/" + id + "/", { headers: headers, responseType: "json" });
     }
+    async parseDataCiteAlternateIdentifiers(alternateIdentifiers) {
+        const result = {
+            alternativeSessionUrls: []
+        };
+        for (const identifier of alternateIdentifiers) {
+            switch (identifier.alternateIdentifierType) {
+                case "Curtain Main Session Data":
+                    result.mainSessionUrl = identifier.alternateIdentifier;
+                    break;
+                case "Curtain Alternative Session Data":
+                    result.alternativeSessionUrls.push(identifier.alternateIdentifier);
+                    break;
+                case "Curtain Collection Metadata":
+                    result.collectionMetadataUrl = identifier.alternateIdentifier;
+                    break;
+            }
+        }
+        if (result.collectionMetadataUrl) {
+            try {
+                const response = await this.axiosInstance.get(result.collectionMetadataUrl);
+                result.collectionMetadata = response.data;
+            }
+            catch (error) {
+                console.error("Failed to fetch collection metadata:", error);
+            }
+        }
+        return result;
+    }
+    async loadDataCiteSession(url) {
+        try {
+            const response = await this.axiosInstance.get(url);
+            return response.data;
+        }
+        catch (error) {
+            console.error("Failed to load session data:", error);
+            throw error;
+        }
+    }
+    async loadAllDataCiteSessions(parsedData) {
+        const result = {
+            alternatives: []
+        };
+        if (parsedData.mainSessionUrl) {
+            result.main = await this.loadDataCiteSession(parsedData.mainSessionUrl);
+        }
+        for (const url of parsedData.alternativeSessionUrls) {
+            try {
+                const data = await this.loadDataCiteSession(url);
+                result.alternatives.push(data);
+            }
+            catch (error) {
+                console.error(`Failed to load alternative session from ${url}:`, error);
+            }
+        }
+        return result;
+    }
     changeDataCiteStatus(id, status) {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "curtain-web-api",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "description": "",
   "type": "module",
   "main": "./build/index.js",

package/src/classes/curtain-api.ts

@@ -39,6 +39,8 @@ export interface SiteProperties {
     jwt_refresh_token_lifetime_days: number;
     jwt_remember_me_access_token_lifetime_days: number;
     jwt_remember_me_refresh_token_lifetime_days: number;
+    umami_website_id?: string;
+    umami_url?: string;
 }
 
 export interface CurtainChunkedUploadStatus {
@@ -162,6 +164,33 @@ export interface AddCurtainToCollection {
     link_id?: string;
 }
 
+export interface DataCiteAlternateIdentifier {
+    alternateIdentifier: string;
+    alternateIdentifierType: string;
+}
+
+export interface DataCiteCollectionMetadata {
+    collection_id: number;
+    collection_name: string;
+    collection_description: string;
+    main_session: {
+        curtain_id: number | null;
+        link_id: string | null;
+    };
+    sessions: Array<{
+        curtain_id: number;
+        link_id: string;
+        data_url: string;
+    }>;
+}
+
+export interface ParsedDataCiteData {
+    mainSessionUrl?: string;
+    alternativeSessionUrls: string[];
+    collectionMetadataUrl?: string;
+    collectionMetadata?: DataCiteCollectionMetadata;
+}
+
 export class CurtainWebAPI {
     loginURL: string = "";
     logoutURL: string = "";
@@ -581,10 +610,14 @@ export class CurtainWebAPI {
         });
     }
 
-    getSiteProperties() {
+    getSiteProperties(appType?: string) {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";
-        return this.axiosInstance.get<SiteProperties>(this.baseURL + "site-properties/", {headers: headers, responseType:"json"});
+        let params = new URLSearchParams();
+        if (appType) {
+            params.append("app", appType);
+        }
+        return this.axiosInstance.get<SiteProperties>(this.baseURL + "site-properties/", {headers: headers, params: params, responseType:"json"});
     }
 
     saveDataFilterList(name: string, data: string, category: string = "") {
@@ -821,6 +854,68 @@ export class CurtainWebAPI {
         return this.axiosInstance.delete(this.baseURL + "datacite/" + id + "/", {headers: headers, responseType: "json"})
     }
 
+    async parseDataCiteAlternateIdentifiers(alternateIdentifiers: DataCiteAlternateIdentifier[]): Promise<ParsedDataCiteData> {
+        const result: ParsedDataCiteData = {
+            alternativeSessionUrls: []
+        };
+
+        for (const identifier of alternateIdentifiers) {
+            switch (identifier.alternateIdentifierType) {
+                case "Curtain Main Session Data":
+                    result.mainSessionUrl = identifier.alternateIdentifier;
+                    break;
+                case "Curtain Alternative Session Data":
+                    result.alternativeSessionUrls.push(identifier.alternateIdentifier);
+                    break;
+                case "Curtain Collection Metadata":
+                    result.collectionMetadataUrl = identifier.alternateIdentifier;
+                    break;
+            }
+        }
+
+        if (result.collectionMetadataUrl) {
+            try {
+                const response = await this.axiosInstance.get<DataCiteCollectionMetadata>(result.collectionMetadataUrl);
+                result.collectionMetadata = response.data;
+            } catch (error) {
+                console.error("Failed to fetch collection metadata:", error);
+            }
+        }
+
+        return result;
+    }
+
+    async loadDataCiteSession(url: string): Promise<any> {
+        try {
+            const response = await this.axiosInstance.get(url);
+            return response.data;
+        } catch (error) {
+            console.error("Failed to load session data:", error);
+            throw error;
+        }
+    }
+
+    async loadAllDataCiteSessions(parsedData: ParsedDataCiteData): Promise<{main?: any, alternatives: any[]}> {
+        const result: {main?: any, alternatives: any[]} = {
+            alternatives: []
+        };
+
+        if (parsedData.mainSessionUrl) {
+            result.main = await this.loadDataCiteSession(parsedData.mainSessionUrl);
+        }
+
+        for (const url of parsedData.alternativeSessionUrls) {
+            try {
+                const data = await this.loadDataCiteSession(url);
+                result.alternatives.push(data);
+            } catch (error) {
+                console.error(`Failed to load alternative session from ${url}:`, error);
+            }
+        }
+
+        return result;
+    }
+
     changeDataCiteStatus(id: number, status: string) {
         let headers = new AxiosHeaders()
         headers["Accept"] = "application/json"