16730210565

Committed 15 May 2025 06:46AM UTC coverage: 49.341% (-0.3%) from 49.666%

Build # 16730210565

Build Type

push

github

Committed by

sirpy

Commit Message

fix: remove defualt gas fees

Run Details

597 of 1485 branches covered (40.2%)

Branch coverage included in aggregate %.

1875 of 3525 relevant lines covered (53.19%)

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

GoodDollar / GoodServer / 16730210565

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