pixel.horse/src/ts/server/services/hiding.ts

import * as fs from 'fs';
import { Subject } from 'rxjs';
import { HIDE_LIMIT, MINUTE } from '../../common/constants';
import { NotificationFlags } from '../../common/interfaces';
import { IClient, ServerNotification } from '../serverInterfaces';
import { systemMessage, logger } from '../logger';
import { NotificationService } from './notification';
import { includes } from '../../common/utils';
import { isFriend } from './friends';
import { pathTo } from '../paths';
import { addHide } from '../db';
import { HidingStats } from '../../common/adminInterfaces';
import { getEntityName } from '../entityUtils';
import { saySystem } from '../chat';

interface Hide {
  by: string;
  who: string;
}

const hidePlayerLimit = 'Cannot hide any more players.';
const cannotHidePlayerInParty = 'Cannot hide players from your party.';
const cannotHideFriends = 'Cannot hide friends.';
const unhideAllLimit = 'Cannot unhide hidden players, try again later.';
const unhideAllLimitNote = 'You can only do this once per hour.';

function clientInfo({ accountId, account, characterName }: IClient) {
  return `${characterName} (${account.name}) [${accountId}]`;
}

function simpleNotification(message: string, note?: string): ServerNotification {
  return { id: 0, name: '', message, note, flags: NotificationFlags.Ok };
}

export function hidingDataPath(serverId: string) {
  return pathTo('settings', `hiding-${serverId}.json`);
}

export async function saveHidingData(hiding: HidingService, serverId: string) {
  if (!TESTS) {
    try {
      const data = hiding.serialize();
      await fs.writeFileAsync(hidingDataPath(serverId), data, 'utf8');
    } catch (e) {
      logger.error(e);
    }
  }
}

export function pollHidingDataSave(hiding: HidingService, serverId: string) {
  setInterval(() => saveHidingData(hiding, serverId), 10 * MINUTE);
}

