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

package/src/services/twinsService.test.ts

@@ -1,228 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import TwinsService from '~/services/twinsService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Twins Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getTwins success', async () => {
-    const mockTwins = [
-      {
-        _id: '63a1d1f4dc0df42c6af2eebd',
-        name: 'testQuentin',
-        description: '',
-        labels: { stateful_incident: '3d54e4f7-cf42-4d9e-969f-29cbbc083689' },
-        digitalTwinType: 'e8cc8e7d-900b-49da-b3df-43dceb101690',
-        customAttributes: {},
-        tenantId: 'ruban',
-        deviceType: 'digitalTwin',
-        UUID: '3d54e4f7-cf42-4d9e-969f-29cbbc083689',
-        createdTime: 1671549428165,
-        owner: '451e5a4868b3fd5bda206fc82e436ac3',
-        digitalTwinTypeName: 'stateful_incident',
-      },
-    ]
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockTwins, status: 200, headers: { 'com-davra-total-results': '1' } })
-
-    const result = await TwinsService.getTwins(0, 10, 'name', 'name=test')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins?start=0&limit=10&sort=name&name=test', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual({ totalRecords: 1, records: mockTwins })
-  })
-
-  it('getTwins api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    await expect(TwinsService.getTwins(0, 10, 'name', 'name=test')).rejects.toThrow(new Error('Twins API Error'))
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins?start=0&limit=10&sort=name&name=test', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-
-  it('queryTwins success', async () => {
-    const mockTwins = [
-      {
-        _id: '63a1d1f4dc0df42c6af2eebd',
-        name: 'testQuentin',
-        description: '',
-        labels: { stateful_incident: '3d54e4f7-cf42-4d9e-969f-29cbbc083689' },
-        digitalTwinType: 'e8cc8e7d-900b-49da-b3df-43dceb101690',
-        customAttributes: {},
-        tenantId: 'ruban',
-        deviceType: 'digitalTwin',
-        UUID: '3d54e4f7-cf42-4d9e-969f-29cbbc083689',
-        createdTime: 1671549428165,
-        owner: '451e5a4868b3fd5bda206fc82e436ac3',
-        digitalTwinTypeName: 'stateful_incident',
-      },
-    ]
-    const axiosPost = mockPost.mockResolvedValueOnce({ data: mockTwins, status: 200, headers: { 'com-davra-total-results': '1' } })
-
-    const result = await TwinsService.queryTwins({ start: 0, limit: 20000, gpsLastSeen: { $exists: true } })
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/twins/query', { start: 0, limit: 20000, gpsLastSeen: { $exists: true } }, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual({ totalRecords: 1, records: mockTwins })
-  })
-
-  it('queryTwins api unkown error', async () => {
-    const axiosPost = mockPost.mockRejectedValueOnce('')
-
-    await expect(TwinsService.queryTwins({ start: 0, limit: 20000, gpsLastSeen: { $exists: true } })).rejects.toThrow(new Error('Twins API Error'))
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/twins/query', { start: 0, limit: 20000, gpsLastSeen: { $exists: true } }, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-  it('getTwinsByTypeName success', async () => {
-    const mockTwins = [
-      {
-        _id: '63a1d1f4dc0df42c6af2eebd',
-        name: 'testQuentin',
-        description: '',
-        labels: { stateful_incident: '3d54e4f7-cf42-4d9e-969f-29cbbc083689' },
-        digitalTwinType: 'e8cc8e7d-900b-49da-b3df-43dceb101690',
-        customAttributes: {},
-        tenantId: 'ruban',
-        deviceType: 'digitalTwin',
-        UUID: '3d54e4f7-cf42-4d9e-969f-29cbbc083689',
-        createdTime: 1671549428165,
-        owner: '451e5a4868b3fd5bda206fc82e436ac3',
-        digitalTwinTypeName: 'stateful_incident',
-      },
-    ]
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockTwins, status: 200, headers: { 'com-davra-total-results': '1' } })
-
-    const result = await TwinsService.getTwinsByTypeName('stateful_incident')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins/?digitalTwinTypeName=stateful_incident&limit=1000&start=0', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual({ totalRecords: 1, records: mockTwins })
-  })
-
-  it('getTwinsByTypeName api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    await expect(TwinsService.getTwinsByTypeName('stateful_incident')).rejects.toThrow(new Error('Twins API Error'))
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins/?digitalTwinTypeName=stateful_incident&limit=1000&start=0', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-    await expect(TwinsService.getTwinByUUID('abc123')).rejects.toThrow(new Error('Twins API Error'))
-  })
-
-  it('should return an array of twins when given an array of uuids', async () => {
-    const uuids = ['uuid1', 'uuid2', 'uuid3']
-    const data = [{ uuid: 'uuid1' }, { uuid: 'uuid2' }, { uuid: 'uuid3' }]
-
-    mockGet.mockResolvedValueOnce({ data, headers: { 'com-davra-total-results': '3' } })
-
-    const result = await TwinsService.getTwinByUUIDs(uuids)
-
-    expect(result).toEqual({ totalRecords: 3, records: data })
-    expect(mockGet).toHaveBeenCalledWith(
-      '/api/v1/twins?arrayUUIDs=uuid1,uuid2,uuid3',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-  })
-
-  it('should return an empty array when an error occurs', async () => {
-    const uuids = ['uuid1', 'uuid2', 'uuid3']
-    const error = new Error('API Error')
-
-    mockGet.mockRejectedValueOnce(error)
-
-    await expect(TwinsService.getTwinByUUIDs(uuids)).rejects.toThrow(new Error('Twins API Error'))
-
-    expect(mockGet).toHaveBeenCalledWith(
-      '/api/v1/twins?arrayUUIDs=uuid1,uuid2,uuid3',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-  })
-
-  it('should return the twin data when successful', async () => {
-    const mockResponse = { data: { uuid: 'abc123', name: 'test twin' } }
-    mockGet.mockResolvedValueOnce(mockResponse)
-
-    const result = await TwinsService.getTwinByUUID('abc123')
-    expect(mockGet).toHaveBeenCalledWith('/api/v1/twins/abc123', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-    expect(result).toEqual(mockResponse.data)
-  })
-
-  it('should return null when the API call fails', async () => {
-    const mockError = new Error('API error')
-    mockGet.mockRejectedValueOnce(mockError)
-
-    await expect(TwinsService.getTwinByUUID('abc123')).rejects.toThrow(new Error('Twins API Error'))
-  })
-
-  it('getTwinAttachements success', async () => {
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: '', status: 200, headers: { 'com-davra-total-results': '1' } })
-
-    const result = await TwinsService.getTwinAttachements('uuid111')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins/uuid111/attachments', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual('')
-  })
-
-  it('getTwinAttachements api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    await expect(TwinsService.getTwinAttachements('uuid111')).rejects.toThrow(new Error('Twins API Error'))
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twins/uuid111/attachments', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-})

package/src/services/twinsService.ts

@@ -1,137 +0,0 @@
-import {DavraApiClient} from './davraApi'
-
-import type { Twin } from '~/types'
-
-const getTwins = async (start = 0, limit = 1000, sort?: string, filters?: string): Promise< { totalRecords: number; records: Twin[] } > => {
-  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, headers } = await DavraApiClient().get<any>(
-      `/api/v1/twins?${params.join('&')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return { totalRecords: parseInt(headers['com-davra-total-results']), records: data }
-  }
-  catch (error) {
-    throw new Error('Twins API Error')
-  }
-}
-
-const queryTwins = async (query: any) => {
-  try {
-    const { data, headers } = await DavraApiClient().post<any>(
-      '/api/v1/twins/query',
-      query,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return { totalRecords: parseInt(headers['com-davra-total-results']), records: data }
-  }
-  catch (error) {
-    throw new Error('Twins API Error')
-  }
-}
-// to be replace by twin query
-const getTwinByUUIDs = async (uuids: string[]): Promise<{ totalRecords: number; records: Twin[] }> => {
-  try {
-    const { data, headers } = await DavraApiClient().get<any>(
-      `/api/v1/twins?arrayUUIDs=${uuids.join(',')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return { totalRecords: parseInt(headers['com-davra-total-results']), records: data }
-  }
-  catch (error) {
-    throw new Error('Twins API Error')
-  }
-}
-const getTwinsByTypeName = async (twinTypeName: string, start = 0, limit = 1000, sort?: string, searchString?: string): Promise<{ totalRecords: number; records: Twin[] }> => {
-  const params = [`digitalTwinTypeName=${twinTypeName}`, `limit=${limit}`, `start=${start}`]
-  if (sort)
-    params.push(`sort=${sort}`)
-
-  if (searchString)
-    params.push(`name=~${searchString}`)
-
-  try {
-    const { data, headers } = await DavraApiClient().get<any>(
-      `/api/v1/twins/?${params.join('&')}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return { totalRecords: parseInt(headers['com-davra-total-results']), records: data }
-  }
-  catch (error) {
-    throw new Error('Twins API Error')
-  }
-}
-
-const getTwinByUUID = async (uuid: string): Promise<Twin | null> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/twins/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Twins API Error')
-  }
-}
-
-const getTwinAttachements = async (uuid: string): Promise<any> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/twins/${uuid}/attachments`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch {
-    throw new Error('Twins API Error')
-  }
-}
-
-export default {
-  getTwins,
-  getTwinsByTypeName,
-  getTwinByUUID,
-  getTwinByUUIDs,
-  getTwinAttachements,
-  queryTwins,
-}

package/src/services/userSessionService.test.ts

@@ -1,74 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import UserSessionService from '~/services/userSessionService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    DavraApiClient: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Tenant Settings Service', () => {
-  beforeEach(() => {
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getUser success', async () => {
-    const mockUser = { _id: '631b1b74abf76669a84d0d54', name: 'admin', UUID: '451e5a4868b3fd5bda206fc82e436ac3', roles: ['6e4a4605-548e-4afb-a887-dfbf7a3232ea'], tenantId: 'ruban', tenants: ['ruban'], creationTime: '2022-09-09T10:54:44.904Z', id: 'admin', displayName: 'admin', modifiedTime: '2022-10-27T08:51:10.622Z', sso: null, isAdmin: true, isAdministrator: true }
-
-    const axiosGet = mockGet.mockResolvedValue({ data: mockUser, status: 200 })
-
-    const result = await UserSessionService.getUser()
-
-    expect(axiosGet).toHaveBeenCalledWith('/user', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockUser)
-  })
-
-  it('getUser api error', async () => {
-    mockGet.mockRejectedValueOnce(new Error('Get user error'))
-
-    await expect(UserSessionService.getUser()).rejects.toThrow(new Error('Get user error'))
-  }) 
-
-  it('getUserPermissions success', async () => {
-    const mockUserPermissions = [{ Action: 'devices.ACCESS', Allowed: true }, { Action: 'devices.CREATE_DEVICE', Allowed: true }, { Action: 'devicetypes.CREATE_DEVICE_TYPE', Allowed: true }, { Action: 'devices.DELETE', Allowed: true }, { Action: 'metrics.ACCESS', Allowed: true }, { Action: 'metrics.CREATE_METRIC', Allowed: true }, { Action: 'users.ACCESS', Allowed: true }, { Action: 'users.CREATE_USER', Allowed: true }, { Action: 'applications.ACCESS', Allowed: true }, { Action: 'applications.CREATE_APPLICATION', Allowed: true }, { Action: 'rulesengine.ACCESS', Allowed: true }, { Action: 'rulesengine.CREATE_RULE', Allowed: true }, { Action: 'microservices.ACCESS', Allowed: true }, { Action: 'microservices.CREATE_MICROSERVICE', Allowed: true }, { Action: 'componenttoolkit.ACCESS', Allowed: true }, { Action: 'componenttoolkit.CREATE_WIDGET', Allowed: true }, { Action: 'authorization.roles.ACCESS', Allowed: true }, { Action: 'authorization.roles.CREATE_ROLE', Allowed: true }, { Action: 'jobs.ACCESS', Allowed: true }, { Action: 'jobs.CREATE_JOB', Allowed: true }, { Action: 'files.ACCESS', Allowed: true }, { Action: 'files.CREATE_FILE', Allowed: true }, { Action: 'auditlogs.ACCESS', Allowed: true }, { Action: 'twintypes.ACCESS', Allowed: true }, { Action: 'twintypes.CREATE_TWINTYPE', Allowed: true }, { Action: 'twins.ACCESS', Allowed: true }, { Action: 'twins.CREATE_TWIN', Allowed: true }, { Action: 'features.ACCESS', Allowed: true }, { Action: 'features.CREATE_FEATURE', Allowed: true }, { Action: 'oauthclients.ACCESS', Allowed: true }, { Action: 'oauthclients.CREATE', Allowed: true }, { Action: 'digitalSignatures.ACCESS' }, { Action: 'digitalSignatures.CREATE_DIGITAL_SIGNATURE' }]
-
-    const axiosPost = mockPost.mockResolvedValue({ data: mockUserPermissions, status: 200 })
-
-    const result = await UserSessionService.getUserPermissions()
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/authorization/policy/check', UserSessionService.permissionList, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockUserPermissions)
-  })
-
-  it('getUserPermissions api unknown error', async () => {
-    const axiosPost = mockPost.mockRejectedValueOnce('')
-
-    const result = await UserSessionService.getUserPermissions()
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/authorization/policy/check', UserSessionService.permissionList, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual([])
-  })
-})

package/src/services/userSessionService.ts

@@ -1,82 +0,0 @@
-import {DavraApiClient} from './davraApi'
-import type { Permission, User } from '~/types'
-
-const getUser = async (): Promise<User | null> => {
-  try {
-    const { data } = await DavraApiClient().get<User>(
-      '/user',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-
-    return data
-  }
-  catch (error) {
-    throw error
-  }
-}
-const permissionList = [{ Action: 'devices.ACCESS' },
-  { Action: 'devices.CREATE_DEVICE' },
-  { Action: 'devicetypes.CREATE_DEVICE_TYPE' },
-  { Action: 'devices.DELETE' },
-  { Action: 'metrics.ACCESS' },
-  { Action: 'metrics.CREATE_METRIC' },
-  { Action: 'users.ACCESS' },
-  { Action: 'users.CREATE_USER' },
-  { Action: 'applications.ACCESS' },
-  { Action: 'applications.CREATE_APPLICATION' },
-  { Action: 'rulesengine.ACCESS' },
-  { Action: 'rulesengine.CREATE_RULE' },
-  { Action: 'microservices.ACCESS' },
-  { Action: 'microservices.CREATE_MICROSERVICE' },
-  { Action: 'componenttoolkit.ACCESS' },
-  { Action: 'componenttoolkit.CREATE_WIDGET' },
-  { Action: 'authorization.roles.ACCESS' },
-  { Action: 'authorization.roles.CREATE_ROLE' },
-  { Action: 'jobs.ACCESS' },
-  { Action: 'jobs.CREATE_JOB' },
-  { Action: 'files.ACCESS' },
-  { Action: 'files.CREATE_FILE' },
-  { Action: 'auditlogs.ACCESS' },
-  { Action: 'twintypes.ACCESS' },
-  { Action: 'twintypes.CREATE_TWINTYPE' },
-  { Action: 'twins.ACCESS' },
-  { Action: 'twins.CREATE_TWIN' },
-  { Action: 'features.ACCESS' },
-  { Action: 'features.CREATE_FEATURE' },
-  { Action: 'oauthclients.ACCESS' },
-  { Action: 'oauthclients.CREATE' },
-  { Action: 'digitalSignatures.ACCESS' },
-  { Action: 'digitalSignatures.CREATE_DIGITAL_SIGNATURE' },
-  { Action: 'dashboards.ACCESS' },
-  { Action: 'dashboards.CREATE_DASHBOARD' },
-  { Action: 'integrations.ACCESS' },
-]
-
-const getUserPermissions = async (permissions: { Action: string; Resource: string }[] = []): Promise<Permission[]> => {
-  try {
-    const { data } = await DavraApiClient().post<Permission[]>(
-      '/api/v1/authorization/policy/check',
-      permissions.length ? permissions : permissionList,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-
-    return data
-  }
-  catch (error) {
-    return []
-  }
-}
-
-export default {
-  getUser,
-  getUserPermissions,
-  permissionList,
-}

package/src/stores/alertMessages.test.ts

@@ -1,27 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useAlertMessagesStore } from './alertMessages'
-
-describe('Devices Store', () => {
-  beforeEach(() => {
-    // creates a fresh pinia and make it active so it's automatically picked
-    // up by any useStore() call without having to pass it to it:
-    // `useStore(pinia)`
-    setActivePinia(createPinia())
-  })
-
-  it('should setSnackbarMessage', async () => {
-    const store = useAlertMessagesStore()
-
-    store.setSnackbarMessage('hello', 'info', 1000)
-
-    expect(store.snackbar).toEqual(true)
-    expect(store.snackbarText).toEqual('hello')
-    expect(store.snackbarSeverity).toEqual('info')
-    expect(store.snackbarTimeout).toEqual(1000)
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-})

package/src/stores/alertMessages.ts

@@ -1,26 +0,0 @@
-import { acceptHMRUpdate, defineStore } from 'pinia'
-
-export const useAlertMessagesStore = defineStore('alertMessages', () => {
-  const snackbar = ref<boolean>(false)
-  const snackbarText = ref<string>('')
-  const snackbarSeverity = ref<string>('')
-  const snackbarTimeout = ref<number>(5000)
-
-  const setSnackbarMessage = (text = '', severity = '', timeout = 5000) => {
-    snackbarText.value = text
-    snackbarSeverity.value = severity
-    snackbarTimeout.value = timeout
-    snackbar.value = true
-  }
-
-  return {
-    snackbar,
-    snackbarText,
-    snackbarSeverity,
-    snackbarTimeout,
-    setSnackbarMessage,
-  }
-})
-if (import.meta.hot)
-  import.meta.hot.accept(acceptHMRUpdate(useAlertMessagesStore, import.meta.hot))
-