bfg-common 1.2.186 → 1.2.187

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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,43 @@
+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,
+}

package/components/common/wizards/vm/migrate/select/computeResource/ComputeResource.vue

@@ -184,6 +184,8 @@ const checkValidityBlock = (): boolean => {
     errorMessages.value = [errorText]
     return false
   }
+
+  onHideErrorMessageAlert()
   emits('next-step', {
     ...computeResourceDataLocal.value,
   })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bfg-common",
   "private": false,
-  "version": "1.2.186",
+  "version": "1.2.187",
   "scripts": {
     "build": "nuxt build",
     "dev": "nuxt dev --port=3002",