bfg-common 1.3.205 → 1.3.206

package/components/common/wizards/network/add/Add.vue

@@ -1,190 +1,191 @@
 <template>
-    <atoms-wizard
-            v-model:show="props.show"
-            :steps="wizard.steps"
-            :selected-scheme="selectedScheme"
-            :is-loading="wizard.wizardLoader.status"
-            :loader-messages="wizard.wizardLoader.messages"
-            :title="title"
-            max-height="551px"
-            :was-completed="wasCompleted"
-            :localization="localization"
-            :class="[
+  <atoms-wizard
+    v-model:show="props.show"
+    :steps="wizard.steps"
+    :selected-scheme="selectedScheme"
+    :is-loading="wizard.wizardLoader.status"
+    :loader-messages="wizard.wizardLoader.messages"
+    :title="title"
+    max-height="551px"
+    :was-completed="wasCompleted"
+    :localization="localization"
+    :class="[
       'add-networking-wizard',
       {
         'is-dark': props.isDarkMode,
       },
     ]"
-            @change-steps="onChangeSteps"
-            @hide="onHideAddNetworkingModal"
-            @submit="onSubmit"
-    >
-        <template #modalBody="{ selectedStep }">
-            <common-wizards-network-add-steps-select-connection-type
-                    v-if="selectedStep.id === 0"
-                    v-model="connectionTypeLocal"
-            />
-            <common-wizards-network-add-steps-selected-target-device
-                    v-if="selectedStep.id === 1"
-                    :wizard="wizard"
-                    :target-device="targetDevice"
-                    :connection-type="connectionTypeLocal"
-                    :standard-switches-initial="props.standardSwitchesInitial"
-                    :messages-fields="selectedStep.fields"
-                    :alert-messages="alertMessages[1]"
-                    :selected-standard-switch-id="props.selectedStandardSwitchId"
-                    :selected-switch-id="props.selectedSwitchId"
-                    @hide-alert="onHideAlert"
-                    @change-target-device="onChangeTargetDevice"
-            />
-            <common-wizards-network-add-steps-create-standard-switch
-                    v-if="selectedStep.id === 2 || selectedStep.id === 6"
-                    :free-adapters="props.freeAdapters"
-                    :added-adapters="addedAdapters"
-                    :core-adapters="coreAdapters"
-                    :adapter-status="adapterStatus"
-                    :adapters="props.adapters"
-                    :is-show-no-connected-active-adapters-modal="
+    @change-steps="onChangeSteps"
+    @hide="onHideAddNetworkingModal"
+    @submit="onSubmit"
+  >
+    <template #modalBody="{ selectedStep }">
+      <common-wizards-network-add-steps-select-connection-type
+        v-if="selectedStep.id === 0"
+        v-model="connectionTypeLocal"
+      />
+      <common-wizards-network-add-steps-selected-target-device
+        v-if="selectedStep.id === 1"
+        :wizard="wizard"
+        :target-device="targetDevice"
+        :connection-type="connectionTypeLocal"
+        :standard-switches-initial="props.standardSwitchesInitial"
+        :messages-fields="selectedStep.fields"
+        :alert-messages="alertMessages[1]"
+        :selected-standard-switch-id="props.selectedStandardSwitchId"
+        :selected-switch-id="props.selectedSwitchId"
+        @hide-alert="onHideAlert"
+        @change-target-device="onChangeTargetDevice"
+      />
+      <common-wizards-network-add-steps-create-standard-switch
+        v-if="selectedStep.id === 2 || selectedStep.id === 6"
+        :free-adapters="props.freeAdapters"
+        :added-adapters="addedAdapters"
+        :core-adapters="coreAdapters"
+        :adapter-status="adapterStatus"
+        :adapters="props.adapters"
+        :is-show-no-connected-active-adapters-modal="
           isShowNoConnectedActiveAdaptersModal
         "
-                    :is-show-no-active-adapters-modal="isShowNoActiveAdaptersModal"
-                    :is-dark-mode="props.isDarkMode"
-                    @get-free-adapters="onGetFreeAdapters"
-                    @change-added-adapters="onChangeAddedAdapters"
-                    @change-adapter-status="onChangeAdapterStatus"
-                    @confirm-no-active-adapters-modal="onConfirmNoActiveAdaptersModal"
-                    @hide-no-connected-active-adapters-modal="
+        :is-show-no-active-adapters-modal="isShowNoActiveAdaptersModal"
+        :is-dark-mode="props.isDarkMode"
+        @get-free-adapters="onGetFreeAdapters"
+        @change-added-adapters="onChangeAddedAdapters"
+        @change-adapter-status="onChangeAdapterStatus"
+        @confirm-no-active-adapters-modal="onConfirmNoActiveAdaptersModal"
+        @hide-no-connected-active-adapters-modal="
           onHideNoConnectedActiveAdaptersModal
         "
