sporttery/server/triangle/eventsMatch.js

const Logs = require('../libs/logs');
const { eventsCombination } = require('./trangleCalc');
const { getSetting, updateSetting } = require('./settings');

const Request = {
  callbacks: {},
  count: 0,
}

const GLOBAL_DATA = {
  relationLength: 0,
  loopStatus: -1,
};

const getDataFromParent = (type, callback) => {
  const id = ++Request.count;
  Request.callbacks[id] = callback;
  process.send({ method: 'get', id, type });
}

const postDataToParent = (type, data) => {
  process.send({ method: 'post', type, data });
}

process.on('message', (message) => {
  const { callbacks } = Request;
  const { method, id, type, data } = message;
  if (method == 'get' && id) {
    let responseData = null;
    // if (data == 'getSolution') {
    //   responseData = Solution.get();
    // }
    process.send({ type: 'response', id, data: responseData });
  }
  else if (method == 'post') {
    if (type == 'updateSetting') {
      updateSetting(data);
    }
  }
  else if (type == 'response' && id && callbacks[id]) {
    callbacks[id](data);
    delete callbacks[id];
  }
});

/**
 * 精确浮点数字
 * @param {number} number
 * @param {number} x
 * @returns {number}
 */
const fixFloat = (number, x=2) => {
  return parseFloat(number.toFixed(x));
}

const getGamesRelation = () => {
  const setting = getSetting();
  const status = +setting.runWorkerEnabled;
  if (GLOBAL_DATA.loopStatus !== status) {
    GLOBAL_DATA.loopStatus = status;
    Logs.out('loop status changed to', status);
  }

  if (!setting.runWorkerEnabled) {
    return Promise.resolve([]);
  }
  return new Promise(resolve => {
    getDataFromParent('getGamesRelation', (relations) => {
      resolve(relations);
    });
  });
}

const updateSolutions = (solutions) => {
  postDataToParent('updateSolutions', solutions);
}

const extractOdds = ({ evtime, events, sptime, special }) => {
  const setting = getSetting();
  const expireTimeEv = Date.now() - setting.expireTimeEvents;
  const expireTimeSP = Date.now() - setting.expireTimeSpecial;
  const extractData = {
    odds: null,
    evExpire: false,
    spExpire: false,
    removeCount: 0,
  }
  let odds = {};
  if (evtime > expireTimeEv) {
    odds = { ...odds, ...events };
  }
  else if (events) {
    extractData.evExpire = true;
  }
  if (sptime > expireTimeSP) {
    odds = { ...odds, ...special };
  }
  else if (special) {
    extractData.spExpire = true;
  }
  Object.keys(odds).forEach(ior => {
    if (!odds[ior]?.v || odds[ior].v <= 0) {
      delete odds[ior];
      extractData.removeCount++;
    }
  });
  extractData.odds = odds;
  return extractData;
}

const eventMatch = () => {
  getGamesRelation()
  .then(relations => {

    const relationLength = relations?.length;
    if (!relationLength) {
      if (GLOBAL_DATA.relationLength) {
        GLOBAL_DATA.relationLength = 0;
        Logs.out('relation list is empty');
      }
      return [];
    }

    GLOBAL_DATA.relationLength = relationLength;

    const eventsLogsMap = {
      expireEvents: [],
      removeEvents: [],
      noPsRelations: [],
    };

    const passableEvents = relations.map(({ id, rel }) => {
      const eventsMap = {};
      const oddsMap = {};
      if (!rel.hasOwnProperty('ps')) {
        eventsLogsMap.noPsRelations.push({
          rel,
          noPs: true,
        });
        return;
      }
      Object.keys(rel).forEach(platform => {
        const { leagueName, teamHomeName, teamAwayName, timestamp, stage, score, evtime, events, sptime, special } = rel[platform];
        if (!events && !special) {
          return;
        }
        if (platform == 'ps') {
          eventsMap.info = { leagueName, teamHomeName, teamAwayName, id, timestamp, stage, score };
        }
        const { odds, evExpire, spExpire, removeCount } = extractOdds({ evtime, events, sptime, special });
        if (evExpire || spExpire) {
          eventsLogsMap.expireEvents.push({
            rel,
            platform,
            evExpire,
            spExpire,
          });
        }
        if (removeCount) {
          eventsLogsMap.removeEvents.push({
            rel,
            platform,
            removeCount,
          });
        }
        Object.keys(odds).forEach(ior => {
          if (!oddsMap[ior]) {
            oddsMap[ior] = {};
          }
          oddsMap[ior][platform] = odds[ior];
        });
      });
      eventsMap.odds = oddsMap;
      return eventsMap;
    })
    .filter(item => item.info);

    Logs.out('invalid events, expire %d, remove %d, no ps %d',
      eventsLogsMap.expireEvents.length,
      eventsLogsMap.removeEvents.length,
      eventsLogsMap.noPsRelations.length,
    );

    const solutions = eventsCombination(passableEvents);

    // Logs.out('eventMatch solutions', solutions);
    if (solutions?.length) {
      updateSolutions(solutions);
    }
  })
  .finally(() => {
    setTimeout(() => {
      eventMatch();
    }, 2000);
  });
};

const syncSetting = () => {
  getDataFromParent('getSetting', (setting) => {
    if (setting) {
      updateSetting(setting);
    }
    else {
      Logs.out('syncSetting setting is empty');
    }
  });
}

syncSetting();
eventMatch();