sendFile(modelForm: any, form?: any) {

    // tudo que esta em this.appService, são serviços que retorna um obsevable do http do angular.

    // aqui eu começo convertendo o objeto do arquivo que pego do input
    this.appService.convertFile(this.objFile)
      .map(response => {
        // o retorno de convertFile eu apenas monto essa estrutura mountData e coloco o arquivo em base64 em mountData.file.
        let mountData = {
          'file': response,
          'terms': []
        };
        return mountData;
      })

      // o .concatMap é executado em seguida recebendo como parametro o resultado do convertFile.
      .concatMap(mountData => {
        // novamente eu utilizo outro serviço que faz um GET, eu pego a lista de termos de uma determinada coleção.
        return this.ciService.objectList('instance_ci_terms', 'collection_id=' + this.collectionChecked)
          .map(
            terms => {
              // a lista de termos retornada do GET eu apenas insiro dentro de mountData.terms e retorno ela para o proximo concatMap.
              mountData.terms = terms;
              return mountData;
            });
      })

      // aqui novamente só vai ser executada depois do anterior finalizar e passar o retorno.
      .concatMap(mountData => {
        // aqui eu chamo o metodo que criei que vai pegar todos os termos que tem dentro de mountData.terms, e fazer um GET para pegar
           todos os subtermos de cada termo.
        return this.mountTermsSubterms(mountData);

      })

      // novamente vai receber o mountData com o arquivo em base64 e todos os terms e seus subtermos.
      .concatMap(mountData => {
        // novamente eu chamo o convertFile para converter nosso mountData, agora como ele não é um objeto file, então o segundo
            parametro tem que ser false.
        return this.appService.convertFile(mountData, false);
      })

      // Ao finalizar todo esse processo, chamaremos o Serviço de upload de arquivo.
      .concatMap(response => {
        // esse metodo getNewName só pega o nome atual do arquivo e insere um timestamp entre o nome e a ext.
        let fileName = this.config.getNewName(this.objFile.name);
        return this.appService.uploadFile(response, fileName);
      })

      // para isso tudo funcionar eu preciso rodar o subscribe e ver foi tudo ok ou se aconteceu algum error durante esse processo.
      .subscribe(
        data => {

          this.messageService.success('Arquivo enviado com sucesso.');
        },
        error => {

          this.messageService.error('Ocorreu algum problema na durante o envio do arquivo.');
          console.log(error, 'Error inside of sendFile');

        }
      );
  }




// esse metodo pega uma lista de terms e monta ele da forma que a api aceita.
ex:
entrada: mountData = {
  file: 'base64',
  terms: [{obj term}, {obj term}, {obj term}]
}

raida: mountData = {
  file: 'base64',
  terms: [
    {
      term_name: [
        subterm_name,
        subterm_name
      ]
    },
    {
      term_name: [
        subterm_name,
        subterm_name
      ]
    }
}

mountTermsSubterms(mountData): Observable<any> {
    let listTermsSubterms = []; // lista de termos montado que ira substituir os terms atuais em mountData.

    //aqui estou criando um observable que ira retornar o mountData atualizado e será finalizado apenas quando terminar os requests dos subtermos de cada termo.
    let observableObj = Observable.create((observer: any) => {
      Observable.from(mountData.terms).concatMap(term => {
        return this.ciService.objectList('instance_ci_subterms', 'term_id=' + term['id'])
        .map(
          response => {
            // eu mounto a estutura com o nome do termo e a lista de subtermos e retorno.

            let listSubterms = [];
            for (let subterm of response) {
              listSubterms.push(subterm.name);
            }

            listTermsSubterms.push({[term['name']]: listSubterms});
          })
      })
      .subscribe(
        data => {
          // aqui eu insiro a lista atualizada dentro do mountData
          mountData.terms = listTermsSubterms;
        },
        error => {
          console.log(error, 'Error inside of observableProcess')
        },

        // esse metodo só é chamado se der tudo certo em todo processo, se der algum error ele não é chamado.
        () => {
          //aqui insiro o mountData atualizado para ser retornado e finalizo o observable.
          observer.next(mountData);
          observer.complete();
        }
      );
    });

    return observableObj;
  };