Executando verificação de segurança...
Em resposta a [ RESOLVIDO ]PODEM ME AJUDAR COM ESSA LÓGICA
2
kht

Esta estrutura tem um detalhe estranho: é um array no qual cada elemento é outro array, que por sua vez só tem um elemento (o objeto com id, números, etc). Não deveria ser um array de objetos?

Mas enfim, mantendo essa estrutura, a básica ideia é: cada elemento de APOSTAS é outro array, então para cada um eu faço um loop para verificar os acertos.

Aí uso split para separar os números, e verifico se cada um deles está no array de resultados. Algo assim:

for (const elemento of APOSTAS) {
    for (const aposta of elemento) {  // cada elemento de APOSTAS é outro array, então faço outro for
        for (const n of aposta.nambers.split(',')) { // split para separar os números
            if (_APOSTA_RESULTADO.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
                aposta.acertos++;
            }
        }
    }
}
console.log(APOSTAS);

Outro detalhe, foi erro de digitação ou o nome da propriedade é nambers mesmo? Não deveria ser numbers? Enfim, fiz acima com nambers mesmo...

Claro, se é garantido que cada sub-array só tem uma única aposta, poderia trocar para:

for (const aposta of APOSTAS) {
    for (const n of aposta[0].nambers.split(',')) { // split para separar os números
        if (_APOSTA_RESULTADO.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
            aposta[0].acertos++;
        }
    }
}

No caso, aposta[0] pega o primeiro elemento do array. Como eu disse, se vc garante que sempre terá somente um, é o suficiente. Mas se puder ter vários, aí é melhor usar a primeira opção acima.

Carregando publicação patrocinada...
1
heuderdev

Eu fiz algo bem parecido com o que você disse, mais sem sucesso.

import cron from "node-cron"
import { returnLastIdTableGames } from "../utils/returnLastIdTableGames"
import { generateUniqueNumbers } from "../utils/generateUniqueNumbers"
import { insertValueTableGame } from "../utils/insertValueTableGame"
import { calculateBetMetch } from "../utils/calculateBetMetch"
import { prisma } from "../db/database"
import { UpdateValuesTableBet } from "../utils/UpdateValuesTableBet"

import axios from "axios"

let totalNumber: any = []

class CronJobGamer {
    static async startGamer(io: any) {
        return cron.schedule('3 * * * * *', async () => {
            io.emit("__CLEAN__")

            // NUMERO UNÍCO GAME
            const NEW_NAMBER_GAME = String(await this.FN_GET_NUMBER_GAME())

            // BUSCAR ULTIMO ID INSERIDO NA TABELA GAME
            const LAST_NAMBER_INSERTED_TABLE_GAME = Number(await this.FN_VERIFY_LAST_INSERT_TABLE_GAMER())

            // INSERI NO BANCO DE DADOS
            const GAMER = await insertValueTableGame(NEW_NAMBER_GAME, LAST_NAMBER_INSERTED_TABLE_GAME)
            const _ID = GAMER?.match_id
            // ENVIAR PARA O FRON-END O ID DO GAMER
            io.emit("number::aposta", _ID)

            console.log(_ID);


            const TRANSFORME_STRING_TO_ARRAY = NEW_NAMBER_GAME.split(",").map(n => Number(n))

            let _quantity_loop = 0
            const resultados: any = [];

            TRANSFORME_STRING_TO_ARRAY.forEach((n, i) => {

                setTimeout(async () => {
                    if (totalNumber.length == 6) {
                        totalNumber = []
                    } else {
                        totalNumber.push(n)
                        io.emit("gamer:total", [...totalNumber])
                        io.emit("gamer", n)
                    }
                    _quantity_loop++

                    if (_quantity_loop == 6) {
                        // CALCULAR AS APOSTAS E MOSTRAR AS APOSTAS QUE FORAM PREMIADAS
                        calculateBetMetch.verifyBetMatch(GAMER).then(async response => {
                            // const game = NEW_NAMBER_GAME.split(",").map(_R => Number(_R))

                            const BETS = await prisma.bet.findMany({ where: { number_game_result: String(GAMER?.match_id), awarded: false, status: "IN_PROCESSING" } })


                            if (BETS.length <= 0) {
                                io.emit("_GANHADORES_", { resultados: [], bet: false })
                                return false
                            }

                            let correspondencias = 0;

                            for (const _BET of BETS) {

                                for (const _RESPONSE of _BET.numbers.split(",").map(_R => Number(_R))) {
                                    if (TRANSFORME_STRING_TO_ARRAY.includes(_RESPONSE)) {
                                    console.log(_RESPONSE);                                    
                                        correspondencias++;
                                    }
                                }

                                if (correspondencias >= 1) {
                                    UpdateValuesTableBet.winners(correspondencias, _BET.id).then(items => {
                                        resultados.push({ id: _BET.id, numeros: _BET.numbers, correspondencias, aposta: items });

                                    }).finally(() => {
                                        io.emit("_GANHADORES_", { resultados, bet: true })
                                    })
                                } else {
                                    UpdateValuesTableBet.losers(_BET.id).then(r => r)
                                }                               

                            }
                        })
                    }

                }, 3000 * i)



            })


        })



    }

    private static async FN_GET_NUMBER_GAME(): Promise<any> {
        // Gerar um GAME aleatório que tenha 6 posições
        const numbersGame = await generateUniqueNumbers()
        // @ts-ignore
        const newNumbersGame = numbersGame.toString().slice(",")

        return newNumbersGame

    }

    private static async FN_VERIFY_LAST_INSERT_TABLE_GAMER(): Promise<Number> {
        // VERIFICAR NA LABELA GAMER O ULTIMO REGISTRO - CASO NÃO TENHA NENHUM O PRIMEIRO É O 1, E A PARTIR DISSO SEMPRE FAZER O INCREMENT +1
        const last = await returnLastIdTableGames()
        return last
    }



}


export { CronJobGamer }
1
kht
Autor
Autor

Pra debugar seu sistema eu teria que criar esse banco de dados, além de implementar todas essas funções que estão na pasta utils (que eu teria que adivinhar o que fazem e quais dados retornam), etc. Desculpe, mas estou sem tempo pra isso.

Enfim, pra vc resolver, eu sugiro deixar o código mais organizado.

Primeiro vc chama tudo que precisa (a função que traz os jogos, outra que traz os resultados, etc).

Depois vc cria uma função que verifica e atualiza os acertos:

function verificaAcertos(apostas, resultados) {
    for (const aposta of apostas) {
        for (const n of aposta[0].nambers.split(',')) { // split para separar os números
            if (resultados.includes(parseInt(n))) { // parseInt para converter para número, e verifico se está no resultado
                aposta[0].acertos++;
            }
        }
    }
}

Aí, depois que vc já tem as apostas e acertos, vc chama a função:

verificaAcertos(array_de_apostas, array_de_resultados);

// aqui o array_de_respostas estará com os acertos atualizados

Depois vc continua o que tem que fazer (atualizar os acertos no banco, etc).

1
1