bfg-common 1.2.197 → 1.2.198

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

@@ -0,0 +1,58 @@
+import {
+  UI_I_AdapterStatus,
+  UI_I_Adapter,
+} from '~/components/common/diagramMain/models/interfaces'
+import { UI_I_Localization } from '~/models/interfaces'
+import {
+  UI_I_ValidationReturn,
+  UI_I_WizardStep,
+} from '~/components/atoms/wizard/models/interfaces'
+
+export const checkAdaptersSync = (
+  localization: UI_I_Localization,
+  data: UI_I_AdapterStatus,
+  value: UI_I_WizardStep[],
+  currentStepId: number,
+  nextStepId: number,
+  freeAdapters: UI_I_Adapter[],
+  showNoActiveAdaptersModal: () => void,
+  showNoConnectedActiveAdaptersModal: () => void
+): UI_I_ValidationReturn => {
+  const stepShouldStop = {
+    ifOnCurrentStep: false,
+    ifFromAnyStep: false,
+    stoppageStepId: 2,
+  }
+
+  const isOnStoppageStep = currentStepId === stepShouldStop.stoppageStepId
+
+  if (isOnStoppageStep && data.active.length === 0) {
+    stepShouldStop.ifOnCurrentStep = true
+    showNoActiveAdaptersModal()
+  }
+
+  if (stepShouldStop.ifOnCurrentStep)
+    return {
+      newValue: value,
+      stepHasError: false,
+      stepShouldStop,
+    }
+
+  const activeAndConnectedAdapters = data.active.filter(
+    (adapterName: string) =>
+      freeAdapters.find(
+        (freeAdapter: UI_I_Adapter) => freeAdapter.name === adapterName
+      )?.carrier
+  )
+
+  if (isOnStoppageStep && activeAndConnectedAdapters.length === 0) {
+    stepShouldStop.ifOnCurrentStep = true
+    showNoConnectedActiveAdaptersModal()
+  }
+
+  return {
+    newValue: value,
+    stepHasError: false,
+    stepShouldStop,
+  }
+}

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/models/composables/useMyFetch/interfaces.ts

@@ -1,25 +1,25 @@
-import type { UI_T_Method } from '~/models/composables/useMyFetch/types'
-
-export interface UI_I_Response<Data, Error> {
-  data: globalThis.Ref<Data>
-  error: globalThis.Ref<Error>
-  refresh: any
-}
-
-export interface UI_I_Options {
-  method: UI_T_Method
-  body?: any
-  query?: any
-  key?: any
-  initialCache?: boolean
-  headers?: any
-  onRequest?: () => void
-  onResponse?: (response: any) => void
-  onResponseError?: (response: any) => void
-  onRequestError?: (error: any) => void
-}
-
-export interface UI_I_StackFetchUrls {
-  url: string
-  options: UI_I_Options
-}
+import type { UI_T_Method } from '~/models/composables/useMyFetch/types'
+
+export interface UI_I_Response<Data, Error> {
+  data: globalThis.Ref<Data>
+  error: globalThis.Ref<Error>
+  refresh: any
+}
+
+export interface UI_I_Options {
+  method: UI_T_Method
+  body?: any
+  query?: any
+  key?: any
+  initialCache?: boolean
+  headers?: any
+  onRequest?: () => void
+  onResponse?: (response: any) => void
+  onResponseError?: (response: any) => void
+  onRequestError?: (error: any) => void
+}
+
+export interface UI_I_StackFetchUrls {
+  url: string
+  options: UI_I_Options
+}

package/package.json

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