@davra/ui-core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/src/services/devicesCountersService.ts

@@ -1,117 +0,0 @@
-import { DavraApiClient} from './davraApi'
-import type { DeviceCounter, DeviceCounterMetric } from '~/types'
-
-const getDevicesCountersMetric = async (filters?: string): Promise< DeviceCounterMetric[] > => {
-  const params = []
-
-  if (filters)
-    params.push(filters)
-
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/metrics?${params.join('&')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-
-const getDevicesCountersMetricByUUIDs = async (uuids: string[]): Promise< DeviceCounterMetric[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/metrics?arrayUUIDs=${uuids.join(',')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-
-const getDevicesCountersMetricByUUID = async (uuid: string): Promise< DeviceCounterMetric[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/metrics/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-const getDevicesCountersByUUID = async (uuid: string): Promise< DeviceCounter[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-const getDevicesCountersLatestByUUID = async (uuid: string): Promise< any > => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/latest/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data[0]
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-
-const getDevicesCountersLatestByUUIDs = async (uuids: string[]): Promise< any []> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/devices/counters/latest?arrayUUIDs=${uuids.join(',')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices Counters API Error')
-  }
-}
-
-export default {
-  getDevicesCountersMetric,
-  getDevicesCountersMetricByUUID,
-  getDevicesCountersMetricByUUIDs,
-  getDevicesCountersByUUID,
-  getDevicesCountersLatestByUUID,
-  getDevicesCountersLatestByUUIDs,
-}

package/src/services/devicesService.test.ts

@@ -1,207 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import DeviceService from '~/services/devicesService'
-import type { Device } from '~/types'
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-
-describe('Devices Service', () => {
-  describe('getDevices', () => {
-    const mockDevices: Device[] = [
-      { id: '1', name: 'Device 1' },
-      { id: '2', name: 'Device 2' },
-      { id: '3', name: 'Device 3' },
-    ] as any
-    beforeEach(() => {
-      vi.mock('./davraApi', () => {
-        return {
-          default: vi.fn(() => ({
-            get: mockGet,
-            post: mockPost,
-          })),
-        }
-      })
-    })
-    afterEach(() => {
-      vi.restoreAllMocks()
-    })
-
-    it('should return devices with default params', async () => {
-      // Arrange
-      const expectedUrl = '/api/v1/devices?start=0'
-      const expectedHeaders = { Accept: 'application/json' }
-      const mockResponse = { data: { totalRecords: mockDevices.length, records: mockDevices } }
-      const start = undefined
-      const limit = undefined
-      const sort = undefined
-      const filters = undefined
-      mockGet.mockResolvedValueOnce(mockResponse)
-
-      // Act
-      const result = await DeviceService.getDevices(start, limit, sort, filters)
-
-      // Assert
-      expect(mockGet).toHaveBeenCalledTimes(1)
-      expect(mockGet).toHaveBeenCalledWith(expectedUrl, { headers: expectedHeaders })
-      expect(result.totalRecords).toEqual(mockDevices.length)
-      expect(result.records).toEqual(mockDevices)
-    })
-
-    it('should return devices with custom params', async () => {
-      // Arrange
-      const expectedUrl = '/api/v1/devices?start=10&limit=20&sort=name&filter=type:camera'
-      const expectedHeaders = { Accept: 'application/json' }
-      const mockResponse = { data: { totalRecords: mockDevices.length, records: mockDevices } }
-      const start = 10
-      const limit = 20
-      const sort = 'name'
-      const filters = 'filter=type:camera'
-      mockGet.mockResolvedValueOnce(mockResponse)
-
-      // Act
-      const result = await DeviceService.getDevices(start, limit, sort, filters)
-
-      // Assert
-      expect(mockGet).toHaveBeenCalledTimes(1)
-      expect(mockGet).toHaveBeenCalledWith(expectedUrl, { headers: expectedHeaders })
-      expect(result.totalRecords).toEqual(mockDevices.length)
-      expect(result.records).toEqual(mockDevices)
-    })
-
-    it('should throw an error if the API call fails', async () => {
-      // Arrange
-      const expectedError = new Error('Devices API Error')
-      const start = undefined
-      const limit = undefined
-      const sort = undefined
-      const filters = undefined
-      mockGet.mockRejectedValueOnce(expectedError)
-
-      // Act + Assert
-      await expect(DeviceService.getDevices(start, limit, sort, filters)).rejects.toThrow(expectedError)
-    })
-  })
-
-  describe('queryDevices', () => {
-    it('should queryDevices successfully', async () => {
-      const mockDevice: Device = {
-        _id: '1',
-        name: 'name',
-        description: '',
-        labels: {},
-        tenantId: '',
-        deviceType: '',
-        UUID: '123123',
-        createdTime: 0,
-        owner: '',
-      }
-      const axiosPost = mockPost.mockResolvedValueOnce({ data: { totalRecords: 1, records: mockDevice }, status: 200 })
-
-      const result = await DeviceService.queryDevices({ start: 0, limit: 20000, gpsLastSeen: { $exists: true } })
-
-      expect(axiosPost).toHaveBeenCalledWith('/api/v1/devices/query', { start: 0, limit: 20000, gpsLastSeen: { $exists: true } }, {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-
-      expect(result).toEqual({ totalRecords: 1, records: mockDevice })
-    })
-
-    it('should throw an error if the API call fails', async () => {
-      const axiosPost = mockPost.mockRejectedValueOnce('')
-
-      await expect(DeviceService.queryDevices({ start: 0, limit: 20000, gpsLastSeen: { $exists: true } })).rejects.toThrow(new Error('Devices API Error'))
-      expect(axiosPost).toHaveBeenCalledWith('/api/v1/devices/query', { start: 0, limit: 20000, gpsLastSeen: { $exists: true } }, {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-    })
-  })
-
-  describe('getDeviceByUUID', () => {
-    it('returns the device record for a valid UUID', async () => {
-      const uuid = '12345'
-      const expectedDevice: Device = { id: 1, name: 'Device 1' } as any
-      const mockedResponse = { data: { records: [expectedDevice] } }
-      mockGet.mockResolvedValueOnce(mockedResponse)
-
-      const result = await DeviceService.getDeviceByUUID(uuid)
-
-      expect(mockGet).toHaveBeenCalledWith(`/api/v1/devices/${uuid}`, { headers: { Accept: 'application/json' } })
-      expect(result).toEqual(expectedDevice)
-    })
-
-    it('should throw an error if the API call fails', async () => {
-      const uuid = 'invalid'
-      const expectedError = new Error('Devices API Error')
-      mockGet.mockRejectedValueOnce(expectedError)
-
-      await expect(DeviceService.getDeviceByUUID(uuid)).rejects.toThrow(expectedError)
-    })
-  })
-
-  describe('getDeviceByUUIDs', () => {
-    it('should return an empty array when uuids is empty', async () => {
-      mockGet.mockResolvedValueOnce({ data: { totalRecords: 0, records: [] } })
-
-      const result = await DeviceService.getDeviceByUUIDs([])
-      expect(result).toEqual({
-        totalRecords: 0,
-        records: [],
-      })
-    })
-
-    it('should return an array of devices when uuids are provided', async () => {
-      mockGet.mockResolvedValueOnce({ data: { totalRecords: 2, records: [{ id: 1, name: 'Device 1' }, { id: 2, name: 'Device 2' }] } })
-
-      const result = await DeviceService.getDeviceByUUIDs(['uuid1', 'uuid2'])
-      expect(result).toEqual({ records: [{ id: 1, name: 'Device 1' }, { id: 2, name: 'Device 2' }], totalRecords: 2 })
-    })
-
-    it('should call with the correct URL and headers', async () => {
-      const uuids = ['uuid1', 'uuid2']
-      mockGet.mockResolvedValueOnce({ data: { totalRecords: 0, records: [] } })
-
-      await DeviceService.getDeviceByUUIDs(uuids)
-      expect(mockGet).toHaveBeenCalledWith(`/api/v1/devices?arrayUUIDs=${uuids.join(',')}`, {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-    })
-
-    it('should return an empty array when an error occurs', async () => {
-      const expectedError = new Error('Devices API Error')
-      mockGet.mockRejectedValueOnce(new Error('qweqwe API Error'))
-      await expect(DeviceService.getDeviceByUUIDs(['uuid1', 'uuid2'])).rejects.toThrow(expectedError)
-    })
-  })
-
-  describe('getDeviceAttachements', () => {
-    it('getDeviceAttachements success', async () => {
-      const axiosGet = mockGet.mockResolvedValueOnce({ data: '', status: 200 })
-
-      const result = await DeviceService.getDeviceAttachements('uuid111')
-
-      expect(axiosGet).toHaveBeenCalledWith('/api/v1/devices/attachments/uuid111', {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-
-      expect(result).toEqual('')
-    })
-
-    it('getDeviceAttachements api unkown error', async () => {
-      const axiosGet = mockGet.mockRejectedValueOnce('')
-
-      await expect(DeviceService.getDeviceAttachements('uuid111')).rejects.toThrow(new Error('Devices API Error'))
-      expect(axiosGet).toHaveBeenCalledWith('/api/v1/devices/attachments/uuid111', {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-    })
-  })
-})

package/src/services/devicesService.ts

@@ -1,110 +0,0 @@
-import {DavraApiClient} from './davraApi'
-
-import type { Device } from '~/types'
-
-const getDevices = async (start?: number, limit?: number, sort?: string, filters?: string): Promise<{ totalRecords: number; records: Device[] }> => {
-  const params = []
-  params.push(`start=${start || 0}`)
-
-  if (limit)
-    params.push(`limit=${limit}`)
-  if (sort)
-    params.push(`sort=${sort}`)
-  if (filters)
-    params.push(filters)
-
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/devices?${params.join('&')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch {
-    throw new Error('Devices API Error')
-  }
-}
-
-const queryDevices = async (query: any): Promise<{ totalRecords: number; records: Device[] }> => {
-  try {
-    const { data } = await DavraApiClient().post<any>(
-      '/api/v1/devices/query',
-      query,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Devices API Error')
-  }
-}
-
-const getDeviceByUUID = async (uuid: string): Promise<Device | null> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/devices/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data.records[0]
-  }
-  catch {
-    throw new Error('Devices API Error')
-  }
-}
-const getDeviceByUUIDs = async (uuids: string[]): Promise<{ totalRecords: number; records: Device[] }> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/devices?arrayUUIDs=${uuids.join(',')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch {
-    throw new Error('Devices API Error')
-  }
-}
-
-const getDeviceAttachements = async (uuid: string): Promise<any> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/devices/attachments/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch {
-    throw new Error('Devices API Error')
-  }
-}
-export default {
-  getDevices,
-  queryDevices,
-  getDeviceByUUID,
-  getDeviceByUUIDs,
-  getDeviceAttachements,
-}

package/src/services/index.ts

@@ -1,22 +0,0 @@
-
-import UserSessionService from './userSessionService'
-import DevicesCountersService from './devicesCountersService'
-import TwinsCountersService from './twinsCountersService'
-import DevicesService from './devicesService'
-import TwinsService from './twinsService'
-import TimeseriesService from './timeseriesService'
-import LabelService from './labelsService'
-import MetricsService from './metricsService'
-
-export * from './davraApi'
-
-export {
-    UserSessionService,
-    DevicesCountersService,
-    TwinsCountersService,
-    DevicesService,
-    TwinsService,
-    TimeseriesService,
-    LabelService,
-    MetricsService
-}

package/src/services/labelsService.test.ts

@@ -1,124 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import LabelsService from '~/services/labelsService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Labels Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getLabels success', async () => {
-    const mockLabels = ['label1']
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockLabels, status: 200 })
-
-    const result = await LabelsService.getLabels()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/tags/keys', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockLabels)
-  })
-
-  it('getLabels api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    const result = await LabelsService.getLabels()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/tags/keys', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual([])
-  })
-
-  it('getValuesByKey success', async () => {
-    const mockValues = ['val1', 'val2']
-
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockValues, status: 200 })
-
-    const result = await LabelsService.getValuesByKey('testKey')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/tags/values/testKey', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockValues)
-  })
-
-  it('getValuesByKey api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    const result = await LabelsService.getValuesByKey('test')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/tags/values/testKey', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual([])
-  })
-
-  it('createLabel success', async () => {
-    const axiosPost = mockPost.mockResolvedValueOnce({})
-
-    const result = await LabelsService.createLabel({ qwe: 'qqwe' })
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/tags', { qwe: 'qqwe' }, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(true)
-  })
-
-  it('createLabel without a clean payload', async () => {
-    const axiosPost = mockPost.mockResolvedValueOnce({})
-
-    const result = await LabelsService.createLabel({ qwe: 'qqwe', twinType1: 'uuidtwinType', aaw: 'n@123123"" "!!' }, ['twinType1'])
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/tags', { qwe: 'qqwe' }, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(true)
-  })
-
-  it('createLabel api unkown error', async () => {
-    const axiosPost = mockPost.mockRejectedValueOnce('')
-
-    const result = await LabelsService.createLabel({ test: 'test1' })
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/tags', { test: 'test1' }, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(false)
-  })
-})

package/src/services/labelsService.ts

@@ -1,71 +0,0 @@
-import { DavraApiClient } from './davraApi'
-
-const getLabels = async (): Promise<any[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      '/api/v1/tags/keys',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data || []
-  }
-  catch (error) {
-    return []
-  }
-}
-
-const getValuesByKey = async (key: string): Promise<string[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/tags/values/${key}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data || []
-  }
-  catch (error) {
-    return []
-  }
-}
-
-const createLabel = async (labels: { [key: string]: string }, twinTypeNames?: string[]): Promise<boolean> => {
-  const labelsToPost = { ...labels }
-  Object.entries(labelsToPost).forEach(([key, value]) => {
-    if (twinTypeNames && twinTypeNames.includes(key))
-      delete labelsToPost[key]
-
-    const pattern = /[^a-zA-Z_0-9\-+]/g
-    if (!value || pattern.test(value))
-      delete labelsToPost[key]
-  })
-  try {
-    await DavraApiClient().post<any>(
-      '/api/v1/tags',
-      labelsToPost,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return true
-  }
-  catch (error) {
-    return false
-  }
-}
-
-export default {
-  getLabels,
-  createLabel,
-  getValuesByKey,
-}

package/src/services/metricsCountersService.test.ts

@@ -1,44 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import MetricsCountersService from '~/services/metricsCountersService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('MetricsCounters Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getMetricsCounters success', async () => {
-    const mockMetricsCounters = ['metric1']
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockMetricsCounters, status: 200 })
-
-    const result = await MetricsCountersService.getMetricsCounters()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/metrics/counters', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockMetricsCounters)
-  })
-
-  it('getMetricsCounters api unkown error', async () => {
-    mockGet.mockRejectedValueOnce({ response: { status: 500 } })
-
-    await expect(MetricsCountersService.getMetricsCounters()).rejects.toThrow(new Error('Metric Counter API Error'))
-  })
-})