bfg-common 1.0.0

package/models/store/host/interfaces.ts

@@ -0,0 +1,38 @@
+import { API_UI_I_DataTable } from '~/models/interfaces'
+
+interface API_UI_I_ConfigureAllPciDevicesItemGeneralInfo {
+  class_id: string
+  device_id: string
+  subdevice_id: string
+  subvendor_id: string
+  vendor_id: string
+  vendor_name: string
+}
+
+interface API_UI_I_ConfigureAllPciDevicesItemLocation {
+  bus: string
+  function: string
+  id: string
+  name: string
+  slot: string
+}
+
+export interface API_UI_I_ConfigureAllPciDevicesItem {
+  location: API_UI_I_ConfigureAllPciDevicesItemLocation
+  class_name: string
+  device_name: string
+  general_info: API_UI_I_ConfigureAllPciDevicesItemGeneralInfo
+  hardware_label: string
+  id: string
+  passthrough: string
+  sriov: string
+  vendor_name: string
+}
+
+export interface UI_I_ConfigureAllPciDevicesItem
+  extends API_UI_I_ConfigureAllPciDevicesItem {}
+
+export interface API_UI_I_ConfigurePciDevicesTable
+  extends API_UI_I_DataTable<API_UI_I_ConfigureAllPciDevicesItem[]> {}
+export interface UI_I_ConfigurePciDevicesTable
+  extends API_UI_I_ConfigurePciDevicesTable {}

package/models/store/interfaces.ts

@@ -0,0 +1,47 @@
+import { UI_I_Pagination } from '~/models/interfaces'
+import { UI_T_Schema } from '~/models/types'
+
+export interface UI_I_ErrorValidationField<T = string> {
+  error_message: string
+  field: T
+}
+
+export interface API_UI_I_Error {
+  data: {
+    error_code: number
+    error_message: any
+    name?: any
+  }
+}
+
+export interface API_UI_I_NodeStatus {
+  text: string
+  code: number
+}
+
+export interface API_UI_I_NodeState extends API_UI_I_NodeStatus {
+  icon: string
+}
+
+export interface API_UI_I_Node {
+  id: string
+  name: string
+  state: API_UI_I_NodeState
+  status: API_UI_I_NodeStatus
+  net_bridge?: string
+  console_type?: string
+}
+
+export interface UI_I_SchemaTablePayload {
+  schema: UI_T_Schema
+}
+
+export interface UI_I_TablePayload extends UI_I_SchemaTablePayload {
+  pagination: UI_I_Pagination
+  type: any
+  sortBy: string | null
+}
+
+export interface UI_I_CommitOptions {
+  root: boolean
+}

package/models/store/network/interfaces.ts

@@ -0,0 +1,13 @@
+import { API_UI_I_Node } from '~/models/store/interfaces'
+
+export interface API_UI_I_NetworkTableItem extends API_UI_I_Node {
+  vlan: string
+  net_bridge: string
+  type_code: number
+  type_text: string
+  vswitch_name: string
+  vms_amount: number
+  active_ports: number
+}
+
+export interface UI_I_NetworkTableItem extends API_UI_I_NetworkTableItem {}

package/models/store/storage/interfaces.ts

@@ -0,0 +1,32 @@
+import { API_UI_I_Node } from '~/models/store/interfaces'
+
+export interface API_UI_I_DatastoreTableItemCapacity {
+  capacity_mb: number
+  provisioned_mb: number
+  free_mb: number
+  used_mb: number
+}
+
+export interface API_UI_I_DatastoreTableItem extends API_UI_I_Node {
+  pool_name: string
+  type_code: number
+  type_text: string
+  drive_type: string
+  capacity: API_UI_I_DatastoreTableItemCapacity
+  thin_provisioning: boolean
+  access_mode: string
+  hardware_acceleration: string
+  device: string
+  storage_io_control: boolean
+  storage_compatibility: string
+}
+
+export interface UI_I_DatastoreTableItem extends API_UI_I_DatastoreTableItem {}
+
+export interface UI_I_FolderOrFileTreePayload {
+  type: string
+  id: string
+  path: string
+  merge: boolean
+  show: boolean
+}

