jaakrecog-verify/esm2015/lib/enroll.service.js

This is a JAAK.AI Enroll© Angular Component for verify and authenticate users

import { Inject, Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { map } from 'rxjs/operators';
import { Builder } from 'builder-pattern';
import { OneToNVerify } from './classes/one-to-n-enroll';
import { LibConfigService } from './verify.module';
import * as i0 from "@angular/core";
import * as i1 from "./verify.module";
import * as i2 from "@angular/common/http";
export class EnrollService {
    constructor(config, http) {
        this.config = config;
        this.http = http;
    }
    oneToNVerify(request, accessToken) {
        let headers;
        if (accessToken) {
            headers = new HttpHeaders()
                .set('authorization', `Bearer ${accessToken}`)
                .append('auth', `Bearer ${accessToken}`);
        }
        return this.http
            .post(`${this.config.apiUrl
            ? this.config.apiUrl
            : 'https://dev-facade-1ton-http-635t26xtnq-uc.a.run.app/api/v1/one2n/verify/'}`, request, {
            headers: headers,
        })
            .pipe(map((response) => Builder(OneToNVerify)
            .id(response.eventId)
            .user(response.user)
            .processingTime(response.processTime)
            .build()));
    }
}
EnrollService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnrollService_Factory() { return new EnrollService(i0.ɵɵinject(i1.LibConfigService), i0.ɵɵinject(i2.HttpClient)); }, token: EnrollService, providedIn: "root" });
EnrollService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root',
            },] }
];
EnrollService.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [LibConfigService,] }] },
    { type: HttpClient }
];
//# sourceMappingURL=data:application/json;base64,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