export class HidingService {
  changes = new Subject<Hide>();
  unhidesAll = new Subject<string>();
  private hides = new Map<string, Map<string, number>>();
  private unhides = new Map<string, number>();
  private interval: any;
  constructor(
    private clearUnhides: number,
    private notifications: NotificationService,
    private findClient: (accountId: string) => IClient | undefined,
    private log: (message: string) => void,
  ) {
  }
  serialize() {
    const hides: any = {};
    const unhides: any = {};

    this.hides.forEach((hidesMap, by) => {
      const list: any = {};
      hidesMap.forEach((value, key) => list[key] = value);
      hides[by] = list;
    });

    this.unhides.forEach((value, key) => unhides[key] = value);

    return JSON.stringify({ hides, unhides });
  }
  deserialize(data: string) {
    try {
      const { hides, unhides } = JSON.parse(data);

      for (const by of Object.keys(hides)) {
        const hidesMap = new Map<string, number>();

        for (const key of Object.keys(hides[by])) {
          hidesMap.set(key, hides[by][key]);
        }

        this.hides.set(by, hidesMap);
      }

      for (const key of Object.keys(unhides)) {
        this.unhides.set(key, unhides[key]);
      }

      this.cleanup();
    } catch (e) {
      logger.error(e);
    }
  }
  getStatsFor(account: string): HidingStats {
    const hides = this.hides.get(account);
    const hidden = hides ? Array.from(hides.keys()) : [];
    const hiddenBy: string[] = [];

    this.hides.forEach((hides, by) => {
      if (hides.has(account)) {
        hiddenBy.push(by);
      }
    });

    return { account, hidden, hiddenBy, permaHidden: [], permaHiddenBy: [] };
  }
  connected(client: IClient) {
    const hides = this.hides.get(client.accountId);

    if (hides) {
      for (const id of Array.from(hides.keys())) {
        client.hides.add(id);
      }
    }
  }
  requestHide(requester: IClient, target: IClient, timeout: number) {
    const hides = this.hides.get(requester.accountId);
    const count = hides && hides.size || 0;

    if (requester.accountId === target.accountId) {
      saySystem(requester, `Cannot hide yourself`);
    } else if (requester.party && includes(requester.party.clients, target)) {
      this.notifications.addNotification(requester, simpleNotification(cannotHidePlayerInParty));
    } else if (isFriend(requester, target)) {
      this.notifications.addNotification(requester, simpleNotification(cannotHideFriends));
    } else if (count >= HIDE_LIMIT) {
      this.notifications.addNotification(requester, simpleNotification(hidePlayerLimit));
    } else {
      this.notifications.addNotification(requester, {
        id: 0,
        name: target.pony.name || '',
        entityId: target.pony.id,
        message: `Are you sure you want to hide <b>#NAME#</b> ?`,
        flags: NotificationFlags.Yes | NotificationFlags.No | (target.pony.nameBad ? NotificationFlags.NameBad : 0),
        accept: () => this.confirmHide(requester, target, timeout),
      });
    }
  }
  requestUnhideAll(requester: IClient) {
    const unhideTimestamp = this.unhides.get(requester.accountId) || 0;

    if (unhideTimestamp > Date.now()) {
      this.notifications.addNotification(requester, simpleNotification(unhideAllLimit, unhideAllLimitNote));
    } else {
      this.notifications.addNotification(requester, {
        id: 0,
        name: '',
        message: 'Are you sure you want to unhide all temporarily hidden players ?',
        note: 'You can only do this once per hour. This action will require re-joining the game.',
        flags: NotificationFlags.Yes | NotificationFlags.No,
        accept: () => this.unhideAll(requester),
      });
    }
  }
  confirmHide(requester: IClient, target: IClient, timeout: number) {
    if (this.hide(requester, target, timeout)) {
      let message = `${requester.characterName} (${requester.account.name}) hides ${clientInfo(target)}`;

      if (timeout === 0) {
        message += ' (permanent)';
      }

      this.log(systemMessage(requester.accountId, message));
    }
  }
  private isHiddenInner(who: string, from: string): boolean {
    const hides = this.hides.get(who);
    return hides !== undefined && hides.has(from);
  }
  isHidden(who: string, from: string): boolean {
    return this.isHiddenInner(who, from) || this.isHiddenInner(from, who);
  }
  isHiddenClient(who: IClient, from: IClient) {
    return this.isHidden(who.accountId, from.accountId);
  }
  hide(byClient: IClient, whoClient: IClient, timeout: number) {
    const by = byClient.accountId;
    const who = whoClient.accountId;

    if (timeout === 0) { // permanent
      addHide(by, who, getEntityName(whoClient.pony, byClient) || '[none]')
        .then(() => {
          byClient.permaHides.add(who);
          this.notify([{ by, who }]);
        })
        .catch(e => logger.error(e));
      return true;
    } else {

      if (by === who)
        return false;

      if (this.isHiddenInner(by, who))
        return false;

      const hides = this.hides.get(by) || new Map<string, number>();
      hides.set(who, Date.now() + timeout);
      this.hides.set(by, hides);
      byClient.hides.add(who);
      this.notify([{ by, who }]);
      return true;
    }
  }
  // TODO: remove ?
  unhide(byClient: IClient, whoClient: IClient) {
    const by = byClient.accountId;
    const who = whoClient.accountId;
    const hides = this.hides.get(by);

    if (hides) {
      if (hides.has(who)) {
        hides.delete(who);

        if (hides.size === 0) {
          this.hides.delete(by);
        }

        byClient.hides.delete(who);

        this.notify([{ by, who }]);
      }
    }
  }
  unhideAll(byClient: IClient) {
    const by = byClient.accountId;

    if (this.unhides.has(by))
      return;

    const hides = this.hides.get(by);

    if (hides) {
      const notify: Hide[] = [];
      hides.forEach((_, who) => notify.push({ by, who }));
      this.hides.delete(by);
      this.unhides.set(by, Date.now() + this.clearUnhides);
      byClient.hides.clear();
      this.notify(notify);
      this.unhidesAll.next(by);
    }

    this.log(systemMessage(by, 'unhide all'));
  }
  merged(target: string, merge: string) {
    const targetHides = this.hides.get(target);
    const mergeHides = this.hides.get(merge);
    const notify: Hide[] = [];

    if (targetHides) {
      targetHides.delete(merge);
    }

    if (mergeHides) {
      const targetClient = this.findClient(target);
      mergeHides.delete(target);

      if (targetHides) {
        for (const id of Array.from(mergeHides.keys())) {
          const who = targetHides.get(id);
          targetHides.set(id, Math.max(who || 0, mergeHides.get(id)!));
          targetClient && targetClient.hides.add(id);

          if (!who) {
            notify.push({ by: target, who: id });
            notify.push({ by: merge, who: id });
          }
        }
      } else {
        this.hides.set(target, mergeHides);

        for (const id of Array.from(mergeHides.keys())) {
          targetClient && targetClient.hides.add(id);
          notify.push({ by: target, who: id });
          notify.push({ by: merge, who: id });
        }
      }

      this.hides.delete(merge);
    }

    const targetUnhides = this.unhides.get(target);
    const mergeUnhides = this.unhides.get(merge);

    if (mergeUnhides) {
      this.unhides.set(target, Math.max(targetUnhides || 0, mergeUnhides));
      this.unhides.delete(merge);
    }

    this.hides.forEach((_, by) => {
      const hides = this.hides.get(by)!;
      const mergeHide = hides.get(merge);

      if (mergeHide) {
        hides.set(target, Math.max(mergeHide, hides.get(target) || 0));
        hides.delete(merge);
        const client = this.findClient(by);

        if (client) {
          client.hides.delete(merge);

          if (target !== by) {
            client && client.hides.add(target);
          }
        }

        notify.push({ by, who: target });
        notify.push({ by, who: merge });
      }
    });

    this.notify(notify);
  }
  cleanup() {
    const now = Date.now();
    const notify: Hide[] = [];

    for (const by of Array.from(this.hides.keys())) {
      const hides = this.hides.get(by)!;

      for (const who of Array.from(hides.keys())) {
        if (hides.get(who)! < now) {
          hides.delete(who);
          const client = this.findClient(by);
          client && client.hides.delete(who);
          notify.push({ by, who });
        }
      }

      if (hides.size === 0) {
        this.hides.delete(by);
      }
    }

    this.notify(notify);

    for (const key of Array.from(this.unhides.keys())) {
      if (this.unhides.get(key)! < now) {
        this.unhides.delete(key);
      }
    }
  }
  start() {
    this.interval = this.interval || setInterval(() => this.cleanup(), 10 * MINUTE);
  }
  stop() {
    clearInterval(this.interval);
    this.interval = undefined;
  }
  private notify(hides: Hide[]) {
    for (const hide of hides) {
      this.changes.next(hide);
    }
  }
}