TypeScript ServerApp.service方法代码示例

export default function onJoin(
  app: ServerApp,
  connection: SocketConnection,
): SocketEventHandler<'queues:join'> {
  const queues = app.service('queues');
  const players = app.service('players');

  return async (data, cb) => {
    const { user } = connection.feathers;

    // Make sure a userId is authenticated
    if (!user) {
      return cb(new NotAuthenticated('You aren\'t authenticated!'));
    }

    const {
      region,
      id: userId,
    } = user;
    const queueId = `${region}-${data.gamemode}`;

    try {
      const queue = await queues.get(queueId);
      const player = await getPlayer(app, queueId, userId);

      if (player) {
        await players.patch(player.id, { class: data.class });
      } else {
        await players.create({
          id: new mongoose.Types.ObjectId().toHexString(),
          userId,
          queueId,
          map: null,
          isReady: queue.state === 'ready-up',
          isSubbed: false,
          pickupId: null,
          joinedOn: Date.now(),
          class: data.class,
        });
      }

      await checkForUpdateState(app, queue);

      return cb(null);
    } catch (error) {
      log('Error while player wanted to join pickup queue', {
        error,
        userId,
        data,
      });

      return cb(error);
    }
  };
}

  app.on('login', async (_, { connection }) => {
    const userId = connection.user.id;

    try {
      const profile = await app.service('user-profiles').get(userId);
      const data = await getUserData(profile);

      await app.service('user-profiles').patch(userId, data);
    } catch (error) {
      log('Error in login callback', error);
    }
  });

async function setupQueue(
  app: ServerApp,
  region: keyof typeof regions,
  gamemode: keyof typeof gamemodes,
) {
  const queues = app.service('queues');
  const id = `${region}-${gamemode}`;

  try {
    await queues.patch(id, {
      state: QueueStates.WaitingForPlayers,
      readyUpEnd: null,
    });
  } catch (error) {
    if (error.code === 404) {
      await queues.create({
        id,
        region,
        gamemode,
        state: QueueStates.WaitingForPlayers,
        maps: getRandomMaps(id, null),
        readyUpEnd: null,
      });
    }
  }
}

async function handleReadyUpTimeout(app: ServerApp, queueId: string) {
  const queues = app.service('queues');

  try {
    const queue = await queues.get(queueId);
    const hasEnough = await hasEnoughPlayers(
      app,
      queue,
      // Check if the enough players are ready
      players => players.filter(player => player.isReady).length,
    );

    if (hasEnough) {
      await queues.patch(queueId, {
        state: QueueStates.CreatingPickup,
        readyUpEnd: null,
      });
    } else {
      await resetQueue(app, queueId);
    }
  } catch (error) {
    log('Error while handling end of ready up timeout', {
      error,
      data: { queueId },
    });

    await resetQueue(app, queueId);
  }
}

async function createNewPickup(
  app: ServerApp,
  region: keyof typeof regions,
  gamemode: keyof typeof gamemodes,
  map: keyof typeof maps,
) {
  const pickups = app.service('pickups');

  try {
    const [lastPickup] = await pickups.find({ query: { $sort: { id: 1 } } });

    const pickup = await pickups.create({
      id: lastPickup ? lastPickup.id + 1 : 1,
      map,
      region,
      gamemode,
      state: PickupStates.ReservingServer,
      createdOn: Date.now(),
      startDate: null,
      endDate: null,
    });

    return pickup;
  } catch (error) {
    return null;
  }
}

export default function onChangeVolume(
  app: ServerApp,
  connection: SocketConnection,
): SocketEventHandler<'user-settings:change-volume'> {
  const userSettings = app.service('user-settings');

  return async (data, cb) => {
    const user = connection.feathers.user;

    // Make sure a userId is authenticated
    if (!user) {
      return cb(new NotAuthenticated('You aren\'t authenticated!'));
    }

    if (data.volume < 0 || data.volume > 100) {
      return cb(new BadRequest('Not allowed volume value!'));
    }

    try {
      await userSettings.patch(user.id, { volume: data.volume });

      return cb(null);
    } catch (error) {
      log('Error while changing the volume', {
        userId: user.id,
        error,
        data,
      });

      return cb(error);
    }
  };
}

export default function onAcceptRules(
  app: ServerApp,
  connection: SocketConnection,
): SocketEventHandler<'users:accept-rules'> {
  const users = app.service('users');

  return async (_, cb) => {
    const user = connection.feathers.user;

    // Make sure a userId is authenticated
    if (!user) {
      return cb(new NotAuthenticated('You aren\'t authenticated!'));
    }

    try {
      await users.patch(user.id, { hasAcceptedTheRules: true });

      log('User accepted the rules', { userId: user.id });

      return cb(null);
    } catch (error) {
      log('Error while accepting the rules', {
        userId: user.id,
        error,
      });

      return cb(error);
    }
  };
}

export default function onChangeAnnouncer(
  app: ServerApp,
  connection: SocketConnection,
): SocketEventHandler<'user-settings:change-announcer'> {
  const userSettings = app.service('user-settings');

  return async (data, cb) => {
    const user = connection.feathers.user;

    // Make sure a userId is authenticated
    if (!user) {
      return cb(new NotAuthenticated('You aren\'t authenticated!'));
    }

    if (!(data.announcer in announcers)) {
      return cb(new BadRequest('Not a valid announcer!'));
    }

    try {
      await userSettings.patch(user.id, { announcer: data.announcer });

      return cb(null);
    } catch (error) {
      log('Error while changing the announcer', {
        userId: user.id,
        error,
        data,
      });

      return cb(error);
    }
  };
}

      otherPlayers.map((player) => {
        if (player.map === pickup.map) {
          return app.service('players').patch(player.id, { map: null });
        }

        return player;
      })

  return async (payload: Payload, meta: Meta) => {
    if (meta.provider === 'rest') {
      return;
    }

    try {
      const user = await getUserFromPayload(app, payload);

      if (user === null) {
        return;
      }

      // Check if the userId is still authenticated on any other socket
      const isStillConnected = app
        .channel('authenticated')
        .filter(connection => connection.user && connection.user.id === user.id)
        .length > 0;

      // Don't set the userId to online: false when the userId has still active sockets
      if (isStillConnected) {
        return;
      }

      await app.service('users').patch(user.id, {
        online: false,
        lastOnline: Date.now(),
      });

      log('Successfully logged out user', { userId: user.id });
    } catch (error) {
      log('Error in logout callback', { error });
    }
  };