package/models/store/vm/interfaces.ts

@@ -0,0 +1,87 @@
+import { UI_I_DatastoreTableItem } from '~/models/store/storage/interfaces'
+import { UI_I_OptionItem } from '~/components/atoms/models/interfaces'
+import {
+  UI_I_SendDataNewCdDvdDrive,
+  UI_I_SendDataNewHardDisk,
+  UI_I_SendDataNewNetwork,
+  UI_I_SendDataNewPciDevice,
+  UI_I_SendDataVideoCard,
+} from '~/components/common/vm/actions/add/customizeHardware/virtualHardware/models/interfaces'
+import { UI_I_CreateVmData } from '~/components/common/vm/actions/add/models/interfaces'
+
+export interface API_UI_I_VmEditCpu {
+  core_per_socket: number
+  hotplug: boolean
+  limit_mhz: number
+  max_vcpus: number
+  model: string
+  reservation_mhz: number
+  shares: number
+  vcpus: number
+}
+export interface API_UI_I_VmEditMemory {
+  hotplug: boolean
+  limit_mb: number
+  reservation_mb: number
+  size_mb: number
+}
+export interface API_UI_I_VmEditOptions {
+  boot_options: {
+    boot_delay_ms: number
+    boot_menu: boolean
+    firmware: string
+  }
+  guest_tools: {
+    enabled: boolean
+    synchronized_time: boolean
+  }
+  remote_console: {
+    guest_os_lock: boolean
+    keymap: string
+    limit_sessions: number
+    password: string
+    port: number
+    spice: {
+      clipboard: boolean
+      file_transfer: boolean
+      img_compression: string
+      jpeg_compression: string
+      playback_compression: boolean
+      streaming_mode: string
+      zlib_glz_compression: string
+    }
+    type: string
+  }
+}
+
+export interface UI_I_VmSettings {
+  name: string
+  storage: UI_I_DatastoreTableItem
+  guestMachineType: UI_I_OptionItem
+  guestOsFamily: UI_I_OptionItem
+  guestOsVersion: UI_I_OptionItem
+  cpuModels: UI_I_OptionItem[]
+  hardDisks: UI_I_SendDataNewHardDisk[] | null
+  cdDvdDrives: UI_I_SendDataNewCdDvdDrive[] | null
+  networks: UI_I_SendDataNewNetwork[] | null
+  videoCard: UI_I_SendDataVideoCard
+  pciDevices: UI_I_SendDataNewPciDevice[] | null
+  usbController: string
+  maxCpus: number
+  maxMemory: number
+  uuid: string
+  compatibility: string
+  options: API_UI_I_VmEditOptions
+  cpu: API_UI_I_VmEditCpu
+  memory: API_UI_I_VmEditMemory
+}
+
+export interface UI_I_CreateVmPayload {
+  start: boolean
+  pvm: UI_I_CreateVmData
+}
+
+export interface UI_I_EditVmPayload {
+  vmId: string
+  body: UI_I_CreateVmData
+}

package/models/types.ts

@@ -0,0 +1,6 @@
+export type UI_T_Project = 'sphere' | 'procurator'
+
+export type UI_T_Schema = 'short' | 'ui' | 'full'
+
+export type UI_T_Binary = 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB'
+export type UI_T_BinaryLower = 'kb' | 'mb' | 'gb' | 'tb' | 'pb' | 'eb' | 'zb' | 'yb'

package/nuxt.config.ts

