bfg-common 1.2.189 → 1.2.190

package/components/common/wizards/network/add/validations/ipFourSettings.ts

@@ -1,188 +0,0 @@
-import { UI_I_IpFourSettings } from '~/components/common/wizards/network/add/models/interfaces'
-import { UI_E_ValidationFields } from '~/components/common/wizards/network/add/models/enums'
-import { UI_I_Localization } from '~/models/interfaces'
-import type Wizard from '~/components/atoms/wizard/utils/utils'
-import {
-  UI_I_ValidationReturn,
-  UI_I_WizardStep,
-} from '~/components/atoms/wizard/models/interfaces'
-import {
-  validateFieldLocal,
-  checkIfValidIP,
-} from '~/components/common/wizards/network/add/validations/common'
-
-export const validateAddressIpFourSettingsLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_IpFourSettings,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    4,
-    UI_E_ValidationFields.IPV_SETTINGS_IPV,
-    [!data.static.ipFourAddress, !checkIfValidIP(data.static.ipFourAddress)],
-    [localization.ipFourAddressEmpty, localization.ipFourAddressInvalid],
-    [localization.ipFourAddressEmpty, localization.ipFourAddressInvalid]
-  )
-}
-
-export const validateMaskIpFourSettingsLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_IpFourSettings,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    4,
-    UI_E_ValidationFields.IPV_SETTINGS_MASK,
-    [!data.static.subnetMask, !checkIfValidIP(data.static.subnetMask)],
-    [localization.subnetMaskEmpty, localization.subnetMaskInvalid],
-    [localization.subnetMaskEmpty, localization.subnetMaskInvalid]
-  )
-}
-
-export const validateGatewayIpFourSettingsLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_IpFourSettings,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    4,
-    UI_E_ValidationFields.IPV_SETTINGS_GATEWAY,
-    [
-      data.static.defaultGateway.override && !data.static.defaultGateway.value,
-      data.static.defaultGateway.override &&
-        !checkIfValidIP(data.static.defaultGateway.value),
-    ],
-    [localization.defaultGatewayEmpty, localization.defaultGatewayInvalid],
-    [localization.defaultGatewayEmpty, localization.defaultGatewayInvalid]
-  )
-}
-
-export const removeIpFourSettingsValidationLocal = (wizard: Wizard): void => {
-  wizard.removeValidationLocal(4, UI_E_ValidationFields.IPV_SETTINGS_IPV)
-  wizard.removeValidationLocal(4, UI_E_ValidationFields.IPV_SETTINGS_MASK)
-  wizard.removeValidationLocal(4, UI_E_ValidationFields.IPV_SETTINGS_GATEWAY)
-}
-
-export const checkIpFourSettingsSync = (
-  localization: UI_I_Localization,
-  data: UI_I_IpFourSettings,
-  wizard: Wizard,
-  value: UI_I_WizardStep[]
-): UI_I_ValidationReturn => {
-  let stepHasError = false
-
-  if (data.ipSettings === '0') {
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_IPV,
-      value
-    )
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_MASK,
-      value
-    )
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_GATEWAY,
-      value
-    )
-
-    return {
-      newValue: value,
-      stepHasError: false,
-    }
-  }
-
-  if (!data.static.ipFourAddress) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_IPV,
-      {
-        fieldMessage: localization.ipFourAddressEmpty,
-        alertMessage: localization.ipFourAddressEmpty,
-      }
-    )
-  } else if (!checkIfValidIP(data.static.ipFourAddress)) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_IPV,
-      {
-        fieldMessage: localization.ipFourAddressInvalid,
-        alertMessage: localization.ipFourAddressInvalid,
-      }
-    )
-  } else if (wizard.hasMessage(4, UI_E_ValidationFields.IPV_SETTINGS_IPV)) {
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_IPV,
-      value
-    )
-  }
-
-  if (!data.static.subnetMask) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_MASK,
-      {
-        fieldMessage: localization.subnetMaskEmpty,
-        alertMessage: localization.subnetMaskEmpty,
-      }
-    )
-  } else if (!checkIfValidIP(data.static.subnetMask)) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_MASK,
-      {
-        fieldMessage: localization.subnetMaskInvalid,
-        alertMessage: localization.subnetMaskInvalid,
-      }
-    )
-  } else if (wizard.hasMessage(4, UI_E_ValidationFields.IPV_SETTINGS_MASK)) {
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_MASK,
-      value
-    )
-  }
-
-  if (
-    data.static.defaultGateway.override &&
-    !data.static.defaultGateway.value
-  ) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_GATEWAY,
-      {
-        fieldMessage: localization.defaultGatewayEmpty,
-        alertMessage: localization.defaultGatewayEmpty,
-      }
-    )
-  } else if (
-    data.static.defaultGateway.override &&
-    !checkIfValidIP(data.static.defaultGateway.value)
-  ) {
-    stepHasError = wizard.setValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_GATEWAY,
-      {
-        fieldMessage: localization.defaultGatewayInvalid,
-        alertMessage: localization.defaultGatewayInvalid,
-      }
-    )
-  } else if (wizard.hasMessage(4, UI_E_ValidationFields.IPV_SETTINGS_GATEWAY)) {
-    value = wizard.removeValidation(
-      4,
-      UI_E_ValidationFields.IPV_SETTINGS_GATEWAY,
-      value
-    )
-  }
-
-  return {
-    newValue: value,
-    stepHasError,
-  }
-}

