TypeScript net.service.NetService類代碼示例

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

 removeItem(cacheKey: string, attr: string): Promise<string> {
     return this.net.request(
         'open-ils.actor',
         'open-ils.actor.anon_cache.set_value',
         cacheKey, attr, null
     ).toPromise();
 }

 ngOnInit() {
     this.server = window.location.hostname;
     this.net.request(
         'open-ils.actor',
         'opensrf.open-ils.system.ils_version'
     ).subscribe(v => this.version = v);
 }

 this.basket.getRecordIds().then(ids => {
     this.net.request(
         'open-ils.search',
         'open-ils.search.biblio.record.email',
         this.auth.token(), ids
     ).toPromise(); // fire-and-forget
 });

    // Create a new bucket then add the record
    addToNew() {
        const bucket = this.idl.create('cbreb');

        bucket.owner(this.auth.user().id());
        bucket.name(this.newBucketName);
        bucket.description(this.newBucketDesc);
        bucket.btype(this.bucketType);

        this.net.request(
            'open-ils.actor',
            'open-ils.actor.container.create',
            this.auth.token(), 'biblio', bucket
        ).subscribe(bktId => {
            const evt = this.evt.parse(bktId);
            if (evt) {
                this.toast.danger(evt.desc);
            } else {
                // make it find-able to the queue-add method which
                // requires the bucket name.
                bucket.id(bktId);
                this.buckets.push(bucket);
                this.addToBucket(bktId);
            }
        });
    }

    fetchHold() {
        if (!this._holdId) { return; }

        this.net.request(
            'open-ils.circ',
            'open-ils.circ.hold.wide_hash.stream',
            this.auth.token(), {id: this._holdId}
        ).subscribe(wideHold => {
            this.hold = wideHold;
        });
    }

    // Get -> Set -> Return bib hold count
    getHoldCount(): Promise<number> {

        if (Number.isInteger(this.holdCount)) {
            return Promise.resolve(this.holdCount);
        }

        return this.net.request(
            'open-ils.circ',
            'open-ils.circ.bre.holds.count', this.id
        ).toPromise().then(count => this.holdCount = count);
    }

            const deleteNext = (idx: number) => {
                const queue = selected[idx];
                if (!queue) {
                    this.currentGrid().reload();
                    return Promise.resolve();
                }

                return this.net.request('open-ils.vandelay',
                    method, this.auth.token(), queue.id()
                ).toPromise().then(() => deleteNext(++idx));
            };

 this.gridSource.getRows = (pager: Pager) => {
     return this.net.request(
         'open-ils.vandelay',
         'open-ils.vandelay.import_item.queue.retrieve',
         this.auth.token(), this.queueId, {
             with_import_error: this.filterImportErrors,
             offset: pager.offset,
             limit: pager.limit
         }
     );
 };

    placeHold(request: HoldRequest): Observable<HoldRequest> {

        let method = 'open-ils.circ.holds.test_and_create.batch';
        if (request.override) { method = method + '.override'; }

        return this.net.request(
            'open-ils.circ', method, this.auth.token(), {
                patronid:       request.recipient,
                pickup_lib:     request.pickupLib,
                hold_type:      request.holdType,
                email_notify:   request.notifyEmail,
                phone_notify:   request.notifyPhone,
                thaw_date:      request.thawDate,
                frozen:         request.frozen,
                sms_notify:     request.notifySms,
                sms_carrier:    request.smsCarrier,
                holdable_formats_map: request.holdableFormats
            },
            [request.holdTarget]
        ).pipe(map(
            resp => {
                let result = resp.result;
                const holdResult: HoldRequestResult = {success: true};

                // API can return an ID, an array of events, or a hash
                // of info.

                if (Number(result) > 0) {
                    // On success, the API returns the hold ID.
                    holdResult.holdId = result;
                    console.debug(`Hold successfully placed ${result}`);

                } else {
                    holdResult.success = false;
                    console.info('Hold request failed: ', result);

                    if (Array.isArray(result)) { result = result[0]; }

                    if (this.evt.parse(result)) {
                        holdResult.evt = this.evt.parse(result);
                    } else {
                        holdResult.evt = this.evt.parse(result.last_event);
                    }
                }

                request.result = holdResult;
                return request;
            }
        ));
    }