@bifold/core 2.4.5 → 2.5.0

package/src/modules/history/context/historyManager.tsx

@@ -1,247 +0,0 @@
-/**
- *  USAGE
- * 
-        const { agent } = useAgent()
-
-        //Log history
-        const historyManager = container.resolve(TOKENS.FN_LOAD_HISTORY)(agent)
-         const recordData: HistoryRecord = {
-           type: HistoryCardType.CardAccepted,
-           message: `Wallet Initialized at ${new Date()}`,
-           createdAt: new Date(),
-           correspondenceId: 'Some data',
-           correspondenceName: 'Some name',
-         }
-        await historyManager.saveHistory(recordData)
-        
-        const allRecords = await historyManager.getHistoryItems({ type: RecordType.HistoryRecord })
-        console.log("$$:", JSON.stringify(allRecords))
- * 
- */
-
-import { Agent } from '@credo-ts/core'
-import { GenericRecord, GenericRecordTags } from '@credo-ts/core/build/modules/generic-records/repository/GenericRecord'
-import moment from 'moment'
-
-import { i18n } from '../../../localization/index'
-import { BifoldLogger } from '../../../services/logger'
-import QueeManager from '../services/queue.service'
-import {
-  AppNotificationRecord,
-  CustomRecord,
-  HistoryBlockSelection,
-  HistoryQuery,
-  HistoryRecord,
-  IHistoryManager,
-  NotificationRecord,
-  RecordType,
-} from '../types'
-import { LocalStorageKeys } from '../../../constants'
-import { PersistentStorage } from '../../../services/storage'
-export default class HistoryManager implements IHistoryManager {
-  private agent: Agent<any> | null
-  private logger = new BifoldLogger()
-  public constructor(agent: Agent<any> | null) {
-    this.agent = agent
-    if (!agent) {
-      this.error(`[${HistoryManager.name}]: History module loaded with undefined agent!!`)
-      return
-    }
-    this.trace(`[${HistoryManager.name}]: History module loaded!`)
-  }
-
-  private async addGenericRecord(customRecord: CustomRecord, type: RecordType): Promise<void> {
-    try {
-      if (!this.agent) {
-        this.error(`[${HistoryManager.name}]: Add generic record: Agent not set yet adding generic record into quee`)
-        QueeManager.getInstance()?.addQuee({ customRecord, type })
-        return
-      }
-      const tags = {
-        type: type,
-      }
-      const storedContent = customRecord.content as unknown as Record<string, unknown>
-      this.trace(`[${HistoryManager.name}]: Adding history record:${JSON.stringify(storedContent)}`)
-      this.trace(`[${HistoryManager.name}]: >> Tags:${JSON.stringify(tags)}`)
-      await this.agent.genericRecords.save({
-        content: storedContent,
-        tags: tags,
-      })
-    } catch (e: unknown) {
-      this.error(`[${HistoryManager.name}]: Add generic record: ${e}`)
-      throw new Error(`${e}`)
-    }
-  }
-
-  private error(message: string): void {
-    this.logger.error(message)
-  }
-
-  private trace(message: string): void {
-    this.logger.trace(message)
-  }
-
-  private async getGenericRecordsbyQuery(query: Partial<GenericRecordTags>): Promise<CustomRecord[]> {
-    try {
-      if (!this.agent) {
-        this.error(`[${HistoryManager.name}]: Find generic record by query: Agent not set`)
-        throw new Error(`Agent not set `)
-      }
-      this.trace(`[${HistoryManager.name}]: Searching saved history by query:${JSON.stringify(query)}`)
-
-      const retrievedRecords: CustomRecord[] = []
-
-      const savedRecords = await this.agent.genericRecords.findAllByQuery(query)
-      if (savedRecords) {
-        savedRecords.forEach((element) => {
-          const tags = element.getTags()
-          switch (tags.type) {
-            case RecordType.AppNotificationRecord: {
-              const appNotificationRecord: AppNotificationRecord = element.content as unknown as AppNotificationRecord
-              const appNotification: AppNotificationRecord = {
-                id: element.id,
-                createdAt: element.createdAt,
-                type: appNotificationRecord.type,
-              }
-              retrievedRecords.push({ content: appNotification, tags })
-              break
-            }
-            case RecordType.NotificationRecord: {
-              const notificationRecord: NotificationRecord = element.content as unknown as NotificationRecord
-              const notification: NotificationRecord = {
-                message: notificationRecord.message,
-                credentialId: notificationRecord.credentialId,
-                type: notificationRecord.type,
-                id: element.id,
-                createdAt: element.createdAt,
-                isNotificationRemoved: notificationRecord.isNotificationRemoved,
-              }
-              retrievedRecords.push({ content: notification, tags })
-              break
-            }
-            case RecordType.HistoryRecord: {
-              const historyRecord: HistoryRecord = element.content as unknown as HistoryRecord
-              const history: HistoryRecord = {
-                message: historyRecord.message,
-                id: element.id,
-                createdAt: element.createdAt,
-                type: historyRecord.type,
-                correspondenceId: historyRecord.correspondenceId,
-                correspondenceName: historyRecord.correspondenceName,
-              }
-              retrievedRecords.push({ content: history, tags })
-              break
-            }
-            default: {
-              break
-            }
-          }
-        })
-      }
-      this.trace(`[${HistoryManager.name}]: Found saved history length:${retrievedRecords.length}`)
-      return retrievedRecords
-    } catch (e: unknown) {
-      this.error(`[${HistoryManager.name}]: Find generic record by query: ${e}`)
-      throw new Error(`${e}`)
-    }
-  }
-
-  // PUBLIC
-  public async saveHistory(recordData: HistoryRecord) {
-    this.trace(`[${HistoryManager.name}]: Saving history record:${JSON.stringify(recordData)}`)
-    try {
-      const historySettingsOption = await PersistentStorage.fetchValueForKey<string>(
-        LocalStorageKeys.HistorySettingsOption
-      )
-
-      // Save History when history settings option is not 'Never'
-      if (!(historySettingsOption === 'Never')) {
-        await this.addGenericRecord(
-          {
-            content: recordData,
-          },
-          RecordType.HistoryRecord
-        )
-      }
-    } catch (e: unknown) {
-      this.error(`[${HistoryManager.name}]: Saving history error: ${e}`)
-      throw new Error(`${e}`)
-    }
-  }
-
-  public async getHistoryItems(query: HistoryQuery): Promise<CustomRecord[]> {
-    return this.getGenericRecordsbyQuery(query)
-  }
-
-  public async findGenericRecordById(id: string): Promise<GenericRecord | null> {
-    try {
-      if (!this.agent) {
-        this.error(`[${HistoryManager.name}]: Find generic record by id: Agent not set`)
-        throw new Error(`Agent not set `)
-      }
-      return await this.agent.genericRecords.findById(id)
-    } catch (e: unknown) {
-      this.error(`[${HistoryManager.name}]: Find generic record by id: ${e}`)
-      throw new Error(`${e}`)
-    }
-  }
-
-  public async removeGenericRecord(genericRecord: GenericRecord): Promise<void> {
-    try {
-      if (!this.agent) {
-        this.error(`[${HistoryManager.name}]: Remove generic record: Agent not set`)
-        throw new Error(`Agent not set `)
-      }
-      return await this.agent.genericRecords.delete(genericRecord)
-    } catch (e: unknown) {
-      this.error(`[${HistoryManager.name}]: Remove generic record: ${e}`)
-      throw new Error(`${e}`)
-    }
-  }
-
-  public async handleStoreHistorySettings(selectedValue: HistoryBlockSelection | undefined): Promise<void> {
-    if (!selectedValue) {
-      throw new Error('No option selected')
-    }
-
-    await PersistentStorage.storeValueForKey<string>(LocalStorageKeys.HistorySettingsOption, selectedValue.id)
-
-    //TODO: Delete old history
-    /*
-    if (selectedValue.id !== 'Always') {
-      // Filter history record data and get the ones that needs to be deleted.
-      const selectedHistoryRecords = historyItems && filterDataByGivenDate(historyItems, selectedValue.date)
-      // Remove history past the selected date.
-      if (selectedHistoryRecords) {
-        for await (const record of selectedHistoryRecords) {
-          const recordHistory = record.content as HistoryRecord
-          if (!recordHistory || !recordHistory.id) {
-            return
-          }
-          const deleteRecord = await findGenericRecordById(recordHistory.id)
-          if (!deleteRecord) {
-            return
-          }
-          await removeGenericRecord(deleteRecord)
-        }
-      }
-    }
-    */
-  }
-
-  public async getStoredHistorySettingsOption(): Promise<string | null> {
-    return (await PersistentStorage.fetchValueForKey<string>(LocalStorageKeys.HistorySettingsOption)) ?? null
-  }
-
-  public getHistorySettingsOptionList(): Array<HistoryBlockSelection> {
-    const oneMonth = moment().subtract(1, 'month')
-    const sixMonth = moment().subtract(6, 'month')
-    const oneYear = moment().subtract(1, 'year')
-    return [
-      { key: 0, id: '1 month', date: oneMonth, value: i18n.t('ActivityHistory.DeleteActivityAfter.1month') },
-      { key: 1, id: '6 month', date: sixMonth, value: i18n.t('ActivityHistory.DeleteActivityAfter.6month') },
-      { key: 2, id: '1 year', date: oneYear, value: i18n.t('ActivityHistory.DeleteActivityAfter.1year') },
-      { key: 3, id: 'Always', value: i18n.t('ActivityHistory.DeleteActivityAfter.Always') },
-    ]
-  }
-}