@@ -0,0 +1,8 @@
+import eslintPlugin from 'vite-plugin-eslint'
+export default defineNuxtConfig({
+  // @ts-ignore
+  vite: {
+    plugins: [eslintPlugin()],
+  },
+  css: ['~/assets/scss/main.scss'],
+})

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "bfg-common",
+  "private": false,
+  "version": "1.0.0",
+  "scripts": {
+    "build": "nuxt build",
+    "dev": "nuxt dev --port=3002",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare"
+  },
+  "devDependencies": {
+    "@novnc/novnc": "^1.4.0",
+    "@vueuse/core": "^10.1.2",
+    "@vueuse/nuxt": "^10.1.2",
+    "eslint-config-prettier": "^8.5.0",
+    "nuxt": "^3.1.2",
+    "prettier": "2.7.1",
+    "sass": "^1.54.9",
+    "sass-loader": "^10.3.1",
+    "terser": "^5.22.0",
+    "vite-plugin-eslint": "^1.8.1",
+    "xterm": "^5.1.0",
+    "xterm-addon-attach": "^0.8.0",
+    "xterm-addon-fit": "^0.7.0",
+    "xterm-addon-serialize": "^0.9.0",
+    "xterm-addon-unicode11": "^0.5.0",
+    "xterm-addon-web-links": "^0.8.0",
+    "eslint-plugin-myrules": "file:./eslint"
+  },
+  "dependencies": {
+    "@nuxtjs/eslint-config-typescript": "^12.0.0",
+    "@vueuse/components": "^10.1.2",
+    "date-fns": "^2.29.3",
+    "bfg-nuxt-3-graph": "^1.0.6",
+    "html2canvas": "^1.4.1",
+    "prettier-eslint": "^15.0.1"
+  }
+}

package/plugins/binary.ts

@@ -0,0 +1,122 @@
+export default defineNuxtPlugin(() => {
+  const binary = function () {
+    const self: any = {}
+    self.kbToGb = function (kb: number, fix = 2): number {
+      return +(kb / 1_048_576).toFixed(fix)
+    }
+
+    self.bToMb = function (b: number, fix = 2): number {
+      return +(b / 1_048_576).toFixed(fix)
+    }
+    self.bToGb = function (b: number, fix = 2): number {
+      return +(b / 1_073_741_824).toFixed(fix)
+    }
+
+    self.mbToKb = function (mb: number, fix = 2): number {
+      return +(mb * 1_024).toFixed(fix)
+    }
+    self.mbToGb = function (mb: number, fix = 2): number {
+      return +(mb / 1_024).toFixed(fix)
+    }
+    self.mbToTb = function (mb: number, fix = 2): number {
+      return +(mb / 1_048_576).toFixed(fix)
+    }
+
+    self.gbToMb = function (gb: number, fix = 2): number {
+      return +(gb * 1_024).toFixed(fix)
+    }
+    self.gbToTb = function (gb: number, fix = 2): number {
+      return +(gb / 1_024).toFixed(fix)
+    }
+
+    self.tbToMb = function (tb: number, fix = 2): number {
+      return +(tb * 1_048_576).toFixed(fix)
+    }
+    self.tbToGb = function (tb: number, fix = 2): number {
+      return +(tb * 1_024).toFixed(fix)
+    }
+
+    const sizeLabels:Record<string, { fromBytes: string[]; sizes: string[] }> = {
+      en: {
+        fromBytes: ['Bytes', 'KB'],
+        sizes: ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
+      },
+      ru: {
+        fromBytes: ['Байт', 'КБ'],
+        sizes: ['МБ', 'ГБ', 'ТБ', 'ПБ', 'ЭБ', 'ЗБ', 'ИБ'],
+      },
+    }
+
+    self.round = function (mb: number, byte = false, language = 'en'): string {
+      switch (language) {
+        case 'ru':
+          if (mb <= 0) return '0 Б';
+          if (mb < 1) return `${mb} МБ`;
+          break;
+        default:
+          if (mb <= 0) return '0 B';
+          if (mb < 1) return `${mb} MB`;
+          break;
+      }
+
+      const k = 1_024;
+      let { fromBytes, sizes } = sizeLabels[language] || sizeLabels.en;
+
+      if (byte) sizes = [...fromBytes, ...sizes]
+
+      const i = Math.floor(Math.log(mb) / Math.log(k));
+      const value =
+        (mb / Math.pow(k, i))
+          .toString()
+          .match(/^-?\d+(?:\.\d{0,2})?/)?.[0] || '0';
+
+      const sizeLabel = sizes[i];
+      return parseFloat(value) + ' ' + sizeLabel;
+    };
+
+
+    const hzLabels: {en: string[], ru: string[]} = {
+      en: ['MHz', 'GHz'],
+      ru: ['МГц', 'ГГц'],
+    };
+
+    self.roundHz = function (hz: number, lang = 'en') {
+      if (hz <= 0) return `0 ${lang === 'en' ? 'Hz' : 'Гц'}`;
+      const k = 1_000;
+      const dm = 2;
+      const size = lang === 'en' ? hzLabels.en : hzLabels.ru;
+      const i = Math.floor(Math.log(hz) / Math.log(k));
+      return parseFloat((hz / Math.pow(k, i)).toFixed(dm)) + ' ' + size[i];
+    }
+
+
+    self.mhzToGhz = function (mhz: number, fix = 2): number {
+      return +(mhz / 1_000).toFixed(fix)
+    }
+    self.ghzToMhz = function (mhz: number, fix = 2): number {
+      return +(mhz * 1_000).toFixed(fix)
+    }
+
+    self.universalFromTo = function (
+      val: number,
+      typeFrom: string,
+      typeTo: string,
+      fix = 2
+    ): number {
+      if (typeFrom === typeTo) return val
+
+      const from = typeFrom.toLowerCase()
+      const to = typeTo[0].toUpperCase() + typeTo.slice(1)
+      const methodName = `${from}To${to}`
+      return self[methodName](val, fix)
+    }
+
+    return self
+  }.call({})
+
+  return {
+    provide: {
+      binary,
+    },
+  }
+})

