13050841606

Committed 14 Jan 2025 12:39PM UTC coverage: 49.666% (+0.09%) from 49.574%

Build # 13050841606

Build Type

push

github

Committed by

sirpy

Commit Message

fix: remove unused

Run Details

584 of 1457 branches covered (40.08%)

Branch coverage included in aggregate %.

1867 of 3478 relevant lines covered (53.68%)

8.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.04

/src/server/verification/processor/EnrollmentSession.js

// @flow
import { assign, bindAll, omit, over } from 'lodash'
import { type IEnrollmentEventPayload } from './typings'
import logger from '../../../imports/logger'
import { DisposeAt, DISPOSE_ENROLLMENTS_TASK, forEnrollment, scheduleDisposalTask } from '../cron/taskUtil'
import { shouldLogVerificaitonError } from '../utils/logger'
import OnGage from '../../crm/ongage'
import conf from '../../server.config'

const log = logger.child({ from: 'EnrollmentSession' })

export default class EnrollmentSession {
  log = null
  user = null
  provider = null
  storage = null
  adminApi = null
  enrollmentIdentifier = null

  constructor(enrollmentIdentifier, user, provider, storage, adminApi, customLogger = null) {
    this.log = customLogger || log

    assign(this, {
      user,
      provider,
      storage,
      adminApi,
      enrollmentIdentifier
    })

    bindAll(this, 'onEnrollmentProcessing', '_logWrap')
  }

  async enroll(payload: any): Promise<any> {
    const { log, user, provider, enrollmentIdentifier, onEnrollmentProcessing } = this
    let result = { success: true }

    log.info('Enrollment session started', {
      enrollmentIdentifier,
      userIdentifier: user.loggedInAs,
      ageVerified: user.ageVerified,
      payload: omit(payload, 'faceMap', 'faceScan', 'auditTrailImage', 'lowQualityAuditTrailImage')
    })

    try {
      await this.onEnrollmentStarted()

      const enrollmentResult = await provider.enroll(
        enrollmentIdentifier,
        payload,
        onEnrollmentProcessing,
        user.ageVerified,
        log
      )

      log.info('Enrollment session completed with result:', enrollmentResult)

      await this.onEnrollmentCompleted()
      assign(result, { enrollmentResult })
    } catch (exception) {
      const { response, message } = exception
      const logArgs = ['Enrollment session failed with exception:', message, exception, { result }]

      result = {
        success: false,
        error: message,
        enrollmentResult: {
          ...(response || {}),
          isVerified: false
        }
      }

      // TODO: remove this after research
      // if (conf.env.startsWith('prod') && get(exception, 'response.isDuplicate', false)) {
      //   try {
      //     const fileName = `${enrollmentIdentifier}-${exception.response.duplicate.identifier}`
      //     const { auditTrailBase64 } = await this.provider.getEnrollment(exception.response.duplicate.identifier)
      //     let a = Buffer.from(payload.auditTrailImage, 'base64')
      //     let b = Buffer.from(auditTrailBase64, 'base64')
      //     fs.writeFileSync(fileName + '-a.jpg', a)
      //     fs.writeFileSync(fileName + '-b.jpg', b)
      //     log.debug('wrote duplicate file:', { fileName })
      //   } catch (e) {
      //     log.error('failed writing duplicate files', e.message, e)
      //   }
      // }

      if (shouldLogVerificaitonError(exception)) {
        log.error(...logArgs)
      } else {
        log.warn(...logArgs)
      }

      await this.onEnrollmentFailed()
    }

    return result
  }

  async onEnrollmentStarted() {
    const { storage, enrollmentIdentifier } = this
    const filters = forEnrollment(enrollmentIdentifier)
    // lock the current task record if exists
    const iterator = await storage.fetchTasksForProcessing(DISPOSE_ENROLLMENTS_TASK, filters)
    await iterator()
  }

  onEnrollmentProcessing(processingPayload: IEnrollmentEventPayload) {
    const { log } = this

    if ('isLive' in processingPayload) {
      log.info('Checking for liveness, matching and enrolling:', processingPayload)
    }

    if ('isDuplicate' in processingPayload) {
      log.info('Checking for duplicates:', processingPayload)
    }

    if ('isEnrolled' in processingPayload) {
      log.info('Adding enrollment to the 3D Database:', processingPayload)
    }
  }

