568 lines
19 KiB
Java
568 lines
19 KiB
Java
package world.bentobox.challenges;
|
|
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.io.OutputStreamWriter;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Paths;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.bukkit.World;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
import com.google.gson.annotations.Expose;
|
|
|
|
import world.bentobox.bentobox.api.user.User;
|
|
import world.bentobox.bentobox.database.json.BentoboxTypeAdapterFactory;
|
|
import world.bentobox.bentobox.database.objects.DataObject;
|
|
import world.bentobox.bentobox.util.Util;
|
|
import world.bentobox.challenges.database.object.Challenge;
|
|
import world.bentobox.challenges.database.object.ChallengeLevel;
|
|
import world.bentobox.challenges.utils.Utils;
|
|
|
|
|
|
/**
|
|
* Imports challenges
|
|
* @author BONNe1704
|
|
*
|
|
*/
|
|
public class ChallengesImportManager
|
|
{
|
|
/**
|
|
* Import challenges from default.json
|
|
* @param challengesAddon
|
|
*/
|
|
public ChallengesImportManager(ChallengesAddon challengesAddon)
|
|
{
|
|
this.addon = challengesAddon;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Default Challenge Loader
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* This method loads default challenges into memory.
|
|
* @param user User who calls default challenge loading
|
|
* @param world Target world.
|
|
* @return <code>true</code> if everything was successful, otherwise <code>false</code>.
|
|
*/
|
|
public boolean loadDefaultChallenges(User user, World world)
|
|
{
|
|
ChallengesManager manager = this.addon.getChallengesManager();
|
|
|
|
// If exist any challenge or level that is bound to current world, then do not load default challenges.
|
|
if (manager.hasAnyChallengeData(world.getName()))
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.errors.exist-challenges-or-levels");
|
|
}
|
|
else
|
|
{
|
|
this.addon.logWarning("challenges.errors.exist-challenges-or-levels");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// default configuration should be removed.
|
|
// user made configuration should not!.
|
|
boolean removeAtEnd =
|
|
!Files.exists(Paths.get(this.addon.getDataFolder().getPath() + "/default.json"));
|
|
|
|
// Safe json configuration to Challenges folder.
|
|
this.addon.saveResource("default.json", false);
|
|
|
|
try
|
|
{
|
|
// This prefix will be used to all challenges. That is a unique way how to separate challenged for
|
|
// each game mode.
|
|
String uniqueIDPrefix = Utils.getGameMode(world) + "_";
|
|
DefaultDataHolder defaultChallenges = new DefaultJSONHandler(this.addon).loadObject();
|
|
if (defaultChallenges != null) {
|
|
// All new challenges should get correct ID. So we need to map it to loaded challenges.
|
|
defaultChallenges.getChallengeList().forEach(challenge -> {
|
|
// Set correct challenge ID
|
|
challenge.setUniqueId(uniqueIDPrefix + challenge.getUniqueId());
|
|
// Set up correct level ID if it is necessary
|
|
if (!challenge.getLevel().isEmpty())
|
|
{
|
|
challenge.setLevel(uniqueIDPrefix + challenge.getLevel());
|
|
}
|
|
// Load challenge in memory
|
|
manager.loadChallenge(challenge, false, user, user == null);
|
|
});
|
|
|
|
defaultChallenges.getLevelList().forEach(challengeLevel -> {
|
|
// Set correct level ID
|
|
challengeLevel.setUniqueId(uniqueIDPrefix + challengeLevel.getUniqueId());
|
|
// Set correct world name
|
|
challengeLevel.setWorld(Util.getWorld(world).getName());
|
|
// Reset names for all challenges.
|
|
challengeLevel.setChallenges(challengeLevel.getChallenges().stream().
|
|
map(challenge -> uniqueIDPrefix + challenge).
|
|
collect(Collectors.toSet()));
|
|
// Load level in memory
|
|
manager.loadLevel(challengeLevel, false, user, user == null);
|
|
});
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
return false;
|
|
}
|
|
|
|
this.addon.getChallengesManager().save();
|
|
|
|
if (removeAtEnd)
|
|
{
|
|
// Remove default.yml file from resources to avoid interacting with it.
|
|
return new File(this.addon.getDataFolder(), "default.json").delete();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method loads downloaded challenges into memory.
|
|
* @param user User who calls downloaded challenge loading
|
|
* @param world Target world.
|
|
* @param downloadString String that need to be loaded via DefaultDataHolder.
|
|
* @return <code>true</code> if everything was successful, otherwise <code>false</code>.
|
|
*/
|
|
public boolean loadDownloadedChallenges(User user, World world, String downloadString)
|
|
{
|
|
ChallengesManager manager = this.addon.getChallengesManager();
|
|
|
|
// If exist any challenge or level that is bound to current world, then do not load default challenges.
|
|
if (manager.hasAnyChallengeData(world.getName()))
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.errors.exist-challenges-or-levels");
|
|
}
|
|
else
|
|
{
|
|
this.addon.logWarning("challenges.errors.exist-challenges-or-levels");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
// This prefix will be used to all challenges. That is a unique way how to separate challenged for
|
|
// each game mode.
|
|
String uniqueIDPrefix = Utils.getGameMode(world) + "_";
|
|
DefaultDataHolder downloadedChallenges = new DefaultJSONHandler(this.addon).loadWebObject(downloadString);
|
|
|
|
// All new challenges should get correct ID. So we need to map it to loaded challenges.
|
|
downloadedChallenges.getChallengeList().forEach(challenge -> {
|
|
// Set correct challenge ID
|
|
challenge.setUniqueId(uniqueIDPrefix + challenge.getUniqueId());
|
|
// Set up correct level ID if it is necessary
|
|
if (!challenge.getLevel().isEmpty())
|
|
{
|
|
challenge.setLevel(uniqueIDPrefix + challenge.getLevel());
|
|
}
|
|
// Load challenge in memory
|
|
manager.loadChallenge(challenge, false, user, user == null);
|
|
});
|
|
|
|
downloadedChallenges.getLevelList().forEach(challengeLevel -> {
|
|
// Set correct level ID
|
|
challengeLevel.setUniqueId(uniqueIDPrefix + challengeLevel.getUniqueId());
|
|
// Set correct world name
|
|
challengeLevel.setWorld(Util.getWorld(world).getName());
|
|
// Reset names for all challenges.
|
|
challengeLevel.setChallenges(challengeLevel.getChallenges().stream().
|
|
map(challenge -> uniqueIDPrefix + challenge).
|
|
collect(Collectors.toSet()));
|
|
// Load level in memory
|
|
manager.loadLevel(challengeLevel, false, user, user == null);
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
addon.getPlugin().logStacktrace(e);
|
|
return false;
|
|
}
|
|
|
|
this.addon.getChallengesManager().save();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Default generation
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* Create method that can generate default challenge file from existing challenges in given world.
|
|
* This method will create default.json file in Challenges folder.
|
|
* @param user User who calls this method.
|
|
* @param world from which challenges must be stored.
|
|
* @param overwrite indicates if existing default.json file can be overwritten.
|
|
* @return <code>true</code> if everything was successful, otherwise <code>false</code>
|
|
*/
|
|
public boolean generateDefaultChallengeFile(User user, World world, boolean overwrite)
|
|
{
|
|
File defaultFile = new File(this.addon.getDataFolder(), "default.json");
|
|
|
|
if (defaultFile.exists())
|
|
{
|
|
if (overwrite)
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.messages.defaults-file-overwrite");
|
|
}
|
|
else
|
|
{
|
|
this.addon.logWarning("challenges.messages.defaults-file-overwrite");
|
|
}
|
|
|
|
defaultFile.delete();
|
|
}
|
|
else
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.errors.defaults-file-exist");
|
|
}
|
|
else
|
|
{
|
|
this.addon.logWarning("challenges.errors.defaults-file-exist");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
if (defaultFile.createNewFile())
|
|
{
|
|
String replacementString = Utils.getGameMode(world) + "_";
|
|
ChallengesManager manager = this.addon.getChallengesManager();
|
|
|
|
List<Challenge> challengeList = manager.getAllChallenges(world).
|
|
stream().
|
|
map(challenge -> {
|
|
// Use clone to avoid any changes in existing challenges.
|
|
Challenge clone = challenge.clone();
|
|
// Remove world name from challenge id.
|
|
clone.setUniqueId(challenge.getUniqueId().replaceFirst(replacementString, ""));
|
|
// Remove world name from level id.
|
|
clone.setLevel(challenge.getLevel().replaceFirst(replacementString, ""));
|
|
|
|
return clone;
|
|
}).
|
|
collect(Collectors.toList());
|
|
|
|
List<ChallengeLevel> levelList = manager.getLevels(world).
|
|
stream().
|
|
map(challengeLevel -> {
|
|
// Use clone to avoid any changes in existing levels.
|
|
ChallengeLevel clone = challengeLevel.clone();
|
|
// Remove world name from level ID.
|
|
clone.setUniqueId(challengeLevel.getUniqueId().replaceFirst(replacementString, ""));
|
|
// Remove world name.
|
|
clone.setWorld("");
|
|
// Challenges must be reassign, as they also contains world name.
|
|
clone.setChallenges(challengeLevel.getChallenges().stream().
|
|
map(challenge -> challenge.replaceFirst(replacementString, "")).
|
|
collect(Collectors.toSet()));
|
|
|
|
return clone;
|
|
}).
|
|
collect(Collectors.toList());
|
|
|
|
DefaultDataHolder defaultChallenges = new DefaultDataHolder();
|
|
defaultChallenges.setChallengeList(challengeList);
|
|
defaultChallenges.setLevelList(levelList);
|
|
defaultChallenges.setVersion(this.addon.getDescription().getVersion());
|
|
|
|
try (BufferedWriter writer = new BufferedWriter(
|
|
new OutputStreamWriter(new FileOutputStream(defaultFile), StandardCharsets.UTF_8))) {
|
|
writer.write(Objects.requireNonNull(
|
|
new DefaultJSONHandler(this.addon).toJsonString(defaultChallenges)));
|
|
}
|
|
}
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.errors.defaults-file-error");
|
|
}
|
|
|
|
this.addon.logError("Could not save json file: " + e.getMessage());
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
if (user.isPlayer())
|
|
{
|
|
user.sendMessage("challenges.messages.defaults-file-completed", "[world]", world.getName());
|
|
}
|
|
else
|
|
{
|
|
this.addon.logWarning("challenges.messages.defaults-file-completed");
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Private classes for default challenges
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* This Class allows to load default challenges and their levels as objects much easier.
|
|
*/
|
|
private static final class DefaultJSONHandler
|
|
{
|
|
/**
|
|
* This constructor inits JSON builder that will be used to parse challenges.
|
|
* @param addon Challenges Adddon
|
|
*/
|
|
DefaultJSONHandler(ChallengesAddon addon)
|
|
{
|
|
GsonBuilder builder = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().enableComplexMapKeySerialization();
|
|
// Register adapters
|
|
builder.registerTypeAdapterFactory(new BentoboxTypeAdapterFactory(addon.getPlugin()));
|
|
// Keep null in the database
|
|
builder.serializeNulls();
|
|
// Allow characters like < or > without escaping them
|
|
builder.disableHtmlEscaping();
|
|
|
|
this.addon = addon;
|
|
this.gson = builder.setPrettyPrinting().create();
|
|
}
|
|
|
|
|
|
/**
|
|
* This method returns json object that is parsed to string. Json object is made from given instance.
|
|
* @param instance Instance that must be parsed to json string.
|
|
* @return String that contains JSON information from instance object.
|
|
*/
|
|
String toJsonString(DefaultDataHolder instance)
|
|
{
|
|
// Null check
|
|
if (instance == null)
|
|
{
|
|
this.addon.logError("JSON database request to store a null. ");
|
|
return null;
|
|
}
|
|
|
|
return this.gson.toJson(instance);
|
|
}
|
|
|
|
|
|
/**
|
|
* This method creates and adds to list all objects from default.json file.
|
|
* @return List of all objects from default.json that is with T instance.
|
|
*/
|
|
DefaultDataHolder loadObject()
|
|
{
|
|
File defaultFile = new File(this.addon.getDataFolder(), "default.json");
|
|
|
|
try (InputStreamReader reader = new InputStreamReader(new FileInputStream(defaultFile), StandardCharsets.UTF_8))
|
|
{
|
|
DefaultDataHolder object = this.gson.fromJson(reader, DefaultDataHolder.class);
|
|
|
|
reader.close(); // NOSONAR Required to keep OS file handlers low and not rely on GC
|
|
|
|
return object;
|
|
}
|
|
catch (FileNotFoundException e)
|
|
{
|
|
this.addon.logError("Could not load file '" + defaultFile.getName() + "': File not found.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
this.addon.logError("Could not load objects " + defaultFile.getName() + " " + e.getMessage());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method creates and adds to list all objects from default.json file.
|
|
* @return List of all objects from default.json that is with T instance.
|
|
*/
|
|
DefaultDataHolder loadWebObject(String downloadedObject)
|
|
{
|
|
return this.gson.fromJson(downloadedObject, DefaultDataHolder.class);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Variables
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* Holds JSON builder object.
|
|
*/
|
|
private Gson gson;
|
|
|
|
/**
|
|
* Holds ChallengesAddon object.
|
|
*/
|
|
private ChallengesAddon addon;
|
|
}
|
|
|
|
|
|
/**
|
|
* This is simple object that will allow to store all current challenges and levels
|
|
* in single file.
|
|
*/
|
|
private static final class DefaultDataHolder implements DataObject
|
|
{
|
|
/**
|
|
* Default constructor. Creates object with empty lists.
|
|
*/
|
|
DefaultDataHolder()
|
|
{
|
|
this.challengeList = Collections.emptyList();
|
|
this.challengeLevelList = Collections.emptyList();
|
|
this.version = "";
|
|
}
|
|
|
|
|
|
/**
|
|
* This method returns stored challenge list.
|
|
* @return list that contains default challenges.
|
|
*/
|
|
List<Challenge> getChallengeList()
|
|
{
|
|
return challengeList;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method sets given list as default challenge list.
|
|
* @param challengeList new default challenge list.
|
|
*/
|
|
void setChallengeList(List<Challenge> challengeList)
|
|
{
|
|
this.challengeList = challengeList;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method returns list of default challenge levels.
|
|
* @return List that contains default challenge levels.
|
|
*/
|
|
List<ChallengeLevel> getLevelList()
|
|
{
|
|
return challengeLevelList;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method sets given list as default challenge level list.
|
|
* @param levelList new default challenge level list.
|
|
*/
|
|
void setLevelList(List<ChallengeLevel> levelList)
|
|
{
|
|
this.challengeLevelList = levelList;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method returns the version value.
|
|
* @return the value of version.
|
|
*/
|
|
public String getVersion()
|
|
{
|
|
return version;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method sets the version value.
|
|
* @param version the version new value.
|
|
*
|
|
*/
|
|
public void setVersion(String version)
|
|
{
|
|
this.version = version;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return default.json
|
|
*/
|
|
@Override
|
|
public String getUniqueId()
|
|
{
|
|
return "default.json";
|
|
}
|
|
|
|
|
|
/**
|
|
* @param uniqueId - unique ID the uniqueId to set
|
|
*/
|
|
@Override
|
|
public void setUniqueId(String uniqueId)
|
|
{
|
|
// method not used.
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Variables
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* Holds a list with default challenges.
|
|
*/
|
|
@Expose
|
|
private List<Challenge> challengeList;
|
|
|
|
/**
|
|
* Holds a list with default levels.
|
|
*/
|
|
@Expose
|
|
private List<ChallengeLevel> challengeLevelList;
|
|
|
|
/**
|
|
* Holds a variable that stores in which addon version file was made.
|
|
*/
|
|
@Expose
|
|
private String version;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Section: Variables
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
private ChallengesAddon addon;
|
|
} |