package/components/common/wizards/network/add/validations/networkValidation.ts

@@ -1,73 +0,0 @@
-import { UI_I_AddNetworkingEmits } from '~/components/common/wizards/network/add/models/interfaces'
-import { UI_I_Localization } from '~/models/interfaces'
-import type Wizard from '~/components/atoms/wizard/utils/utils'
-import {
-  UI_I_AsyncCheckReturn, UI_I_ValidationReturn,
-  UI_I_WizardStep,
-} from '~/components/atoms/wizard/models/interfaces'
-
-const checkNetwork = async (
-  networkLabel: string,
-  localization: UI_I_Localization,
-  emits: UI_I_AddNetworkingEmits
-): Promise<UI_I_AsyncCheckReturn> => {
-  if (networkLabel) {
-    return new Promise((resolve, _reject) =>
-      emits('check-network-label', networkLabel, (error_message: string) => {
-        if (error_message === '') {
-          resolve({
-            isValid: true,
-            message: '',
-          })
-        }
-
-        if (error_message !== '') {
-          resolve({
-            isValid: false,
-            message: error_message,
-          })
-        }
-      })
-    )
-  } else {
-    return {
-      isValid: false,
-      message: localization.networkLabelInvalidMessage,
-    }
-  }
-}
-
-export const checkNetworkAsync = async (
-  value: UI_I_WizardStep[],
-  networkLabel: string,
-  stepId: number,
-  fieldName: string,
-  emits: UI_I_AddNetworkingEmits,
-  localization: UI_I_Localization,
-  wizard: Wizard
-): Promise<UI_I_ValidationReturn> => {
-  let stepHasError = false
-
-  wizard.setLoader(true)
-
-  const labelValidation: {
-    isValid: boolean
-    message: string
-  } = await checkNetwork(networkLabel, localization, emits)
-
-  wizard.setLoader(false)
-
-  if (!labelValidation.isValid) {
-    stepHasError = wizard.setValidation(stepId, fieldName, {
-      fieldMessage: labelValidation.message,
-      alertMessage: labelValidation.message,
-    })
-  } else if (wizard.hasMessage(stepId, fieldName)) {
-    value = wizard.removeValidation(stepId, fieldName, value)
-  }
-
-  return {
-    newValue: value,
-    stepHasError,
-  }
-}

package/components/common/wizards/network/add/validations/portProperties.ts