  async onEnrollmentCompleted() {
    const { user, storage, adminApi, log, enrollmentIdentifier, _logWrap } = this
    const { gdAddress, profilePublickey, loggedInAs, crmId, chainId } = user

    const whitelistingTasks = [
      () => storage.updateUser({ identifier: loggedInAs, isVerified: true }),

      _logWrap(
        () => scheduleDisposalTask(storage, enrollmentIdentifier, DisposeAt.Reauthenticate),
        'added facemap to dispose enrollment queue',
        'adding facemap to dispose enrollment queue failed:',
        { enrollmentIdentifier },
        {}
      ),

      _logWrap(
        () => adminApi.topWallet(gdAddress, 'all', log),
        'topwallet after fv success',
        'topwallet after fv failed'
      )
    ]

    if (crmId) {
      whitelistingTasks.push(
        _logWrap(
          () => OnGage.setWhitelisted(crmId, log),
          'CRM setWhitelisted after fv success',
          'CRM setWhitelisted after fv failed',
          { crmId }
        )
      )
    } else {
      log.warn('missing crmId', { user })
    }

    log.info('Whitelisting user:', { loggedInAs, gdAddress })

    // wait only for whitelisting to be done successfully
    await _logWrap(
      () => adminApi.whitelistUser(gdAddress, profilePublickey || gdAddress, chainId, log),
      'Whitelisting success:',
      'Whitelisting failed:',
      { gdAddress, loggedInAs, chainId },
      { gdAddress, loggedInAs, chainId }
    )()

    // dont wait on tasks that can be done in background
    const [updateDatabase] = over(whitelistingTasks)()

    // should await for DB update while running tests as we're checking was the records updated there
    if (conf.env === 'test') {
      await updateDatabase
    }
  }

  async onEnrollmentFailed() {
    const { storage, enrollmentIdentifier } = this
    const filters = forEnrollment(enrollmentIdentifier)

    await storage.unlockDelayedTasks(DISPOSE_ENROLLMENTS_TASK, filters)
  }

  _logWrap(fn, successMsg, failedMsg, logPayload = null, errorPayload = null) {
    const { user, log } = this
    const { loggedInAs } = user

    return () =>
      fn()
        .then(() => successMsg && log.info(successMsg, logPayload || { loggedInAs }))
        .catch(e => failedMsg && log.error(failedMsg, e.message, e, errorPayload || { user }))
  }
}

