Comment puis-je traduire plusieurs chaînes à partir d'un objet après obtention d'un objet à partir d'une requête http puis stocker cet objet avec des chaînes traduites?

Question

Je reçois un objet d'une requête http. Je stocke cet objet par une autre requête http en utilisant la méthode put. Je veux traduire certaines chaînes de cet objet dans une autre langue en utilisant google translate api avant de stocker cet objet. Comment puis-je y parvenir?

service.ts

import { Injectable } from '@angular/core'; 
import { HttpClient, HttpErrorResponse } from '@angular/common/http'; 
import { Observable } from 'rxjs/Rx'; 

import { BaseApi } from '../../../../laas/base-api.service'; 
import { ApplicantService } from '../../../../laas/applicant.service'; 
import { environment as ENV } from '../../../../../environments/environment' 

@Injectable() 
export class NregaService { 

    private applicantId: string; 
    private baseUrl: string; 

    constructor(
    private http: HttpClient, 
    private api: BaseApi, 
    private applicant: ApplicantService 
) { 
    this.applicantId = applicant.getApplicantID() 
    this.baseUrl = `/applicants/${this.applicantId}/id/nrega`; 

    } 

    get() { 
    return this.api.newGet(this.baseUrl); 
    } 

    save(type, data) { 
    return this.api.put(this.baseUrl, { type: type, data: data }); 
    } 

    translate(q) { 
    const translateUrl = ENV.googleAddress.translateUrl; 
    const apiKey = ENV.googleAddress.apiKey; 
    const target = 'en'; 
    const model = 'base'; 
    return this.http.post(`${translateUrl}${apiKey}`, { q, target, model }).map(res => { 
     const value = res['data'].translations[0]; 
     console.log(`Translated ${q}:`, value); 
     return value.translatedText; 
    }); 
    } 

    verify(id) { 
    return this.api.post('nrega', { jobcardid: id }).map(result => { 
     if (typeof result === typeof '') { 
     throw result; 
     } 

     const incomes = []; 
     if (result.incomeDetail) { 
     result.incomeDetail 
      .sort((a, b) => a.year <= b.year ? -1 : 1) 
      .forEach(income => incomes.push({ income: income['income(Rs.)'], year: income.year })); 
     } 

     const details = []; 
     if (result.applicantDetail) { 
     result.applicantDetail.forEach(detail => details.push({ 
      name: detail.name, 
      gender: detail.gender[0].toLowerCase(), 
      age: detail.age, 
      bankOrPostOffice: detail.bankorpostoffice, 
      aadhaarNo: detail.aadhaarNo, 
      accountNo: detail.accountNo 
     })); 
     } 

     const data = { 
     jobCardId: result.jobcardno, 
     regDate: result.dateOfRegistration, 
     photo: result.photoImageUrl, 
     voterId: result.voterId, 
     fatherOrHusband: result.nameOfFatherOrHusband, 
     family: { 
      ids: [result.familyId1, result.familyId], 
      members: details, 
      head: result.nameOfHead, 
      isBpl: result.bplFamily.toLowerCase() === 'yes' ? true : false, 
      bplId: result.bplFamilyId, 
     }, 
     address: { 
      full: result.address, 
      village: result.village, 
      district: result.district, 
      panchayat: result.panchayat, 
      block: result.block 
     }, 
     category: result.category, 
     incomes: incomes, 
     }; 
     console.log('NREGA: ', data); 

     return data; 
    }); 
    } 

} 

Si j'utilise traduire méthode pour traduire les chaînes en service lui-même alors que je reçois une erreur peut-être parce que je ne l'ai pas utiliser la méthode .subscribe (qui je l'utilise dans le composant où J'appelle la méthode verify() du service Est-il possible de convertir plusieurs chaînes en service avant même de retourner les données au composant?

Answer 1

Je pense que ce que vous cherchez est le Rxjs carte opérateur.

Tout d'abord, importez cet opérateur dans votre fichier service.ts.

import 'rxjs/add/operator/map'; 

Alors, si je suis votre point, vous voulez traduire certaines chaînes lorsque votre composant appelle la méthode get, après que les données ont été reçues du serveur, mais avant que la méthode a envoyé les données au composant .

composant> Service.get()> http demande> données reçues du serveur>traduire> données envoyées au composant

Si je ne me trompe pas, la seule chose que vous devez faire est d'utiliser l'opérateur de carte:

get() { 
    return this.api.newGet(this.baseUrl) 
    .map(data => this.translate(data)); 
} 

Imaginons un type SourceData et ModifiedData types. L'opérateur de carte vous laissera retourner un Observable<ModifiedData> au lieu du Observable<SourceData> que vous avez renvoyé. Regardez la documentation here pour une meilleure explication.

Notez que vous pouvez également effectuer la traduction lorsque votre méthode de sauvegarde est appelée.

save(type, data) { 
    data = this.translate(data) 
    return this.api.put(this.baseUrl, { type: type, data: data }); 
}