mergeParts() {
        console.log('Merging parts into lead part ', this.leadPart);

        if (!this.leadPart) { return; }

        this.leadPart = Number(this.leadPart);

        // 1. Migrate copy maps to the lead part.
        const partIds = this.parts
            .filter(p => Number(p.id()) !== this.leadPart)
               .map(p => Number(p.id()));

        const maps = [];
        this.pcrud.search('acpm', {part: partIds})
        .subscribe(
            map => {
                map.part(this.leadPart);
                map.ischanged(true);
                maps.push(map);
            },
            err => {},
            ()  => {
                // 2. Delete the now-empty subordinate parts.  Note the
                // delete must come after the part map changes are committed.
                if (maps.length > 0) {
                    this.pcrud.autoApply(maps)
                        .toPromise().then(() => this.deleteParts());
                } else {
                    this.deleteParts();
                }
            }
        );
    }

 this.deleteSelected = (rows: any[]) => {
     this.pcrud.remove(rows).subscribe(
         ok  => console.log('deleted ', ok),
         err => console.error(err),
         ()  => this.grid.reload()
     );
 };

    // Flesh the creator and editor fields.
    // Handling this separately lets us pull from the cache and
    // avoids the requirement that the main bib query use a staff
    // (VIEW_USER) auth token.
    fleshBibUsers(records: IdlObject[]): Promise<void> {

        const search = [];

        records.forEach(rec => {
            ['creator', 'editor'].forEach(field => {
                const id = rec[field]();
                if (Number.isInteger(id)) {
                    if (this.userCache[id]) {
                        rec[field](this.userCache[id]);
                    } else if (!search.includes(id)) {
                        search.push(id);
                    }
                }
            });
        });

        if (search.length === 0) {
            return Promise.resolve();
        }

        return this.pcrud.search('au', {id: search})
        .pipe(map(user => {
            this.userCache[user.id()] = user;
            records.forEach(rec => {
                if (user.id() === rec.creator()) {
                    rec.creator(user);
                }
                if (user.id() === rec.editor()) {
                    rec.editor(user);
                }
            });
        })).toPromise();
    }

 ngOnInit() {
     this.pcrud.retrieve('vms', this.matchSetId)
         .toPromise().then(ms => {
             ms.owner(this.org.get(ms.owner()));
             this.matchSet = ms;
         });
 }

    // Note when multiple IDs are provided, responses are emitted in order
    // of receipt, not necessarily in the requested ID order.
    getBibSummary(bibIds: number | number[],
        orgId?: number, orgDepth?: number): Observable<BibRecordSummary> {

        const ids = [].concat(bibIds);

        if (ids.length === 0) {
            return from([]);
        }

        return this.pcrud.search('bre', {id: ids},
            {   flesh: 1,
                flesh_fields: {bre: ['flat_display_entries', 'mattrs']},
                select: {bre : this.fetchableBreFields()}
            },
            {anonymous: true} // skip unneccesary auth
        ).pipe(mergeMap(bib => {
            const summary = new BibRecordSummary(bib, orgId, orgDepth);
            summary.net = this.net; // inject
            summary.ingest();
            return this.getHoldingsSummary(bib.id(), orgId, orgDepth)
            .then(holdingsSummary => {
                summary.holdingsSummary = holdingsSummary;
                return summary;
            });
        }));
    }

 ngOnInit() {
     this.pcrud.retrieveAll('crad', {order_by: {crad: 'label'}})
     .subscribe(attr => {
         this.bibAttrDefs.push(attr);
         this.bibAttrDefEntries.push({id: attr.name(), label: attr.label()});
     });
 }

 getUser(id: number) {
     this.pcrud.retrieve('au', id, {flesh: 1, flesh_fields: {au: ['settings']}})
     .subscribe(user => {
         this.user = user;
         this.applyUserSettings();
     });
 }

        .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();
                });
            });
        });

 this.deleteSelected = (parts: IdlObject[]) => {
     parts.forEach(part => part.isdeleted(true));
     this.pcrud.autoApply(parts).subscribe(
         val => console.debug('deleted: ' + val),
         err => {},
         ()  => this.partsGrid.reload()
     );
 };

    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));
    }