-                    @hide-no-active-adapters-modal="onHideNoActiveAdaptersModal"
-            />
-            <common-wizards-network-add-steps-port-properties
-                    v-if="selectedStep.id === 3"
-                    :wizard="wizard"
-                    :port-properties="portProperties"
-                    :mtu-from-switch="mtuFromSwitch"
-                    :project="props.project"
-                    :messages-fields="selectedStep.fields"
-                    :alert-messages="alertMessages[3]"
-                    :tcp-stacks="props.tcpStacks"
-                    @change-gateway-flag="onChangeGatewayFlag"
-                    @change-port-properties="onChangePortProperties"
-                    @hide-alert="onHideAlert"
-            />
-            <common-wizards-network-add-steps-ip-four-settings
-                    v-if="selectedStep.id === 4"
-                    :wizard="wizard"
-                    :ip-four-settings="ipFourSettings"
-                    :messages-fields="selectedStep.fields"
-                    :alert-messages="alertMessages[4]"
-                    :tcp-stacks="props.tcpStacks"
-                    :tcp="portProperties.tcp"
-                    :gateway-flag="gatewayFlag"
-                    @change-gateway-flag="onChangeGatewayFlag"
-                    @change-ip-four-settings="onChangeIpFourSettings"
-                    @hide-alert="onHideAlert"
-            />
-            <common-wizards-network-add-steps-connection-settings
-                    v-if="selectedStep.id === 5"
-                    :wizard="wizard"
-                    :connection-settings="connectionSettings"
-                    :messages-fields="selectedStep.fields"
-                    :alert-messages="alertMessages[5]"
-                    @change-connection-settings="onChangeConnectionSettings"
-                    @hide-alert="onHideAlert"
-            />
-            <!--      <common-wizards-network-add-steps-physical-adapter-->
-            <!--        v-if="selectedStep.id === 6"-->
-            <!--      />-->
-            <common-wizards-network-add-steps-ready-complete
-                    v-if="selectedStep.id === 7"
-                    :ready-complete-fields="readyCompleteFields"
-            />
-        </template>
-    </atoms-wizard>
+        @hide-no-active-adapters-modal="onHideNoActiveAdaptersModal"
+      />
+      <common-wizards-network-add-steps-port-properties
+        v-if="selectedStep.id === 3"
+        :wizard="wizard"
+        :port-properties="portProperties"
+        :mtu-from-switch="mtuFromSwitch"
+        :project="props.project"
+        :messages-fields="selectedStep.fields"
+        :alert-messages="alertMessages[3]"
+        :tcp-stacks="props.tcpStacks"
+        @change-gateway-flag="onChangeGatewayFlag"
+        @change-port-properties="onChangePortProperties"
+        @hide-alert="onHideAlert"
+      />
+      <common-wizards-network-add-steps-ip-four-settings
+        v-if="selectedStep.id === 4"
+        :wizard="wizard"
+        :ip-four-settings="ipFourSettings"
+        :messages-fields="selectedStep.fields"
+        :alert-messages="alertMessages[4]"
+        :tcp-stacks="props.tcpStacks"
+        :tcp="portProperties.tcp"
+        :gateway-flag="gatewayFlag"
+        @change-gateway-flag="onChangeGatewayFlag"
+        @change-ip-four-settings="onChangeIpFourSettings"
+        @hide-alert="onHideAlert"
+      />
+      <common-wizards-network-add-steps-connection-settings
+        v-if="selectedStep.id === 5"
+        :wizard="wizard"
+        :connection-settings="connectionSettings"
+        :messages-fields="selectedStep.fields"
+        :alert-messages="alertMessages[5]"
+        @change-connection-settings="onChangeConnectionSettings"
+        @hide-alert="onHideAlert"
+      />
+      <!--      <common-wizards-network-add-steps-physical-adapter-->
+      <!--        v-if="selectedStep.id === 6"-->
+      <!--      />-->
+      <common-wizards-network-add-steps-ready-complete
+        v-if="selectedStep.id === 7"
+        :ready-complete-fields="readyCompleteFields"
+      />
+    </template>
+  </atoms-wizard>
 </template>
 
 <script setup lang="ts">
 import {
-    UI_I_ArbitraryObject,
-    UI_I_Localization,
+  UI_I_ArbitraryObject,
+  UI_I_Localization,
+  UI_I_ItemsWithTotalCounts,
 } from '~/lib/models/interfaces'
 import { UI_T_Project } from '~/lib/models/types'
 import {
-    UI_I_PortProperties,
-    UI_I_IpFourSettings,
-    UI_I_ConnectionSettings,
-    UI_I_TargetDevice,
-    UI_I_Switch,
-    UI_I_ReadyCompleteFields,
-    UI_I_AddNetworkingSecondOrThirdSchemeDataSend,
-    UI_I_AddNetworkingZeroOrFirstSchemeDataSend,
-    UI_I_AddNetworkingFourthOrFifthSchemeDataSend,
-    UI_I_AddNetworkingEmits,
-    UI_I_TCPStack,
+  UI_I_PortProperties,
+  UI_I_IpFourSettings,
+  UI_I_ConnectionSettings,
+  UI_I_TargetDevice,
+  UI_I_Switch,
+  UI_I_ReadyCompleteFields,
+  UI_I_AddNetworkingSecondOrThirdSchemeDataSend,
+  UI_I_AddNetworkingZeroOrFirstSchemeDataSend,
+  UI_I_AddNetworkingFourthOrFifthSchemeDataSend,
+  UI_I_AddNetworkingEmits,
+  UI_I_TCPStack,
 } from '~/components/common/wizards/network/add/lib/models/interfaces'
 import {
-    UI_I_Adapter,
-    UI_I_AdapterStatus,
-    UI_I_SwitchAdapters,
+  UI_I_Adapter,
+  UI_I_AdapterStatus,
+  UI_I_SwitchAdapterItem,
+  UI_I_DiagramData,
 } from '~/components/common/diagramMain/lib/models/interfaces'
 import {
-    UI_I_ValidationReturn,
-    UI_I_WizardStep,
+  UI_I_ValidationReturn,
+  UI_I_WizardStep,
 } from '~/components/atoms/wizard/lib/models/interfaces'
 import { UI_E_ValidationFields } from '~/components/common/wizards/network/add/lib/models/enums'
 import { getVlanId } from '~/components/common/wizards/network/add/lib/utils'
 import Wizard from '~/components/atoms/wizard/lib/utils/utils'
 import {
-    createZeroSchemeReadyCompleteFunc,
-    createFirstSchemeReadyCompleteFunc,
-    createSecondSchemeReadyCompleteFunc,
-    createThirdSchemeReadyCompleteFunc,
-    stepsSchemeInitial,
-    stepsFunc,
-    connectionSettingsInitial,
-    portPropertiesInitial,
-    ipFourSettingsInitial,
-    targetDeviceInitial,
-    addNetworkingZeroOrFirstSchemeDataFunc,
-    addNetworkingSecondOrThirdSchemeDataFunc,
-    addNetworkingFourthOrFifthSchemeDataFunc,
+  createZeroSchemeReadyCompleteFunc,
+  createFirstSchemeReadyCompleteFunc,
+  createSecondSchemeReadyCompleteFunc,
+  createThirdSchemeReadyCompleteFunc,
+  stepsSchemeInitial,
+  stepsFunc,
+  connectionSettingsInitial,
+  portPropertiesInitial,
+  ipFourSettingsInitial,
+  targetDeviceInitial,
+  addNetworkingZeroOrFirstSchemeDataFunc,
+  addNetworkingSecondOrThirdSchemeDataFunc,
+  addNetworkingFourthOrFifthSchemeDataFunc,
 } from '~/components/common/wizards/network/add/lib/config'