package/src/modules/history/index.ts

@@ -1,2 +0,0 @@
-import { IHistoryManager, HistoryRecord } from './types'
-export type { IHistoryManager, HistoryRecord }

package/src/modules/history/navigation/HistoryStack.tsx

@@ -1,29 +0,0 @@
-import { createStackNavigator } from '@react-navigation/stack'
-import React from 'react'
-import { useTranslation } from 'react-i18next'
-
-import { useTheme } from '../../../contexts/theme'
-import { useDefaultStackOptions } from '../../../navigators/defaultStackOptions'
-import { HistoryStackParams, Screens } from '../../../types/navigators'
-import { testIdWithKey } from '../../../utils/testable'
-// import HistoryDetailsPage from '../ui/HistoryDetails'
-import HistoryPage from '../ui/HistoryPage'
-
-const HistoryStack: React.FC = () => {
-  const Stack = createStackNavigator<HistoryStackParams>()
-  const theme = useTheme()
-  const { t } = useTranslation()
-  const defaultStackOptions = useDefaultStackOptions(theme)
-
-  return (
-    <Stack.Navigator screenOptions={{ ...defaultStackOptions }}>
-      <Stack.Screen
-        name={Screens.HistoryPage}
-        component={HistoryPage}
-        options={{ title: t('Screens.History'), headerBackTestID: testIdWithKey('Back') }}
-      />
-    </Stack.Navigator>
-  )
-}
-
-export default HistoryStack