@@ -1,87 +0,0 @@
-import { UI_I_PortProperties } from '~/components/common/wizards/network/add/models/interfaces'
-import { UI_E_ValidationFields } from '~/components/common/wizards/network/add/models/enums'
-import { UI_I_Localization } from '~/models/interfaces'
-import type Wizard from '~/components/atoms/wizard/utils/utils'
-import {UI_I_ValidationReturn, UI_I_WizardStep} from '~/components/atoms/wizard/models/interfaces'
-import {
-  validateFieldLocal,
-  checkVlanId,
-  checkMtu,
-} from '~/components/common/wizards/network/add/validations/common'
-
-export const validateNetworkPortPropertiesLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_PortProperties,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    3,
-    UI_E_ValidationFields.PORT_PROPERTIES_NETWORK,
-    data.networkLabel === '',
-    localization.networkLabelInvalidMessage,
-    localization.networkLabelInvalidMessage
-  )
-}
-
-export const validateVlanIdPortPropertiesLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_PortProperties,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    3,
-    UI_E_ValidationFields.PORT_PROPERTIES_VLAN,
-    checkVlanId(data.vlanId),
-    localization.vlanIdInvalidMessage,
-    localization.vlanIdInvalidMessage
-  )
-}
-
-export const validateMtuPortPropertiesLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_PortProperties,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    3,
-    UI_E_ValidationFields.PORT_PROPERTIES_MTU,
-    data.mtu.option === '1' && checkMtu(data.mtu.size),
-    localization.mtuInvalidMessage,
-    localization.mtuInvalidMessage
-  )
-}
-
-export const checkPortPropertiesSync = (
-  localization: UI_I_Localization,
-  data: UI_I_PortProperties,
-  wizard: Wizard,
-  value: UI_I_WizardStep[]
-): UI_I_ValidationReturn => {
-  let stepHasError = false
-
-  if (checkVlanId(data.vlanId)) {
-    stepHasError = wizard.setValidation(3, UI_E_ValidationFields.PORT_PROPERTIES_VLAN, {
-      fieldMessage: localization.vlanIdInvalidMessage,
-      alertMessage: localization.vlanIdInvalidMessage,
-    })
-  } else if (wizard.hasMessage(3, UI_E_ValidationFields.PORT_PROPERTIES_VLAN)) {
-    value = wizard.removeValidation(3, UI_E_ValidationFields.PORT_PROPERTIES_VLAN, value)
-  }
-
-  if (data.mtu.option === '1' && checkMtu(data.mtu.size)) {
-    stepHasError = wizard.setValidation(3, UI_E_ValidationFields.PORT_PROPERTIES_MTU, {
-      fieldMessage: localization.mtuInvalidMessage,
-      alertMessage: localization.mtuInvalidMessage,
-    })
-  } else if (wizard.hasMessage(3, UI_E_ValidationFields.PORT_PROPERTIES_MTU)) {
-    value = wizard.removeValidation(3, UI_E_ValidationFields.PORT_PROPERTIES_MTU, value)
-  }
-
-  return {
-    newValue: value,
-    stepHasError,
-  }
-}

package/components/common/wizards/network/add/validations/targetDevice.ts

