TypeScript steam-api.get函數代碼示例

async function fetchSteamData(
  profile: UserProfile,
  oneDaySinceLastUpdate: boolean,
): Promise<{ steam?: SteamProfile }> {
  try {
    const { data } = await steamApi.get(
      'ISteamUser/GetPlayerSummaries/v0002/',
      { params: { steamids: profile.id } },
    );
    const player = data.response.players[0];

    const [bans, friends] = await Promise.all([
      fetchVacBans(profile),
      fetchFriends(profile, oneDaySinceLastUpdate),
    ]);

    return {
      steam: {
        ...profile.steam,
        id: profile.id,
        name: player.personaname,
        customUrl: player.profileurl,
        avatar: {
          small: player.avatar,
          medium: player.avatarmedium,
          large: player.avatarfull,
        },
        ...friends,
        ...bans,
      },
    };
  } catch (error) {
    log('Error while requesting steam data', {
      userId: profile.id,
      error,
    });

    return {};
  }
}

export default async function validateHours(hook: CreateBeforeHookContext<User>) {
  if (requiredHours === null) {
    return;
  }

  let hours = 0;

  try {
    const { data } = await steamApi.get('IPlayerService/GetOwnedGames/v0001/', {
      params: {
        steamid: hook.data.id,
        include_played_free_games: 1, // eslint-disable-line camelcase, @typescript-eslint/camelcase
      },
    });
    const games = data.response && data.response.games ? data.response.games : [];
    const game = games.find(({ appid }: { appid: number }) => appid === tf2AppId);

    hours = game ? Math.floor(game.playtime_forever / 60) : 0;
  } catch (error) {
    log('Error while getting tf2 hours for userId', {
      error,
      userId: hook.data.id,
    });

    throw new GeneralError(generalErrorMessage);
  }

  if (hours < requiredHours) {
    log('User doesn\'t have enough hours', {
      userId: hook.data.id,
      data: {
        hours,
        requiredHours,
      },
    });

    throw new Forbidden(notEnoughHoursMessage);
  }
}

async function fetchVacBans(user: UserProfile): Promise<WithBans> {
  try {
    const params = { steamids: user.id };
    const result = await steamApi.get('ISteamUser/GetPlayerBans/v1/', { params });
    const player = result.data.players[0];

    return {
      isBanned: player.VACBanned && player.DaysSinceLastBan < 365,
      bannedUntil: addDays(new Date(), 365 - player.DaysSinceLastBan).getUTCSeconds(),
    };
  } catch (error) {
    log('Error while requesting VAC bans', {
      userId: user.id,
      error,
    });

    return {
      isBanned: false,
      bannedUntil: null,
    };
  }
}

async function fetchFriends(user: UserProfile, oneDaySinceLastUpdate: boolean) {
  if (!oneDaySinceLastUpdate) {
    return {};
  }

  try {
    const { data } = await steamApi.get('ISteamUser/GetFriendList/v0001/', {
      params: {
        steamid: user.id,
        relationship: 'friend',
      },
    });
    const friends = data.friendslist.friends.map((friend: Friend) => friend.steamid);

    return { friends };
  } catch (error) {
    log('Error while requesting steam friends', {
      userId: user.id,
      error,
    });

    return {};
  }
}