package/src/modules/history/services/queue.service.tsx

@@ -1,31 +0,0 @@
-import { CustomRecord, RecordType } from '../types'
-
-interface HistoryQueeItem {
-  customRecord: CustomRecord
-  type: RecordType
-}
-export default class QueeManager {
-  private recordsQuee: HistoryQueeItem[]
-  public constructor() {
-    this.recordsQuee = []
-  }
-
-  // public
-  public addQuee(item: HistoryQueeItem) {
-    this.recordsQuee.push(item)
-  }
-
-  public getLast(): HistoryQueeItem | undefined {
-    return this.recordsQuee.pop()
-  }
-
-  // Static methods
-  private static myInstance: QueeManager | null = null
-  public static getInstance(): QueeManager | null {
-    if (QueeManager.myInstance == null) {
-      QueeManager.myInstance = new QueeManager()
-    }
-
-    return this.myInstance
-  }
-}

package/src/modules/history/types/index.ts

@@ -1,92 +0,0 @@
-import { GenericRecord } from '@credo-ts/core/build/modules/generic-records/repository/GenericRecord'
-import { Moment } from 'moment'
-
-export interface IHistoryManager {
-  saveHistory: (recordData: HistoryRecord) => Promise<void>
-  getHistoryItems: (query: HistoryQuery) => Promise<CustomRecord[]>
-  findGenericRecordById: (id: string) => Promise<GenericRecord | null>
-  removeGenericRecord: (genericRecord: GenericRecord) => Promise<void>
-  handleStoreHistorySettings: (selectedValue: HistoryBlockSelection | undefined) => Promise<void>
-  getStoredHistorySettingsOption: () => Promise<string | null>
-  getHistorySettingsOptionList: () => Array<HistoryBlockSelection>
-}
-
-export interface HistoryBlockSelection {
-  value: string
-  id: string
-  key?: number
-  date?: Moment
-}
-
-export enum HistoryCardType {
-  CardAccepted = 'CardAccepted',
-  CardDeclined = 'CardDeclined',
-  CardExpired = 'CardExpired', // TODO: log this type of event
-  CardRemoved = 'CardRemoved',
-  CardRevoked = 'CardRevoked', // TODO: log this type of event
-  CardUpdates = 'CardUpdates', // TODO: log this type of event
-  PinChanged = 'PinChanged',
-  InformationSent = 'InformationSent',
-  InformationNotSent = 'InformationNotSent',
-  Connection = 'Connection',
-  ConnectionRemoved = 'ConnectionRemoved',
-  ActivateBiometry = 'ActivateBiometry',
-  DeactivateBiometry = 'DeactivateBiometry',
-}
-export interface HistoryRecord {
-  /** History Record ID */
-  id?: string
-  /** History Record Type */
-  type?: HistoryCardType
-  /** History Record Message */
-  message: string
-  /** History Record Date */
-  createdAt?: Date
-  /** History Record Item ID */
-  correspondenceId?: string
-  /** History Record Item Name */
-  correspondenceName?: string
-}
-export enum RecordType {
-  AppNotificationRecord = 'AppNotificationRecord',
-  NotificationRecord = 'NotificationRecord',
-  HistoryRecord = 'HistoryRecord',
-}
-export type TagObject = {
-  [key: string]: string | boolean | undefined | Array<string> | null
-  [key: number]: never
-}
-
-export interface CustomRecord {
-  content: RecordTypes
-  tags?: TagObject
-}
-
-export interface AppNotificationRecord {
-  id?: string
-  createdAt?: Date
-  type?: AppNotificationCardType
-}
-
-export interface NotificationRecord {
-  message: string
-  credentialId: string
-  type?: NotificationCardType
-  id?: string
-  createdAt?: Date
-  isNotificationRemoved: boolean
-}
-
-export enum AppNotificationCardType {
-  AppPinReminder = 'AppPinReminder',
-}
-
-export enum NotificationCardType {
-  CardExpired = 'CardExpired',
-  CardRevoked = 'CardRevoked',
-}
-
-type RecordTypes = NotificationRecord | HistoryRecord | AppNotificationRecord
-export type HistoryQuery = {
-  type: RecordType
-}

