poi-plugin-senka-calc/lib/util.js

Ranking point calculator for poi

"use strict";

exports.__esModule = true;
exports.transferArchiveToNewMonth = exports.saveArchiveData = exports.removeKeysGreaterThan = exports.getRankDateNo = exports.getElementFromNumberRecords = exports.getElementByIndex = exports.getDateNo = exports.getAchieveFilePath = exports.getAchieveData = exports.dateNoToDate = void 0;

var _path = _interopRequireDefault(require("path"));

var _fsExtra = _interopRequireDefault(require("fs-extra"));

var _momentTimezone = _interopRequireDefault(require("moment-timezone"));

var _const = require("./const");

var _lodash = require("lodash");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// Get record no
const getDateNo = (ts = new Date()) => {
  const startOfSenka = _momentTimezone.default.tz('Asia/Tokyo').startOf('month').add(2, 'hour');

  const now = (0, _momentTimezone.default)(ts).tz('Asia/Tokyo');
  const no = Math.trunc(now.diff(startOfSenka) / _const.MILLISECONDS_OF_12_HOURS);
  return no;
}; // Get refresh no


exports.getDateNo = getDateNo;

const getRankDateNo = (ts = new Date()) => {
  const startOfSenkaRefresh = _momentTimezone.default.tz('Asia/Tokyo').startOf('month').add(3, 'hour');

  const now = (0, _momentTimezone.default)(ts).tz('Asia/Tokyo');
  const no = Math.trunc(now.diff(startOfSenkaRefresh) / _const.MILLISECONDS_OF_12_HOURS);
  return no;
};

exports.getRankDateNo = getRankDateNo;

const getAchieveFilePath = memberId => {
  const {
    APPDATA_PATH
  } = window;

  const folder = _path.default.join(APPDATA_PATH, 'achieve');

  _fsExtra.default.ensureDirSync(folder);

  const file = memberId ? `${memberId}.json` : 'achieve.json';
  return _path.default.join(folder, file);
};

exports.getAchieveFilePath = getAchieveFilePath;

const getAchieveData = async memberId => {
  try {
    const savedpath = getAchieveFilePath(memberId);
    const data = await _fsExtra.default.readJson(savedpath);
    const archiveDate = (0, _momentTimezone.default)(data.date).tz('Asia/Tokyo');

    const now = _momentTimezone.default.tz('Asia/Tokyo');

    if (now.year() === archiveDate.year() && now.month() === archiveDate.month()) {
      return data;
    } else {
      console.warn('Archive outdated. Return new state');
      return transferArchiveToNewMonth(data);
    }
  } catch (e) {
    console.warn('Read archive failed', e);

    try {
      const savedpath = getAchieveFilePath();

      const data = _fsExtra.default.readJsonSync(savedpath);

      const now = _momentTimezone.default.tz('Asia/Tokyo');

      const transferred = legacyArchiveToArchive(data);

      if (now.month() === data.lastmonth) {
        return transferred;
      } else {
        return transferArchiveToNewMonth(transferred);
      }
    } catch (e) {
      console.warn('Read legacy archive failed', e);
      return _const.EMPTY_ARCHIVE;
    }
  }
};

exports.getAchieveData = getAchieveData;

const transferArchiveToNewMonth = archive => {
  const now = _momentTimezone.default.tz('Asia/Tokyo');

  const archiveDate = (0, _momentTimezone.default)(archive.date).tz('Asia/Tokyo');

  if (archiveDate.year() === now.year() && archiveDate.month() === now.month()) {
    return archive;
  }

  const newArchive = { ..._const.EMPTY_ARCHIVE,
    magic: archive.magic,
    targetSenka: archive.targetSenka,
    date: _momentTimezone.default.tz('Asia/Tokyo').format()
  }; // From former quarterly cycle

  if (_momentTimezone.default.tz('Asia/Tokyo').startOf('month').subtract(2, 'month').isAfter(archiveDate)) {
    return newArchive;
  }

  for (const month of _const.QUARTERLY_QUEST_REFRESH_MONTH) {
    if (archiveDate.month() < month && month <= now.month()) {
      return newArchive;
    }
  }

  if (now.month() < 2 && archiveDate.month() < _const.QUARTERLY_QUEST_REFRESH_MONTH[3]) {
    return newArchive;
  }

  const excludedQuestsSet = new Set(archive.excludedQuests);

  for (const key of Object.keys(archive.questHistory)) {
    const ts = parseInt(key); // Get senka quest that completed after last month's deadline

    if (ts === 1000) {
      newArchive.questHistory[0] = archive.questHistory[ts]; // Move other quests to excluded quests
    } else {
      archive.questHistory[ts].forEach(id => {
        excludedQuestsSet.add(id);
      });
    }
  }

  newArchive.excludedQuests = [...excludedQuestsSet];
  return newArchive;
};

exports.transferArchiveToNewMonth = transferArchiveToNewMonth;

const saveArchiveData = async (memberId, archive) => {
  try {
    const savedpath = getAchieveFilePath(memberId);
    await _fsExtra.default.writeJSON(savedpath, archive);
  } catch (e) {
    console.error('save data failed', e);
  }
};

exports.saveArchiveData = saveArchiveData;

const legacyArchiveToArchive = legacy => {
  return {
    experienceHistory: legacy.exphis,
    rank5: legacy.r5his,
    rank20: legacy.r20his,
    rank100: legacy.r100his,
    rank501: legacy.r501his,
    rankUser: legacy.myhis,
    targetSenka: legacy.targetsenka,
    exHistory: toExHistory(legacy.rankuex),
    questHistory: toQuestHistory(legacy.extraSenkalist),
    magic: legacy.mymagic,
    currentRank: legacy.mylastno,
    excludedQuests: [],
    date: _momentTimezone.default.tz('Asia/Tokyo').month(legacy.lastmonth).format()
  };
};

const toExHistory = rankuex => {
  const unfinishedExIds = rankuex.map(mapName => parseInt(mapName.replace('-', '')));
  const exIds = Object.keys(_const.EX_MAPS).map(id => parseInt(id)).filter(id => !unfinishedExIds.includes(id));
  return {
    0: exIds
  };
};

const toQuestHistory = extraSenkalist => {
  const questIds = extraSenkalist.map((status, index) => {
    if (status === 0) return -1;
    return _const.SENKA_QUESTS[index].id;
  }).filter(id => id > 0);
  return {
    0: questIds
  };
};

const getElementByIndex = (arr = [], index) => {
  if (arr.length === 0) {
    return arr[0];
  }

  let actualIndex = index;

  while (actualIndex < 0) {
    actualIndex += arr.length;
  }

  actualIndex = actualIndex % arr.length;
  return arr[actualIndex];
};

exports.getElementByIndex = getElementByIndex;

const getElementFromNumberRecords = (record = {}, index) => {
  const keys = Object.keys(record);
  const key = getElementByIndex(keys, index);
  return record[parseInt(key)];
}; // [date, isDay]


exports.getElementFromNumberRecords = getElementFromNumberRecords;

const dateNoToDate = dateNo => {
  return [Math.floor(dateNo / 2) + 1, dateNo % 2 === 1];
};

exports.dateNoToDate = dateNoToDate;

const removeKeysGreaterThan = (record = {}, limit) => {
  return (0, _lodash.omitBy)(record, (value, key) => parseInt(key) > limit);
};

exports.removeKeysGreaterThan = removeKeysGreaterThan;