package/plugins/date.ts

@@ -0,0 +1,179 @@
+import { defineNuxtPlugin } from '#app'
+import { format } from 'date-fns'
+import * as localizations from 'date-fns/locale'
+import { UI_T_DateFormat } from '~/models/plugins/date/types'
+import { UI_I_Dateformat } from '~/models/plugins/date/interfaces'
+
+export default defineNuxtPlugin(() => {
+  // Проверяем переданое является датой
+  const isDate = (date: string | number) => {
+    return new Date(date).toString() !== 'Invalid Date'
+  }
+
+  // Проверяем формат времени браузера равно 24h
+  const isBrowserLocale24h = () =>
+    !new Intl.DateTimeFormat(undefined, { hour: 'numeric' })
+      .format(0)
+      .match(/AM/)
+
+  // Получаем переводы для даты
+  const getDateLocalization = (lang?: string) => {
+    const currentLanguage = lang || useLocalStorage('lang') || 'en_US'
+    const { be, enUS, hy, kk, ru, zhCN } = localizations
+    let localization
+
+    switch (currentLanguage) {
+      case 'be_BY':
+        localization = be
+        break
+      case 'en_US':
+        localization = enUS
+        break
+      case 'hy_AM':
+        localization = hy
+        break
+      case 'kk_KZ':
+        localization = kk
+        break
+      case 'ru_RU':
+        localization = ru
+        break
+      case 'zh_CHS':
+        localization = zhCN
+        break
+    }
+
+    return localization
+  }
+
+  // Получаем формат даты
+  const getDateFormat = (lang?: string): UI_T_DateFormat => {
+    const currentLanguage = lang || useLocalStorage('lang') || 'en_US'
+    const dateFormats: UI_I_Dateformat = {
+      be_BY: 'yyyy-MM-dd',
+      en_US: 'MM-dd-yyyy',
+      hy_AM: 'yyyy-MM-dd',
+      kk_KZ: 'dd/MM/yyyy',
+      ru_RU: 'dd/MM/yyyy',
+      zh_CHS: 'yyyy-MM-dd',
+    }
+
+    const dateFormat = ref(dateFormats[currentLanguage])
+
+    window.addEventListener('timeFormatStorageChanged', function handler() {
+      dateFormat.value = dateFormats[lang || useLocalStorage('lang') || 'en_US'] // TODO нужно проверить когда будем работать без useLocalStorage
+
+      window.removeEventListener('timeFormatStorageChanged', handler)
+    })
+
+    return dateFormat.value
+  }
+
+  // Получаем формат времени
+  const getTimeFormat = (hasSeconds: boolean, timeFormat?: string) => {
+    let appTimeFormat = timeFormat || useLocalStorage('timeFormat') || 'DEFAULT'
+    let timeFormatLocal = ''
+
+    if (appTimeFormat === 'DEFAULT') {
+      const isBrowserTimeFormat24 = isBrowserLocale24h()
+
+      appTimeFormat = isBrowserTimeFormat24 ? '24H' : appTimeFormat
+    }
+
+    if (appTimeFormat === '24H') {
+      timeFormatLocal = 'HH:mm'
+    } else {
+      timeFormatLocal = 'h:mm aa'
+    }
+
+    hasSeconds && (timeFormatLocal = timeFormatLocal.replace(':mm', ':mm:ss'))
+
+    return timeFormatLocal
+  }
+
+  // Форматирование даты из английского в стандартный
+  const enFormatToStandardFormat = (date: string): string => {
+    const splitDate = date.split('-')
+    return [splitDate[2], splitDate[0], splitDate[1]].join('/')
+  }
+  const getUnixByDate = (dateTime: string, lang?: string): number => {
+    const currentFormat: UI_T_DateFormat = getDateFormat(lang)
+
+    const [date, time] = dateTime.split(' ')
+
+    let standardDate = ''
+    switch (currentFormat) {
+      case 'dd/MM/yyyy':
+        standardDate = date.split('/').reverse().join('/')
+        break
+      case 'yyyy-MM-dd':
+        standardDate = date.replaceAll('-', '/')
+        break
+      case 'MM-dd-yyyy':
+        standardDate = enFormatToStandardFormat(date)
+        break
+    }
+
+    const standard = time ? standardDate + ' ' + time : standardDate
+    return new Date(standard).getTime()
+  }
+
+  // Форматирование даты без временим
+  const formattedDate = (
+    date: number | string | Date,
+    formatDate = '',
+    lang?: string
+  ) => {
+    const formatDateLocal = formatDate || getDateFormat(lang)
+
+    return format(new Date(date), formatDateLocal)
+  }
+  // Форматирование временим
+  const formattedTime = (
+    date: number | string | Date,
+    formatDate = '',
+    hasSeconds = false,
+    timeFormat?: string
+  ) => {
+    const formatDateLocal = formatDate || getTimeFormat(hasSeconds, timeFormat)
+
+    return format(new Date(date), formatDateLocal)
+  }
+
+  // Форматирование даты с временим
+  const formattedDatetime = (
+    date: number | string | Date,
+    formatDate = '',
+    hasSeconds = false,
+    lang?: string,
+    timeFormat?: string,
+  ) => {
+    const formatDateLocal = ref(formatDate || getDateFormat(lang))
+    const formatDatetime = ref(
+      formatDateLocal.value + ' ' + getTimeFormat(hasSeconds, timeFormat)
+    )
+
+    window.addEventListener('timeFormatStorageChanged', function handler() {
+      formatDatetime.value =
+        formatDateLocal.value + ' ' + getTimeFormat(hasSeconds, timeFormat)
+
+      window.removeEventListener('timeFormatStorageChanged', handler)
+    })
+
+    return format(new Date(date), formatDatetime.value, {
+      locale: getDateLocalization(lang),
+    })
+  }
+
+  return {
+    provide: {
+      isDate,
+      getTimeFormat,
+      getDateFormat,
+      formattedTime,
+      formattedDate,
+      formattedDatetime,
+      getUnixByDate,
+    },
+  }
+})