@fabric-es/operator/dist/tasks/registerAndEnroll.js

Network operator

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerAndEnroll = void 0;
const util_1 = __importDefault(require("util"));
const fabric_common_1 = require("fabric-common");
const types_1 = require("../types");
const utils_1 = require("../utils");
const registerAndEnroll = (option) => async ({ enrollmentId, enrollmentSecret, asLocalhost = true }) => {
    let caService;
    let gateway;
    const logger = utils_1.getLogger({ name: '[operator] registerAndEnroll.js' });
    const { caName, caAdmin, caAdminPW, connectionProfile, wallet, mspId } = option;
    if (!enrollmentId)
        throw new Error(types_1.MISSING_ENROLLMENTID);
    if (!enrollmentSecret)
        throw new Error(types_1.MISSING_ENROLLMENTSECRET);
    if (!mspId) {
        logger.error('mspId not found');
        throw new Error('mspId not found');
    }
    try {
        caService = await utils_1.getFabricCaService(connectionProfile, caName);
    }
    catch (e) {
        logger.error(util_1.default.format('fail to newFabricCAServices: %j', e));
        throw new Error(e);
    }
    try {
        gateway = await utils_1.getGateway({
            connectionProfile,
            identity: caAdmin,
            wallet,
            asLocalhost,
        });
    }
    catch (e) {
        logger.error(util_1.default.format('fail to connect gateway, %j', e));
        throw new Error(e);
    }
    return {
        disconnect: () => gateway.disconnect(),
        registerAndEnroll: async () => {
            let adminExist;
            let enrollmentIdExist;
            try {
                adminExist = await wallet.get(caAdmin);
            }
            catch (e) {
                logger.error(e);
                throw new Error(e);
            }
            if (!adminExist) {
                logger.error(types_1.ORG_ADMIN_NOT_EXIST);
                throw new Error(types_1.ORG_ADMIN_NOT_EXIST);
            }
            try {
                enrollmentIdExist = await wallet.get(enrollmentId);
            }
            catch (e) {
                logger.error(e);
                throw new Error(e);
            }
            if (enrollmentIdExist) {
                logger.warn(`registerAndEnroll: ${types_1.IDENTITY_ALREADY_EXIST}`);
                throw new Error(types_1.IDENTITY_ALREADY_EXIST);
            }
            const credentials = gateway.getIdentity().credentials;
            const registrar = fabric_common_1.User.createUser(caAdmin, caAdminPW, mspId, credentials.certificate, credentials.privateKey);
            try {
                await caService.register({
                    enrollmentID: enrollmentId,
                    enrollmentSecret,
                    affiliation: '',
                    maxEnrollments: -1,
                    role: 'client',
                }, registrar);
            }
            catch (e) {
                logger.error(util_1.default.format('operator fail to register %s: %j', enrollmentId, e));
                return new Error(e);
            }
            logger.info(util_1.default.format('register user: %s at %s', enrollmentId, mspId));
            let enroll;
            try {
                enroll = await caService.enroll({
                    enrollmentID: enrollmentId,
                    enrollmentSecret,
                });
            }
            catch (e) {
                logger.error(util_1.default.format('operator fail to enroll: %j', e));
                return new Error(e);
            }
            const x509identity = {
                credentials: { certificate: enroll.certificate, privateKey: enroll.key.toBytes() },
                mspId,
                type: 'X.509',
            };
            try {
                await wallet.put(enrollmentId, x509identity);
            }
            catch (e) {
                logger.error(util_1.default.format('operator fail to import: %j', e));
                return new Error(e);
            }
            logger.info(util_1.default.format('Enroll user and import wallet: %s at %s', enrollmentId, mspId));
            return {
                status: types_1.SUCCESS,
                info: `Successfully register & enroll ${enrollmentId}; and import into the wallet`,
            };
        },
    };
};
exports.registerAndEnroll = registerAndEnroll;
//# sourceMappingURL=registerAndEnroll.js.map