3m-portal/api.js

// One2Edit API Configuration
const API_CONFIG = {
    baseUrl: 'https://oliver.one2edit.com/v3/Api.php',
    authDomain: 'local',
    clientId: 1,
    domain: 'local'
};

// API Helper Functions
const One2EditAPI = {
    /**
     * Authenticate user with one2edit API
     * @param {string} username - User email
     * @param {string} password - User password
     * @returns {Promise<Object>} User data including ID and session
     */
    async authenticate(username, password) {
        try {
            const params = new URLSearchParams({
                command: 'user.session.extern.add',
                authDomain: API_CONFIG.authDomain,
                authUsername: AUTH_CONFIG.authUsername,
                authPassword: AUTH_CONFIG.authPassword,
                clientId: API_CONFIG.clientId,
                username: username,
                //password: password,
                domain: API_CONFIG.domain
            });

            const response = await fetch(`${API_CONFIG.baseUrl}?${params.toString()}`);
            const xmlText = await response.text();

            // Parse XML response
            const parser = new DOMParser();
            const xmlDoc = parser.parseFromString(xmlText, 'text/xml');

            // Check for errors
            const error = xmlDoc.querySelector('error');
            if (error) {
                const code = error.querySelector('code')?.textContent;
                const message = error.querySelector('message')?.textContent;
                throw new Error(`Authentication failed: ${message} (Code: ${code})`);
            }

            // Extract user data
            const userData = {
                session: xmlDoc.querySelector('session')?.textContent,
                userId: xmlDoc.querySelector('user > id')?.textContent,
                name: xmlDoc.querySelector('user > name')?.textContent,
                email: xmlDoc.querySelector('user > contact')?.textContent,
                role: xmlDoc.querySelector('user > role')?.textContent
            };

            if (!userData.userId) {
                throw new Error('Invalid response: User ID not found');
            }

            return userData;
        } catch (error) {
            console.error('Authentication error:', error);
            throw error;
        }
    },

    /**
     * Re-authenticate to get a fresh session (useful for editor)
     * @param {string} username - User email
     * @param {string} password - User password
     * @returns {Promise<string>} Session ID
     */
    async getEditorSession(username, password) {
        const userData = await this.authenticate(username, password);
        return userData.session;
    },

    /**
     * Get list of jobs for a user
     * @param {string} username - User email
     * @param {string} password - User password
     * @param {string} userId - User ID from authentication
     * @returns {Promise<Array>} Array of job objects
     */
    async getJobList(username, password, userId) {
        try {
            const params = new URLSearchParams({
                command: 'job.list',
                authDomain: API_CONFIG.authDomain,
                authUsername: username,
                authPassword: password,
                clientId: API_CONFIG.clientId,
                userId: userId,
                includeDocumentInfos: 0,
                includeDocumentPreviews: 1
            });

            // Add status filters
            ['STARTED', 'RUNNING', 'STOPPED', 'FINISH'].forEach((status, index) => {
                params.append(`status[${index}]`, status);
            });

            const response = await fetch(`${API_CONFIG.baseUrl}?${params.toString()}`);
            const xmlText = await response.text();

            // Parse XML response
            const parser = new DOMParser();
            const xmlDoc = parser.parseFromString(xmlText, 'text/xml');

            // Check for errors
            const error = xmlDoc.querySelector('error');
            if (error) {
                const code = error.querySelector('code')?.textContent;
                const message = error.querySelector('message')?.textContent;
                throw new Error(`Failed to fetch jobs: ${message} (Code: ${code})`);
            }

            // Extract job data
            const jobs = [];
            const jobElements = xmlDoc.querySelectorAll('job');

            jobElements.forEach(jobEl => {
                const job = {
                    id: jobEl.querySelector('id')?.textContent,
                    name: jobEl.querySelector('name')?.textContent,
                    status: jobEl.querySelector('status')?.textContent,
                    contentType: jobEl.querySelector('contentType')?.textContent,
                    stepData: {
                        type: jobEl.querySelector('stepData > type')?.textContent,
                        name: jobEl.querySelector('stepData > name')?.textContent,
                        editor: jobEl.querySelector('stepData > editor')?.textContent
                    },
                    totalItems: jobEl.querySelector('totalItems')?.textContent,
                    doneItems: jobEl.querySelector('doneItems')?.textContent,
                    documentId: jobEl.querySelector('documentId')?.textContent,
                    documentPreview: jobEl.querySelector('documentPreview')?.textContent,
                    translationLanguage: jobEl.querySelector('translationLanguage > name')?.textContent
                };
                jobs.push(job);
            });

            return jobs;
        } catch (error) {
            console.error('Get jobs error:', error);
            throw error;
        }
    },

    /**
     * Export job as PDF
     * @param {string} username - User email
     * @param {string} password - User password
     * @param {string} jobId - Job ID to export
     * @returns {Promise<Blob>} PDF blob
     */
    async exportJobPDF(username, password, jobId) {
        try {
            const params = new URLSearchParams({
                command: 'job.export.pdf',
                authDomain: API_CONFIG.authDomain,
                authUsername: username,
                authPassword: password,
                clientId: API_CONFIG.clientId,
                id: jobId
            });

            const response = await fetch(`${API_CONFIG.baseUrl}?${params.toString()}`);

            // Check if response is ok
            if (!response.ok) {
                throw new Error(`PDF export failed: ${response.statusText}`);
            }

            // Get the blob
            const blob = await response.blob();
            return blob;
        } catch (error) {
            console.error('Export PDF error:', error);
            throw error;
        }
    }
};

// Session Management
const SessionManager = {
    save(userData, credentials) {
        sessionStorage.setItem('user', JSON.stringify(userData));
        sessionStorage.setItem('credentials', JSON.stringify(credentials));
    },

    getUser() {
        const user = sessionStorage.getItem('user');
        return user ? JSON.parse(user) : null;
    },

    getCredentials() {
        const creds = sessionStorage.getItem('credentials');
        return creds ? JSON.parse(creds) : null;
    },

    clear() {
        sessionStorage.removeItem('user');
        sessionStorage.removeItem('credentials');
    },

    isAuthenticated() {
        return this.getUser() !== null && this.getCredentials() !== null;
    }
};