TypeScript service.IdlObject.id方法代碼示例

    holdForChanged() {
        this.user = null;

        if (this.holdFor === 'patron') {
            if (this.userBarcode) {
                this.userBarcodeChanged();
            }
        } else {
            // To bypass the dupe check.
            this.currentUserBarcode = '_' + this.requestor.id();
            this.getUser(this.requestor.id());
        }
    }

    // Server API deletes and recreates the tree on update.
    // It manages parent/child relationships via the children array.
    // We only need send the current tree in a form the API recognizes.
    saveTree(): Promise<any> {


        const compileTree = (node?: TreeNode) => {

            if (!node) { node = this.tree.rootNode; }

            const point = node.callerData.point;

            node.children.forEach(child =>
                point.children().push(compileTree(child)));

            return point;
        };

        const rootPoint: IdlObject = compileTree();

        return this.net.request(
            'open-ils.vandelay',
            'open-ils.vandelay.match_set.update',
            this.auth.token(), this.matchSet_.id(), rootPoint
        ).toPromise().then(
            ok => this.refreshTree(),
            err => console.error(err)
        );
    }

    // Download a queue as a MARC file.
    exportQueue(queue: IdlObject, nonImported?: boolean) {

        const etype = queue.queue_type().match(/auth/) ? 'auth' : 'bib';

        let url =
          `${VANDELAY_EXPORT_PATH}?type=${etype}&queueid=${queue.id()}`;

        let saveName = queue.name();

        if (nonImported) {
            url += '&nonimported=1';
            saveName += '_nonimported';
        }

        saveName += '.mrc';

        this.http.get(url, {responseType: 'text'}).subscribe(
            data => {
                saveAs(
                    new Blob([data], {type: 'application/octet-stream'}),
                    saveName
                );
            },
            err  => {
                console.error(err);
            }
        );
    }

        .subscribe(summary => {
            summary.metabibId = Number(metabib.id());
            summary.metabibRecords =
                metabib.source_maps().map(m => Number(m.source()));

            let promise;

            if (relatedBibIds.length > 0) {

                // Grab data for MR bib summary augmentation
                promise = this.pcrud.search('mraf', {id: relatedBibIds})
                    .pipe(tap(attr => summary.record.mattrs().push(attr)))
                    .toPromise();
            } else {

                // Metarecord has only one constituent bib.
                promise = Promise.resolve();
            }

            promise.then(() => {

                // Re-compile with augmented data
                summary.compileRecordAttrs();

                // Fetch holdings data for the metarecord
                this.getHoldingsSummary(metabib.id(), orgId, orgDepth, true)
                .then(holdingsSummary => {
                    summary.holdingsSummary = holdingsSummary;
                    observer.next(summary);
                    observer.complete();
                });
            });
        });

 (part: IdlObject) => {
     this.editDialog.mode = 'update';
     this.editDialog.recId = part.id();
     this.editDialog.open().then(
         ok => this.partsGrid.reload(),
         err => {}
     );
 }

    refreshTree(): Promise<any> {
        if (!this.matchSet_) { return Promise.resolve(); }

        return this.pcrud.search('vmsp',
            {match_set: this.matchSet_.id()}, {},
            {atomic: true, authoritative: true}
        ).toPromise().then(points => this.ingestMatchPoints(points));
    }

 (matchSet: IdlObject) => {
     this.editDialog.mode = 'update';
     this.editDialog.recId = matchSet.id();
     this.editDialog.open({size: 'lg'}).then(
         ok => this.grid.reload(),
         err => {}
     );
 }

 constructor(record: IdlObject, orgId: number, orgDepth: number) {
     this.id = record.id();
     this.record = record;
     this.orgId = orgId;
     this.orgDepth = orgDepth;
     this.display = {};
     this.attributes = {};
     this.bibCallNumber = null;
 }

    placeOneHold(ctx: HoldContext, override?: boolean): Promise<any> {

        ctx.processing = true;
        const selectedFormats = this.mrSelectorsToFilters(ctx);

        return this.holds.placeHold({
            holdTarget: ctx.holdTarget,
            holdType: this.holdType,
            recipient: this.user.id(),
            requestor: this.requestor.id(),
            pickupLib: this.pickupLib,
            override: override,
            notifyEmail: this.notifyEmail, // bool
            notifyPhone: this.notifyPhone ? this.phoneValue : null,
            notifySms: this.notifySms ? this.smsValue : null,
            smsCarrier: this.notifySms ? this.smsCarrier : null,
            thawDate: this.suspend ? this.activeDate : null,
            frozen: this.suspend,
            holdableFormats: selectedFormats

        }).toPromise().then(
            request => {
                console.log('hold returned: ', request);
                ctx.lastRequest = request;
                ctx.processing = false;

                // If this request failed and was not already an override,
                // see of this user has permission to override.
                if (!request.override &&
                    !request.result.success && request.result.evt) {

                    const txtcode = request.result.evt.textcode;
                    const perm = txtcode + '.override';

                    return this.perm.hasWorkPermHere(perm).then(
                        permResult => ctx.canOverride = permResult[perm]);
                }
            },
            error => {
                ctx.processing = false;
                console.error(error);
            }
        );
    }

            promise.then(() => {

                // Re-compile with augmented data
                summary.compileRecordAttrs();

                // Fetch holdings data for the metarecord
                this.getHoldingsSummary(metabib.id(), orgId, orgDepth, true)
                .then(holdingsSummary => {
                    summary.holdingsSummary = holdingsSummary;
                    observer.next(summary);
                    observer.complete();
                });
            });