dpworld_web/src/main/resources/static/js/main.js

import { loadDeviceConfig, loadProtocolConfig, saveDeviceConfig, saveProtocolConfig } from './api.js';
import { createNavigation } from './navigation.js';
import { createDeviceDataController } from './device/deviceData.js';
import { bindDeviceFileActions, bindProtocolFileActions } from './device/deviceFile.js';
import { createSsidController } from './device/ssid.js';
import { createCanController } from './protocol/can.js';
import { createModbusController } from './protocol/modbus.js';
import { createOdometerController } from './protocol/odometer.js';
import { createOpcUaController } from './protocol/opcua.js';
import { createProtocolDataController } from './protocol/protocolData.js';
import { getRegisterConfigValidationError, isValidRegisterConfig } from './protocol/protocolValidation.js';
import { byId, queryAll } from './utils/dom.js';

async function initializeApp() {
    const navigation = createNavigation();
    const ssidController = createSsidController({
        listElement: byId('ssid-list'),
        templateElement: byId('ssid-template'),
        addButton: byId('add-ssid'),
        countryCodeInput: byId('wifi_country_code'),
    });

    const deviceController = createDeviceDataController({ ssidController });
    const protocolController = createProtocolDataController({
        navigation,
        modbusController: createModbusController(),
        opcUaController: createOpcUaController(),
        canController: createCanController(),
        odometerController: createOdometerController(),
    });

    navigation.initialize();
    ssidController.bindEvents();
    deviceController.initialize();
    protocolController.initialize();

    bindDeviceFileActions({
        onLoadLocal: (data) => deviceController.loadFromData(data),
        getDownloadData: () => deviceController.collectDeviceData(),
    });

    bindProtocolFileActions({
        onLoadLocal: (data) => {
            const validationError = getRegisterConfigValidationError(data);
            if (validationError) {
                alert(`The contents of the selected file are not valid.\n${validationError}`);
                return;
            }

            protocolController.loadFromRegisterJson(data);
        },
        getDownloadData: () => protocolController.collectProtocolData(),
    });

    queryAll('.save-file').forEach((button) => {
        button.addEventListener('click', async () => {
            const devicePayload = deviceController.collectDeviceData();
            const protocolPayload = protocolController.normalizeRegisterForPost(
                protocolController.collectProtocolData(),
            );

            const validationError = getRegisterConfigValidationError(protocolPayload);
            if (validationError) {
                alert(`Register settings are currently invalid.\n${validationError}`);
                return;
            }

            try {
                const [deviceResponse, protocolResponse] = await Promise.all([
                    saveDeviceConfig(devicePayload),
                    saveProtocolConfig(protocolPayload),
                ]);

                const isDeviceSaved = deviceResponse.ok && deviceResponse.data?.success === true;
                const isProtocolSaved = protocolResponse.ok && protocolResponse.data?.success === true;

                if (isDeviceSaved && isProtocolSaved) {
                    alert('saved successfully');
                    return;
                }

                const failureMessages = [
                    !isDeviceSaved ? (deviceResponse.data?.message || `Device save failed (${deviceResponse.status})`) : null,
                    !isProtocolSaved ? (protocolResponse.data?.message || `Protocol save failed (${protocolResponse.status})`) : null,
                ].filter(Boolean);

                alert(failureMessages.join('\n') || 'save failure');
                console.error('device response:', deviceResponse, 'protocol response:', protocolResponse);
            } catch (error) {
                console.error('Error during transfer:', error);
                alert('save failure');
            }
        });
    });

    try {
        const deviceData = await loadDeviceConfig();
        if (deviceData) {
            deviceController.loadFromData(deviceData);
        }
    } catch (error) {
        console.error('Device load failed:', error);
    }

    try {
        const protocolData = await loadProtocolConfig();
        if (protocolData) {
            protocolController.loadFromRegisterJson(protocolData);
        }
    } catch (error) {
        console.error('Protocol load failed:', error);
    }
}

document.addEventListener('DOMContentLoaded', initializeApp);