@davra/ui-core 1.0.0-alpha.1

package/src/services/twinsService.test.ts

@@ -0,0 +1,228 @@
+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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,26 @@
+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))
+