bfg-common 1.2.186 → 1.2.187

package/components/common/addNetworking/steps/IpFourSettings.vue

@@ -1,361 +0,0 @@
-<template>
-  <div class="wizard-content-container add-networking-step">
-    <common-add-networking-steps-header
-      :title="props.title"
-      :text="props.text"
-    />
-    <div class="wizard-content wizard-content-port">
-      <atoms-alert
-        v-if="hasValidationError"
-        status="alert-danger"
-        :items="props.errorMessages"
-        @remove="onHideErrorMessageAlert"
-      />
-      <form>
-        <div class="radio">
-          <input
-            id="Obtain"
-            v-model="fields.ipSettings"
-            type="radio"
-            value="0"
-            name="IPv4-settings"
-          />
-          <label for="Obtain">
-            {{ localization.obtainIPv4SettingsAutomatically }}
-          </label>
-        </div>
-        <div class="radio">
-          <input
-            id="static"
-            v-model="fields.ipSettings"
-            type="radio"
-            value="1"
-            name="IPv4-settings"
-          />
-          <label for="static"> {{ localization.useStaticIPv4Settings }} </label>
-        </div>
-
-        <div
-          :class="[
-            'form-block form-block-ipv',
-            { disabled: fields.ipSettings === '0' },
-          ]"
-        >
-          <div class="horizontal-flex-container p-b-14">
-            <label class="property-label-group">
-              {{ localization.ipv4address }}
-            </label>
-            <div class="margin-left-property-value-group">
-              <div class="property-value-group">
-                <fieldset>
-                  <atoms-tooltip-error
-                    :has-error="!!fieldsErrorMessages.ipFourAddress"
-                  >
-                    <template #elem>
-                      <input
-                        v-model="fields.static.ipFourAddress"
-                        type="text"
-                        placeholder="e.g. 192.168.1.1"
-                        :class="[
-                          'tooltip-field port-properties-network-label',
-                          {
-                            'danger-not-valid':
-                              fieldsErrorMessages.ipFourAddress,
-                          },
-                        ]"
-                      />
-                    </template>
-                    <template #content>
-                      {{ fieldsErrorMessages.ipFourAddress }}
-                    </template>
-                  </atoms-tooltip-error>
-                </fieldset>
-              </div>
-            </div>
-          </div>
-          <div class="horizontal-flex-container p-b-14">
-            <label class="property-label-group">
-              {{ localization.subnetMask }}
-            </label>
-            <div class="margin-left-property-value-group">
-              <div class="property-value-group">
-                <fieldset>
-                  <atoms-tooltip-error
-                    :has-error="!!fieldsErrorMessages.subnetMask"
-                  >
-                    <template #elem>
-                      <input
-                        v-model="fields.static.subnetMask"
-                        type="text"
-                        placeholder="e.g. 255.255.255.0"
-                        :class="[
-                          'tooltip-field',
-                          {
-                            'danger-not-valid': fieldsErrorMessages.subnetMask,
-                          },
-                        ]"
-                      />
-                    </template>
-                    <template #content>
-                      {{ fieldsErrorMessages.subnetMask }}
-                    </template>
-                  </atoms-tooltip-error>
-                </fieldset>
-              </div>
-            </div>
-          </div>
-          <div class="horizontal-flex-container p-b-14">
-            <label class="property-label-group">
-              {{ localization.defaultGateway }}
-            </label>
-            <div class="margin-left-property-value-group">
-              <div class="property-value-group">
-                <div
-                  class="flex-property-label-group small checkbox-inline with-margin p-b-14"
-                >
-                  <input
-                    id="default-gateway"
-                    v-model="fields.static.defaultGateway.override"
-                    type="checkbox"
-                  />
-                  <label
-                    for="default-gateway"
-                    class="normal-weight normal-font-size"
-                  >
-                    {{ localization.overrideDefaultGatewayForThisAdapter }}
-                  </label>
-                </div>
-                <div>
-                  <fieldset>
-                    <atoms-tooltip-error
-                      :has-error="!!fieldsErrorMessages.defaultGateway"
-                    >
-                      <template #elem>
-                        <input
-                          v-model="fields.static.defaultGateway.value"
-                          type="text"
-                          :disabled="!fields.static.defaultGateway.override"
-                          placeholder="10.10.101.1"
-                          :class="[
-                            'tooltip-field',
-                            {
-                              'danger-not-valid':
-                                fieldsErrorMessages.defaultGateway,
-                            },
-                          ]"
-                        />
-                      </template>
-                      <template #content>
-                        {{ fieldsErrorMessages.defaultGateway }}
-                      </template>
-                    </atoms-tooltip-error>
-                  </fieldset>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </form>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { UI_I_ArbitraryObject, UI_I_Localization } from '~/models/interfaces'
-import {
-  UI_I_IpFourSettings,
-  UI_I_IpFourSettingsFieldsErrorMessages,
-} from '~/components/common/addNetworking/models/interfaces'
-import { UI_T_IpFourSettingsFieldName } from '~/components/common/addNetworking/models/types'
-import { ipFourSettingsFieldsErrorMessages } from '~/components/common/addNetworking/config'
-
-// Props from up
-const props = defineProps<{
-  title: string
-  text: string
-  stepId: number
-  ipFourSettings: UI_I_IpFourSettings
-  isShowErrorMessageAlert: boolean
-  errorMessages: string[]
-  error: UI_I_ArbitraryObject<string>
-}>()
-
-// UI_I_Localization
-const localization = computed<UI_I_Localization>(() => useLocal())
-
-// Define emits for changing data and validation messages
-const emits = defineEmits<{
-  (event: 'change-ip-four-settings', ipFourSettings: UI_I_IpFourSettings): void
-  (
-    event: 'change-error-messages',
-    errorMessages: string[],
-    stepIndex: number
-  ): void
-  (event: 'hide-error-message-alert'): void
-  // (event: 'set-error-empty', fieldName: string): void
-}>()
-
-// Validation error check for this step
-const hasValidationError = computed<boolean>(
-  () => props.isShowErrorMessageAlert && !!props.errorMessages.length
-)
-const fields = ref<UI_I_IpFourSettings>({ ...props.ipFourSettings })
-
-const fieldsErrorMessages = ref<UI_I_IpFourSettingsFieldsErrorMessages>(
-  ipFourSettingsFieldsErrorMessages
-)
-
-const checkIfValidIP = (str: string): boolean => {
-  const regexExp =
-    /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/gi
-
-  return regexExp.test(str)
-}
-
-const messageTexts = (
-  local: UI_I_Localization
-): UI_I_ArbitraryObject<string> => ({
-  ipFourAddressEmpty: local.ipFourAddressEmpty,
-  subnetMaskEmpty: local.subnetMaskEmpty,
-  defaultGatewayEmpty: local.defaultGatewayEmpty,
-  ipFourAddressInvalid: local.ipFourAddressInvalid,
-  subnetMaskInvalid: local.subnetMaskInvalid,
-  defaultGatewayInvalid: local.defaultGatewayInvalid,
-})
-
-const setMessageOnChangedField = (
-  values: string,
-  name: UI_T_IpFourSettingsFieldName,
-  ipSettings: string,
-  override?: boolean
-): void => {
-  if (ipSettings === '0') {
-    fieldsErrorMessages.value[name] = ''
-    return
-  }
-  if (name === 'ipFourAddress') {
-    if (!values) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Empty`
-      ]
-      return
-    }
-    if (!checkIfValidIP(values)) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Invalid`
-      ]
-      return
-    }
-  }
-  if (name === 'subnetMask') {
-    if (!values) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Empty`
-      ]
-      return
-    }
-    if (!checkIfValidIP(values)) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Invalid`
-      ]
-      return
-    }
-  }
-  if (name === 'defaultGateway' && override) {
-    if (!values) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Empty`
-      ]
-      return
-    }
-    if (!checkIfValidIP(values)) {
-      fieldsErrorMessages.value[name] = messageTexts(localization.value)[
-        `${name}Invalid`
-      ]
-      return
-    }
-  }
-  fieldsErrorMessages.value[name] = ''
-}
-
-// For late
-// const setErrorEmpty = (
-//     newValue: UI_I_IpFourSettings,
-//     oldValue: UI_I_IpFourSettings,
-//     fieldName: keyof UI_I_IpFourSettings,
-//     errFieldName: string
-// ) => {
-//     newValue[fieldName] !== oldValue[fieldName] &&
-//     emits('set-error-empty', errFieldName)
-// }
-
-// Changing data and validate they
-watch(
-  fields,
-  (newFields: UI_I_IpFourSettings) => {
-    setMessageOnChangedField(
-      newFields.static.ipFourAddress,
-      'ipFourAddress',
-      newFields.ipSettings
-    )
-    setMessageOnChangedField(
-      newFields.static.subnetMask,
-      'subnetMask',
-      newFields.ipSettings
-    )
-    setMessageOnChangedField(
-      newFields.static.defaultGateway.value,
-      'defaultGateway',
-      newFields.ipSettings,
-      newFields.static.defaultGateway.override
-    )
-    const fieldsErrorMessagesFiltered = Object.values(
-      fieldsErrorMessages.value
-    ).filter((errorMessage: string) => errorMessage !== '')
-
-    fieldsErrorMessagesFiltered.length === 0 &&
-      emits('hide-error-message-alert')
-    emits('change-error-messages', fieldsErrorMessagesFiltered, props.stepId)
-
-    emits('change-ip-four-settings', newFields)
-  },
-  { deep: true }
-)
-
-watch(
-  () => props.error,
-  (newError) => {
-    fieldsErrorMessages.value = {
-      ipFourAddress: newError['tcp_config.ipv4'] || '',
-      subnetMask: newError['tcp_config.net_mask'] || '',
-      defaultGateway: newError['tcp_config.gateway'] || '',
-    }
-
-    const fieldsErrorMessagesFiltered = Object.values(
-      fieldsErrorMessages.value
-    ).filter(
-      (errorMessage: string | undefined) =>
-        errorMessage !== '' && errorMessage !== undefined
-    )
-
-    emits('change-error-messages', fieldsErrorMessagesFiltered, props.stepId)
-  },
-  { deep: true, immediate: true }
-)
-
-// Validation message show and hide
-const onHideErrorMessageAlert = (): void => {
-  emits('hide-error-message-alert')
-}
-onUnmounted(() => {
-  emits('hide-error-message-alert')
-})
-</script>
-<style lang="scss" scoped>
-.p-b-14 {
-  padding-bottom: 14px;
-}
-fieldset :deep(.flex) {
-  width: 144px;
-}
-</style>

package/components/common/addNetworking/utils/index.ts

@@ -1,212 +0,0 @@
-import {
-  UI_I_NetworkLabelCheckExisting,
-  UI_I_Step,
-} from '~/components/common/addNetworking/models/interfaces'
-import { UI_E_StepStatus } from '~/components/common/addNetworking/models/enums'
-
-export class Wizard {
-  stepsScheme: UI_I_Step[][]
-  selectedStepScheme: Ref<number>
-  private _selectedStep: Ref<number>
-  completedStepsId: Ref<number[]>
-  private _waitingStepId: Ref<number>
-
-  constructor(stepsScheme: UI_I_Step[][]) {
-    this.selectedStepScheme = ref<number>(0)
-    this._selectedStep = ref<number>(0)
-    this.stepsScheme = stepsScheme
-    this.completedStepsId = ref<number[]>([])
-    this._waitingStepId = ref<number>(0)
-  }
-
-  get selectedScheme(): number {
-    return this.selectedStepScheme.value
-  }
-
-  set selectedScheme(stepScheme: number) {
-    this.selectedStepScheme.value = stepScheme
-  }
-
-  isSelectedScheme(stepScheme: number): boolean {
-    return this.selectedStepScheme.value === stepScheme
-  }
-
-  resetStepsUntilX(x: number): void {
-    this.completedStepsId.value.length >= x &&
-      (this.completedStepsId.value.length = x - 1)
-  }
-
-  get selectedStep(): number {
-    return this._selectedStep.value
-  }
-
-  set selectedStep(step: number) {
-    this._selectedStep.value = step
-  }
-
-  get waitingStepId(): number {
-    return this._waitingStepId.value
-  }
-
-  set waitingStepId(step: number) {
-    this._waitingStepId.value = step
-  }
-
-  isSelectedStep(step: number): boolean {
-    return this.selectedStep === step
-  }
-
-  isUpThenSelectedStep(step: number): boolean {
-    return this.selectedStep <= step
-  }
-
-  isDownThenSelectedStep(step: number): boolean {
-    return this.selectedStep >= step
-  }
-
-  reset(): void {
-    this.selectedScheme = 0
-    this.selectedStep = 0
-    this.resetStepsUntilX(1)
-  }
-
-  goToNextStep(
-    cb?: (
-      selectedStepIndex: number,
-      nextStepId: number,
-      ...args: any
-    ) => boolean,
-    ...args: any
-  ): void {
-    const selectedStepIndex: number = this.stepsWithStatus().findIndex(
-      (step: UI_I_Step) => this.isSelectedStep(step.id)
-    )
-
-    const nextStepId: number = this.stepsWithStatus()[selectedStepIndex + 1].id
-
-    if (!cb || cb(selectedStepIndex, nextStepId, ...args)) {
-      this.selectedStep = this.stepsWithStatus()[selectedStepIndex + 1].id
-    }
-  }
-
-  goToSelectedStep(step: number, cb?: (step: number) => boolean): void {
-    if (!cb || cb(step)) {
-      this.selectedStep = step
-    }
-  }
-
-  goToBackStep(): void {
-    const selectedStepIndex: number = this.stepsWithStatus().findIndex(
-      (step: UI_I_Step) => this.isSelectedStep(step.id)
-    )
-    this.selectedStep = this.stepsWithStatus()[selectedStepIndex - 1].id
-  }
-
-  isBeforeLastStep(): boolean {
-    const selectedScheme: UI_I_Step[] = this.stepsScheme[this.selectedScheme]
-
-    return selectedScheme[selectedScheme.length - 2].id === this.selectedStep
-  }
-
-  isLastStep(step: number): boolean {
-    const selectedScheme: UI_I_Step[] = this.stepsScheme[this.selectedScheme]
-
-    return selectedScheme[selectedScheme.length - 1].id === step
-  }
-
-  stepsWithStatus(): UI_I_Step[] {
-    // let selectedFlag = false
-    let lastId = 0
-
-    return this.stepsScheme[this.selectedScheme].map(
-      (step: UI_I_Step): UI_I_Step => {
-        if (
-          // If a selected step is completed
-          step.id === this.selectedStep &&
-          this.completedStepsId.value.includes(step.id)
-        ) {
-          lastId = step.id
-          return { ...step, status: UI_E_StepStatus.CompleteSelected }
-        } else if (
-          // If a step is completed
-          step.id < this.selectedStep ||
-          this.completedStepsId.value.includes(step.id)
-        ) {
-          !this.completedStepsId.value.includes(step.id) &&
-            this.completedStepsId.value.push(step.id)
-          lastId = step.id
-          return { ...step, status: UI_E_StepStatus.Complete }
-        } else if (
-          // If a step is selected, but is not active
-          step.id === this.selectedStep
-        ) {
-          // selectedFlag = true
-          lastId = step.id
-          return { ...step, status: UI_E_StepStatus.Selected }
-        } else if (
-          // If a step is active
-
-          lastId ===
-          this.completedStepsId.value[this.completedStepsId.value.length - 1]
-        ) {
-          // console.log(selectedFlag)
-          // selectedFlag = false
-          lastId = step.id
-          return { ...step, status: UI_E_StepStatus.Active }
-        } // If a step is disabled
-        else {
-          lastId = step.id
-          return { ...step, status: UI_E_StepStatus.Disabled }
-        }
-      }
-    )
-  }
-
-  // -----------------
-  // Not common-------
-
-  checkNetworkLabelBeforeGoToNextStep(
-    currentStep: number,
-    networkLabel: string,
-    isNetworkInvalid: UI_I_NetworkLabelCheckExisting | undefined,
-    checkNetwork: (networkLabel: string, nextStep?: number) => void
-  ): boolean {
-    if (
-      this.isSelectedStep(currentStep) &&
-      (!isNetworkInvalid?.checked ||
-        (isNetworkInvalid.checked && !isNetworkInvalid.valid))
-    ) {
-      checkNetwork(networkLabel)
-      return true
-    }
-    return false
-  }
-
-  checkNetworkLabelBeforeGoToNewStep(
-    nextStep: number,
-    currentStepScheme: number,
-    currentStep: number,
-    networkLabel: string,
-    isNetworkInvalid: UI_I_NetworkLabelCheckExisting | undefined,
-    checkNetwork: (networkLabel: string, nextStep?: number) => void
-  ): boolean {
-    if (
-      this.isSelectedScheme(currentStepScheme) &&
-      nextStep > currentStep &&
-      (!isNetworkInvalid?.checked ||
-        (isNetworkInvalid.checked && !isNetworkInvalid.valid))
-    ) {
-      checkNetwork(networkLabel, nextStep)
-      return true
-    }
-    return false
-  }
-
-  // Not common-------
-  // -----------------
-}
-
-export const getVlanId = (vlanId: string): string =>
-  (vlanId === 'All (4095)' && '4095') ||
-  (vlanId === 'None (0)' && '0') ||
-  vlanId