implement import systems from eddb

client/src/main/java/ru/trader/controllers/MainController.java

@@ -11,7 +11,9 @@ import org.xml.sax.SAXException;
 import ru.trader.Main;
 import ru.trader.ServicesManager;
 import ru.trader.World;
+import ru.trader.eddb.EDDBParser;
 import ru.trader.model.*;
+import ru.trader.services.ImportTask;
 import ru.trader.services.MaddavoParserTask;
 import ru.trader.services.PowerPlayParserTask;
 import ru.trader.view.support.Localization;
@@ -327,6 +329,15 @@ public class MainController {
 
     }
 
+    @FXML
+    private void importEDDBSystems() {
+        chooseFile(new FileChooser.ExtensionFilter("EDDB Systems file (systems*.json)","systems*.json"), file -> {
+            EDDBParser parser = EDDBParser.createSystemParser(file);
+            ImportTask task = new ImportTask(parser, World.getMarket());
+            Screeners.showProgress(Localization.getString("message.import.systems"), task, () -> ViewUtils.doFX(this::reload));
+        });
+    }
+
 
     private void chooseFile(FileChooser.ExtensionFilter filter, Consumer<File> action) {
         FileChooser fileChooser = new FileChooser();

client/src/main/java/ru/trader/services/ImportTask.java

@@ -0,0 +1,29 @@
+package ru.trader.services;
+
+import javafx.concurrent.Task;
+import ru.trader.core.Market;
+import ru.trader.store.imp.Importer;
+
+
+public class ImportTask extends Task<Void> {
+
+    private final Market market;
+    private final Importer importer;
+
+    public ImportTask(Importer importer, Market market) {
+        this.importer = importer;
+        this.market = market;
+    }
+
+    @Override
+    protected void cancelled() {
+        importer.cancel();
+    }
+
+    @Override
+    protected Void call() throws Exception {
+        importer.imp(market);
+        return null;
+    }
+
+}

client/src/main/resources/view/main.fxml

@@ -22,6 +22,9 @@
                        <MenuItem text="StarSystem" onAction="#importPowerPlaySystems"/>
                        <MenuItem text="Prediction" onAction="#importPowerPlayPrediction"/>
                    </Menu>
+                   <Menu text="EDDB">
+                       <MenuItem text="%market.systems" onAction="#importEDDBSystems"/>
+                   </Menu>
                    <MenuItem text="XML" onAction="#importWorld"/>
                    <MenuItem text="EDCE JSON" onAction="#importEDCE"/>
                </Menu>

core/src/main/java/ru/trader/core/POWER_STATE.java

@@ -3,11 +3,11 @@ package ru.trader.core;
 public enum POWER_STATE {
     CONTROL, EXPLOITED, EXPANSION, NONE, CONTESTED, HEADQUARTERS, BLOCKED, TURMOIL;
 
-    boolean isControl(){
+    public boolean isControl(){
         return this == CONTROL || this == HEADQUARTERS || this == TURMOIL;
     }
 
-    boolean isExploited(){
+    public boolean isExploited(){
         return this == EXPLOITED || this == BLOCKED;
     }
 }

utils/src/main/java/ru/trader/eddb/EDDBConverter.java

@@ -0,0 +1,98 @@
+package ru.trader.eddb;
+
+
+import org.jetbrains.annotations.Nullable;
+import ru.trader.core.*;
+
+public class EDDBConverter {
+
+    @Nullable
+    public static FACTION asAlliance(int id){
+        switch (id){
+            case 1: return FACTION.ALLIANCE;
+            case 2: return FACTION.EMPIRE;
+            case 3: return FACTION.FEDERATION;
+            case 4: return FACTION.INDEPENDENT;
+            case 5: return FACTION.NONE;
+        }
+        return null;
+    }
+
+    @Nullable
+    public static GOVERNMENT asGovernment(int id){
+        switch (id){
+            case 16: return GOVERNMENT.ANARCHY;
+            case 32: return GOVERNMENT.COMMUNISM;
+            case 48: return GOVERNMENT.CONFEDERACY;
+            case 64: return GOVERNMENT.CORPORATE;
+            case 80: return GOVERNMENT.COOPERATIVE;
+            case 96: return GOVERNMENT.DEMOCRACY;
+            case 112: return GOVERNMENT.DICTATORSHIP;
+            case 128: return GOVERNMENT.FEUDAL;
+            case 133: return GOVERNMENT.IMPERIAL;
+            case 144: return GOVERNMENT.PATRONAGE;
+            case 150: return GOVERNMENT.PRISON_COLONY;
+            case 160: return GOVERNMENT.THEOCRACY;
+            case 176: return GOVERNMENT.NONE;
+        }
+        return null;
+    }
+
+
+    @Nullable
+    public static ECONOMIC_TYPE asEconomic(int id){
+    switch (id){
+        case 1: return ECONOMIC_TYPE.AGRICULTURE;
+        case 2: return ECONOMIC_TYPE.EXTRACTION;
+        case 3: return ECONOMIC_TYPE.HIGH_TECH;
+        case 4: return ECONOMIC_TYPE.INDUSTRIAL;
+        case 5: return ECONOMIC_TYPE.MILITARY;
+        case 6: return ECONOMIC_TYPE.REFINERY;
+        case 7: return ECONOMIC_TYPE.SERVICE;
+        case 8: return ECONOMIC_TYPE.TERRAFORMING;
+        case 9: return ECONOMIC_TYPE.TOURISM;
+        case 11: return ECONOMIC_TYPE.COLONY;
+        case 10: return ECONOMIC_TYPE.NONE;
+    }
+    return null;
+}
+
+    @Nullable
+    public static POWER asPower(int id) {
+        switch (id) {
+            case 1:
+                return POWER.MAHON;
+            case 2:
+                return POWER.WINTERS;
+            case 3:
+                return POWER.HUDSON;
+            case 4:
+                return POWER.TORVAL;
+            case 5:
+                return POWER.LAVIGNY_DUVAL;
+            case 6:
+                return POWER.DUVAL;
+            case 7:
+                return POWER.PATREUS;
+            case 8:
+                return POWER.DELAINE;
+            case 9:
+                return POWER.YONG_RUI;
+            case 10:
+                return POWER.ANTAL;
+            case 11:
+                return POWER.GROM;
+        }
+        return null;
+    }
+
+    @Nullable
+    public static POWER_STATE asPowerState(int id){
+        switch (id){
+            case 16: return POWER_STATE.CONTROL;
+            case 32: return POWER_STATE.EXPLOITED;
+            case 64: return POWER_STATE.EXPANSION;
+        }
+        return null;
+    }
+}

utils/src/main/java/ru/trader/eddb/EDDBParser.java

@@ -0,0 +1,81 @@
+package ru.trader.eddb;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.trader.eddb.entities.EDDBSystemData;
+import ru.trader.store.imp.AbstractImporter;
+import ru.trader.store.imp.entities.StarSystemData;
+
+import java.io.File;
+import java.io.IOException;
+
+public class EDDBParser extends AbstractImporter {
+    private final static Logger LOG = LoggerFactory.getLogger(EDDBParser.class);
+    private final FILE_TYPE type;
+    private final File file;
+    private JsonParser parser;
+    private final ObjectMapper mapper;
+    private EDDBSystemData next;
+
+    private EDDBParser(File file, FILE_TYPE type) {
+        super();
+        this.type = type;
+        this.file = file;
+        this.mapper = new ObjectMapper();
+    }
+
+
+    @Override
+    protected void before() throws IOException {
+        parser = mapper.getFactory().createParser(file);
+    }
+
+    @Override
+    protected void after() throws IOException {
+        parser.close();
+    }
+
+    @Override
+    public boolean next() throws IOException {
+        readNext();
+        return next != null;
+    }
+
+    @Override
+    public StarSystemData getSystem() {
+        return next;
+    }
+
+    private void readNext() throws IOException {
+        JsonToken token;
+        next = null;
+        while ((token = parser.nextToken()) != null){
+            if (token == JsonToken.START_OBJECT){
+                JsonNode node = parser.readValueAsTree();
+                next = new EDDBSystemData(node, type);
+                break;
+            }
+        }
+    }
+
+    public static EDDBParser createSystemParser(File file){
+        return new EDDBParser(file, FILE_TYPE.SYSTEMS);
+    }
+
+    public enum FILE_TYPE {
+        SYSTEMS, STATIONS;
+
+        public boolean hasSystemData(){
+            return this == SYSTEMS;
+        }
+
+        public boolean hasStationsData(){
+            return this == STATIONS;
+        }
+    }
+
+}

utils/src/main/java/ru/trader/eddb/entities/EDDBSystemData.java

@@ -0,0 +1,125 @@
+package ru.trader.eddb.entities;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.trader.core.FACTION;
+import ru.trader.core.GOVERNMENT;
+import ru.trader.eddb.EDDBConverter;
+import ru.trader.eddb.EDDBParser;
+import ru.trader.store.imp.ImportDataError;
+import ru.trader.store.imp.entities.StarSystemDataBase;
+import ru.trader.store.imp.entities.StationData;
+
+import java.util.Collection;
+
+
+public class EDDBSystemData extends StarSystemDataBase {
+    private final static Logger LOG = LoggerFactory.getLogger(EDDBSystemData.class);
+
+    private final JsonNode node;
+    private final EDDBParser.FILE_TYPE type;
+
+    public EDDBSystemData(JsonNode node, EDDBParser.FILE_TYPE type) {
+        this.node = node;
+        this.type = type;
+    }
+
+    @Override
+    public String getName() {
+        String name = null;
+        JsonNode n = node.get("name");
+        if (n != null) name = n.asText();
+        if (name == null){
+            throw new ImportDataError("EDDB entry don't have system name");
+        }
+        return name;
+    }
+
+    @Override
+    public double getX() {
+        if (!type.hasSystemData()) return super.getX();
+        Double x = null;
+        JsonNode n = node.get("x");
+        if (n != null) x = n.asDouble();
+        if (x == null){
+            throw new ImportDataError("EDDB entry don't have X coordination");
+        }
+        return x;
+    }
+
+    @Override
+    public double getY() {
+        if (!type.hasSystemData()) return super.getY();
+        Double y = null;
+        JsonNode n = node.get("y");
+        if (n != null) y = n.asDouble();
+        if (y == null){
+            throw new ImportDataError("EDDB entry don't have Y coordination");
+        }
+        return y;
+    }
+
+    @Override
+    public double getZ() {
+        if (!type.hasSystemData()) return super.getZ();
+        Double z = null;
+        JsonNode n = node.get("z");
+        if (n != null) z = n.asDouble();
+        if (z == null){
+            throw new ImportDataError("EDDB entry don't have Z coordination");
+        }
+        return z;
+    }
+
+    @Nullable
+    @Override
+    public Long getPopulation() {
+        if (!type.hasSystemData()) return super.getPopulation();
+        Long population = null;
+        JsonNode n = node.get("population");
+        if (n != null) population = n.asLong();
+        if (population == null){
+            throw new ImportDataError("EDDB entry don't have population");
+        }
+        return population;
+    }
+
+    @Nullable
+    @Override
+    public FACTION getFaction() {
+        if (!type.hasSystemData()) return super.getFaction();
+        FACTION faction = null;
+        JsonNode n = node.get("allegiance_id");
+        if (n != null){
+            faction = EDDBConverter.asAlliance(n.asInt());
+            if (faction == null){
+                LOG.warn("Unknown allegiance eddb id: {}", n.asInt());
+            }
+        }
+        return faction;
+    }
+
+    @Nullable
+    @Override
+    public GOVERNMENT getGovernment() {
+        if (!type.hasSystemData()) return super.getGovernment();
+        GOVERNMENT government = null;
+        JsonNode n = node.get("government_id");
+        if (n != null){
+            government = EDDBConverter.asGovernment(n.asInt());
+            if (government == null){
+                LOG.warn("Unknown government eddb id: {}", n.asInt());
+            }
+        }
+        return government;
+    }
+
+    @Nullable
+    @Override
+    public Collection<StationData> getStations() {
+        if (!type.hasStationsData()) return super.getStations();
+        return super.getStations();
+    }
+}

utils/src/main/java/ru/trader/powerplay/PPParser.java

@@ -73,10 +73,20 @@ public class PPParser {
         String starSystemName = getName(values[0]);
         POWER power = getPower(values[1]);
         POWER_STATE state = getState(values[3]);
+        String upkeep = values[4];
+        String income = values[6];
         if (starSystemName == null || power == null || state == null) return;
-        if (state == POWER_STATE.CONTROL || state == POWER_STATE.EXPANSION){
+        if (state.isControl()){
             Place place = market.get(starSystemName);
             if (place != null){
+                if (upkeep != null){
+                    long value = Long.valueOf(upkeep);
+                    if (value > 0) place.setUpkeep(value);
+                }
+                if (income != null){
+                    long value = Long.valueOf(income);
+                    if (value > 0) place.setIncome(value);
+                }
                 controllingSystems.add(new PowerData(place, power, state));
             } else {
                 LOG.warn("Not found system {} for import powerplay data", starSystemName);
@@ -143,14 +153,13 @@ public class PPParser {
             case "control": return POWER_STATE.CONTROL;
             case "contested": return POWER_STATE.CONTESTED;
             case "takingControl": return POWER_STATE.CONTROL;
-            case "turmoil": return POWER_STATE.NONE;
+            case "turmoil": return POWER_STATE.TURMOIL;
             default:
                 LOG.warn("Unknown power state: {}", value);
         }
         return null;
     }
 
-    private final static double CONTROLLING_RADIUS = 15;
     private void updatePowerState(){
         if (controllingSystems.isEmpty()) return;
         for (Place starSystem : market.get()) {
@@ -164,8 +173,8 @@ public class PPParser {
                         starSystem.setPower(powerData.power, powerData.state);
                     }
                 } else {
-                    if (powerData.state != POWER_STATE.CONTROL) continue;
+                    if (!powerData.state.isControl()) continue;
-                    if (starSystem.getDistance(powerData.starSystem) <= CONTROLLING_RADIUS){
+                    if (starSystem.getDistance(powerData.starSystem) <= Market.CONTROLLING_RADIUS){
                         if (starSystem.getPowerState() == POWER_STATE.EXPLOITED){
                             if (starSystem.getPower() != powerData.power){
                                 starSystem.setPower(powerData.power, POWER_STATE.CONTESTED);

utils/src/main/java/ru/trader/store/imp/AbstractImporter.java

@@ -5,17 +5,22 @@ import org.slf4j.LoggerFactory;
 import ru.trader.core.*;
 import ru.trader.store.imp.entities.*;
 
+import java.io.IOException;
 import java.util.*;
 import java.util.function.Predicate;
 
 public abstract class AbstractImporter implements Importer {
     private final static Logger LOG = LoggerFactory.getLogger(AbstractImporter.class);
     private final EnumSet<IMPORT_FLAG> flags;
+    private boolean canceled;
 
     protected AbstractImporter() {
         this.flags = EnumSet.copyOf(IMPORT_FLAG.ADD_AND_UPDATE);
     }
 
+    protected abstract void before() throws IOException;
+    protected abstract void after() throws IOException;
+
     @Override
     public void addFlag(IMPORT_FLAG flag) {
         flags.add(flag);
@@ -33,8 +38,18 @@ public abstract class AbstractImporter implements Importer {
     }
 
     @Override
-    public void imp(Market market){
+    public void cancel(){
+        this.canceled = true;
+    }
+
+    @Override
+    public void imp(Market market) throws IOException {
+        canceled = false;
+        before();
+        market.startBatch();
+        try {
             while (next()) {
+                if (canceled) break;
                 StarSystemData systemData = getSystem();
                 Place system = impSystem(market, systemData);
                 if (system != null) {
@@ -44,6 +59,10 @@ public abstract class AbstractImporter implements Importer {
                     LOG.warn("System {} not found", systemData.getName());
                 }
             }
+        } finally {
+            market.doBatch();
+            after();
+        }
     }
 
     protected Place impSystem(Market market, StarSystemData data){
@@ -65,6 +84,9 @@ public abstract class AbstractImporter implements Importer {
                 (data.getX() != system.getX() || data.getY() != system.getY() || data.getZ() != system.getZ())){
             system.setPosition(data.getX(), data.getY(), data.getZ());
         }
+        if (data.getPopulation() != null){
+            system.setPopulation(data.getPopulation());
+        }
         if (data.getFaction() != null){
             system.setFaction(data.getFaction());
         }
@@ -74,6 +96,12 @@ public abstract class AbstractImporter implements Importer {
         if (data.getPower() != null && data.getPowerState() != null) {
             system.setPower(data.getPower(), data.getPowerState());
         }
+        if (data.getUpkeep() != null && data.getUpkeep() > 0) {
+            system.setUpkeep(data.getUpkeep());
+        }
+        if (data.getIncome() != null && data.getIncome() > 0) {
+            system.setIncome(data.getIncome());
+        }
     }
 
     protected void impStations(Market market, Place system, Collection<StationData> stations){

utils/src/main/java/ru/trader/store/imp/Importer.java

@@ -3,6 +3,7 @@ package ru.trader.store.imp;
 import ru.trader.core.Market;
 import ru.trader.store.imp.entities.StarSystemData;
 
+import java.io.IOException;
 import java.util.EnumSet;
 
 public interface Importer {
@@ -12,11 +13,11 @@ public interface Importer {
     void removeFlag(IMPORT_FLAG flag);
     void setFlags(EnumSet<IMPORT_FLAG> flags);
 
-
+    void cancel();
-    boolean next();
+    boolean next() throws IOException;
     StarSystemData getSystem();
 
-    void imp(Market market);
+    void imp(Market market) throws IOException;
 
 
 }

utils/src/main/java/ru/trader/store/imp/entities/StarSystemData.java

@@ -17,6 +17,8 @@ public interface StarSystemData {
     double getY();
     double getZ();
 
+    Long getPopulation();
+
     @Nullable
     FACTION getFaction();
     @Nullable
@@ -26,6 +28,9 @@ public interface StarSystemData {
     @Nullable
     POWER_STATE getPowerState();
 
+    Long getUpkeep();
+    Long getIncome();
+
     @Nullable
     Collection<StationData> getStations();
 }

utils/src/main/java/ru/trader/store/imp/entities/StarSystemDataBase.java

@@ -29,6 +29,12 @@ public abstract class StarSystemDataBase implements StarSystemData {
         return Double.NaN;
     }
 
+    @Nullable
+    @Override
+    public Long getPopulation() {
+        return null;
+    }
+
     @Nullable
     @Override
     public FACTION getFaction() {
@@ -53,6 +59,18 @@ public abstract class StarSystemDataBase implements StarSystemData {
         return null;
     }
 
+    @Nullable
+    @Override
+    public Long getUpkeep() {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public Long getIncome() {
+        return null;
+    }
+
     @Nullable
     @Override
     public Collection<StationData> getStations() {

utils/src/test/resources/eddb/systems.json

@@ -0,0 +1,132 @@
+[
+  {
+    "id": 1,
+    "edsm_id": 12695,
+    "name": "1 G. Caeli",
+    "x": 80.90625,
+    "y": -83.53125,
+    "z": -30.8125,
+    "population": 6544826,
+    "is_populated": true,
+    "government_id": 144,
+    "government": "Patronage",
+    "allegiance_id": 2,
+    "allegiance": "Empire",
+    "state_id": 80,
+    "state": "None",
+    "security_id": 32,
+    "security": "Medium",
+    "primary_economy_id": 4,
+    "primary_economy": "Industrial",
+    "power": null,
+    "power_state": null,
+    "power_state_id": null,
+    "needs_permit": false,
+    "updated_at": 1477792352,
+    "simbad_ref": "",
+    "controlling_minor_faction_id": 31816,
+    "controlling_minor_faction": "1 G. Caeli Empire League",
+    "reserve_type_id": 3,
+    "reserve_type": "Common",
+    "minor_faction_presences": [
+      {
+        "minor_faction_id": 31816,
+        "state_id": 80,
+        "influence": null,
+        "state": "None"
+      },
+      {
+        "minor_faction_id": 54517,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 54518,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 54519,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 74917,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 40897,
+        "state_id": 16,
+        "influence": null,
+        "state": "Boom"
+      }
+    ]
+  },
+  {
+    "id": 2,
+    "edsm_id": 3979,
+    "name": "1 Geminorum",
+    "x": 19.78125,
+    "y": 3.5625,
+    "z": -153.8125,
+    "population": 141727,
+    "is_populated": true,
+    "government_id": 96,
+    "government": "Democracy",
+    "allegiance_id": 3,
+    "allegiance": "Federation",
+    "state_id": 72,
+    "state": "Outbreak",
+    "security_id": 32,
+    "security": "Medium",
+    "primary_economy_id": 8,
+    "primary_economy": "Terraforming",
+    "power": null,
+    "power_state": null,
+    "power_state_id": null,
+    "needs_permit": false,
+    "updated_at": 1477865367,
+    "simbad_ref": "1 Geminorum",
+    "controlling_minor_faction_id": 56677,
+    "controlling_minor_faction": "1 Geminorum Liberals",
+    "reserve_type_id": 1,
+    "reserve_type": "Pristine",
+    "minor_faction_presences": [
+      {
+        "minor_faction_id": 56677,
+        "state_id": 72,
+        "influence": null,
+        "state": "Outbreak"
+      },
+      {
+        "minor_faction_id": 56678,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 56679,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      },
+      {
+        "minor_faction_id": 56680,
+        "state_id": 80,
+        "influence": null,
+        "state": "None"
+      },
+      {
+        "minor_faction_id": 56681,
+        "state_id": null,
+        "influence": null,
+        "state": null
+      }
+    ]
+  }
+]