-
 import {
-    checkTargetDeviceSync,
-    checkAdaptersSync,
-    checkPortPropertiesSync,
-    checkIpFourSettingsSync,
-    checkConnectionSettingsSync,
-    checkNetworkAsync,
+  checkTargetDeviceSync,
+  checkAdaptersSync,
+  checkPortPropertiesSync,
+  checkIpFourSettingsSync,
+  checkConnectionSettingsSync,
+  checkNetworkAsync,
 } from '~/components/common/wizards/network/add/validations/validations'
 
 const props = withDefaults(
-    defineProps<{
-        show: boolean
-        adapters: UI_I_SwitchAdapters
-        standardSwitchesInitial: UI_I_Switch[]
-        freeAdapters: UI_I_Adapter[]
-        project?: UI_T_Project
-        isDarkMode?: boolean
-        selectedStandardSwitchId?: string
-        selectedSwitchId?: string
-        tcpStacks?: UI_I_TCPStack[]
-        tcpStackLoading?: boolean
-        diagramsData?: UI_I_DiagramData[]
-    }>(),
-    {
-        standardSwitchesInitial: () => [],
-        freeAdapters: () => [],
-        project: 'procurator',
-        isDarkMode: false,
-        selectedStandardSwitchId: '',
-        selectedSwitchId: '',
-        tcpStacks: () => [],
-        tcpStackLoading: false,
-        diagramsData: [],
-    }
+  defineProps<{
+    show: boolean
+    adapters: UI_I_ItemsWithTotalCounts<UI_I_SwitchAdapterItem>
+    standardSwitchesInitial: UI_I_Switch[]
+    freeAdapters: UI_I_Adapter[]
+    project?: UI_T_Project
+    isDarkMode?: boolean
+    selectedStandardSwitchId?: string
+    selectedSwitchId?: string
+    tcpStacks?: UI_I_TCPStack[]
+    tcpStackLoading?: boolean
+    diagramsData?: UI_I_DiagramData[]
+  }>(),
+  {
+    standardSwitchesInitial: () => [],
+    freeAdapters: () => [],
+    project: 'procurator',
+    isDarkMode: false,
+    selectedStandardSwitchId: '',
+    selectedSwitchId: '',
+    tcpStacks: () => [],
+    tcpStackLoading: false,
+    diagramsData: [],
+  }
 )
 
 const emits = defineEmits<UI_I_AddNetworkingEmits>()
@@ -193,12 +194,12 @@ const localization = computed<UI_I_Localization>(() => useLocal())
 
 const hostname = ref<string>('')
 const title = computed<string>(
-    () => `${hostname.value} - ${localization.value.addNetworking}`
+  () => `${hostname.value} - ${localization.value.addNetworking}`
 )
 
 const wizard: Wizard = new Wizard(
-    stepsFunc(localization.value),
-    stepsSchemeInitial
+  stepsFunc(localization.value),
+  stepsSchemeInitial
 )
 const wasCompleted = computed<boolean>(() => wizard.wasCompleted())
 const selectedScheme = computed<number[]>(() => wizard.selectedScheme.value)
@@ -210,15 +211,15 @@ const readyCompleteFields = ref<UI_I_ReadyCompleteFields[]>([])
 const connectionType = ref<string>('0')
 
 const connectionTypeLocal = computed<string>({
-    get() {
-        return connectionType.value
-    },
-    set(newValue: string) {
-        wizard.resetAfterSelected()
-        connectionType.value = newValue
-        targetDevice.value.standardSwitch = props.selectedStandardSwitchId
-        targetDevice.value.switch = props.selectedSwitchId
-    },
+  get() {
+    return connectionType.value
+  },
+  set(newValue: string) {
+    wizard.resetAfterSelected()
+    connectionType.value = newValue
+    targetDevice.value.standardSwitch = props.selectedStandardSwitchId
+    targetDevice.value.switch = props.selectedSwitchId
+  },
 })
 
 // Step's content data (createStandardSwitch)
@@ -226,16 +227,16 @@ const addedAdapters = ref<string[]>([])
 const coreAdapters = ref<string[]>([])
 
 const onChangeAddedAdapters = (addedAdaptersNew: string[]): void => {
-    addedAdapters.value = addedAdaptersNew
+  addedAdapters.value = addedAdaptersNew
 }
 
 const adapterStatus = ref<UI_I_AdapterStatus>({
-    active: [],
-    standby: [],
-    unused: [],
+  active: [],
+  standby: [],
+  unused: [],
 })
 const onChangeAdapterStatus = (adapterStatusNew: UI_I_AdapterStatus): void => {
-    adapterStatus.value = adapterStatusNew
+  adapterStatus.value = adapterStatusNew
 }
 
 // Step's content data and changers (targetDevice)
@@ -243,525 +244,525 @@ const targetDevice = ref<UI_I_TargetDevice>(useDeepCopy(targetDeviceInitial))
 const mtuFromSwitch = ref<number>(1500)
 
 const onChangeTargetDevice = (newTargetDevice: UI_I_TargetDevice): void => {
-    const oldTargetDeviceSelected = useDeepCopy(targetDevice.value).selected
-    const newTargetDeviceSelected = newTargetDevice.selected
+  const oldTargetDeviceSelected = useDeepCopy(targetDevice.value).selected
+  const newTargetDeviceSelected = newTargetDevice.selected
 
-    if (oldTargetDeviceSelected !== newTargetDeviceSelected) {
-        wizard.resetAfterSelected()
-    }
+  if (oldTargetDeviceSelected !== newTargetDeviceSelected) {
+    wizard.resetAfterSelected()
+  }
 
-    const selectedSwitch = props.standardSwitchesInitial.find(
-        (sw) => newTargetDevice.standardSwitch === sw.name
-    )
+  const selectedSwitch = props.standardSwitchesInitial.find(
+    (sw) => newTargetDevice.standardSwitch === sw.name
+  )
 
-    if (newTargetDeviceSelected === '1' && selectedSwitch) {
-        mtuFromSwitch.value = selectedSwitch?.mtu || 1500
-    }
-    if (newTargetDeviceSelected === '3') {
-        mtuFromSwitch.value = newTargetDevice.mtu || 1500
-    }
+  if (newTargetDeviceSelected === '1' && selectedSwitch) {
+    mtuFromSwitch.value = selectedSwitch?.mtu || 1500
+  }
+  if (newTargetDeviceSelected === '3') {
+    mtuFromSwitch.value = newTargetDevice.mtu || 1500
+  }
 
-    targetDevice.value = useDeepCopy(newTargetDevice)
+  targetDevice.value = useDeepCopy(newTargetDevice)
 }
 
 // Step's content data and changers (portProperties)
 const portProperties = ref<UI_I_PortProperties>(
-    useDeepCopy(portPropertiesInitial)
+  useDeepCopy(portPropertiesInitial)
 )
 const onChangePortProperties = (newFields: UI_I_PortProperties): void => {
-    if (portProperties.value.tcp !== newFields.tcp) {
-        ipFourSettings.value.static.defaultGateway.value =
-            props.tcpStacks?.find((tcp: UI_I_TCPStack) => tcp.id === newFields.tcp)
-                .gateway || ''
-    }
-    portProperties.value = newFields
+  if (portProperties.value.tcp !== newFields.tcp) {
+    ipFourSettings.value.static.defaultGateway.value =
+      props.tcpStacks?.find((tcp: UI_I_TCPStack) => tcp.id === newFields.tcp)
+        .gateway || ''
+  }
+  portProperties.value = newFields
 }
 
 // Step's content data and changers (ipFourSettings)
 const ipFourSettings = ref<UI_I_IpFourSettings>(ipFourSettingsInitial)
 const onChangeIpFourSettings = (newFields: UI_I_IpFourSettings): void => {
-    ipFourSettings.value = newFields
+  ipFourSettings.value = newFields
 }
 
 const gatewayFlag = ref<boolean>(false)
 const onChangeGatewayFlag = (newValue: boolean) => {
-    gatewayFlag.value = newValue
+  gatewayFlag.value = newValue
 }
 
 // Step's content data and changers (connectionSettings)
 const connectionSettings = ref<UI_I_ConnectionSettings>(
-    connectionSettingsInitial
+  connectionSettingsInitial
 )
 const onChangeConnectionSettings = (
-    newFields: UI_I_ConnectionSettings
+  newFields: UI_I_ConnectionSettings
 ): void => {
-    connectionSettings.value = newFields
+  connectionSettings.value = newFields
 }
 
 const onHideAlert = (stepId: number): void => {
-    wizard.hideAlertMessagesByStepId(stepId)
+  wizard.hideAlertMessagesByStepId(stepId)
 }
 
 let flagSwitch = ''
 
 // Choosing Scheme
 watch(
-    [connectionTypeLocal, targetDevice],
-    (newValues, oldValues) => {
-        const newCT = newValues[0] // -> newConnectionType
-        const oldCT = oldValues[0] // -> oldConnectionType
-        const newTD = newValues[1] // -> newTargetDevice
-        const oldTD = oldValues[1] // -> oldTargetDevice
-        if (!oldTD || oldTD.selected !== newTD.selected) {
-            flagSwitch = ''
-            addedAdapters.value = []
-            adapterStatus.value = {
-                active: [],
-                standby: [],
-                unused: [],
-            }
-        }
-        if (newCT !== oldCT) {
-            newCT === '0' && props.selectedStandardSwitchId
-                ? (targetDevice.value.selected = '1')
-                : (targetDevice.value.selected = '0')
-            newCT === '1' && (targetDevice.value.selected = '1')
-            newCT === '2' && (targetDevice.value.selected = '2')
-        }
-        if (newCT === '0') {
-            ;(newTD.selected === '0' || newTD.selected === '1') &&
-            wizard.changeScheme(0)
-            newTD.selected === '3' && wizard.changeScheme(1)
-        }
-        if (newCT === '1') {
-            newTD.selected === '1' && wizard.changeScheme(2)
-            newTD.selected === '3' && wizard.changeScheme(3)
-        }
-        if (newCT === '2') {
-            newTD.selected === '2' && wizard.changeScheme(4)
-            newTD.selected === '3' && wizard.changeScheme(5)
-        }
-    },
-    { deep: true, immediate: true }
+  [connectionTypeLocal, targetDevice],
+  (newValues, oldValues) => {
+    const newCT = newValues[0] // -> newConnectionType
+    const oldCT = oldValues[0] // -> oldConnectionType
+    const newTD = newValues[1] // -> newTargetDevice
+    const oldTD = oldValues[1] // -> oldTargetDevice
+    if (!oldTD || oldTD.selected !== newTD.selected) {
+      flagSwitch = ''
+      addedAdapters.value = []
+      adapterStatus.value = {
+        active: [],
+        standby: [],
+        unused: [],
+      }
+    }
+    if (newCT !== oldCT) {
+      newCT === '0' && props.selectedStandardSwitchId
+        ? (targetDevice.value.selected = '1')
+        : (targetDevice.value.selected = '0')
+      newCT === '1' && (targetDevice.value.selected = '1')
+      newCT === '2' && (targetDevice.value.selected = '2')
+    }
+    if (newCT === '0') {
+      ;(newTD.selected === '0' || newTD.selected === '1') &&
+        wizard.changeScheme(0)
+      newTD.selected === '3' && wizard.changeScheme(1)
+    }
+    if (newCT === '1') {
+      newTD.selected === '1' && wizard.changeScheme(2)
+      newTD.selected === '3' && wizard.changeScheme(3)
+    }
+    if (newCT === '2') {
+      newTD.selected === '2' && wizard.changeScheme(4)
+      newTD.selected === '3' && wizard.changeScheme(5)
+    }
+  },
+  { deep: true, immediate: true }
 )
 
 const onGetExistingStandardSwitches = (): void => {
-    wizard.setLoader(true)
-    emits('get-existing-standard-switches', () => wizard.setLoader(false))
+  wizard.setLoader(true)
+  emits('get-existing-standard-switches', () => wizard.setLoader(false))
 }
 
 const onGetTcpStacks = (): void => {
-    emits('get-tcp-stacks')
+  emits('get-tcp-stacks')
 }
 
 watch(
-    () => props.tcpStackLoading,
-    (newValue: boolean) => {
-        wizard.setLoader(newValue)
-    }
+  () => props.tcpStackLoading,
+  (newValue: boolean) => {
+    wizard.setLoader(newValue)
+  }
 )
 
 watch(
-    () => wizard.selectedStepId,
-    (newSelectedStep: number) => {
-        if (newSelectedStep === 1) {
-            onGetExistingStandardSwitches()
-        }
-        if (newSelectedStep === 3) {
-            onGetTcpStacks()
-        }
-        if (newSelectedStep === 6 && flagSwitch !== targetDevice.value.switch) {
-            const nics = props.standardSwitchesInitial.find(
-                (sw) => sw.id === targetDevice.value.switch
-            ).nics
-            adapterStatus.value = {
-                active: nics.active || [],
-                standby: nics.standby || [],
-                unused: nics.unused || [],
-            }
-            coreAdapters.value = [
-                ...adapterStatus.value.active,
-                ...adapterStatus.value.standby,
-                ...adapterStatus.value.unused,
-            ]
-            flagSwitch = targetDevice.value.switch
-        }
-
-        if (newSelectedStep !== 7) return // If last step
-        if (wizard.isSelectedScheme(0)) {
-            readyCompleteFields.value = createZeroSchemeReadyCompleteFunc(
-                targetDevice.value,
-                portProperties.value,
-                ipFourSettings.value,
-                localization.value
-            )
-            return
-        }
-
-        if (wizard.isSelectedScheme(1)) {
-            readyCompleteFields.value = createFirstSchemeReadyCompleteFunc(
-                targetDevice.value,
-                portProperties.value,
-                ipFourSettings.value,
-                addedAdapters.value,
-                localization.value
-            )
-            return
-        }
-        if (wizard.isSelectedScheme(2)) {
-            readyCompleteFields.value = createSecondSchemeReadyCompleteFunc(
-                connectionSettings.value,
-                targetDevice.value,
-                localization.value
-            )
-            return
-        }
-        if (wizard.isSelectedScheme(3)) {
-            readyCompleteFields.value = createThirdSchemeReadyCompleteFunc(
-                connectionSettings.value,
-                targetDevice.value,
-                addedAdapters.value,
-                localization.value
-            )
-        }
+  () => wizard.selectedStepId,
+  (newSelectedStep: number) => {
+    if (newSelectedStep === 1) {
+      onGetExistingStandardSwitches()
+    }
+    if (newSelectedStep === 3) {
+      onGetTcpStacks()
+    }
+    if (newSelectedStep === 6 && flagSwitch !== targetDevice.value.switch) {
+      const nics = props.standardSwitchesInitial.find(
+        (sw) => sw.id === targetDevice.value.switch
+      ).nics
+      adapterStatus.value = {
+        active: nics.active || [],
+        standby: nics.standby || [],
+        unused: nics.unused || [],
+      }
+      coreAdapters.value = [
+        ...adapterStatus.value.active,
+        ...adapterStatus.value.standby,
+        ...adapterStatus.value.unused,
+      ]
+      flagSwitch = targetDevice.value.switch
+    }
+
+    if (newSelectedStep !== 7) return // If last step
+    if (wizard.isSelectedScheme(0)) {
+      readyCompleteFields.value = createZeroSchemeReadyCompleteFunc(
+        targetDevice.value,
+        portProperties.value,
+        ipFourSettings.value,
+        localization.value
+      )
+      return
+    }
+
+    if (wizard.isSelectedScheme(1)) {
+      readyCompleteFields.value = createFirstSchemeReadyCompleteFunc(
+        targetDevice.value,
+        portProperties.value,
+        ipFourSettings.value,
+        addedAdapters.value,
+        localization.value
+      )
+      return
+    }
+    if (wizard.isSelectedScheme(2)) {
+      readyCompleteFields.value = createSecondSchemeReadyCompleteFunc(
+        connectionSettings.value,
+        targetDevice.value,
+        localization.value
+      )
+      return
+    }
+    if (wizard.isSelectedScheme(3)) {
+      readyCompleteFields.value = createThirdSchemeReadyCompleteFunc(
+        connectionSettings.value,
+        targetDevice.value,
+        addedAdapters.value,
+        localization.value
+      )
     }
+  }
 )
 
 // Reset data
 const reset = (): void => {
-    wizard.reset()
-    connectionTypeLocal.value = '0'
-    targetDevice.value = useDeepCopy(targetDeviceInitial)
-    connectionSettings.value = useDeepCopy(connectionSettingsInitial)
-    portProperties.value = useDeepCopy(portPropertiesInitial)
-    ipFourSettings.value = useDeepCopy(ipFourSettingsInitial)
-    coreAdapters.value = []
-    addedAdapters.value = []
-    adapterStatus.value = {
-        active: [],
-        standby: [],
-        unused: [],
-    }
+  wizard.reset()
+  connectionTypeLocal.value = '0'
+  targetDevice.value = useDeepCopy(targetDeviceInitial)
+  connectionSettings.value = useDeepCopy(connectionSettingsInitial)
+  portProperties.value = useDeepCopy(portPropertiesInitial)
+  ipFourSettings.value = useDeepCopy(ipFourSettingsInitial)
+  coreAdapters.value = []
+  addedAdapters.value = []
+  adapterStatus.value = {
+    active: [],
+    standby: [],
+    unused: [],
+  }
 }
 
 const isShowNoConnectedActiveAdaptersModal = ref(false)
 const isShowNoActiveAdaptersModal = ref(false)
 
 const showNoConnectedActiveAdaptersModal = (): void => {
-    isShowNoConnectedActiveAdaptersModal.value = true
+  isShowNoConnectedActiveAdaptersModal.value = true
 }
 const onHideNoConnectedActiveAdaptersModal = (): void => {
-    isShowNoConnectedActiveAdaptersModal.value = false
+  isShowNoConnectedActiveAdaptersModal.value = false
 }
 const showNoActiveAdaptersModal = (): void => {
-    isShowNoActiveAdaptersModal.value = true
+  isShowNoActiveAdaptersModal.value = true
 }
 const onHideNoActiveAdaptersModal = (): void => {
-    isShowNoActiveAdaptersModal.value = false
+  isShowNoActiveAdaptersModal.value = false
 }
 
 const onConfirmNoActiveAdaptersModal = (): void => {
-    onHideNoConnectedActiveAdaptersModal()
-    onHideNoActiveAdaptersModal()
-    wizard.selectStepHard(wizard.waitingStepId)
+  onHideNoConnectedActiveAdaptersModal()
+  onHideNoActiveAdaptersModal()
+  wizard.selectStepHard(wizard.waitingStepId)
 }
 
 const onGetFreeAdapters = (showAddAdapterModal: () => void): void => {
-    wizard.setLoader(true)
-    emits('get-free-adapters', () => {
-        wizard.setLoader(false)
-        showAddAdapterModal()
-    })
+  wizard.setLoader(true)
+  emits('get-free-adapters', () => {
+    wizard.setLoader(false)
+    showAddAdapterModal()
+  })
 }
 
 const checkFinal = async (): Promise<UI_I_ArbitraryObject<string>> => {
-    let sendData:
-        | UI_I_AddNetworkingZeroOrFirstSchemeDataSend
-        | UI_I_AddNetworkingSecondOrThirdSchemeDataSend
-        | UI_I_AddNetworkingFourthOrFifthSchemeDataSend
-
-    let type: 'network' | 'vmkernel'
-
-    if (wizard.isSelectedScheme(0) || wizard.isSelectedScheme(1)) {
-        const vlan = getVlanId(portProperties.value.vlanId)
-
-        sendData = addNetworkingZeroOrFirstSchemeDataFunc(
-            targetDevice.value,
-            Number(vlan),
-            portProperties.value,
-            ipFourSettings.value,
-            wizard.isSelectedScheme(1),
-            adapterStatus.value
-        )
-
-        type = 'vmkernel'
-    }
-
-    if (wizard.isSelectedScheme(2) || wizard.isSelectedScheme(3)) {
-        const vlan = getVlanId(connectionSettings.value.vlanId)
-
-        sendData = addNetworkingSecondOrThirdSchemeDataFunc(
-            connectionSettings.value,
-            targetDevice.value,
-            Number(vlan),
-            wizard.isSelectedScheme(2),
-            adapterStatus.value
-        )
-
-        type = 'network'
-    }
-
-    if (wizard.isSelectedScheme(4) || wizard.isSelectedScheme(5)) {
-        sendData = addNetworkingFourthOrFifthSchemeDataFunc(
-            targetDevice.value.switch,
-            wizard.isSelectedScheme(4),
-            adapterStatus.value,
-            props.diagramsData,
-            targetDevice.value.mtu
-        )
-
-        type = 'network'
-    }
-
-    return new Promise((resolve, _reject) =>
-        emits(
-            'add-networking-data-validate',
-            sendData,
-            type,
-            (err_arg: UI_I_ArbitraryObject<string>): void => {
-                resolve(err_arg)
-            }
-        )
+  let sendData:
+    | UI_I_AddNetworkingZeroOrFirstSchemeDataSend
+    | UI_I_AddNetworkingSecondOrThirdSchemeDataSend
+    | UI_I_AddNetworkingFourthOrFifthSchemeDataSend
+
+  let type: 'network' | 'vmkernel'
+
+  if (wizard.isSelectedScheme(0) || wizard.isSelectedScheme(1)) {
+    const vlan = getVlanId(portProperties.value.vlanId)
+
+    sendData = addNetworkingZeroOrFirstSchemeDataFunc(
+      targetDevice.value,
+      Number(vlan),
+      portProperties.value,
+      ipFourSettings.value,
+      wizard.isSelectedScheme(1),
+      adapterStatus.value
     )
+
+    type = 'vmkernel'
+  }
+
+  if (wizard.isSelectedScheme(2) || wizard.isSelectedScheme(3)) {
+    const vlan = getVlanId(connectionSettings.value.vlanId)
+
+    sendData = addNetworkingSecondOrThirdSchemeDataFunc(
+      connectionSettings.value,
+      targetDevice.value,
+      Number(vlan),
+      wizard.isSelectedScheme(2),
+      adapterStatus.value
+    )
+
+    type = 'network'
+  }
+
+  if (wizard.isSelectedScheme(4) || wizard.isSelectedScheme(5)) {
+    sendData = addNetworkingFourthOrFifthSchemeDataFunc(
+      targetDevice.value.switch,
+      wizard.isSelectedScheme(4),
+      adapterStatus.value,
+      props.diagramsData,
+      targetDevice.value.mtu
+    )
+
+    type = 'network'
+  }
+
+  return new Promise((resolve, _reject) =>
+    emits(
+      'add-networking-data-validate',
+      sendData,
+      type,
+      (err_arg: UI_I_ArbitraryObject<string>): void => {
+        resolve(err_arg)
+      }
+    )
+  )
 }
 
 const finalValidationFunc = async (
-    value: UI_I_WizardStep[]
+  value: UI_I_WizardStep[]
 ): Promise<UI_I_ValidationReturn> => {
-    let stepHasError = false
+  let stepHasError = false
 
-    wizard.setLoader(true)
+  wizard.setLoader(true)
 
-    const validationFields: {
-        [key: string]: string
-    } = await checkFinal()
+  const validationFields: {
+    [key: string]: string
+  } = await checkFinal()
 
-    wizard.setLoader(false)
+  wizard.setLoader(false)
 
-    for (const fieldName in validationFields) {
-        const stepId = wizard.getStepIdByFieldName(fieldName)
+  for (const fieldName in validationFields) {
+    const stepId = wizard.getStepIdByFieldName(fieldName)
 
-        if (stepId !== -1) {
-            stepHasError = wizard.setValidation(stepId, fieldName, {
-                fieldMessage: validationFields[fieldName],
-                alertMessage: validationFields[fieldName],
-            })
-        }
+    if (stepId !== -1) {
+      stepHasError = wizard.setValidation(stepId, fieldName, {
+        fieldMessage: validationFields[fieldName],
+        alertMessage: validationFields[fieldName],
+      })
     }
+  }
 
-    return {
-        stepHasError,
-        newValue: value,
-    }
+  return {
+    stepHasError,
+    newValue: value,
+  }
 }
 
 const validationFunc = async (
-    value: UI_I_WizardStep[],
-    currentStep: UI_I_WizardStep,
-    nextStep: UI_I_WizardStep
+  value: UI_I_WizardStep[],
+  currentStep: UI_I_WizardStep,
+  nextStep: UI_I_WizardStep
 ): Promise<UI_I_ValidationReturn> => {
-    let stepHasError = false
-    let stepShouldStop = {
-        ifOnCurrentStep: false,
-        ifFromAnyStep: false,
-        stoppageStepId: -1,
-    }
-
-    if (wizard.isValidateForStep(1, currentStep.id, nextStep.id)) {
-        const targetDeviceValidation = checkTargetDeviceSync(
-            localization.value,
-            targetDevice.value,
-            wizard,
-            value
-        )
+  let stepHasError = false
+  let stepShouldStop = {
+    ifOnCurrentStep: false,
+    ifFromAnyStep: false,
+    stoppageStepId: -1,
+  }
 
-        value = targetDeviceValidation.newValue
+  if (wizard.isValidateForStep(1, currentStep.id, nextStep.id)) {
+    const targetDeviceValidation = checkTargetDeviceSync(
+      localization.value,
+      targetDevice.value,
+      wizard,
+      value
+    )
 
-        stepHasError = stepHasError || targetDeviceValidation.stepHasError
-    }
+    value = targetDeviceValidation.newValue
 
-    if (wizard.isValidateForStep(2, currentStep.id, nextStep.id)) {
-        wizard.waitingStepId = nextStep.id
+    stepHasError = stepHasError || targetDeviceValidation.stepHasError
+  }
 
-        const adapterValidation = checkAdaptersSync(
-            localization.value,
-            adapterStatus.value,
-            value,
-            currentStep.id,
-            nextStep.id,
-            props.freeAdapters,
-            showNoActiveAdaptersModal,
-            showNoConnectedActiveAdaptersModal
-        )
+  if (wizard.isValidateForStep(2, currentStep.id, nextStep.id)) {
+    wizard.waitingStepId = nextStep.id
+
+    const adapterValidation = checkAdaptersSync(
+      localization.value,
+      adapterStatus.value,
+      value,
+      currentStep.id,
+      nextStep.id,
+      props.freeAdapters,
+      showNoActiveAdaptersModal,
+      showNoConnectedActiveAdaptersModal
+    )
 
-        value = adapterValidation.newValue
+    value = adapterValidation.newValue
 
-        stepShouldStop = adapterValidation.stepShouldStop || stepShouldStop
+    stepShouldStop = adapterValidation.stepShouldStop || stepShouldStop
 
-        stepHasError = stepHasError || adapterValidation.stepHasError
-    }
+    stepHasError = stepHasError || adapterValidation.stepHasError
+  }
 
-    if (wizard.isValidateForStep(3, currentStep.id, nextStep.id)) {
-        const labelValidation = await checkNetworkAsync(
-            value,
-            portProperties.value.networkLabel,
-            3,
-            UI_E_ValidationFields.PORT_PROPERTIES_NETWORK,
-            emits,
-            localization.value,
-            wizard
-        )
+  if (wizard.isValidateForStep(3, currentStep.id, nextStep.id)) {
+    const labelValidation = await checkNetworkAsync(
+      value,
+      portProperties.value.networkLabel,
+      3,
+      UI_E_ValidationFields.PORT_PROPERTIES_NETWORK,
+      emits,
+      localization.value,
+      wizard
+    )
 
-        value = labelValidation.newValue
+    value = labelValidation.newValue
 
-        const portPropertiesValidation = checkPortPropertiesSync(
-            localization.value,
-            portProperties.value,
-            wizard,
-            value
-        )
+    const portPropertiesValidation = checkPortPropertiesSync(
+      localization.value,
+      portProperties.value,
+      wizard,
+      value
+    )
 
-        value = portPropertiesValidation.newValue
+    value = portPropertiesValidation.newValue
 
-        stepHasError =
-            stepHasError ||
-            labelValidation.stepHasError ||
-            portPropertiesValidation.stepHasError
-    }
+    stepHasError =
+      stepHasError ||
+      labelValidation.stepHasError ||
+      portPropertiesValidation.stepHasError
+  }
 
-    if (wizard.isValidateForStep(4, currentStep.id, nextStep.id)) {
-        const ipValidation = checkIpFourSettingsSync(
-            localization.value,
-            ipFourSettings.value,
-            wizard,
-            value
-        )
+  if (wizard.isValidateForStep(4, currentStep.id, nextStep.id)) {
+    const ipValidation = checkIpFourSettingsSync(
+      localization.value,
+      ipFourSettings.value,
+      wizard,
+      value
+    )
 
-        value = ipValidation.newValue
+    value = ipValidation.newValue
 
-        stepHasError = stepHasError || ipValidation.stepHasError
-    }
+    stepHasError = stepHasError || ipValidation.stepHasError
+  }
 
-    if (wizard.isValidateForStep(5, currentStep.id, nextStep.id)) {
-        const labelValidation = await checkNetworkAsync(
-            value,
-            connectionSettings.value.networkLabel,
-            5,
-            UI_E_ValidationFields.CONNECTION_SETTINGS_NETWORK,
-            emits,
-            localization.value,
-            wizard
-        )
+  if (wizard.isValidateForStep(5, currentStep.id, nextStep.id)) {
+    const labelValidation = await checkNetworkAsync(
+      value,
+      connectionSettings.value.networkLabel,
+      5,
+      UI_E_ValidationFields.CONNECTION_SETTINGS_NETWORK,
+      emits,
+      localization.value,
+      wizard
+    )
 
-        value = labelValidation.newValue
+    value = labelValidation.newValue
 
-        const connectionSettingsValidation = checkConnectionSettingsSync(
-            localization.value,
-            connectionSettings.value,
-            wizard,
-            value
-        )
+    const connectionSettingsValidation = checkConnectionSettingsSync(
+      localization.value,
+      connectionSettings.value,
+      wizard,
+      value
+    )
 
-        value = connectionSettingsValidation.newValue
+    value = connectionSettingsValidation.newValue
 
-        stepHasError =
-            stepHasError ||
-            labelValidation.stepHasError ||
-            connectionSettingsValidation.stepHasError
-    }
+    stepHasError =
+      stepHasError ||
+      labelValidation.stepHasError ||
+      connectionSettingsValidation.stepHasError
+  }
 
-    return {
-        newValue: value,
-        stepHasError,
-        stepShouldStop,
-    }
+  return {
+    newValue: value,
+    stepHasError,
+    stepShouldStop,
+  }
 }
 
 const onChangeSteps = async (value: UI_I_WizardStep[]): Promise<void> =>
-    wizard.changeSteps(value, validationFunc, finalValidationFunc)
+  wizard.changeSteps(value, validationFunc, finalValidationFunc)
 
 const onHideAddNetworkingModal = (): void => {
-    emits('hide')
-    reset()
+  emits('hide')
+  reset()
 }
 
 const onSubmit = async (): Promise<void> => {
-    wizard.setLoader(true)
-    let sendData:
-        | UI_I_AddNetworkingZeroOrFirstSchemeDataSend
-        | UI_I_AddNetworkingSecondOrThirdSchemeDataSend
-        | null = null
-    let type: 'network' | 'vmkernel' = 'network'
-
-    if (wizard.isSelectedScheme(0) || wizard.isSelectedScheme(1)) {
-        const vlan = getVlanId(portProperties.value.vlanId)
-        type = 'vmkernel'
-        sendData = addNetworkingZeroOrFirstSchemeDataFunc(
-            targetDevice.value,
-            Number(vlan),
-            portProperties.value,
-            ipFourSettings.value,
-            wizard.isSelectedScheme(1),
-            adapterStatus.value
-        )
-    }
-
-    if (wizard.isSelectedScheme(2) || wizard.isSelectedScheme(3)) {
-        const vlan = getVlanId(connectionSettings.value.vlanId)
-        type = 'network'
-        sendData = addNetworkingSecondOrThirdSchemeDataFunc(
-            connectionSettings.value,
-            targetDevice.value,
-            Number(vlan),
-            wizard.isSelectedScheme(2),
-            adapterStatus.value
-        )
-    }
-
-    if (wizard.isSelectedScheme(4) || wizard.isSelectedScheme(5)) {
-        sendData = addNetworkingFourthOrFifthSchemeDataFunc(
-            targetDevice.value.switch,
-            wizard.isSelectedScheme(4),
-            adapterStatus.value,
-            props.diagramsData,
-            targetDevice.value.mtu
-        )
-
-        type = 'adapter'
-    }
-
-    sendData &&
+  wizard.setLoader(true)
+  let sendData:
+    | UI_I_AddNetworkingZeroOrFirstSchemeDataSend
+    | UI_I_AddNetworkingSecondOrThirdSchemeDataSend
+    | null = null
+  let type: 'network' | 'vmkernel' = 'network'
+
+  if (wizard.isSelectedScheme(0) || wizard.isSelectedScheme(1)) {
+    const vlan = getVlanId(portProperties.value.vlanId)
+    type = 'vmkernel'
+    sendData = addNetworkingZeroOrFirstSchemeDataFunc(
+      targetDevice.value,
+      Number(vlan),
+      portProperties.value,
+      ipFourSettings.value,
+      wizard.isSelectedScheme(1),
+      adapterStatus.value
+    )
+  }
+
+  if (wizard.isSelectedScheme(2) || wizard.isSelectedScheme(3)) {
+    const vlan = getVlanId(connectionSettings.value.vlanId)
+    type = 'network'
+    sendData = addNetworkingSecondOrThirdSchemeDataFunc(
+      connectionSettings.value,
+      targetDevice.value,
+      Number(vlan),
+      wizard.isSelectedScheme(2),
+      adapterStatus.value
+    )
+  }
+
+  if (wizard.isSelectedScheme(4) || wizard.isSelectedScheme(5)) {
+    sendData = addNetworkingFourthOrFifthSchemeDataFunc(
+      targetDevice.value.switch,
+      wizard.isSelectedScheme(4),
+      adapterStatus.value,
+      props.diagramsData,
+      targetDevice.value.mtu
+    )
+
+    type = 'adapter'
+  }
+
+  sendData &&
     emits(
-        'send-add-networking-data',
-        sendData,
-        type,
-        () => wizard.setLoader(false),
-        onHideAddNetworkingModal
+      'send-add-networking-data',
+      sendData,
+      type,
+      () => wizard.setLoader(false),
+      onHideAddNetworkingModal
     )
 }
 
 onMounted(() => {
-    hostname.value = location.hostname
+  hostname.value = location.hostname
 })
 
 watch(
-    props.tcpStacks,
-    (newValue: UI_I_TCPStack[]) => {
-        portProperties.value.tcp = newValue?.[0]?.id || ''
-        ipFourSettings.value.static.defaultGateway.value =
-            newValue?.[0]?.gateway || ''
-    },
-    { deep: true }
+  props.tcpStacks,
+  (newValue: UI_I_TCPStack[]) => {
+    portProperties.value.tcp = newValue?.[0]?.id || ''
+    ipFourSettings.value.static.defaultGateway.value =
+      newValue?.[0]?.gateway || ''
+  },
+  { deep: true }
 )
 </script>