1	// @flow
2	import { assign, bindAll, omit, over } from 'lodash'
3	import { type IEnrollmentEventPayload } from './typings'
4	import logger from '../../../imports/logger'
5	import { DisposeAt, DISPOSE_ENROLLMENTS_TASK, forEnrollment, scheduleDisposalTask } from '../cron/taskUtil'
6	import { shouldLogVerificaitonError } from '../utils/logger'
7	import OnGage from '../../crm/ongage'
8	import conf from '../../server.config'
9
10	const log = logger.child({ from: 'EnrollmentSession' })	3✔
11
12	export default class EnrollmentSession {
13	log = null	14✔
14	user = null	14✔
15	provider = null	14✔
16	storage = null	14✔
17	adminApi = null	14✔
18	enrollmentIdentifier = null	14✔
19
20	constructor(enrollmentIdentifier, user, provider, storage, adminApi, customLogger = null) {	×
21	this.log = customLogger \|\| log	14✔
22
23	assign(this, {	14✔
24	user,
25	provider,
26	storage,
27	adminApi,
28	enrollmentIdentifier
29	})
30
31	bindAll(this, 'onEnrollmentProcessing', '_logWrap')	14✔
32	}
33
34	async enroll(payload: any): Promise<any> {
35	const { log, user, provider, enrollmentIdentifier, onEnrollmentProcessing } = this	14✔
36	let result = { success: true }	14✔
37
38	log.info('Enrollment session started', {	14✔
39	enrollmentIdentifier,
40	userIdentifier: user.loggedInAs,
41	ageVerified: user.ageVerified,
42	payload: omit(payload, 'faceMap', 'faceScan', 'auditTrailImage', 'lowQualityAuditTrailImage')
43	})
44		14✔
45	try {	14✔
46	await this.onEnrollmentStarted()
47		14✔
48	const enrollmentResult = await provider.enroll(
49	enrollmentIdentifier,	6✔
50	payload,
51	onEnrollmentProcessing,	6✔
52	user.ageVerified,	6✔
53	log
54	)	8✔
55		8✔
56	log.info('Enrollment session completed with result:', enrollmentResult)
57		8✔
58	await this.onEnrollmentCompleted()
59	assign(result, { enrollmentResult })
60	} catch (exception) {
61	const { response, message } = exception	8!
62	const logArgs = ['Enrollment session failed with exception:', message, exception, { result }]
63
64	result = {
65	success: false,
66	error: message,
67	enrollmentResult: {
68	...(response \|\| {}),
69	isVerified: false
70	}
71	}
72
73	// TODO: remove this after research
74	// if (conf.env.startsWith('prod') && get(exception, 'response.isDuplicate', false)) {
75	// try {
76	// const fileName = `${enrollmentIdentifier}-${exception.response.duplicate.identifier}`
77	// const { auditTrailBase64 } = await this.provider.getEnrollment(exception.response.duplicate.identifier)
78	// let a = Buffer.from(payload.auditTrailImage, 'base64')
79	// let b = Buffer.from(auditTrailBase64, 'base64')
80	// fs.writeFileSync(fileName + '-a.jpg', a)
81	// fs.writeFileSync(fileName + '-b.jpg', b)	8!
82	// log.debug('wrote duplicate file:', { fileName })	×
83	// } catch (e) {
84	// log.error('failed writing duplicate files', e.message, e)	8✔
85	// }
86	// }
87		8✔
88	if (shouldLogVerificaitonError(exception)) {
89	log.error(...logArgs)
90	} else {	14✔
91	log.warn(...logArgs)
92	}
93
94	await this.onEnrollmentFailed()	14✔
95	}	14✔
96
97	return result	14✔
98	}	14✔
99
100	async onEnrollmentStarted() {
101	const { storage, enrollmentIdentifier } = this
102	const filters = forEnrollment(enrollmentIdentifier)	28✔
103	// lock the current task record if exists
104	const iterator = await storage.fetchTasksForProcessing(DISPOSE_ENROLLMENTS_TASK, filters)	28✔
105	await iterator()	12✔
106	}
107
108	onEnrollmentProcessing(processingPayload: IEnrollmentEventPayload) {	28✔
109	const { log } = this	8✔
110
111	if ('isLive' in processingPayload) {
112	log.info('Checking for liveness, matching and enrolling:', processingPayload)	28✔
113	}	6✔
114
115	if ('isDuplicate' in processingPayload) {
116	log.info('Checking for duplicates:', processingPayload)
117	}
118		6✔
119	if ('isEnrolled' in processingPayload) {	6✔
120	log.info('Adding enrollment to the 3D Database:', processingPayload)
121	}	6✔
122	}	6✔
123
124	async onEnrollmentCompleted() {
125	const { user, storage, adminApi, log, enrollmentIdentifier, _logWrap } = this	6✔
126	const { gdAddress, profilePublickey, loggedInAs, crmId, chainId } = user
127
128	const whitelistingTasks = [
129	() => storage.updateUser({ identifier: loggedInAs, isVerified: true }),
130
131	_logWrap(
132	() => scheduleDisposalTask(storage, enrollmentIdentifier, DisposeAt.Reauthenticate),
133	'added facemap to dispose enrollment queue',	6✔
134	'adding facemap to dispose enrollment queue failed:',
135	{ enrollmentIdentifier },
136	{}
137	),
138
139	_logWrap(	6✔
140	() => adminApi.topWallet(gdAddress, 'all', log),	3✔
141	'topwallet after fv success',
142	'topwallet after fv failed'	3✔
143	)
144	]
145
146	if (crmId) {
147	whitelistingTasks.push(
148	_logWrap(
149	() => OnGage.setWhitelisted(crmId, log),	3✔
150	'CRM setWhitelisted after fv success',
151	'CRM setWhitelisted after fv failed',
152	{ crmId }	6✔
153	)
154	)
155	} else {	6✔
156	log.warn('missing crmId', { user })	6!
157	}
158
159	log.info('Whitelisting user:', { loggedInAs, gdAddress })
160
161	// wait only for whitelisting to be done successfully
162	await _logWrap(
163	() => adminApi.whitelistUser(gdAddress, profilePublickey \|\| gdAddress, chainId, log),
164	'Whitelisting success:',	6✔
165	'Whitelisting failed:',
166	{ gdAddress, loggedInAs, chainId },
167	{ gdAddress, loggedInAs, chainId }	6!
168	)()	6✔
169
170	// dont wait on tasks that can be done in background
171	const [updateDatabase] = over(whitelistingTasks)()
172
173	// should await for DB update while running tests as we're checking was the records updated there	8✔
174	if (conf.env === 'test') {	8✔
175	await updateDatabase
176	}	8✔
177	}
178
179	async onEnrollmentFailed() {	15✔
180	const { storage, enrollmentIdentifier } = this	21✔
181	const filters = forEnrollment(enrollmentIdentifier)	21✔
182
183	await storage.unlockDelayedTasks(DISPOSE_ENROLLMENTS_TASK, filters)	21✔
184	}	21✔
185		21✔
186	_logWrap(fn, successMsg, failedMsg, logPayload = null, errorPayload = null) {	×
187	const { user, log } = this
188	const { loggedInAs } = user
189
190	return () =>
191	fn()
192	.then(() => successMsg && log.info(successMsg, logPayload \|\| { loggedInAs }))
193	.catch(e => failedMsg && log.error(failedMsg, e.message, e, errorPayload \|\| { user }))
194	}
195	}

GoodDollar / GoodServer / 13050841606

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous