[-] Drop chuni paradise

This commit is contained in:
Azalea 2025-10-25 04:46:37 +08:00
parent 567ed059ad
commit 9fe945007c
124 changed files with 23 additions and 5582 deletions

View File

@ -1,269 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.chunithm.handler.impl.*;
import lombok.AllArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@RestController
@RequestMapping("/g/chu2/{ROM_VERSION}/{CLIENT_ID}/ChuniServlet")
@AllArgsConstructor
public class ChuniServletController {
private final GameLoginHandler gameLoginHandler;
private final GameLogoutHandler gameLogoutHandler;
private final GetGameChargeHandler getGameChargeHandler;
private final GetGameEventHandler getGameEventHandler;
private final GetGameIdlistHandler getGameIdlistHandler;
private final GetGameMessageHandler getGameMessageHandler;
private final GetGameRankingHandler getGameRankingHandler;
private final GetGameSaleHandler getGameSaleHandler;
private final GetGameSettingHandler getGameSettingHandler;
private final GetTeamCourseRuleHandler getTeamCourseRuleHandler;
private final GetTeamCourseSettingHandler getTeamCourseSettingHandler;
private final GetUserActivityHandler getUserActivityHandler;
private final GetUserCharacterHandler getUserCharacterHandler;
private final GetUserChargeHandler getUserChargeHandler;
private final GetUserCourseHandler getUserCourseHandler;
private final GetUserDataExHandler getUserDataExHandler;
private final GetUserDataHandler getUserDataHandler;
private final GetUserDuelHandler getUserDuelHandler;
private final GetUserFavoriteItemHandler getUserFavoriteItemHandler;
private final GetUserFavoriteMusicHandler getUserFavoriteMusicHandler;
private final GetUserItemHandler getUserItemHandler;
private final GetUserLoginBonusHandler getUserLoginBonusHandler;
private final GetUserMapHandler getUserMapHandler;
private final GetUserMusicHandler getUserMusicHandler;
private final GetUserOptionExHandler getUserOptionExHandler;
private final GetUserOptionHandler getUserOptionHandler;
private final GetUserPreviewHandler getUserPreviewHandler;
private final GetUserRecentRatingHandler getUserRecentRatingHandler;
private final GetUserRegionHandler getUserRegionHandler;
private final GetUserRivalDataHandler getUserRivalDataHandler;
private final GetUserRivalMusicHandler getUserRivalMusicHandler;
private final GetUserTeamHandler getUserTeamHandler;
private final UpsertClientSettingHandler upsertClientSettingHandler;
private final UpsertUserAllHandler upsertUserAllHandler;
private final UpsertUserChargelogHandler upsertUserChargelogHandler;
@PostMapping("GameLoginApi")
String gameLogin(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return gameLoginHandler.handle(request);
}
@PostMapping("GameLogoutApi")
String gameLogout(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return gameLogoutHandler.handle(request);
}
@PostMapping("GetGameChargeApi")
String getGameCharge(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameChargeHandler.handle(request);
}
@PostMapping("GetGameEventApi")
String getGameEvent(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameEventHandler.handle(request);
}
@PostMapping("GetGameIdlistApi")
String getGameIdList(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameIdlistHandler.handle(request);
}
@PostMapping("GetGameMessageApi")
String getGameMessage(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameMessageHandler.handle(request);
}
@PostMapping("GetGameRankingApi")
String getGameRanking(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameRankingHandler.handle(request);
}
@PostMapping("GetGameSaleApi")
String getGameSale(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameSaleHandler.handle(request);
}
/**
* The game start up request
*
* @return json of GameSetting object
*/
@PostMapping("GetGameSettingApi")
String getGameSetting(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getGameSettingHandler.handle(request);
}
@PostMapping("GetTeamCourseRuleApi")
String getTeamCourseRule(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getTeamCourseRuleHandler.handle(request);
}
@PostMapping("GetTeamCourseSettingApi")
String getTeamCourseSetting(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getTeamCourseSettingHandler.handle(request);
}
@PostMapping("GetUserActivityApi")
String getUserActivity(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserActivityHandler.handle(request);
}
@PostMapping("GetUserCharacterApi")
String getUserCharacter(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserCharacterHandler.handle(request);
}
@PostMapping("GetUserChargeApi")
String getUserCharge(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserChargeHandler.handle(request);
}
@PostMapping("GetUserCourseApi")
String getUserCourse(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserCourseHandler.handle(request);
}
@PostMapping("GetUserDataApi")
String getUserData(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserDataHandler.handle(request);
}
@PostMapping("GetUserDataExApi")
String getUserDataEx(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserDataExHandler.handle(request);
}
@PostMapping("GetUserDuelApi")
String getUserDuel(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserDuelHandler.handle(request);
}
@PostMapping("GetUserFavoriteItemApi")
String getUserFavoriteItem(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserFavoriteItemHandler.handle(request);
}
@PostMapping("GetUserFavoriteMusicApi")
public String getUserFavoriteMusic(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserFavoriteMusicHandler.handle(request);
}
@PostMapping("GetUserItemApi")
String getUserItem(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserItemHandler.handle(request);
}
@PostMapping("GetUserLoginBonusApi")
String getUserLoginBonus(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserLoginBonusHandler.handle(request);
}
@PostMapping("GetUserMapApi")
String getUserMap(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserMapHandler.handle(request);
}
@PostMapping("GetUserMusicApi")
String getUserMusic(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserMusicHandler.handle(request);
}
@PostMapping("GetUserOptionApi")
String getUserOption(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserOptionHandler.handle(request);
}
@PostMapping("GetUserOptionExApi")
String getUserOptionEx(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserOptionExHandler.handle(request);
}
// Call when login. Return null if no profile exist
@PostMapping("GetUserPreviewApi")
String getUserPreview(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserPreviewHandler.handle(request);
}
@PostMapping("GetUserRecentRatingApi")
String getUserRecentRating(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserRecentRatingHandler.handle(request);
}
/**
* For older version chunithm
*/
@PostMapping("GetUserRecentPlayerApi")
String getUserRecentPlayerApi(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserRecentRatingHandler.handle(request);
}
@PostMapping("GetUserRegionApi")
String getUserRegion(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserRegionHandler.handle(request);
}
@PostMapping("GetUserRivalDataApi")
String getUserRivalData(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserRivalDataHandler.handle(request);
}
@PostMapping("GetUserRivalMusicApi")
String getUserRivalMusic(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserRivalMusicHandler.handle(request);
}
@PostMapping("GetUserTeamApi")
String getUserTeam(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return getUserTeamHandler.handle(request);
}
@PostMapping("UpsertClientBookkeepingApi")
String upsertClientBookkeeping(@ModelAttribute Map<String, Object> request) {
return "{\"returnCode\":\"1\"}";
}
@PostMapping("UpsertClientDevelopApi")
String upsertClientDevelop(@ModelAttribute Map<String, Object> request) {
return "{\"returnCode\":\"1\"}";
}
@PostMapping("UpsertClientErrorApi")
String upsertClientError(@ModelAttribute Map<String, Object> request) {
return "{\"returnCode\":\"1\"}";
}
@PostMapping("UpsertClientSettingApi")
String upsertClientSetting(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return upsertClientSettingHandler.handle(request);
}
@PostMapping("UpsertClientTestmodeApi")
String upsertClientTestmode(@ModelAttribute Map<String, Object> request) {
return "{\"returnCode\":\"1\"}";
}
@PostMapping("UpsertUserAllApi")
String upsertUserAll(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return upsertUserAllHandler.handle(request);
}
@PostMapping("UpsertUserChargelogApi")
String upsertUserChargelog(@ModelAttribute Map<String, Object> request) throws JsonProcessingException {
return upsertUserChargelogHandler.handle(request);
}
@PostMapping("Ping")
String ping(@ModelAttribute Map<String, Object> request) {
return "{\"returnCode\":\"1\"}";
}
}

View File

@ -1,47 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.controller;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.HandlerMapping;
import jakarta.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import static icu.samnyan.aqua.sega.util.AquaConst.*;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@RestControllerAdvice(basePackages = "icu.samnyan.aqua.sega.chunithm")
public class ChuniServletControllerAdvice {
private static final Logger logger = LoggerFactory.getLogger(ChuniServletControllerAdvice.class);
/**
* Get the map object from json string
*
* @param request HttpServletRequest
*/
@ModelAttribute
public Map<String, Object> preHandle(HttpServletRequest request) throws IOException {
var pathVar = (Map<String, String>) request.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
byte[] src = request.getInputStream().readAllBytes();
String outputString = new String(src, StandardCharsets.UTF_8).trim();
logger.info("Request " + request.getRequestURI() + ": " + outputString);
ObjectMapper mapper = new ObjectMapper();
Map<String, Object> result = mapper.readValue(outputString, new TypeReference<>() {
});
result.put(SERIAL_KEY, pathVar.getOrDefault(SERIAL_KEY, DEFAULT_KEYCHIP_ID));
result.put(VERSION_KEY, pathVar.getOrDefault(VERSION_KEY, CHUNI_DEFAULT_VERSION));
return result;
}
}

View File

@ -1,12 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.Character;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameCharacterRepository")
public interface GameCharacterRepository extends JpaRepository<Character, Long> {
}

View File

@ -1,12 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.CharacterSkill;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameCharacterSkillRepository")
public interface GameCharacterSkillRepository extends JpaRepository<CharacterSkill, Long> {
}

View File

@ -1,12 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameCharge;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameChargeRepository")
public interface GameChargeRepository extends JpaRepository<GameCharge, Long> {
}

View File

@ -1,16 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameEvent;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameEventRepository")
public interface GameEventRepository extends JpaRepository<GameEvent, Integer> {
List<GameEvent> findByEnable(boolean enable);
}

View File

@ -1,12 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameMessage;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameMessageRepository")
public interface GameMessageRepository extends JpaRepository<GameMessage, Integer> {
}

View File

@ -1,16 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.gamedata;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.Music;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniGameMusicRepository")
public interface GameMusicRepository extends JpaRepository<Music, Long> {
Optional<Music> findByMusicId(int musicId);
}

View File

@ -1,22 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserActivity;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserActivityRepository extends JpaRepository<UserActivity, Long> {
Optional<UserActivity> findTopByUserAndActivityIdAndKindOrderByIdDesc(UserData user, int activityId, int kind);
List<UserActivity> findAllByUser_Card_ExtIdAndKindOrderBySortNumberDesc(Long extId, int kind);
List<UserActivity> findAllByUser_Card_ExtId(Long extId);
}

View File

@ -1,27 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharacter;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserCharacterRepository extends JpaRepository<UserCharacter, Long> {
Page<UserCharacter> findByUser_Card_ExtId(Long extId, Pageable pageable);
List<UserCharacter> findByUser_Card_ExtId(Long extId);
Optional<UserCharacter> findTopByUserAndCharacterIdOrderByIdDesc(UserData user, int characterId);
Optional<UserCharacter> findByUser_Card_ExtIdAndCharacterId(Long extId, int characterId);
}

View File

@ -1,19 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharge;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserChargeRepository extends JpaRepository<UserCharge, Long> {
List<UserCharge> findByUser_Card_ExtId(Long extId);
Optional<UserCharge> findByUserAndChargeId(UserData extId, int chargeId);
}

View File

@ -1,23 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCourse;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserCourseRepository extends JpaRepository<UserCourse, Long> {
Optional<UserCourse> findTopByUserAndCourseIdOrderByIdDesc(UserData user, int courseId);
Page<UserCourse> findByUser_Card_ExtId(Long extId, Pageable page);
List<UserCourse> findByUser_Card_ExtId(Long extId);
}

View File

@ -1,19 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDataEx;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserDataExRepository extends JpaRepository<UserDataEx, Long> {
Optional<UserDataEx> findByUser(UserData user);
Optional<UserDataEx> findByUser_Card_ExtId(Long extId);
}

View File

@ -1,19 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.general.model.Card;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserDataRepository extends JpaRepository<UserData, Long> {
Optional<UserData> findByCard(Card card);
Optional<UserData> findByCard_ExtId(Long extId);
}

View File

@ -1,20 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDuel;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserDuelRepository extends JpaRepository<UserDuel, Long> {
Optional<UserDuel> findTopByUserAndDuelIdOrderByIdDesc(UserData user, int duelId);
List<UserDuel> findByUser_Card_ExtId(Long extId);
}

View File

@ -1,18 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOptionEx;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserGameOptionExRepository extends JpaRepository<UserGameOptionEx, Long> {
Optional<UserGameOptionEx> findByUser(UserData user);
Optional<UserGameOptionEx> findByUser_Card_ExtId(Long extId);
}

View File

@ -1,19 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOption;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserGameOptionRepository extends JpaRepository<UserGameOption, Long> {
Optional<UserGameOption> findByUser(UserData user);
Optional<UserGameOption> findByUser_Card_ExtId(Long extId);
}

View File

@ -1,20 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGeneralData;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository("ChuniUserGeneralDataRepository")
public interface UserGeneralDataRepository extends JpaRepository<UserGeneralData, Long> {
Optional<UserGeneralData> findByUserAndPropertyKey(UserData user, String key);
Optional<UserGeneralData> findByUser_Card_ExtIdAndPropertyKey(Long extId, String key);
}

View File

@ -1,26 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserItem;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserItemRepository extends JpaRepository<UserItem, Long> {
Optional<UserItem> findTopByUserAndItemIdAndItemKindOrderByIdDesc(UserData user, int itemId, int itemKind);
Page<UserItem> findAllByUser_Card_ExtIdAndItemKind(Long extId, int itemKind, Pageable pageable);
List<UserItem> findAllByUser_Card_ExtId(Long extId);
Page<UserItem> findByUser_Card_ExtId(Long extId, Pageable pageable);
}

View File

@ -1,21 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserMap;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserMapRepository extends JpaRepository<UserMap, Long> {
List<UserMap> findAllByUser(UserData user);
List<UserMap> findAllByUser_Card_ExtId(Long extId);
Optional<UserMap> findTopByUserAndMapIdOrderByIdDesc(UserData user, int mapId);
}

View File

@ -1,26 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserMusicDetail;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserMusicDetailRepository extends JpaRepository<UserMusicDetail, Long> {
Optional<UserMusicDetail> findTopByUserAndMusicIdAndLevelOrderByIdDesc(UserData user, int musicId, int level);
List<UserMusicDetail> findByUser_Card_ExtId(Long extId);
List<UserMusicDetail> findByUser_Card_ExtIdAndMusicId(Long extId, int musicId);
Page<UserMusicDetail> findByUser_Card_ExtId(Long extId, Pageable page);
}

View File

@ -1,28 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.dao.userdata;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameRanking;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserPlaylog;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Repository
public interface UserPlaylogRepository extends JpaRepository<UserPlaylog, Long> {
List<UserPlaylog> findByUser_Card_ExtIdAndLevelNot(Long extId, int levelNot, Pageable page);
Page<UserPlaylog> findByUser_Card_ExtId(Long extId, Pageable page);
List<UserPlaylog> findByUser_Card_ExtIdAndMusicIdAndLevel(Long extId, int musicId, int level);
List<UserPlaylog> findByUser_Card_ExtId(Long extId);
@Query("SELECT NEW icu.samnyan.aqua.sega.chunithm.model.response.data.GameRanking(c.musicId, COUNT(c.musicId)) FROM ChuniUserPlaylog c WHERE NOT c.level = 4 GROUP BY c.musicId ORDER BY COUNT(c.musicId) DESC")
Page<GameRanking> findGameRankingByPlaylog(Pageable page);
}

View File

@ -1,43 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.CodeResp;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.service.UserDataService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GameLoginHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GameLoginHandler.class);
private final StringMapper mapper;
private final UserDataService userDataService;
public GameLoginHandler(StringMapper mapper, UserDataService userDataService) {
this.mapper = mapper;
this.userDataService = userDataService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserData> userDataOptional = userDataService.getUserByExtId(userId);
userDataOptional.ifPresent(userDataService::updateLoginTime);
String json = mapper.write(new CodeResp(1));
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,34 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.CodeResp;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GameLogoutHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GameLogoutHandler.class);
private final StringMapper mapper;
public GameLogoutHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String json = mapper.write(new CodeResp(1));
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,46 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.chunithm.dao.gamedata.GameChargeRepository;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameCharge;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameChargeHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameChargeHandler.class);
private final GameChargeRepository gameChargeRepository;
private final StringMapper mapper;
@Autowired
public GetGameChargeHandler(GameChargeRepository gameChargeRepository, StringMapper mapper) {
this.gameChargeRepository = gameChargeRepository;
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
List<GameCharge> gameChargeList = gameChargeRepository.findAll();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("length", gameChargeList.size());
resultMap.put("gameChargeList", gameChargeList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,50 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.chunithm.dao.gamedata.GameEventRepository;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameEvent;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameEventHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameEventHandler.class);
private final GameEventRepository gameEventRepository;
private final StringMapper mapper;
@Autowired
public GetGameEventHandler(GameEventRepository gameEventRepository, StringMapper mapper) {
this.gameEventRepository = gameEventRepository;
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String type = (String) request.get("type");
List<GameEvent> gameEventList = gameEventRepository.findByEnable(true);
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("type", type);
resultMap.put("length", gameEventList.size());
resultMap.put("gameEventList", gameEventList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,47 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameIdlistHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameIdlistHandler.class);
private final StringMapper mapper;
@Autowired
public GetGameIdlistHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String type = (String) request.get("type");
List<Object> gameIdlistList = new ArrayList<>();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("type", type);
resultMap.put("length", 0);
resultMap.put("gameIdlistList", gameIdlistList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,50 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.chunithm.dao.gamedata.GameMessageRepository;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.GameMessage;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameMessageHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameMessageHandler.class);
private final GameMessageRepository gameMessageRepository;
private final StringMapper mapper;
@Autowired
public GetGameMessageHandler(GameMessageRepository gameMessageRepository, StringMapper mapper) {
this.gameMessageRepository = gameMessageRepository;
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String type = (String) request.get("type");
List<GameMessage> gameMessageList = gameMessageRepository.findAll();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("type", type);
resultMap.put("length", gameMessageList.size());
resultMap.put("gameMessageList", gameMessageList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,51 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserPlaylogRepository;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameRanking;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameRankingHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameRankingHandler.class);
private final UserPlaylogRepository userPlaylogRepository;
private final StringMapper mapper;
@Autowired
public GetGameRankingHandler(StringMapper mapper, UserPlaylogRepository userPlaylogRepository) {
this.userPlaylogRepository = userPlaylogRepository;
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String type = (String) request.get("type");
Page<GameRanking> rankingPage = userPlaylogRepository.findGameRankingByPlaylog(PageRequest.of(0, 10));
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("type", type);
resultMap.put("gameRankingList", rankingPage.getContent());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,47 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameSale;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameSaleHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameSaleHandler.class);
private final StringMapper mapper;
@Autowired
public GetGameSaleHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String type = (String) request.get("type");
List<GameSale> gameSaleList = new ArrayList<>();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("type", type);
resultMap.put("length", 0);
resultMap.put("gameSaleList", gameSaleList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,66 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.GetGameSettingResp;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameSetting;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetGameSettingHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetGameSettingHandler.class);
private final StringMapper mapper;
@Autowired
public GetGameSettingHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
// Fixed reboot time triggers chunithm maintenance lockout, so let's try minime method which sets it dynamically
// Special thanks to skogaby
// Hardcode so that the reboot time always started 3 hours ago and ended 2 hours ago
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss");
LocalDateTime rebootStartTime = LocalDateTime.now().minusHours(3);
LocalDateTime rebootEndTime = LocalDateTime.now().minusHours(2);
GameSetting gameSetting = new GameSetting(
1,
false,
10,
rebootStartTime.format(formatter),
rebootEndTime.format(formatter),
false,
300,
300,
300);
GetGameSettingResp resp = new GetGameSettingResp(
gameSetting,
false,
true
);
String json = mapper.write(resp);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,42 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.CodeResp;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameSale;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.service.UserDataService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.*;
@Component
public class GetTeamCourseRuleHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetTeamCourseRuleHandler.class);
private final StringMapper mapper;
public GetTeamCourseRuleHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("nextIndex", 0);
resultMap.put("teamCourseRuleList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,41 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Component
public class GetTeamCourseSettingHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetTeamCourseSettingHandler.class);
private final StringMapper mapper;
public GetTeamCourseSettingHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("nextIndex", 0);
resultMap.put("teamCourseSettingList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,53 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserActivity;
import icu.samnyan.aqua.sega.chunithm.service.UserActivityService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserActivityHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserActivityHandler.class);
private final StringMapper mapper;
private final UserActivityService userActivityService;
@Autowired
public GetUserActivityHandler(StringMapper mapper, UserActivityService userActivityService) {
this.mapper = mapper;
this.userActivityService = userActivityService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
String kind = (String) request.get("kind");
List<UserActivity> userActivityList = userActivityService.getAllByUserIdAndKind(userId, kind);
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userActivityList.size());
resultMap.put("kind", kind);
resultMap.put("userActivityList", userActivityList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,60 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharacter;
import icu.samnyan.aqua.sega.chunithm.service.UserCharacterService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Handle getUserCharacter request
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserCharacterHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserCharacterHandler.class);
private final StringMapper mapper;
private final UserCharacterService userCharacterService;
@Autowired
public GetUserCharacterHandler(StringMapper mapper, UserCharacterService userCharacterService) {
this.mapper = mapper;
this.userCharacterService = userCharacterService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
int nextIndex = Integer.parseInt((String) request.get("nextIndex"));
int maxCount = Integer.parseInt((String) request.get("maxCount"));
int pageNum = nextIndex / maxCount;
Page<UserCharacter> dbPage = userCharacterService.getByUserId(userId, pageNum, maxCount);
long currentIndex = maxCount * pageNum + dbPage.getNumberOfElements();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", dbPage.getNumberOfElements());
resultMap.put("nextIndex", dbPage.getNumberOfElements() < maxCount ? -1 : currentIndex);
resultMap.put("userCharacterList", dbPage.getContent());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,50 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharge;
import icu.samnyan.aqua.sega.chunithm.service.UserChargeService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserChargeHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserChargeHandler.class);
private final StringMapper mapper;
private final UserChargeService userChargeService;
@Autowired
public GetUserChargeHandler(StringMapper mapper, UserChargeService userChargeService) {
this.mapper = mapper;
this.userChargeService = userChargeService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
List<UserCharge> userChargeList = userChargeService.getByUserId(userId);
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userChargeList.size());
resultMap.put("userChargeList", userChargeList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,67 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCourse;
import icu.samnyan.aqua.sega.chunithm.service.UserCourseService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handle GetUserCourse request
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserCourseHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserCourseHandler.class);
private final StringMapper mapper;
private final UserCourseService userCourseService;
@Autowired
public GetUserCourseHandler(StringMapper mapper, UserCourseService userCourseService) {
this.mapper = mapper;
this.userCourseService = userCourseService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
if(request.containsKey("nextIndex")) {
int nextIndex = Integer.parseInt((String) request.get("nextIndex"));
int maxCount = Integer.parseInt((String) request.get("maxCount"));
int pageNum = nextIndex / maxCount;
Page<UserCourse> dbPage = userCourseService.getByUserId(userId, pageNum, maxCount);
long currentIndex = maxCount * pageNum + dbPage.getNumberOfElements();
resultMap.put("length", dbPage.getNumberOfElements());
resultMap.put("nextIndex", dbPage.getNumberOfElements() < maxCount ? -1 : currentIndex);
resultMap.put("userCourseList", dbPage.getContent());
} else {
List<UserCourse> courseList = userCourseService.getByUserId(userId);
resultMap.put("length", courseList.size());
resultMap.put("userCourseList", courseList);
}
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,53 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDataEx;
import icu.samnyan.aqua.sega.chunithm.service.UserDataExService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserDataExHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserDataExHandler.class);
private final StringMapper mapper;
private final UserDataExService userDataExService;
@Autowired
public GetUserDataExHandler(StringMapper mapper, UserDataExService userDataExService) {
this.mapper = mapper;
this.userDataExService = userDataExService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserDataEx> userDataExOptional = userDataExService.getByExtId(userId);
if (userDataExOptional.isPresent()) {
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("userDataEx", userDataExOptional.get());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
return null;
}
}

View File

@ -1,69 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.service.UserDataService;
import icu.samnyan.aqua.sega.general.service.ClientSettingService;
import icu.samnyan.aqua.sega.util.VersionUtil;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
import static icu.samnyan.aqua.sega.util.AquaConst.SERIAL_KEY;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserDataHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserDataHandler.class);
private final StringMapper mapper;
private final ClientSettingService clientSettingService;
private final UserDataService userDataService;
@Autowired
public GetUserDataHandler(StringMapper mapper,
ClientSettingService clientSettingService, UserDataService userDataService
) {
this.mapper = mapper;
this.clientSettingService = clientSettingService;
this.userDataService = userDataService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserData> userDataOptional = userDataService.getUserByExtId(userId);
if (userDataOptional.isPresent()) {
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
UserData user = userDataOptional.get();
var vo = clientSettingService.getSetting((String) request.get(SERIAL_KEY));
if (vo.isPresent()) {
var version = vo.get();
user.setLastRomVersion(VersionUtil.getTargetVersion(user.getLastRomVersion(), version.getRomVersion()));
user.setLastDataVersion(VersionUtil.getTargetVersion(user.getLastDataVersion(), version.getDataVersion()));
}
resultMap.put("userData", user);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
return null;
}
}

View File

@ -1,55 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDuel;
import icu.samnyan.aqua.sega.chunithm.service.UserDuelService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handle GetUserDuel request
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserDuelHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserDuelHandler.class);
private final StringMapper mapper;
private final UserDuelService userDuelService;
@Autowired
public GetUserDuelHandler(StringMapper mapper, UserDuelService userDuelService) {
this.mapper = mapper;
this.userDuelService = userDuelService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
String duelId = (String) request.get("duelId");
String isAllDuel = (String) request.get("isAllDuel");
// TODO:
List<UserDuel> userDuelList = userDuelService.getByUserId(userId);
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userDuelList.size());
resultMap.put("userDuelList", userDuelList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,51 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handle GetUserFavoriteItem request
* @author yueou (yueou.xu@gmail.com)
*/
@Component
public class GetUserFavoriteItemHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserFavoriteItemHandler.class);
private final StringMapper mapper;
@Autowired
public GetUserFavoriteItemHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
String kind = (String) request.get("kind");
// TODO:
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("kind", kind);
resultMap.put("nextIndex", -1);
resultMap.put("userFavoriteItemList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,49 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDuel;
import icu.samnyan.aqua.sega.chunithm.service.UserDuelService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handle GetUserDuel request
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserFavoriteMusicHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserFavoriteMusicHandler.class);
private final StringMapper mapper;
@Autowired
public GetUserFavoriteMusicHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
// TODO:
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("userFavoriteMusicList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,67 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserItem;
import icu.samnyan.aqua.sega.chunithm.service.UserItemService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handler for getting user item.
* This get call before profile create.
*
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserItemHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserItemHandler.class);
private final StringMapper mapper;
private final UserItemService userItemService;
public GetUserItemHandler(StringMapper mapper, UserItemService userItemService) {
this.mapper = mapper;
this.userItemService = userItemService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Long nextIndexVal = Long.parseLong((String) request.get("nextIndex"));
int maxCount = Integer.parseInt((String) request.get("maxCount"));
Long mul = 10000000000L;
int kind = (int) (nextIndexVal / mul);
int nextIndex = (int) (nextIndexVal % mul);
int pageNum = nextIndex / maxCount;
Page<UserItem> userItemPage = userItemService.getByUserAndItemKind(userId, kind, pageNum, maxCount);
List<UserItem> userItemList = userItemPage.getContent();
long currentIndex = kind * mul + maxCount * pageNum + userItemPage.getNumberOfElements();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userItemPage.getNumberOfElements());
resultMap.put("nextIndex", userItemPage.getNumberOfElements() < maxCount ? -1 : currentIndex);
resultMap.put("itemKind", kind);
resultMap.put("userItemList", userItemList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,43 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Component
public class GetUserLoginBonusHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserLoginBonusHandler.class);
private final StringMapper mapper;
@Autowired
public GetUserLoginBonusHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
// TODO:
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("userLoginBonusList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,51 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserMap;
import icu.samnyan.aqua.sega.chunithm.service.UserMapService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Handle GetUserMap request
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserMapHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserItemHandler.class);
private final StringMapper mapper;
private final UserMapService userMapService;
@Autowired
public GetUserMapHandler(StringMapper mapper, UserMapService userMapService) {
this.mapper = mapper;
this.userMapService = userMapService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
List<UserMap> userMapList = userMapService.getByUserId(userId);
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userMapList.size());
resultMap.put("userMapList", userMapList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,97 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.data.UserMusicListItem;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserMusicDetail;
import icu.samnyan.aqua.sega.chunithm.service.GameMusicService;
import icu.samnyan.aqua.sega.chunithm.service.UserMusicDetailService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import icu.samnyan.aqua.spring.data.OffsetPageRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import java.util.*;
/**
* Response:
*
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserMusicHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserMusicHandler.class);
private final StringMapper mapper;
private final UserMusicDetailService userMusicDetailService;
private final GameMusicService gameMusicService;
@Autowired
public GetUserMusicHandler(StringMapper mapper, UserMusicDetailService userMusicDetailService, GameMusicService gameMusicService) {
this.mapper = mapper;
this.userMusicDetailService = userMusicDetailService;
this.gameMusicService = gameMusicService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
int currentIndex = Integer.parseInt((String) request.get("nextIndex"));
int maxCount = Integer.parseInt((String) request.get("maxCount"));
if(currentIndex < 0) {
currentIndex = 0;
}
Page<UserMusicDetail> dbPage = userMusicDetailService
.getByUserId(userId, OffsetPageRequest.of(currentIndex, maxCount, Sort.by("musicId")));
// Convert to result format
// Result Map
Map<Integer, UserMusicListItem> userMusicMap = new LinkedHashMap<>();
dbPage.getContent().forEach(userMusicDetail -> {
UserMusicListItem list;
if (userMusicMap.containsKey(userMusicDetail.getMusicId())) {
list = userMusicMap.get(userMusicDetail.getMusicId());
} else {
list = new UserMusicListItem(0, new ArrayList<>());
userMusicMap.put(userMusicDetail.getMusicId(), list);
}
list.getUserMusicDetailList().add(userMusicDetail);
list.setLength(list.getUserMusicDetailList().size());
});
// Remove the last music id if the result length is the same as maxCount,
// to prevent a music id split across multiple page, which will cause some
// problem with the game.
int lastListSize = 0;
if(dbPage.getNumberOfElements() >= maxCount) {
// Get last key
int lastMusicId = userMusicMap.keySet().stream().reduce((a, b) -> b).orElseThrow();
List<UserMusicDetail> lastList = userMusicMap.get(lastMusicId).getUserMusicDetailList();
lastListSize = lastList.size();
// Remove last one from map
userMusicMap.remove(lastMusicId);
}
long nextIndex = currentIndex + dbPage.getNumberOfElements() - lastListSize;
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", userMusicMap.size());
resultMap.put("nextIndex", dbPage.getNumberOfElements() < maxCount ? -1 : nextIndex);
resultMap.put("userMusicList", userMusicMap.values());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,53 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOptionEx;
import icu.samnyan.aqua.sega.chunithm.service.UserGameOptionExService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserOptionExHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserOptionExHandler.class);
private final StringMapper mapper;
private final UserGameOptionExService userGameOptionExService;
@Autowired
public GetUserOptionExHandler(StringMapper mapper, UserGameOptionExService userGameOptionExService) {
this.mapper = mapper;
this.userGameOptionExService = userGameOptionExService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserGameOptionEx> userGameOptionEx = userGameOptionExService.getByUserId(userId);
if (userGameOptionEx.isPresent()) {
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("userGameOptionEx", userGameOptionEx.get());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
return null;
}
}

View File

@ -1,52 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOption;
import icu.samnyan.aqua.sega.chunithm.service.UserGameOptionService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserOptionHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserOptionHandler.class);
private final StringMapper mapper;
private final UserGameOptionService userGameOptionService;
@Autowired
public GetUserOptionHandler(StringMapper mapper, UserGameOptionService userGameOptionService) {
this.mapper = mapper;
this.userGameOptionService = userGameOptionService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserGameOption> userGameOption = userGameOptionService.getByUserId(userId);
if (userGameOption.isPresent()) {
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("userGameOption", userGameOption.get());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
return null;
}
}

View File

@ -1,114 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.GetUserPreviewResp;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharacter;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOption;
import icu.samnyan.aqua.sega.chunithm.service.UserCharacterService;
import icu.samnyan.aqua.sega.chunithm.service.UserDataService;
import icu.samnyan.aqua.sega.chunithm.service.UserGameOptionService;
import icu.samnyan.aqua.sega.general.service.ClientSettingService;
import icu.samnyan.aqua.sega.util.VersionUtil;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Optional;
import static icu.samnyan.aqua.sega.util.AquaConst.SERIAL_KEY;
/**
* The handler for loading basic profile information.
* <p>
* return null if no profile exist
*
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserPreviewHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserPreviewHandler.class);
private final StringMapper mapper;
private final ClientSettingService clientSettingService;
private final UserDataService userDataService;
private final UserCharacterService userCharacterService;
private final UserGameOptionService userGameOptionService;
@Autowired
public GetUserPreviewHandler(StringMapper mapper,
ClientSettingService clientSettingService, UserDataService userDataService,
UserCharacterService userCharacterService,
UserGameOptionService userGameOptionService
) {
this.mapper = mapper;
this.clientSettingService = clientSettingService;
this.userDataService = userDataService;
this.userCharacterService = userCharacterService;
this.userGameOptionService = userGameOptionService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserData> userData = userDataService.getUserByExtId(userId);
if (userData.isEmpty()) {
return null;
}
UserData user = userData.get();
GetUserPreviewResp resp = new GetUserPreviewResp();
resp.setUserId(userId);
resp.setLogin(false);
resp.setLastLoginDate(user.getLastLoginDate());
resp.setUserName(user.getUserName());
resp.setReincarnationNum(user.getReincarnationNum());
resp.setLevel(user.getLevel());
resp.setExp(user.getExp());
resp.setPlayerRating(user.getPlayerRating());
resp.setLastGameId(user.getLastGameId());
var vo = clientSettingService.getSetting((String) request.get(SERIAL_KEY));
if (vo.isPresent()) {
var version = vo.get();
resp.setLastRomVersion(VersionUtil.getTargetVersion(user.getLastRomVersion(), version.getRomVersion()));
resp.setLastDataVersion(VersionUtil.getTargetVersion(user.getLastDataVersion(), version.getDataVersion()));
} else {
resp.setLastRomVersion(user.getLastRomVersion());
resp.setLastDataVersion(user.getLastDataVersion());
}
resp.setLastPlayDate(user.getLastPlayDate());
resp.setTrophyId(user.getTrophyId());
Optional<UserCharacter> userCharacterOptional = userCharacterService.getByUserAndCharacterId(user, user.getCharacterId());
userCharacterOptional.ifPresent(resp::setUserCharacter);
Optional<UserGameOption> userGameOptionOptional = userGameOptionService.getByUser(user);
userGameOptionOptional.ifPresent(userGameOption -> {
resp.setPlayerLevel(userGameOption.getPlayerLevel());
resp.setRating(userGameOption.getRating());
resp.setHeadphone(userGameOption.getHeadphone());
});
resp.setChargeState(1);
resp.setUserNameEx(user.getUserName());
String json = mapper.write(resp);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,80 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGeneralData;
import icu.samnyan.aqua.sega.chunithm.service.UserGeneralDataService;
import icu.samnyan.aqua.sega.general.model.response.UserRecentRating;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserPlaylog;
import icu.samnyan.aqua.sega.chunithm.service.UserPlaylogService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.stream.Collectors;
/**
* Return the recent play to calculate rating. Rating base on top 30 songs plus top 10 in recent 30 plays.
*
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserRecentRatingHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserRecentRatingHandler.class);
private final StringMapper mapper;
private final UserPlaylogService userPlaylogService;
private final UserGeneralDataService userGeneralDataService;
@Autowired
public GetUserRecentRatingHandler(StringMapper mapper, UserPlaylogService userPlaylogService, UserGeneralDataService userGeneralDataService) {
this.mapper = mapper;
this.userPlaylogService = userPlaylogService;
this.userGeneralDataService = userGeneralDataService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Optional<UserGeneralData> recentOptional = userGeneralDataService.getByUserIdAndKey(userId, "recent_rating_list");
List<UserRecentRating> ratingList;
if(recentOptional.isPresent()) {
ratingList = new LinkedList<>();
String val = recentOptional.get().getPropertyValue();
if(StringUtils.isNotBlank(val) && val.contains(",")) {
String[] records = val.split(",");
for (String record :
records) {
String[] value = record.split(":");
ratingList.add(new UserRecentRating(
Integer.parseInt(value[0]),
Integer.parseInt(value[1]),
"1030000",
Integer.parseInt(value[2])
));
}
}
} else {
List<UserPlaylog> top = userPlaylogService.getRecent30Plays(userId);
ratingList = top.stream().map(log -> new UserRecentRating(log.getMusicId(), log.getLevel(), "1030000", log.getScore()))
.collect(Collectors.toList());
}
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", ratingList.size());
resultMap.put("userRecentRatingList", ratingList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,46 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class GetUserRegionHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserRegionHandler.class);
private final StringMapper mapper;
@Autowired
public GetUserRegionHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
List<Object> userRegionList = new ArrayList<>();
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("userRegionList", userRegionList);
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,39 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Component
public class GetUserRivalDataHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserRivalDataHandler.class);
private final StringMapper mapper;
public GetUserRivalDataHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("length", 0);
resultMap.put("userRivalData", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,41 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Component
public class GetUserRivalMusicHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserRivalMusicHandler.class);
private final StringMapper mapper;
public GetUserRivalMusicHandler(StringMapper mapper) {
this.mapper = mapper;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
resultMap.put("rivalId", 0);
resultMap.put("length", 0);
resultMap.put("nextIndex", 0);
resultMap.put("userRivalMusicList", List.of());
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,58 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.Map;
@Component
public class GetUserTeamHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(GetUserTeamHandler.class);
private final StringMapper mapper;
private final String teamName;
public GetUserTeamHandler(StringMapper mapper, @Value("${game.chunithm.team-name:#{null}}") String teamName) {
this.mapper = mapper;
this.teamName = teamName;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
String playDate = (String) request.get("playDate");
Map<String, Object> resultMap = new LinkedHashMap<>();
resultMap.put("userId", userId);
if (teamName != null && !teamName.isEmpty()) {
resultMap.put("teamId", 1);
resultMap.put("teamRank", 1);
resultMap.put("teamName", teamName);
Map<String, Object> userTeamMap = new LinkedHashMap<>();
userTeamMap.put("userId", userId);
userTeamMap.put("teamId", 1);
userTeamMap.put("orderId", 1);
userTeamMap.put("teamPoint", 1);
userTeamMap.put("aggrDate", playDate);
resultMap.put("userTeamPoint", userTeamMap);
} else {
resultMap.put("teamId", 0);
}
String json = mapper.write(resultMap);
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,42 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.requet.ClientSettingRequest;
import icu.samnyan.aqua.sega.general.model.GameVersion;
import icu.samnyan.aqua.sega.general.service.ClientSettingService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Map;
import static icu.samnyan.aqua.sega.util.AquaConst.DEFAULT_KEYCHIP_ID;
import static icu.samnyan.aqua.sega.util.AquaConst.SERIAL_KEY;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class UpsertClientSettingHandler implements BaseHandler {
private final StringMapper mapper;
private final ClientSettingService clientSettingService;
public UpsertClientSettingHandler(StringMapper mapper, ClientSettingService clientSettingService) {
this.mapper = mapper;
this.clientSettingService = clientSettingService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
var req = mapper.convert(request, ClientSettingRequest.class);
var set = req.getClientSetting();
var serial = (String) request.get(SERIAL_KEY);
if (!serial.equals(DEFAULT_KEYCHIP_ID)) {
clientSettingService.writeSetting(new GameVersion(serial, set.getRomVersion(), set.getDataVersion(), LocalDateTime.now()));
}
return "{\"returnCode\":\"1\"}";
}
}

View File

@ -1,343 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.requet.UpsertUserAll;
import icu.samnyan.aqua.sega.chunithm.model.response.CodeResp;
import icu.samnyan.aqua.sega.chunithm.model.userdata.*;
import icu.samnyan.aqua.sega.chunithm.service.*;
import icu.samnyan.aqua.sega.general.model.Card;
import icu.samnyan.aqua.sega.general.model.response.UserRecentRating;
import icu.samnyan.aqua.sega.general.service.CardService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.nio.charset.StandardCharsets;
import java.util.*;
/**
* The handler for save user data. Only send in the end of the session.
*
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class UpsertUserAllHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(UpsertUserAllHandler.class);
private final StringMapper mapper;
private final CardService cardService;
private final UserDataService userDataService;
private final UserCharacterService userCharacterService;
private final UserGameOptionService userGameOptionService;
private final UserGameOptionExService userGameOptionExService;
private final UserMapService userMapService;
private final UserItemService userItemService;
private final UserMusicDetailService userMusicDetailService;
private final UserActivityService userActivityService;
private final UserPlaylogService userPlaylogService;
private final UserChargeService userChargeService;
private final UserDataExService userDataExService;
private final UserCourseService userCourseService;
private final UserDuelService userDuelService;
private final UserGeneralDataService userGeneralDataService;
@Autowired
public UpsertUserAllHandler(StringMapper mapper, CardService cardService, UserDataService userDataService, UserCharacterService userCharacterService, UserGameOptionService userGameOptionService, UserGameOptionExService userGameOptionExService, UserMapService userMapService, UserItemService userItemService, UserMusicDetailService userMusicDetailService, UserActivityService userActivityService, UserPlaylogService userPlaylogService, UserChargeService userChargeService, UserDataExService userDataExService, UserCourseService userCourseService, UserDuelService userDuelService, UserGeneralDataService userGeneralDataService) {
this.mapper = mapper;
this.cardService = cardService;
this.userDataService = userDataService;
this.userCharacterService = userCharacterService;
this.userGameOptionService = userGameOptionService;
this.userGameOptionExService = userGameOptionExService;
this.userMapService = userMapService;
this.userItemService = userItemService;
this.userMusicDetailService = userMusicDetailService;
this.userActivityService = userActivityService;
this.userPlaylogService = userPlaylogService;
this.userChargeService = userChargeService;
this.userDataExService = userDataExService;
this.userCourseService = userCourseService;
this.userDuelService = userDuelService;
this.userGeneralDataService = userGeneralDataService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
UpsertUserAll upsertUserAll = mapper.convert(request.get("upsertUserAll"), UpsertUserAll.class);
// Not all field will be sent. Check if they are exist first.
UserData userData;
UserData newUserData;
// UserData
if (upsertUserAll.getUserData() == null) {
return null;
} else {
newUserData = upsertUserAll.getUserData().get(0);
Optional<UserData> userOptional = userDataService.getUserByExtId(userId);
if (userOptional.isPresent()) {
userData = userOptional.get();
} else {
userData = new UserData();
Card card = cardService.getCardByExtId(userId).orElseThrow();
userData.setCard(card);
}
newUserData.setId(userData.getId());
newUserData.setCard(userData.getCard());
// Decode Username
String userName = new String(newUserData.getUserName()
.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
newUserData.setUserName(userName);
userDataService.saveAndFlushUserData(newUserData);
}
// userGameOption
if (upsertUserAll.getUserGameOption() != null) {
UserGameOption newUserGameOption = upsertUserAll.getUserGameOption().get(0);
Optional<UserGameOption> userGameOptionOptional = userGameOptionService.getByUser(newUserData);
UserGameOption userGameOption = userGameOptionOptional.orElseGet(() -> new UserGameOption(newUserData));
newUserGameOption.setId(userGameOption.getId());
newUserGameOption.setUser(userGameOption.getUser());
userGameOptionService.save(newUserGameOption);
}
// userGameOptionEx
if (upsertUserAll.getUserGameOptionEx() != null) {
UserGameOptionEx newUserGameOptionEx = upsertUserAll.getUserGameOptionEx().get(0);
Optional<UserGameOptionEx> userGameOptionExOptional = userGameOptionExService.getByUser(newUserData);
UserGameOptionEx userGameOptionEx = userGameOptionExOptional.orElseGet(() -> new UserGameOptionEx(newUserData));
newUserGameOptionEx.setId(userGameOptionEx.getId());
newUserGameOptionEx.setUser(userGameOptionEx.getUser());
userGameOptionExService.save(newUserGameOptionEx);
}
// userMapList
if (upsertUserAll.getUserMapList() != null) {
List<UserMap> userMapList = upsertUserAll.getUserMapList();
Map<Integer, UserMap> newUserMapMap = new HashMap<>();
userMapList.forEach(newUserMap -> {
int mapId = newUserMap.getMapId();
UserMap userMap;
Optional<UserMap> userMapOptional = userMapService.getByUserAndMapId(newUserData, mapId);
userMap = userMapOptional.orElseGet(() -> new UserMap(newUserData));
newUserMap.setId(userMap.getId());
newUserMap.setUser(userMap.getUser());
newUserMapMap.put(mapId, newUserMap);
});
userMapService.saveAll(newUserMapMap.values());
}
// userCharacterList
if (upsertUserAll.getUserCharacterList() != null) {
List<UserCharacter> userCharacterList = upsertUserAll.getUserCharacterList();
Map<Integer, UserCharacter> newCharacterMap = new HashMap<>();
userCharacterList.forEach(newUserCharacter -> {
int characterId = newUserCharacter.getCharacterId();
Optional<UserCharacter> userCharacterOptional = userCharacterService.getByUserAndCharacterId(newUserData, characterId);
UserCharacter userCharacter = userCharacterOptional.orElseGet(() -> new UserCharacter(newUserData));
newUserCharacter.setId(userCharacter.getId());
newUserCharacter.setUser(userCharacter.getUser());
newCharacterMap.put(characterId, newUserCharacter);
});
userCharacterService.saveAll(newCharacterMap.values());
}
// userItemList
if (upsertUserAll.getUserItemList() != null) {
List<UserItem> userItemList = upsertUserAll.getUserItemList();
Map<String, UserItem> newUserItemMap = new HashMap<>();
userItemList.forEach(newUserItem -> {
int itemId = newUserItem.getItemId();
int itemKind = newUserItem.getItemKind();
Optional<UserItem> userItemOptional = userItemService.getByUserAndItemIdAndKind(newUserData, itemId, itemKind);
UserItem userItem = userItemOptional.orElseGet(() -> new UserItem(newUserData));
newUserItem.setId(userItem.getId());
newUserItem.setUser(userItem.getUser());
newUserItemMap.put(itemId + "-" + itemKind, newUserItem);
});
userItemService.saveAll(newUserItemMap.values());
}
// userMusicDetailList
if (upsertUserAll.getUserMusicDetailList() != null) {
List<UserMusicDetail> userMusicDetailList = upsertUserAll.getUserMusicDetailList();
Map<String, UserMusicDetail> newUserMusicDetailMap = new HashMap<>();
userMusicDetailList.forEach(newUserMusicDetail -> {
int musicId = newUserMusicDetail.getMusicId();
int level = newUserMusicDetail.getLevel();
Optional<UserMusicDetail> userMusicDetailOptional = userMusicDetailService.getByUserAndMusicIdAndLevel(newUserData, musicId, level);
UserMusicDetail userMusicDetail = userMusicDetailOptional.orElseGet(() -> new UserMusicDetail(newUserData));
newUserMusicDetail.setId(userMusicDetail.getId());
newUserMusicDetail.setUser(userMusicDetail.getUser());
newUserMusicDetailMap.put(musicId + "-" + level, newUserMusicDetail);
});
userMusicDetailService.saveAll(newUserMusicDetailMap.values());
}
// userActivityList
if (upsertUserAll.getUserActivityList() != null) {
List<UserActivity> userActivityList = upsertUserAll.getUserActivityList();
List<UserActivity> newUserActivityList = new LinkedList<>();
userActivityList.forEach(newUserActivity -> {
// No need to rename to activityId. jackson auto handle that
int activityId = newUserActivity.getActivityId();
int kind = newUserActivity.getKind();
Optional<UserActivity> userActivityOptional = userActivityService.getByUserAndActivityIdAndKind(newUserData, activityId, kind);
UserActivity userActivity = userActivityOptional.orElseGet(() -> new UserActivity(newUserData));
newUserActivity.setId(userActivity.getId());
newUserActivity.setUser(userActivity.getUser());
newUserActivityList.add(newUserActivity);
});
userActivityService.saveAll(newUserActivityList);
}
// userRecentRatingList
if(upsertUserAll.getUserRecentRatingList() != null) {
List<UserRecentRating> userRecentRatingList = upsertUserAll.getUserRecentRatingList();
StringBuilder sb = new StringBuilder();
userRecentRatingList.forEach(userRecentRating -> {
sb.append(userRecentRating.getMusicId()).append(":");
sb.append(userRecentRating.getDifficultId()).append(":");
sb.append(userRecentRating.getScore()).append(",");
});
if(sb.length() > 0) {
sb.deleteCharAt(sb.length() - 1);
}
UserGeneralData userGeneralData = userGeneralDataService.getByUserAndKey(newUserData, "recent_rating_list")
.orElseGet(() -> new UserGeneralData(newUserData, "recent_rating_list"));
userGeneralData.setPropertyValue(sb.toString());
userGeneralDataService.save(userGeneralData);
}
// userChargeList
if (upsertUserAll.getUserChargeList() != null) {
List<UserCharge> userChargeList = upsertUserAll.getUserChargeList();
List<UserCharge> newUserChargeList = new ArrayList<>();
userChargeList.forEach(newUserCharge -> {
int chargeId = newUserCharge.getChargeId();
Optional<UserCharge> userChargeOptional = userChargeService.getByUserAndChargeId(newUserData, chargeId);
UserCharge userCharge = userChargeOptional.orElseGet(() -> new UserCharge(newUserData));
newUserCharge.setId(userCharge.getId());
newUserCharge.setUser(userCharge.getUser());
newUserChargeList.add(newUserCharge);
});
userChargeService.saveAll(newUserChargeList);
}
// userPlaylogList
if (upsertUserAll.getUserPlaylogList() != null) {
List<UserPlaylog> userPlaylogList = upsertUserAll.getUserPlaylogList();
List<UserPlaylog> newUserPlaylogList = new ArrayList<>();
userPlaylogList.forEach(newUserPlaylog -> {
newUserPlaylog.setUser(newUserData);
newUserPlaylogList.add(newUserPlaylog);
});
if (newUserPlaylogList.size() > 0) userPlaylogService.saveAll(newUserPlaylogList);
}
// userCourseList
if (upsertUserAll.getUserCourseList() != null) {
List<UserCourse> userCourseList = upsertUserAll.getUserCourseList();
userCourseList.forEach(newUserCourse -> {
int courseId = newUserCourse.getCourseId();
Optional<UserCourse> userCourseOptional = userCourseService.getByUserAndCourseId(newUserData, courseId);
UserCourse userCourse = userCourseOptional.orElseGet(() -> new UserCourse(newUserData));
newUserCourse.setId(userCourse.getId());
newUserCourse.setUser(userCourse.getUser());
userCourseService.save(newUserCourse);
});
}
// userDataEx
if (upsertUserAll.getUserDataEx() != null) {
UserDataEx newUserDataEx = upsertUserAll.getUserDataEx().get(0);
Optional<UserDataEx> userDataExOptional = userDataExService.getByUser(newUserData);
UserDataEx userDataEx = userDataExOptional.orElseGet(() -> new UserDataEx(newUserData));
newUserDataEx.setId(userDataEx.getId());
newUserDataEx.setUser(userDataEx.getUser());
userDataExService.save(newUserDataEx);
}
// userDuelList
if (upsertUserAll.getUserDuelList() != null) {
List<UserDuel> userDuelList = upsertUserAll.getUserDuelList();
Map<Integer, UserDuel> newUserDuelMap = new HashMap<>();
userDuelList.forEach(newUserDuel -> {
int duelId = newUserDuel.getDuelId();
Optional<UserDuel> userDuelOptional = userDuelService.getByUserAndDuelId(newUserData, duelId);
UserDuel userDuel = userDuelOptional.orElseGet(() -> new UserDuel(newUserData));
newUserDuel.setId(userDuel.getId());
newUserDuel.setUser(userDuel.getUser());
newUserDuelMap.put(duelId, newUserDuel);
});
userDuelService.saveAll(newUserDuelMap.values());
}
String json = mapper.write(new CodeResp(1));
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,60 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.handler.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import icu.samnyan.aqua.sega.general.BaseHandler;
import icu.samnyan.aqua.sega.chunithm.model.response.CodeResp;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharge;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.service.UserChargeService;
import icu.samnyan.aqua.sega.chunithm.service.UserDataService;
import icu.samnyan.aqua.sega.util.jackson.StringMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Component
public class UpsertUserChargelogHandler implements BaseHandler {
private static final Logger logger = LoggerFactory.getLogger(UpsertUserChargelogHandler.class);
private final StringMapper mapper;
private final UserDataService userDataService;
private final UserChargeService userChargeService;
public UpsertUserChargelogHandler(StringMapper mapper, UserDataService userDataService, UserChargeService userChargeService) {
this.mapper = mapper;
this.userDataService = userDataService;
this.userChargeService = userChargeService;
}
@Override
public String handle(Map<String, ?> request) throws JsonProcessingException {
String userId = (String) request.get("userId");
UserData user = userDataService.getUserByExtId(userId).orElseThrow();
Map<String, Object> userChargeMap = (Map<String, Object>) request.get("userCharge");
String chargeId = (String) userChargeMap.get("chargeId");
UserCharge charge = mapper.convert(userChargeMap, UserCharge.class);
UserCharge userCharge = userChargeService.getByUserAndChargeId(user, Integer.parseInt(chargeId)).orElseGet(() -> new UserCharge(user));
userCharge.setChargeId(charge.getChargeId());
userCharge.setStock(charge.getStock());
userCharge.setPurchaseDate(charge.getPurchaseDate());
userCharge.setValidDate(charge.getValidDate());
userCharge.setParam1(charge.getParam1());
userCharge.setParam2(charge.getParam2());
userCharge.setParamDate(charge.getParamDate());
userChargeService.save(userCharge);
String json = mapper.write(new CodeResp(1));
logger.info("Response: " + json);
return json;
}
}

View File

@ -1,43 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniCharacter")
@Table(name = "chuni_game_character")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Character implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private long id;
private String name;
private String releaseTag;
private String worksName;
private String illustratorName;
private String firstSkillId;
// Format: level:skillId,level:skillId
// Keep 0 skillId
private String skills;
private String addImages;
}

View File

@ -1,28 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import lombok.*;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniCharacterSkill")
@Table(name = "chuni_game_skill")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CharacterSkill implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private long id;
private String name;
private String category;
}

View File

@ -1,28 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
public enum Diff {
BASIC("BASIC"),
ADVANCED("ADVANCED"),
EXPERT("EXPERT"),
MASTER("MASTER"),
WE("WORLD'S END");
private String displayName;
Diff(String displayName) {
this.displayName = displayName;
}
public String displayName() {
return displayName;
}
@Override
public String toString() {
return displayName;
}
}

View File

@ -1,46 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniGameCharge")
@Table(name = "chuni_game_charge")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameCharge implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
private int orderId;
@Column(unique = true)
private int chargeId;
private int price;
private LocalDateTime startDate;
private LocalDateTime endDate;
private int salePrice;
private LocalDateTime saleStartDate;
private LocalDateTime saleEndDate;
}

View File

@ -1,37 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniGameEvent")
@Table(name = "chuni_game_event")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameEvent implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private int id;
private int type;
private LocalDateTime startDate;
private LocalDateTime endDate;
@JsonIgnore
private boolean enable;
}

View File

@ -1,35 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniGameMessage")
@Table(name = "chuni_game_message")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameMessage implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private int id;
private int type;
private String message;
private LocalDateTime startDate;
private LocalDateTime endDate;
}

View File

@ -1,33 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
public enum Genre {
POPS_ANIME("POPS & ANIME"),
GAME("GAME"),
NICONICO("niconico"),
TOUHOU("東方Project"),
RESERVE2("Reserve2"),
ORIGINAL("Original"),
VARIETY("Variety"),
IRODORI("イロドリミドリ"),
KOTONOHA("葉Project"),
GEKICHUMA("ゲキマイ");
private String displayName;
Genre(String displayName) {
this.displayName = displayName;
}
public String displayName() {
return displayName;
}
@Override
public String toString() {
return displayName;
}
}

View File

@ -1,40 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniMusicLevel")
@Table(name = "chuni_music_level")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Level implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "music_id")
private Music music;
private boolean enable;
private int level;
private int levelDecimal;
private int diff;
}

View File

@ -1,43 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.gamedata;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
import java.util.Map;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniMusic")
@Table(name = "chuni_music")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Music implements Serializable {
private static final long serialVersionUID = 1L;
@Id
private int musicId;
private String name;
private String sortName;
// Copyright info
private String copyright;
private String artistName;
private Genre genre;
private String releaseVersion;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "music")
@MapKey(name = "diff")
private Map<Integer, Level> levels;
}

View File

@ -1,21 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.requet;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ClientSetting {
private String placeId;
private String clientId;
private String placeName;
private String regionId;
private String regionName;
private String allNetId;
private String bordId;
private String romVersion;
private String dataVersion;
private String dumpFileNum;
}

View File

@ -1,12 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.requet;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ClientSettingRequest {
private ClientSetting clientSetting;
}

View File

@ -1,88 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.requet;
import com.fasterxml.jackson.annotation.JsonProperty;
import icu.samnyan.aqua.sega.chunithm.model.userdata.*;
import icu.samnyan.aqua.sega.general.model.response.UserRecentRating;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.lang.Nullable;
import java.io.Serializable;
import java.util.List;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UpsertUserAll implements Serializable {
@Nullable
private List<UserData> userData;
@Nullable
private List<UserGameOption> userGameOption;
@Nullable
private List<UserGameOptionEx> userGameOptionEx;
@Nullable
private List<UserMap> userMapList;
@Nullable
private List<UserCharacter> userCharacterList;
@Nullable
private List<UserItem> userItemList;
@Nullable
private List<UserMusicDetail> userMusicDetailList;
@Nullable
private List<UserActivity> userActivityList;
@Nullable
private List<UserRecentRating> userRecentRatingList;
@Nullable
private List<UserCharge> userChargeList;
@Nullable
private List<UserPlaylog> userPlaylogList;
@Nullable
private List<UserCourse> userCourseList;
@Nullable
private List<UserDataEx> userDataEx;
@Nullable
private List<UserDuel> userDuelList;
@Nullable
@JsonProperty("isNewMapList")
private String isNewMapList;
@Nullable
@JsonProperty("isNewCharacterList")
private String isNewCharacterList;
@Nullable
@JsonProperty("isNewMusicDetailList")
private String isNewMusicDetailList;
@Nullable
@JsonProperty("isNewItemList")
private String isNewItemList;
@Nullable
@JsonProperty("isNewCourseList")
private String isNewCourseList;
@Nullable
@JsonProperty("isNewDuelList")
private String isNewDuelList;
}

View File

@ -1,15 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CodeResp {
private int returnCode;
}

View File

@ -1,22 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response;
import com.fasterxml.jackson.annotation.JsonProperty;
import icu.samnyan.aqua.sega.chunithm.model.response.data.GameSetting;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GetGameSettingResp {
private GameSetting gameSetting;
@JsonProperty("isDumpUpload")
private boolean isDumpUpload;
@JsonProperty("isAou")
private boolean isAou;
}

View File

@ -1,40 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response;
import com.fasterxml.jackson.annotation.JsonProperty;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharacter;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GetUserPreviewResp {
private String userId;
@JsonProperty("isLogin")
private boolean isLogin;
private LocalDateTime lastLoginDate;
private String userName;
private int reincarnationNum;
private int level;
private String exp;
private int playerRating;
private String lastGameId;
private String lastRomVersion;
private String lastDataVersion;
private LocalDateTime lastPlayDate;
private int trophyId;
private UserCharacter userCharacter;
private int playerLevel;
private int rating;
private int headphone;
private int chargeState;
private String userNameEx;
}

View File

@ -1,8 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response.data;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
public class AllMusicMapItem {
}

View File

@ -1,16 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response.data;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameRanking {
private int id;
private long point;
}

View File

@ -1,28 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response.data;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameSale {
private int orderId;
private int type;
private int id;
// should be float number??
private int rate;
private LocalDateTime startDate;
private LocalDateTime endDate;
}

View File

@ -1,26 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response.data;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class GameSetting {
private int dataVersion;
@JsonProperty("isMaintenance")
private boolean isMaintenance;
private int requestInterval;
private String rebootStartTime;
private String rebootEndTime;
@JsonProperty("isBackgroundDistribute")
private boolean isBackgroundDistribute;
private int maxCountCharacter;
private int maxCountItem;
private int maxCountMusic;
}

View File

@ -1,19 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.response.data;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserMusicDetail;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserMusicListItem {
private int length;
private List<UserMusicDetail> userMusicDetailList;
}

View File

@ -1,55 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserActivity")
@Table(name = "chuni_user_activity", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "kind", "activity_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({"kind", "id", "sortNumber", "param1", "param2", "param3", "param4"})
public class UserActivity implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private int kind;
@JsonProperty("id")
@Column(name = "activity_id")
private int activityId;
private int sortNumber;
private int param1;
private int param2;
private int param3;
private int param4;
public UserActivity(UserData userData) {
user = userData;
}
}

View File

@ -1,60 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserCharacter")
@Table(name = "chuni_user_character", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "character_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({"characterId", "playCount", "level", "skillId", "friendshipExp", "isValid", "isNewMark", "param1", "param2"})
public class UserCharacter implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "character_id")
private int characterId;
private int playCount = 0;
private int level = 1;
private int skillId = 0;
private int friendshipExp = 0;
@JsonProperty("isValid")
private boolean isValid = true;
@JsonProperty("isNewMark")
private boolean isNewMark = true;
private int param1 = 0;
private int param2 = 0;
public UserCharacter(UserData userData) {
user = userData;
}
}

View File

@ -1,54 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserCharge")
@Table(name = "chuni_user_charge", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "charge_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({"chargeId", "stock", "purchaseDate", "validDate", "param1", "param2", "paramDate"})
public class UserCharge implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "charge_id")
private int chargeId;
private int stock;
private LocalDateTime purchaseDate;
private LocalDateTime validDate;
private int param1;
private int param2;
private LocalDateTime paramDate;
public UserCharge(UserData user) {
this.user = user;
}
}

View File

@ -1,74 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserCourse")
@Table(name = "chuni_user_course", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "course_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserCourse {
@Id
@JsonIgnore
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "course_id")
private int courseId;
private int classId;
private int playCount;
private int scoreMax;
@JsonProperty("isFullCombo")
private boolean isFullCombo;
@JsonProperty("isAllJustice")
private boolean isAllJustice;
@JsonProperty("isSuccess")
private boolean isSuccess;
private int scoreRank;
private int eventId;
private LocalDateTime lastPlayDate;
private int param1;
private int param2;
private int param3;
private int param4;
@JsonProperty("isClear")
private boolean isClear;
public UserCourse(UserData userData) {
user = userData;
}
public UserCourse(int classId) {
this.classId = classId;
}
}

View File

@ -1,188 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import icu.samnyan.aqua.sega.general.model.Card;
import icu.samnyan.aqua.sega.util.jackson.AccessCodeSerializer;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserData")
@Table(name = "chuni_user_data")
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"accessCode",
"userName",
"isWebJoin",
"webLimitDate", "level",
"reincarnationNum",
"exp",
"point",
"totalPoint",
"playCount",
"multiPlayCount",
"multiWinCount",
"requestResCount",
"acceptResCount",
"successResCount",
"playerRating",
"highestRating",
"nameplateId",
"frameId",
"characterId",
"trophyId",
"playedTutorialBit",
"firstTutorialCancelNum",
"masterTutorialCancelNum",
"totalRepertoireCount",
"totalMapNum",
"totalHiScore",
"totalBasicHighScore",
"totalAdvancedHighScore",
"totalExpertHighScore",
"totalMasterHighScore",
"eventWatchedDate",
"friendCount",
"isMaimai",
"firstGameId",
"firstRomVersion",
"firstDataVersion",
"firstPlayDate",
"lastGameId",
"lastRomVersion",
"lastDataVersion",
"lastPlayDate",
"lastPlaceId",
"lastPlaceName",
"lastRegionId",
"lastRegionName",
"lastAllNetId",
"lastClientId"})
public class UserData implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonSerialize(using = AccessCodeSerializer.class)
@JsonProperty(value = "accessCode", access = JsonProperty.Access.READ_ONLY)
@OneToOne
@JoinColumn(name = "card_id")
private Card card;
// Access code in card
private String userName;
private LocalDateTime lastLoginDate;
@JsonProperty("isWebJoin")
private boolean isWebJoin;
private String webLimitDate;
private int level;
private int reincarnationNum;
private String exp;
private long point;
private long totalPoint;
private int playCount;
private int multiPlayCount;
private int multiWinCount;
private int requestResCount;
private int acceptResCount;
private int successResCount;
private int playerRating;
private int highestRating;
private int nameplateId;
private int frameId;
// Currently selected UserCharacter
private int characterId;
private int trophyId;
private int playedTutorialBit;
private int firstTutorialCancelNum;
private int masterTutorialCancelNum;
private int totalRepertoireCount;
private int totalMapNum;
private long totalHiScore;
private long totalBasicHighScore;
private long totalAdvancedHighScore;
private long totalExpertHighScore;
private long totalMasterHighScore;
private LocalDateTime eventWatchedDate;
private int friendCount;
@JsonProperty("isMaimai")
private boolean isMaimai;
private String firstGameId;
private String firstRomVersion;
private String firstDataVersion;
private LocalDateTime firstPlayDate;
private String lastGameId;
private String lastRomVersion;
private String lastDataVersion;
private LocalDateTime lastPlayDate;
private int lastPlaceId;
private String lastPlaceName;
private String lastRegionId;
private String lastRegionName;
private String lastAllNetId;
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String lastClientId;
}

View File

@ -1,142 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserDataEx")
@Table(name = "chuni_user_data_ex")
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"compatibleCmVersion",
"medal",
"mapIconId",
"voiceId",
"ext1",
"ext2",
"ext3",
"ext4",
"ext5",
"ext6",
"ext7",
"ext8",
"ext9",
"ext10",
"ext11",
"ext12",
"ext13",
"ext14",
"ext15",
"ext16",
"ext17",
"ext18",
"ext19",
"ext20",
"extStr1",
"extStr2",
"extStr3",
"extStr4",
"extStr5",
"extLong1",
"extLong2",
"extLong3",
"extLong4",
"extLong5"
})
public class UserDataEx implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private String compatibleCmVersion;
private int medal;
private int mapIconId;
private int voiceId;
private int ext1;
private int ext2;
private int ext3;
private int ext4;
private int ext5;
private int ext6;
private int ext7;
private int ext8;
private int ext9;
private int ext10;
private int ext11;
private int ext12;
private int ext13;
private int ext14;
private int ext15;
private int ext16;
private int ext17;
private int ext18;
private int ext19;
private int ext20;
private String extStr1;
private String extStr2;
private String extStr3;
private String extStr4;
private String extStr5;
private long extLong1;
private long extLong2;
private long extLong3;
private long extLong4;
private long extLong5;
public UserDataEx(UserData userData) {
user = userData;
}
}

View File

@ -1,55 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserDuel")
@Table(name = "chuni_user_duel", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "duel_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserDuel {
@Id
@JsonIgnore
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "duel_id")
private int duelId;
private int progress;
private int point;
@JsonProperty("isClear")
private boolean isClear;
private LocalDateTime lastPlayDate;
private int param1;
private int param2;
private int param3;
private int param4;
public UserDuel(UserData userData) {
user = userData;
}
}

View File

@ -1,106 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserGameOption")
@Table(name = "chuni_user_game_option")
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"bgInfo",
"fieldColor",
"guideSound",
"soundEffect",
"guideLine",
"speed",
"optionSet",
"matching",
"judgePos",
"rating",
"judgeJustice",
"judgeAttack",
"headphone",
"playerLevel",
"successTap",
"successExTap",
"successSlideHold",
"successAir",
"successFlick",
"successSkill",
"successTapTimbre",
"privacy"
})
public class UserGameOption implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@JsonIgnore
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private int bgInfo;
private int fieldColor;
private int guideSound;
private int soundEffect;
private int guideLine;
private int speed;
private int optionSet;
private int matching;
private int judgePos;
private int rating;
private int judgeJustice;
private int judgeAttack;
private int headphone;
private int playerLevel;
private int successTap;
private int successExTap;
private int successSlideHold;
private int successAir;
private int successFlick;
private int successSkill;
private int successTapTimbre;
private int privacy;
public UserGameOption(UserData userData) {
user = userData;
}
}

View File

@ -1,100 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserGameOptionEx")
@Table(name = "chuni_user_game_option_ex")
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"ext1",
"ext2",
"ext3",
"ext4",
"ext5",
"ext6",
"ext7",
"ext8",
"ext9",
"ext10",
"ext11",
"ext12",
"ext13",
"ext14",
"ext15",
"ext16",
"ext17",
"ext18",
"ext19",
"ext20"
})
public class UserGameOptionEx implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private int ext1;
private int ext2;
private int ext3;
private int ext4;
private int ext5;
private int ext6;
private int ext7;
private int ext8;
private int ext9;
private int ext10;
private int ext11;
private int ext12;
private int ext13;
private int ext14;
private int ext15;
private int ext16;
private int ext17;
private int ext18;
private int ext19;
private int ext20;
public UserGameOptionEx(UserData userData) {
user = userData;
}
}

View File

@ -1,44 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* This is for storing the other data that doesn't need to save it in a separate table
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserGeneralData")
@Table(name = "chuni_user_general_data")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserGeneralData implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private String propertyKey;
@Column(columnDefinition = "TEXT")
private String propertyValue;
public UserGeneralData(UserData userData, String key) {
this.user = userData;
this.propertyKey = key;
this.propertyValue = "";
}
}

View File

@ -1,51 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserItem")
@Table(name = "chuni_user_item", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "item_id", "item_kind"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({"itemKind", "itemId", "stock", "isValid"})
public class UserItem implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
// Kind ,Type
@Column(name = "item_kind")
private int itemKind;
@Column(name = "item_id")
private int itemId;
private int stock = 1;
@JsonProperty("isValid")
private boolean isValid = true;
public UserItem(UserData userData) {
user = userData;
}
}

View File

@ -1,70 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserMap")
@Table(name = "chuni_user_map", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "map_id"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"mapId",
"position",
"isClear",
"areaId",
"routeNumber",
"eventId",
"rate",
"statusCount",
"isValid"
})
public class UserMap implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "map_id")
private int mapId;
private int position;
@JsonProperty("isClear")
private boolean isClear;
private int areaId;
private int routeNumber;
private int eventId;
private int rate;
private int statusCount;
@JsonProperty("isValid")
private boolean isValid;
public UserMap(UserData userData) {
user = userData;
}
}

View File

@ -1,113 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserMusicDetail")
@Table(name = "chuni_user_music_detail", uniqueConstraints = {@UniqueConstraint(columnNames = {"user_id", "music_id", "level"})})
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
"musicId",
"level",
"playCount",
"scoreMax",
"resRequestCount",
"resAcceptCount",
"resSuccessCount",
"missCount",
"maxComboCount",
"isFullCombo",
"isAllJustice",
"isSuccess",
"fullChain",
"maxChain",
"scoreRank",
"isLock"
})
public class UserMusicDetail implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
@Column(name = "music_id")
private int musicId;
private int level;
private int playCount;
private int scoreMax;
private int resRequestCount;
private int resAcceptCount;
private int resSuccessCount;
private int missCount;
private int maxComboCount;
@JsonProperty("isFullCombo")
private boolean isFullCombo;
@JsonProperty("isAllJustice")
private boolean isAllJustice;
@JsonProperty("isSuccess")
private boolean isSuccess;
private int fullChain;
private int maxChain;
private int scoreRank;
@JsonProperty("isLock")
private boolean isLock;
public UserMusicDetail(UserData userData) {
user = userData;
}
public UserMusicDetail(int musicId, int level, int playCount, int scoreMax, int resRequestCount, int resAcceptCount, int resSuccessCount, int missCount, int maxComboCount, boolean isFullCombo, boolean isAllJustice, boolean isSuccess, int fullChain, int maxChain, int scoreRank, boolean isLock) {
this.musicId = musicId;
this.level = level;
this.playCount = playCount;
this.scoreMax = scoreMax;
this.resRequestCount = resRequestCount;
this.resAcceptCount = resAcceptCount;
this.resSuccessCount = resSuccessCount;
this.missCount = missCount;
this.maxComboCount = maxComboCount;
this.isFullCombo = isFullCombo;
this.isAllJustice = isAllJustice;
this.isSuccess = isSuccess;
this.fullChain = fullChain;
this.maxChain = maxChain;
this.scoreRank = scoreRank;
this.isLock = isLock;
}
}

View File

@ -1,147 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.model.userdata;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.*;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Entity(name = "ChuniUserPlaylog")
@Table(name = "chuni_user_playlog")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserPlaylog implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonIgnore
private long id;
@JsonIgnore
@ManyToOne
@JoinColumn(name = "user_id")
private UserData user;
private int orderId;
private int sortNumber;
private int placeId;
private LocalDateTime playDate;
private LocalDateTime userPlayDate;
private int musicId;
private int level;
private int customId;
private int playedUserId1;
private int playedUserId2;
private int playedUserId3;
private String playedUserName1;
private String playedUserName2;
private String playedUserName3;
private int playedMusicLevel1;
private int playedMusicLevel2;
private int playedMusicLevel3;
private int playedCustom1;
private int playedCustom2;
private int playedCustom3;
private int track;
private int score;
@Column(name = "\"rank\"")
private int rank;
private int maxCombo;
private int maxChain;
private int rateTap;
private int rateHold;
private int rateSlide;
private int rateAir;
private int rateFlick;
private int judgeGuilty;
private int judgeAttack;
private int judgeJustice;
private int judgeCritical;
private int eventId;
private int playerRating;
@JsonProperty("isNewRecord")
private boolean isNewRecord;
@JsonProperty("isFullCombo")
private boolean isFullCombo;
private int fullChainKind;
@JsonProperty("isAllJustice")
private boolean isAllJustice;
@JsonProperty("isContinue")
private boolean isContinue;
@JsonProperty("isFreeToPlay")
private boolean isFreeToPlay;
private int characterId;
private int skillId;
private int playKind;
@JsonProperty("isClear")
private boolean isClear;
private int skillLevel;
private int skillEffect;
private String placeName;
@JsonProperty("isMaimai")
private boolean isMaimai;
public UserPlaylog(UserData userData) {
user = userData;
}
}

View File

@ -1,37 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.gamedata.GameMusicRepository;
import icu.samnyan.aqua.sega.chunithm.model.gamedata.Music;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class GameMusicService {
private final GameMusicRepository gameMusicRepository;
@Autowired
public GameMusicService(GameMusicRepository gameMusicRepository) {
this.gameMusicRepository = gameMusicRepository;
}
@Cacheable("music")
public List<Music> getAll() {
return gameMusicRepository.findAll();
}
public Map<Integer, Music> getIdMap() {
Map<Integer, Music> musicMap = new LinkedHashMap<>();
getAll().forEach(music -> musicMap.put(music.getMusicId(), music));
return musicMap;
}
}

View File

@ -1,44 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserActivityRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserActivity;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserActivityService {
private final UserActivityRepository userActivityRepository;
@Autowired
public UserActivityService(UserActivityRepository userActivityRepository) {
this.userActivityRepository = userActivityRepository;
}
public UserActivity save(UserActivity userActivity) {
return userActivityRepository.save(userActivity);
}
public List<UserActivity> saveAll(List<UserActivity> userActivityList) {
return userActivityRepository.saveAll(userActivityList);
}
public Optional<UserActivity> getByUserAndActivityIdAndKind(UserData user, int activityId, int kind) {
return userActivityRepository.findTopByUserAndActivityIdAndKindOrderByIdDesc(user, activityId, kind);
}
public List<UserActivity> getAllByUserIdAndKind(String userId, String kind) {
return userActivityRepository.findAllByUser_Card_ExtIdAndKindOrderBySortNumberDesc(Long.parseLong(userId), Integer.parseInt(kind));
}
public List<UserActivity> getByUserId(String userId) {
return userActivityRepository.findAllByUser_Card_ExtId(Long.parseLong(userId));
}
}

View File

@ -1,49 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserCharacterRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharacter;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserCharacterService {
private final UserCharacterRepository userCharacterRepository;
@Autowired
public UserCharacterService(UserCharacterRepository userCharacterRepository) {
this.userCharacterRepository = userCharacterRepository;
}
public UserCharacter save(UserCharacter userCharacter) {
return userCharacterRepository.save(userCharacter);
}
public List<UserCharacter> saveAll(Iterable<UserCharacter> userCharacter) {
return userCharacterRepository.saveAll(userCharacter);
}
public List<UserCharacter> getByUserId(String userId) {
return userCharacterRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
public Page<UserCharacter> getByUserId(String userId, int pageNumber, int maxCount) {
Pageable pageable = PageRequest.of(pageNumber, maxCount);
return userCharacterRepository.findByUser_Card_ExtId(Long.parseLong(userId), pageable);
}
public Optional<UserCharacter> getByUserAndCharacterId(UserData user, int characterId) {
return userCharacterRepository.findTopByUserAndCharacterIdOrderByIdDesc(user, characterId);
}
}

View File

@ -1,39 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserChargeRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCharge;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserChargeService {
private final UserChargeRepository userChargeRepository;
public UserChargeService(UserChargeRepository userChargeRepository) {
this.userChargeRepository = userChargeRepository;
}
public UserCharge save(UserCharge userCharge) {
return userChargeRepository.save(userCharge);
}
public List<UserCharge> saveAll(List<UserCharge> newUserChargeList) {
return userChargeRepository.saveAll(newUserChargeList);
}
public List<UserCharge> getByUserId(String userId) {
return userChargeRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
public Optional<UserCharge> getByUserAndChargeId(UserData user, int chargeId) {
return userChargeRepository.findByUserAndChargeId(user, chargeId);
}
}

View File

@ -1,48 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserCourseRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserCourse;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserCourseService {
private final UserCourseRepository userCourseRepository;
@Autowired
public UserCourseService(UserCourseRepository userCourseRepository) {
this.userCourseRepository = userCourseRepository;
}
public UserCourse save(UserCourse userCourse) {
return userCourseRepository.save(userCourse);
}
public List<UserCourse> saveAll(Iterable<UserCourse> userMusicDetail) {
return userCourseRepository.saveAll(userMusicDetail);
}
public List<UserCourse> getByUserId(String userId) {
return userCourseRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
public Page<UserCourse> getByUserId(String userId, int pageNum, int maxCount) {
Pageable page = PageRequest.of(pageNum, maxCount);
return userCourseRepository.findByUser_Card_ExtId(Long.parseLong(userId), page);
}
public Optional<UserCourse> getByUserAndCourseId(UserData user, int courseId) {
return userCourseRepository.findTopByUserAndCourseIdOrderByIdDesc(user, courseId);
}
}

View File

@ -1,35 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserDataExRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDataEx;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserDataExService {
private final UserDataExRepository userDataExRepository;
@Autowired
public UserDataExService(UserDataExRepository userDataExRepository) {
this.userDataExRepository = userDataExRepository;
}
public UserDataEx save(UserDataEx userDataEx) {
return userDataExRepository.save(userDataEx);
}
public Optional<UserDataEx> getByUser(UserData user) {
return userDataExRepository.findByUser(user);
}
public Optional<UserDataEx> getByExtId(String userId) {
return userDataExRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
}

View File

@ -1,45 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserDataRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.general.model.Card;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserDataService {
private final UserDataRepository userDataRepository;
@Autowired
public UserDataService(UserDataRepository userDataRepository) {
this.userDataRepository = userDataRepository;
}
public UserData saveUserData(UserData userData) {
return userDataRepository.save(userData);
}
public UserData saveAndFlushUserData(UserData userData) {
return userDataRepository.saveAndFlush(userData);
}
public Optional<UserData> getUserByExtId(String aimeId) {
return userDataRepository.findByCard_ExtId(Long.parseLong(aimeId));
}
public Optional<UserData> getUserByCard(Card card) {
return userDataRepository.findByCard(card);
}
public void updateLoginTime(UserData userData) {
userData.setLastLoginDate(LocalDateTime.now());
userDataRepository.save(userData);
}
}

View File

@ -1,40 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserDuelRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserDuel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserDuelService {
private final UserDuelRepository userDuelRepository;
@Autowired
public UserDuelService(UserDuelRepository userDuelRepository) {
this.userDuelRepository = userDuelRepository;
}
public Optional<UserDuel> getByUserAndDuelId(UserData user, int duelId) {
return userDuelRepository.findTopByUserAndDuelIdOrderByIdDesc(user, duelId);
}
public UserDuel save(UserDuel userDuel) {
return userDuelRepository.save(userDuel);
}
public List<UserDuel> saveAll(Iterable<UserDuel> userDuel) {
return userDuelRepository.saveAll(userDuel);
}
public List<UserDuel> getByUserId(String userId) {
return userDuelRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
}

View File

@ -1,35 +0,0 @@
package icu.samnyan.aqua.sega.chunithm.service;
import icu.samnyan.aqua.sega.chunithm.dao.userdata.UserGameOptionExRepository;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserData;
import icu.samnyan.aqua.sega.chunithm.model.userdata.UserGameOptionEx;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Optional;
/**
* @author samnyan (privateamusement@protonmail.com)
*/
@Service
public class UserGameOptionExService {
private final UserGameOptionExRepository userGameOptionExRepository;
@Autowired
public UserGameOptionExService(UserGameOptionExRepository userGameOptionExRepository) {
this.userGameOptionExRepository = userGameOptionExRepository;
}
public UserGameOptionEx save(UserGameOptionEx userGameOptionEx) {
return userGameOptionExRepository.save(userGameOptionEx);
}
public Optional<UserGameOptionEx> getByUser(UserData userData) {
return userGameOptionExRepository.findByUser(userData);
}
public Optional<UserGameOptionEx> getByUserId(String userId) {
return userGameOptionExRepository.findByUser_Card_ExtId(Long.parseLong(userId));
}
}

Some files were not shown because too many files have changed in this diff Show More