@@ -1,113 +0,0 @@
-import { UI_I_TargetDevice } from '~/components/common/wizards/network/add/models/interfaces'
-import { UI_E_ValidationFields } from '~/components/common/wizards/network/add/models/enums'
-import { UI_I_Localization } from '~/models/interfaces'
-import type Wizard from '~/components/atoms/wizard/utils/utils'
-import {
-  UI_I_ValidationReturn,
-  UI_I_WizardStep,
-} from '~/components/atoms/wizard/models/interfaces'
-import {
-  validateFieldLocal,
-  checkMtu,
-} from '~/components/common/wizards/network/add/validations/common'
-
-export const validateMtuTargetDeviceLocal = (
-  localization: UI_I_Localization,
-  data: UI_I_TargetDevice,
-  wizard: Wizard
-): void => {
-  validateFieldLocal(
-    wizard,
-    1,
-    UI_E_ValidationFields.TARGET_DEVICE_MTU,
-    data.selected === '3' && checkMtu(data.mtu || 0),
-    localization.mtuInvalidMessage,
-    localization.mtuInvalidMessage
-  )
-}
-
-export const checkTargetDeviceSync = (
-  localization: UI_I_Localization,
-  data: UI_I_TargetDevice,
-  wizard: Wizard,
-  value: UI_I_WizardStep[]
-): UI_I_ValidationReturn => {
-  let stepHasError = false
-
-  if (data.selected === '0' && !data.network) {
-    stepHasError = wizard.setValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_NETWORK,
-      {
-        fieldMessage: localization.networkInvalidMessage,
-        alertMessage: localization.networkInvalidMessage,
-      }
-    )
-  } else if (
-    wizard.hasMessage(1, UI_E_ValidationFields.TARGET_DEVICE_NETWORK)
-  ) {
-    value = wizard.removeValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_NETWORK,
-      value
-    )
-  }
-
-  if (data.selected === '1' && !data.standardSwitch) {
-    stepHasError = wizard.setValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_STANDARD_SWITCH,
-      {
-        fieldMessage: localization.standardSwitchInvalidMessage,
-        alertMessage: localization.standardSwitchInvalidMessage,
-      }
-    )
-  } else if (
-    wizard.hasMessage(1, UI_E_ValidationFields.TARGET_DEVICE_STANDARD_SWITCH)
-  ) {
-    value = wizard.removeValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_STANDARD_SWITCH,
-      value
-    )
-  }
-
-  if (data.selected === '2' && !data.switch) {
-    stepHasError = wizard.setValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_SWITCH,
-      {
-        fieldMessage: localization.switchInvalidMessage,
-        alertMessage: localization.switchInvalidMessage,
-      }
-    )
-  } else if (wizard.hasMessage(1, UI_E_ValidationFields.TARGET_DEVICE_SWITCH)) {
-    value = wizard.removeValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_SWITCH,
-      value
-    )
-  }
-
-  if (data.selected === '3' && checkMtu(data.mtu || 0)) {
-    stepHasError = wizard.setValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_MTU,
-      {
-        fieldMessage: localization.mtuInvalidMessage,
-        alertMessage: localization.mtuInvalidMessage,
-      }
-    )
-  } else if (wizard.hasMessage(1, UI_E_ValidationFields.TARGET_DEVICE_MTU)) {
-    value = wizard.removeValidation(
-      1,
-      UI_E_ValidationFields.TARGET_DEVICE_MTU,
-      value
-    )
-  }
-
-  return {
-    newValue: value,
-    stepHasError,
-  }
-}

package/components/common/wizards/network/add/validations/validations.ts

@@ -1,43 +0,0 @@
-import {
-  validateVlanIdConnectionSettingsLocal,
-  validateNetworkConnectionSettingsLocal,
-  checkConnectionSettingsSync,
-} from '~/components/common/wizards/network/add/validations/connectionSettings'
-import {
-  validateAddressIpFourSettingsLocal,
-  validateMaskIpFourSettingsLocal,
-  validateGatewayIpFourSettingsLocal,
-  removeIpFourSettingsValidationLocal,
-  checkIpFourSettingsSync,
-} from '~/components/common/wizards/network/add/validations/ipFourSettings'
-import {
-  validateNetworkPortPropertiesLocal,
-  validateVlanIdPortPropertiesLocal,
-  validateMtuPortPropertiesLocal,
-  checkPortPropertiesSync,
-} from '~/components/common/wizards/network/add/validations/portProperties'
-import {
-  validateMtuTargetDeviceLocal,
-  checkTargetDeviceSync,
-} from '~/components/common/wizards/network/add/validations/targetDevice'
-import { checkNetworkAsync } from '~/components/common/wizards/network/add/validations/networkValidation'
-import { checkAdaptersSync } from '~/components/common/wizards/network/add/validations/createStandardSwitch'
-
-export {
-  validateVlanIdConnectionSettingsLocal,
-  validateNetworkConnectionSettingsLocal,
-  checkConnectionSettingsSync,
-  validateAddressIpFourSettingsLocal,
-  validateMaskIpFourSettingsLocal,
-  validateGatewayIpFourSettingsLocal,
-  removeIpFourSettingsValidationLocal,
-  checkIpFourSettingsSync,
-  validateNetworkPortPropertiesLocal,
-  validateVlanIdPortPropertiesLocal,
-  validateMtuPortPropertiesLocal,
-  checkPortPropertiesSync,
-  validateMtuTargetDeviceLocal,
-  checkTargetDeviceSync,
-  checkNetworkAsync,
-  checkAdaptersSync,
-}