sys-dapp.git - Gitblit

			@@ -2,25 +2,27 @@

			import cc.mrbird.febs.common.entity.FebsResponse;
			import cc.mrbird.febs.dapp.soccer.dto.LeaguesApiDto;
			import cc.mrbird.febs.dapp.soccer.entity.SoccerCountries;
			import cc.mrbird.febs.dapp.soccer.entity.SoccerLeagues;
			import cc.mrbird.febs.dapp.soccer.mapper.SoccerCountriesMapper;
			import cc.mrbird.febs.dapp.soccer.mapper.SoccerLeaguesMapper;
			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.JSONArray;
			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
			@@ -29,42 +31,54 @@

			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> response = null;
			HttpResponse<String> httpResponse = null;
			try {
			response = Unirest.get("http://v3.football.api-sports.io/countries")
			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();
			}

			JSONArray jsonArray = SoccerResponseUtil.getResponseToJSONArray(response);
			if(CollUtil.isNotEmpty(jsonArray)){
			for(Object list : jsonArray){
			JSONObject jsonObject = JSONUtil.parseObj(list);
			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);
			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();
			return new FebsResponse().success().data(jsonResponse);
			}

			@Override
			public FebsResponse leagues(LeaguesApiDto leaguesApiDto) {
			HttpResponse<String> response = null;
			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
			*/
			response = Unirest.get(" https://v3.football.api-sports.io/leagues")
			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)
			@@ -74,24 +88,208 @@
			e.printStackTrace();
			}

			JSONArray jsonArray = SoccerResponseUtil.getResponseToJSONArray(response);
			if(CollUtil.isNotEmpty(jsonArray)){
			for(Object list : jsonArray){
			JSONObject parseObj1 = JSONUtil.parseObj(list);
			Object leagueObj = parseObj1.get("league");
			JSONObject parseObjLeague = JSONUtil.parseObj(leagueObj);
			JSONObject leagueStr = JSONUtil.parseObj(parseObjLeague);
			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();
			soccerLeagues.setLeaguesId(SoccerResponseUtil.objectToInteger(leagueStr.get("id")));
			soccerLeagues.setLeaguesName(SoccerResponseUtil.objectToStr(leagueStr.get("name")));
			soccerLeagues.setLeaguesType(SoccerResponseUtil.objectToStr(leagueStr.get("type")));
			soccerLeagues.setLeaguesLogo(SoccerResponseUtil.objectToStr(leagueStr.get("logo")));
			soccerLeaguesMapper.insert(soccerLeagues);
			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);
			}
			}
			}
			System.out.println(jsonArray);
			log.info(String.valueOf(response.getRawBody()));
			return new FebsResponse().success();

			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();
			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();
			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);
			}
			}