package cc.mrbird.febs.dapp.soccer.service.Impl;
|
|
import cc.mrbird.febs.common.entity.FebsResponse;
|
import cc.mrbird.febs.dapp.soccer.dto.LeaguesApiDto;
|
import cc.mrbird.febs.dapp.soccer.dto.TeamsApiDto;
|
import cc.mrbird.febs.dapp.soccer.entity.*;
|
import cc.mrbird.febs.dapp.soccer.mapper.*;
|
import cc.mrbird.febs.dapp.soccer.service.CountryService;
|
import cc.mrbird.febs.dapp.soccer.util.SoccerResponseUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import cn.hutool.json.JSONObject;
|
import cn.hutool.json.JSONUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.mashape.unirest.http.HttpResponse;
|
import com.mashape.unirest.http.Unirest;
|
import com.mashape.unirest.http.exceptions.UnirestException;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import java.util.List;
|
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class CountryServiceImpl extends ServiceImpl<SoccerCountriesMapper, SoccerCountries> implements CountryService {
|
|
private final SoccerCountriesMapper soccerCountriesMapper;
|
private final SoccerLeaguesMapper soccerLeaguesMapper;
|
private final SoccerTimezoneMapper soccerTimezoneMapper;
|
private final SoccerLeaguesSeasonsMapper soccerLeaguesSeasonsMapper;
|
private final SoccerTeamMapper soccerTeamMapper;
|
private final SoccerVenueMapper soccerVenueMapper;
|
|
@Override
|
public FebsResponse countries() {
|
HttpResponse<String> httpResponse = null;
|
try {
|
httpResponse = Unirest.get("http://v3.football.api-sports.io/countries")
|
.header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
|
.header("x-rapidapi-host", "v3.football.api-sports.io").asString();
|
} catch (UnirestException e) {
|
e.printStackTrace();
|
}
|
|
JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
|
if(ObjectUtil.isNotEmpty(jsonResponse)){
|
List<Object> responses = jsonResponse.getResponse();
|
if(CollUtil.isNotEmpty(responses)){
|
for(Object list : responses){
|
JSONObject jsonObject = JSONUtil.parseObj(list);
|
String code = SoccerResponseUtil.objectToStr(jsonObject.get("code"));
|
List<SoccerCountries> soccerCountryList = soccerCountriesMapper.selectList(new QueryWrapper<SoccerCountries>().eq("code", code));
|
if(CollUtil.isNotEmpty(soccerCountryList)){
|
continue;
|
}
|
SoccerCountries soccerCountries = new SoccerCountries();
|
soccerCountries.setName(SoccerResponseUtil.objectToStr(jsonObject.get("code")));
|
soccerCountries.setCode(SoccerResponseUtil.objectToStr(jsonObject.get("name")));
|
soccerCountries.setFlag(SoccerResponseUtil.objectToStr(jsonObject.get("flag")));
|
soccerCountriesMapper.insert(soccerCountries);
|
}
|
}
|
}
|
return new FebsResponse().success().data(jsonResponse);
|
}
|
|
@Override
|
public FebsResponse leagues(LeaguesApiDto leaguesApiDto) {
|
HttpResponse<String> httpResponse = null;
|
int season = ObjectUtil.isEmpty(leaguesApiDto.getSeason()) ? DateUtil.date().year() : leaguesApiDto.getSeason();
|
String current = ObjectUtil.isEmpty(leaguesApiDto.getCurrent()) ? "true" : leaguesApiDto.getCurrent();
|
try {
|
/**
|
* https://v3.football.api-sports.io/leagues?season=2023¤t=true
|
*/
|
httpResponse = Unirest.get(" https://v3.football.api-sports.io/leagues")
|
.header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
|
.header("x-rapidapi-host", "v3.football.api-sports.io")
|
.queryString("season",season)
|
.queryString("current",current)
|
.asString();
|
} catch (UnirestException e) {
|
e.printStackTrace();
|
}
|
|
LeaguesResponse leaguesResponse = SoccerResponseUtil.getLeaguesResponse(httpResponse);
|
if(ObjectUtil.isNotEmpty(leaguesResponse)){
|
List<LeaguesInfo> responses = leaguesResponse.getResponse();
|
if(CollUtil.isNotEmpty(responses)){
|
for(LeaguesInfo leaguesInfo : responses){
|
|
SoccerLeagues soccerLeagues = new SoccerLeagues();
|
Integer leaguesId = SoccerResponseUtil.objectToInteger(leaguesInfo.getLeague().getId());
|
List<SoccerLeagues> soccerLeaguesList = soccerLeaguesMapper.selectList(new QueryWrapper<SoccerLeagues>().eq("leagues_id", leaguesId));
|
if(CollUtil.isNotEmpty(soccerLeaguesList)){
|
continue;
|
}
|
soccerLeagues.setLeaguesId(SoccerResponseUtil.objectToInteger(leaguesInfo.getLeague().getId()));
|
soccerLeagues.setLeaguesName(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getName()));
|
soccerLeagues.setLeaguesType(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getType()));
|
soccerLeagues.setLeaguesLogo(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getLogo()));
|
|
soccerLeagues.setCountryName(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getName()));
|
soccerLeagues.setCountryCode(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getCode()));
|
soccerLeagues.setCountryFlag(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getFlag()));
|
soccerLeaguesMapper.insert(soccerLeagues);
|
}
|
}
|
}
|
|
return new FebsResponse().success().data(leaguesResponse);
|
}
|
|
@Override
|
public FebsResponse timezone() {
|
HttpResponse<String> httpResponse = null;
|
try {
|
httpResponse = Unirest.get("https://v3.football.api-sports.io/timezone")
|
.header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
|
.header("x-rapidapi-host", "v3.football.api-sports.io").asString();
|
} catch (UnirestException e) {
|
e.printStackTrace();
|
}
|
|
JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
|
if(ObjectUtil.isNotEmpty(jsonResponse)){
|
List<Object> responses = jsonResponse.getResponse();
|
if(CollUtil.isNotEmpty(jsonResponse.getResponse())){
|
for(Object timezoneName : responses){
|
SoccerTimezone soccerTimezone = new SoccerTimezone();
|
soccerTimezone.setTimezoneName(SoccerResponseUtil.objectToStr(timezoneName));
|
soccerTimezoneMapper.insert(soccerTimezone);
|
}
|
}
|
}
|
|
return new FebsResponse().success().data(jsonResponse);
|
}
|
|
@Override
|
public FebsResponse seasons() {
|
HttpResponse<String> httpResponse = null;
|
/**
|
* https://v3.football.api-sports.io/leagues/seasons
|
*/
|
try {
|
httpResponse = Unirest.get("https://v3.football.api-sports.io/leagues/seasons")
|
.header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
|
.header("x-rapidapi-host", "v3.football.api-sports.io").asString();
|
} catch (UnirestException e) {
|
e.printStackTrace();
|
}
|
|
JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
|
if(ObjectUtil.isNotEmpty(jsonResponse)){
|
List<Object> responses = jsonResponse.getResponse();
|
if(CollUtil.isNotEmpty(jsonResponse.getResponse())){
|
for(Object seasonsName : responses){
|
SoccerLeaguesSeasons soccerLeaguesSeasons = new SoccerLeaguesSeasons();
|
soccerLeaguesSeasons.setSeasonsName(SoccerResponseUtil.objectToStr(seasonsName));
|
soccerLeaguesSeasonsMapper.insert(soccerLeaguesSeasons);
|
}
|
}
|
}
|
return new FebsResponse().success().data(jsonResponse);
|
}
|
|
@Override
|
public FebsResponse teams(TeamsApiDto teamsApiDto) {
|
HttpResponse<String> httpResponse = null;
|
String country = teamsApiDto.getCountry();
|
|
try {
|
/**
|
* https://v3.football.api-sports.io/teams
|
*/
|
httpResponse = Unirest.get(" https://v3.football.api-sports.io/teams")
|
.header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
|
.header("x-rapidapi-host", "v3.football.api-sports.io")
|
.queryString("country",country)
|
.asString();
|
} catch (UnirestException e) {
|
e.printStackTrace();
|
}
|
|
TeamsInfoResponse teamsInfoResponse = SoccerResponseUtil.getTeamsInfoResponse(httpResponse);
|
if(ObjectUtil.isNotEmpty(teamsInfoResponse)){
|
List<TeamsInfo> responses = teamsInfoResponse.getResponse();
|
if(CollUtil.isNotEmpty(responses)){
|
for(TeamsInfo teamsInfo : responses){
|
|
Team team = teamsInfo.getTeam();
|
if(ObjectUtil.isNotEmpty(team.getId())){
|
Integer teamId = team.getId();
|
List<SoccerTeam> soccerTeams = soccerTeamMapper.selectList(new QueryWrapper<SoccerTeam>().eq("team_id", teamId));
|
if(CollUtil.isEmpty(soccerTeams)){
|
SoccerTeam soccerTeam = new SoccerTeam();
|
soccerTeam.setTeamId(team.getId());
|
soccerTeam.setName(team.getName());
|
soccerTeam.setCode(team.getCode());
|
soccerTeam.setCountry(team.getCountry());
|
soccerTeam.setFounded(team.getFounded());
|
soccerTeam.setNational(team.getNational());
|
soccerTeam.setLogo(team.getLogo());
|
soccerTeamMapper.insert(soccerTeam);
|
}
|
}
|
|
Venue venue = teamsInfo.getVenue();
|
if(ObjectUtil.isNotEmpty(venue.getId())){
|
Integer venueId = venue.getId();
|
List<SoccerVenue> soccerVenues = soccerVenueMapper.selectList(new QueryWrapper<SoccerVenue>().eq("venue_id", venueId));
|
if(CollUtil.isEmpty(soccerVenues)){
|
SoccerVenue soccerVenue = new SoccerVenue();
|
soccerVenue.setVenueId(venue.getId());
|
soccerVenue.setName(venue.getName());
|
soccerVenue.setAddress(venue.getAddress());
|
soccerVenue.setCity(venue.getCity());
|
soccerVenue.setCapacity(venue.getCapacity());
|
soccerVenue.setSurface(venue.getSurface());
|
soccerVenue.setImage(venue.getImage());
|
soccerVenueMapper.insert(soccerVenue);
|
}
|
}
|
}
|
}
|
}
|
return new FebsResponse().success().data(teamsInfoResponse);
|
}
|
|
public static void main(String[] args) {
|
String str = "{\n" +
|
" \"get\": \"leagues\",\n" +
|
" \"parameters\": {\n" +
|
" \"season\": \"2008\",\n" +
|
" \"country\": \"World\"\n" +
|
" },\n" +
|
" \"errors\": [],\n" +
|
" \"results\": 1,\n" +
|
" \"paging\": {\n" +
|
" \"current\": 1,\n" +
|
" \"total\": 1\n" +
|
" },\n" +
|
" \"response\": [\n" +
|
" {\n" +
|
" \"league\": {\n" +
|
" \"id\": 4,\n" +
|
" \"name\": \"Euro Championship\",\n" +
|
" \"type\": \"Cup\",\n" +
|
" \"logo\": \"https://media.api-sports.io/football/leagues/4.png\"\n" +
|
" },\n" +
|
" \"country\": {\n" +
|
" \"name\": \"World\",\n" +
|
" \"code\": null,\n" +
|
" \"flag\": null\n" +
|
" },\n" +
|
" \"seasons\": [\n" +
|
" {\n" +
|
" \"year\": 2008,\n" +
|
" \"start\": \"2008-06-07\",\n" +
|
" \"end\": \"2008-06-29\",\n" +
|
" \"current\": false,\n" +
|
" \"coverage\": {\n" +
|
" \"fixtures\": {\n" +
|
" \"events\": true,\n" +
|
" \"lineups\": true,\n" +
|
" \"statistics_fixtures\": false,\n" +
|
" \"statistics_players\": false\n" +
|
" },\n" +
|
" \"standings\": false,\n" +
|
" \"players\": true,\n" +
|
" \"top_scorers\": true,\n" +
|
" \"top_assists\": true,\n" +
|
" \"top_cards\": true,\n" +
|
" \"injuries\": false,\n" +
|
" \"predictions\": true,\n" +
|
" \"odds\": false\n" +
|
" }\n" +
|
" }\n" +
|
" ]\n" +
|
" }\n" +
|
" ]\n" +
|
"}";
|
LeaguesResponse leaguesResponse = new LeaguesResponse();
|
ObjectMapper mapper = new ObjectMapper();
|
try {
|
leaguesResponse = mapper.readValue(str, LeaguesResponse.class);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
|
System.out.println(leaguesResponse);
|
}
|
}
|