package/src/modules/history/ui/HistoryPage.tsx

@@ -1,133 +0,0 @@
-import { useAgent } from '@credo-ts/react-hooks'
-import { StackScreenProps } from '@react-navigation/stack'
-import React, { useEffect, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-import { FlatList, StyleSheet, View } from 'react-native'
-
-import { ButtonType } from '../../../components/buttons/Button-api'
-import { TOKENS, useServices } from '../../../container-api'
-import { useAnimatedComponents } from '../../../contexts/animated-components'
-import { useTheme } from '../../../contexts/theme'
-import { HistoryStackParams } from '../../../types/navigators'
-import { testIdWithKey } from '../../../utils/testable'
-import { CustomRecord, RecordType } from '../types'
-
-import HistoryListItem from './components/HistoryListItem'
-import { ThemedText } from '../../../components/texts/ThemedText'
-
-type HistoryPageProps = StackScreenProps<HistoryStackParams>
-
-const HistoryPage: React.FC<HistoryPageProps> = () => {
-  const [continueEnabled] = useState(true)
-  const [isLoading] = useState(false)
-  const [historyItems, setHistoryItems] = useState<CustomRecord[]>()
-  const { t } = useTranslation()
-  const { agent } = useAgent()
-  const { ColorPalette } = useTheme()
-  const { ButtonLoading } = useAnimatedComponents()
-
-  const actionButtonLabel = t('Global.SaveSettings')
-  const actionButtonTestId = testIdWithKey('Save')
-  const [Button, logger, historyManagerCurried] = useServices([
-    TOKENS.COMP_BUTTON,
-    TOKENS.UTIL_LOGGER,
-    TOKENS.FN_LOAD_HISTORY,
-  ])
-
-  const style = StyleSheet.create({
-    screenContainer: {
-      height: '100%',
-      backgroundColor: ColorPalette.brand.primaryBackground,
-      padding: 20,
-      justifyContent: 'space-between',
-    },
-    title: {
-      marginTop: 16,
-    },
-    deleteButtonText: {
-      alignSelf: 'flex-start',
-      color: '#CD0000', //TODO: Use Bifold alert color
-    },
-    deleteButton: {
-      marginBottom: 16,
-    },
-    gap: {
-      marginTop: 10,
-      marginBottom: 10,
-    },
-    // below used as helpful labels for views, no properties needed atp
-    contentContainer: {},
-    controlsContainer: {},
-  })
-
-  //UI
-  const renderEmptyListComponent = () => {
-    return (
-      <View>
-        <ThemedText variant="headerTitle" style={style.title}>
-          {t('ActivityHistory.NoHistory')}
-        </ThemedText>
-      </View>
-    )
-  }
-
-  const renderHistoryListItem = (item: CustomRecord) => {
-    return <HistoryListItem item={item} />
-  }
-
-  useEffect(() => {
-    const getHistory = async () => {
-      if (!agent) {
-        logger.error(`[${HistoryPage.name}][getAllHistory]: agent undefined!`)
-        return
-      }
-      const historyManager = historyManagerCurried(agent)
-      if (!historyManager) {
-        logger.error(`[${HistoryPage.name}][getAllHistory]: historyManager undefined!`)
-        return
-      }
-      const allRecords = await historyManager.getHistoryItems({ type: RecordType.HistoryRecord })
-      allRecords.sort((objA, objB) => Number(objB.content.createdAt) - Number(objA.content.createdAt))
-
-      if (allRecords) {
-        setHistoryItems(allRecords)
-      }
-    }
-
-    getHistory().catch((e) => {
-      logger.error(`[${HistoryPage.name}][getAllHistory]: ${e}`)
-    })
-  }, [historyManagerCurried, logger, agent])
-
-  return (
-    <View style={style.screenContainer}>
-      <View style={style.contentContainer}>
-        <View>
-          <Button
-            title={t('History.SortFilterButton')}
-            testID={actionButtonTestId}
-            accessibilityLabel={actionButtonLabel}
-            buttonType={ButtonType.Secondary}
-            onPress={async () => {
-              //TODO: Save settings
-              // console.log('save history')
-            }}
-          >
-            {!continueEnabled && isLoading ? <ButtonLoading /> : null}
-          </Button>
-          <View style={style.gap} />
-
-          <FlatList
-            showsVerticalScrollIndicator={false}
-            style={{ flexGrow: 0 }}
-            data={historyItems}
-            ListEmptyComponent={renderEmptyListComponent}
-            renderItem={(element) => renderHistoryListItem(element.item)}
-          />
-        </View>
-      </View>
-    </View>
-  )
-}
-
-export default HistoryPage