Solucionado (ver solução)
Solucionado
(ver solução)
4
respostas

'This may be converted to an async function' tooltip

class NegociacaoService {

    constructor() {
        this._http = new HttpService();
    }

    cadastra(negociacao) {

        return ConnectionFactory
            .getConnection()
            .then(conexao => new NegociacaoDao(conexao))
            .then(dao => dao.adiciona(negociacao))
            .then(() => 'Negociação adicionada com sucesso!')
            .catch(() => { throw new Error('Não foi possível adicionar a negociação.'); });
    }

    apaga() {
        return ConnectionFactory
            .getConnection()
            .then(conexao => new NegociacaoDao(conexao))
            .then(dao => dao.apagaTodos())
            .then(() => 'Negociações apagadas com sucesso')
            .catch(() => { throw new Error('Não foi possível apagar as negociações.'); });
    }

    todos() {
        return ConnectionFactory
            .getConnection()
            .then(conexao => new NegociacaoDao(conexao))
            .then(dao => dao.listaTodos())
            .catch(() => { throw new Error('Não foi possível recuperar as negociaçõesF') });
    }

    obterNegociacoes(rota) {

        return new Promise((resolve, reject) => {

            this._http
                .get('negociacoes/' + rota)
                .then(negociacoes =>
                    resolve(negociacoes
                        .map(objeto => new Negociacao(new Date(objeto.data), objeto.quantidade, objeto.valor))))
                .catch(erro => reject(erro));
        });

    }

    obterNegociacoesDaSemana() {
        return this.obterNegociacoes('semana');
    }

    obterNegociacoesDaSemanaAnterior() {
        return this.obterNegociacoes('anterior');
    }

    obterNegociacoesDaSemanaRetrasada() {
        return this.obterNegociacoes('retrasada');
    }

    importa(listaAtual) {

        return this.obterNegociacoesDaSemana()
            .then(negociacoes => negociacoes.filter(negociacao =>
                !listaAtual.some(item => JSON.stringify(negociacao) == JSON.stringify(item))))
            .catch(erro => {
                console.log(erro);
                throw new Error('Não foi possível importar as negociações');
            });
    }

    importaTodos(listaAtual) {
        return Promise.all([
            this.obterNegociacoesDaSemana(),
            this.obterNegociacoesDaSemanaAnterior(),
            this.obterNegociacoesDaSemanaRetrasada()])
            .then(negociacoes => {
                return negociacoes.reduce((retorno, item) => retorno.concat(item), []);
            })
            .then(negociacoes => negociacoes.filter(negociacao =>
                !listaAtual.some(item => JSON.stringify(negociacao) == JSON.stringify(item))))
            .catch(erro => {
                console.log(erro);
                throw new Error('Não foi possível importar todas as negociações.');
            });
    }
}

O código está funcionando mas os métodos "importa" e "importaTodos" ficam com "..." abaixo do nome provendo a mensagem do título deste tópico. Algum motivo?

4 respostas

Fala ai Diego, tudo bem? A ideia seria tu converter as Promises para async/await, algo assim: https://imasters.com.br/front-end/entenda-tudo-sobre-asyncawait

Espero ter ajudado.

Isso até o visual studio code sugere e faz para você. A questão é o porquê ele sugere que a função seja convertida?

solução!

As IDEs sugerem alterações do tipo por entenderem que a utilização do async/await tem vantagens sobre Promises.

Existem diversas sugestões desse tipo, nesse caso, a dica é para substituir por uma forma de escrever o código assíncrono de uma forma mais legível (não sei se a perfomance é melhor, talvez seja tb)

Fala Diego, depende muito, isso é bem relativo. Mas basicamente com async/await os códigos ficam mais claros e evitamos possiveis problemas como promise hell.

Mas de novo, é relativo, isso porque com Promise.all tu consegue executar coisas em paralelo, já com async/await seria sequencial, o que pode diminuir a performance da aplicação.

Espero ter ajudado.