Voomra/trader
Archived
0
Fork 0
Code Activity

implement saving vendor filters, modify filter screen

Browse Source
This commit is contained in:
iMoHax
2016-03-16 16:56:49 +03:00
parent 10bdb62164
commit 63299d825c
10 changed files with 523 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
core/src/main/java/ru/trader/core/MarketFilter.java
View File

@@ -11,7 +11,10 @@ public class MarketFilter {
private Place center;
private double radius;
private double distance;
private final EnumSet<STATION_TYPE> types;
private final EnumSet<SERVICE_TYPE> services;
private final EnumSet<FACTION> factions;
private final EnumSet<GOVERNMENT> governments;
private final Collection<Vendor> excludes;
private final VendorFilter defaultVendorFilter;
private final HashMap<String, VendorFilter> customFilteredVendors;
@@ -21,7 +24,10 @@ public class MarketFilter {
}
public MarketFilter(VendorFilter defaultVendorFilter) {
this.types = EnumSet.noneOf(STATION_TYPE.class);
this.services = EnumSet.noneOf(SERVICE_TYPE.class);
this.factions = EnumSet.noneOf(FACTION.class);
this.governments = EnumSet.noneOf(GOVERNMENT.class);
this.excludes = new ArrayList<>();
this.customFilteredVendors = new HashMap<>();
this.defaultVendorFilter = defaultVendorFilter;
@@ -51,6 +57,22 @@ public class MarketFilter {
this.distance = distance;
}
public void add(STATION_TYPE type){
types.add(type);
}
public void remove(STATION_TYPE type){
types.remove(type);
}
public void clearTypes(){
types.clear();
}
public Collection<STATION_TYPE> getTypes(){
return types;
}
public void add(SERVICE_TYPE service){
services.add(service);
}
@@ -67,6 +89,14 @@ public class MarketFilter {
return services.contains(service);
}
public void clearServices(){
services.clear();
}
public Collection<SERVICE_TYPE> getServices(){
return services;
}
public void addExclude(Vendor vendor){
excludes.add(vendor);
}
@@ -83,6 +113,38 @@ public class MarketFilter {
return excludes;
}
public void add(FACTION faction){
factions.add(faction);
}
public void remove(FACTION faction){
factions.remove(faction);
}
public void clearFactions(){
factions.clear();
}
public Collection<FACTION> getFactions(){
return factions;
}
public void add(GOVERNMENT government){
governments.add(government);
}
public void remove(GOVERNMENT government){
governments.remove(government);
}
public void clearGovernments(){
governments.clear();
}
public Collection<GOVERNMENT> getGovernments(){
return governments;
}
public static String getVendorKey(Vendor vendor){
return vendor == null ? null : vendor.getFullName();
}
@@ -132,6 +194,12 @@ public class MarketFilter {
if (checkPlace && isFiltered(vendor.getPlace())) return true;
if (distance > 0 && vendor.getDistance() > distance) return true;
if (excludes.contains(vendor)) return true;
STATION_TYPE stationType = vendor.getType();
if (stationType != null && !types.isEmpty() && !types.contains(stationType)) return true;
FACTION faction = vendor.getFaction();
if (faction != null && !factions.isEmpty() && !factions.contains(faction)) return true;
GOVERNMENT government = vendor.getGovernment();
if (government != null && !governments.isEmpty() && !governments.contains(vendor.getGovernment())) return true;
for (SERVICE_TYPE service : services) {
if (!vendor.has(service)) return true;
}
@@ -205,7 +273,10 @@ public class MarketFilter {
"center=" + center +
", radius=" + radius +
", distance=" + distance +
", types=" + types +
", services=" + services +
", factions=" + factions +
", governments=" + governments +
", excludes=" + excludes +
'}';
}

223
core/src/main/java/ru/trader/store/json/FiltersStore.java Normal file
View File

@@ -0,0 +1,223 @@
package ru.trader.store.json;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.*;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
public class FiltersStore {
private static final Logger LOG = LoggerFactory.getLogger(FiltersStore.class);
private static final String DISABLE_FIELD = "disable";
private static final String CENTER_FIELD = "center";
private static final String RADIUS_FIELD = "radius";
private static final String DISTANCE_FIELD = "distance";
private static final String TYPES_FIELD = "types";
private static final String SERVICES_FIELD = "services";
private static final String FACTIONS_FIELD = "factions";
private static final String GOVERNMENTS_FIELD = "governments";
private static final String EXCLUDE_VENDORS_FIELD = "excludes";
private static final String SYSTEM_FIELD = "system";
private static final String STATION_FIELD = "station";
private static final String DEFAULT_VENDOR_FILTER_KEY = "default";
private static final String VENDOR_FILTERS_FIELD = "stations";
private static final String LEGAL_ONLY_FIELD = "legalOnly";
private static final String DONT_SELL_FIELD = "notSell";
private static final String DONT_BUY_FIELD = "notBuy";
private static final String SELL_FILTER_FIELD = "excludeSell";
private static final String BUY_FILTER_FIELD = "excludeBuy";
private final ObjectMapper objectMapper;
public FiltersStore(ObjectMapper objectMapper) {
this.objectMapper = objectMapper;
}
public void write(MarketFilter filter, File file) throws IOException {
try (JsonGenerator generator = objectMapper.getFactory().createGenerator(file, JsonEncoding.UTF8)){
write(filter, generator);
generator.flush();
}
}
private void write(MarketFilter filter, JsonGenerator generator) throws IOException {
generator.writeStartObject();
Place center = filter.getCenter();
generator.writeStringField(CENTER_FIELD, center != null ? center.getName() : "");
generator.writeNumberField(RADIUS_FIELD, filter.getRadius());
generator.writeNumberField(DISTANCE_FIELD, filter.getDistance());
generator.writeArrayFieldStart(TYPES_FIELD);
for (STATION_TYPE stationType : filter.getTypes()) {
generator.writeString(stationType.toString());
}
generator.writeEndArray();
generator.writeArrayFieldStart(SERVICES_FIELD);
for (SERVICE_TYPE service : filter.getServices()) {
generator.writeString(service.toString());
}
generator.writeEndArray();
generator.writeArrayFieldStart(FACTIONS_FIELD);
for (FACTION faction : filter.getFactions()) {
generator.writeString(faction.toString());
}
generator.writeEndArray();
generator.writeArrayFieldStart(GOVERNMENTS_FIELD);
for (GOVERNMENT government : filter.getGovernments()) {
generator.writeString(government.toString());
}
generator.writeEndArray();
generator.writeArrayFieldStart(EXCLUDE_VENDORS_FIELD);
for (Vendor vendor : filter.getExcludes()) {
generator.writeStartObject();
generator.writeStringField(SYSTEM_FIELD, vendor.getPlace().getName());
generator.writeStringField(STATION_FIELD, vendor.getName());
generator.writeEndObject();
}
generator.writeEndArray();
generator.writeObjectFieldStart(VENDOR_FILTERS_FIELD);
write(DEFAULT_VENDOR_FILTER_KEY, filter.getDefaultVendorFilter(), generator);
for (Map.Entry<String, VendorFilter> entry : filter.getVendorFilters().entrySet()) {
write(entry.getKey(), entry.getValue(), generator);
}
generator.writeEndObject();
generator.writeEndObject();
}
private void write(String key, VendorFilter filter, JsonGenerator generator) throws IOException {
generator.writeObjectFieldStart(key);
generator.writeBooleanField(DISABLE_FIELD, filter.isDisable());
generator.writeBooleanField(LEGAL_ONLY_FIELD, filter.isSkipIllegal());
generator.writeBooleanField(DONT_SELL_FIELD, filter.isDontSell());
generator.writeBooleanField(DONT_BUY_FIELD, filter.isDontBuy());
generator.writeArrayFieldStart(SELL_FILTER_FIELD);
for (Item item : filter.getSellExcludes()) {
generator.writeString(item.getName());
}
generator.writeEndArray();
generator.writeArrayFieldStart(BUY_FILTER_FIELD);
for (Item item : filter.getBuyExcludes()) {
generator.writeString(item.getName());
}
generator.writeEndArray();
generator.writeEndObject();
}
public MarketFilter read(Market market, File file) throws IOException {
MarketFilter filter = new MarketFilter();
if (!file.exists()){
LOG.warn("Don't exists filters file {}", file);
} else {
try (JsonParser parser = objectMapper.getFactory().createParser(file)){
read(filter, market, parser);
}
}
return filter;
}
private void read(MarketFilter filter, Market market, JsonParser parser) throws IOException {
JsonNode node = parser.readValueAsTree();
String placeName = node.get(CENTER_FIELD).asText();
if (!placeName.isEmpty()){
Place place = market.get(placeName);
if (place != null){
filter.setCenter(place);
} else {
LOG.warn("Parse filter error: Don't found system {}", placeName);
}
}
filter.setRadius(node.get(RADIUS_FIELD).asDouble());
filter.setDistance(node.get(DISTANCE_FIELD).asDouble());
Iterator<JsonNode> iterator = node.get(TYPES_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
STATION_TYPE value = STATION_TYPE.valueOf(n.asText());
filter.add(value);
}
iterator = node.get(SERVICES_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
SERVICE_TYPE value = SERVICE_TYPE.valueOf(n.asText());
filter.add(value);
}
iterator = node.get(FACTIONS_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
FACTION value = FACTION.valueOf(n.asText());
filter.add(value);
}
iterator = node.get(GOVERNMENTS_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
GOVERNMENT value = GOVERNMENT.valueOf(n.asText());
filter.add(value);
}
iterator = node.get(EXCLUDE_VENDORS_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
placeName = n.get(SYSTEM_FIELD).asText();
Place place = market.get(placeName);
if (place == null){
LOG.warn("Parse filter error: Don't found system {}", placeName);
} else {
String vendorName = n.get(STATION_FIELD).asText();
Vendor vendor = place.get(vendorName);
if (vendor == null){
LOG.warn("Parse filter error: Don't found vendor {} in system {}", vendorName, place);
} else {
filter.addExclude(vendor);
}
}
}
Iterator<Map.Entry<String,JsonNode>> fi = node.get(VENDOR_FILTERS_FIELD).fields();
while (fi.hasNext()){
Map.Entry<String,JsonNode> n = fi.next();
if (DEFAULT_VENDOR_FILTER_KEY.equals(n.getKey())){
VendorFilter vendorFilter = filter.getDefaultVendorFilter();
read(vendorFilter, market, n.getValue());
} else {
VendorFilter vendorFilter = new VendorFilter();
read(vendorFilter, market, n.getValue());
filter.addFilter(n.getKey(), vendorFilter);
}
}
}
private void read(VendorFilter filter, Market market, JsonNode node){
filter.setDisable(node.get(DISABLE_FIELD).asBoolean());
filter.setSkipIllegal(node.get(LEGAL_ONLY_FIELD).asBoolean());
filter.dontSell(node.get(DONT_SELL_FIELD).asBoolean());
filter.dontBuy(node.get(DONT_BUY_FIELD).asBoolean());
Iterator<JsonNode> iterator = node.get(SELL_FILTER_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
String itemName = n.asText();
Item item = market.getItem(itemName);
if (item == null){
LOG.warn("Parse filter error: Don't found item {}", itemName);
} else {
filter.addSellExclude(item);
}
}
iterator = node.get(BUY_FILTER_FIELD).elements();
while (iterator.hasNext()) {
JsonNode n = iterator.next();
String itemName = n.asText();
Item item = market.getItem(itemName);
if (item == null){
LOG.warn("Parse filter error: Don't found item {}", itemName);
} else {
filter.addBuyExclude(item);
}
}
}
}

27
core/src/main/java/ru/trader/store/json/JsonStore.java Normal file
View File

@@ -0,0 +1,27 @@
package ru.trader.store.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import ru.trader.core.Market;
import ru.trader.core.MarketFilter;
import java.io.File;
import java.io.IOException;
public class JsonStore {
private final ObjectMapper objectMapper;
private static final String FILTERS_FILE_NAME = "filters.cfg";
public JsonStore() {
objectMapper = new ObjectMapper();
}
public MarketFilter getFilter(Market market) throws IOException {
FiltersStore store = new FiltersStore(objectMapper);
return store.read(market, new File(FILTERS_FILE_NAME));
}
public void saveFilter(MarketFilter filter) throws IOException {
FiltersStore store = new FiltersStore(objectMapper);
store.write(filter, new File(FILTERS_FILE_NAME));
}
}

116
core/src/test/java/ru/trader/store/json/FiltersStoreTest.java Normal file
View File

@@ -0,0 +1,116 @@
package ru.trader.store.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import ru.trader.core.*;
import ru.trader.store.simple.Store;
import java.io.File;
import java.io.InputStream;
import java.util.Map;
public class FiltersStoreTest extends Assert {
private static final File file = new File("filters-test.json");
private static final ObjectMapper objectMapper = new ObjectMapper();
private Market world;
private Place ithaca;
private Place lhs3262;
private Place morgor;
private Place lhs3006;
private Item gold;
private Item tea;
@Before
public void setUp() throws Exception {
InputStream is = getClass().getResourceAsStream("/world.xml");
world = Store.loadFromFile(is);
gold = world.getItem("gold");
tea = world.getItem("tea");
ithaca = world.get("Ithaca");
lhs3262 = world.get("LHS 3262");
morgor = world.get("Morgor");
lhs3006 = world.get("LHS 3006");
}
private MarketFilter createFilter(){
Vendor ithaca_st = ithaca.get().iterator().next();
Vendor lhs3262_st = lhs3262.get().iterator().next();
Vendor lhs3006_st = lhs3006.get().iterator().next();
Vendor morgor_st = morgor.get().iterator().next();
MarketFilter filter = new MarketFilter();
filter.setCenter(ithaca);
filter.setRadius(15.22);
filter.setDistance(2456.44);
filter.add(STATION_TYPE.CORIOLIS_STARPORT);
filter.add(STATION_TYPE.ORBIS_STARPORT);
filter.add(SERVICE_TYPE.MARKET);
filter.add(SERVICE_TYPE.BLACK_MARKET);
filter.add(FACTION.EMPIRE);
filter.add(GOVERNMENT.ANARCHY);
filter.add(GOVERNMENT.COMMUNISM);
filter.addExclude(morgor_st);
filter.addExclude(ithaca_st);
VendorFilter vendorFilter = new VendorFilter();
vendorFilter.setDisable(true);
vendorFilter.setSkipIllegal(true);
vendorFilter.dontBuy(true);
vendorFilter.addSellExclude(gold);
vendorFilter.addSellExclude(tea);
vendorFilter.addBuyExclude(tea);
filter.addFilter(lhs3006_st, vendorFilter);
vendorFilter = filter.getDefaultVendorFilter();
vendorFilter.dontSell(true);
vendorFilter.addBuyExclude(gold);
vendorFilter = new VendorFilter();
vendorFilter.setSkipIllegal(true);
filter.addFilter(lhs3262_st, vendorFilter);
return filter;
}
@Test
public void testSaveLoadFilter() throws Exception {
MarketFilter filter = createFilter();
FiltersStore store = new FiltersStore(objectMapper);
store.write(filter, file);
MarketFilter actual = store.read(world, file);
assertFilter(filter, actual);
}
private void assertFilter(MarketFilter expected, MarketFilter actual){
assertEquals(expected.getCenter(), actual.getCenter());
assertEquals(expected.getRadius(), actual.getRadius(), 0.0001);
assertEquals(expected.getDistance(), actual.getDistance(), 0.0001);
assertEquals(expected.getTypes(), actual.getTypes());
assertEquals(expected.getServices(), actual.getServices());
assertEquals(expected.getFactions(), actual.getFactions());
assertEquals(expected.getGovernments(), actual.getGovernments());
assertEquals(expected.getExcludes(), actual.getExcludes());
assertFilter(expected.getDefaultVendorFilter(), actual.getDefaultVendorFilter());
Map<String, VendorFilter> expectedFilters = expected.getVendorFilters();
Map<String, VendorFilter> actualFilters = actual.getVendorFilters();
assertEquals(expectedFilters.size(), actualFilters.size());
for (Map.Entry<String, VendorFilter> entry : expectedFilters.entrySet()) {
VendorFilter act = actualFilters.get(entry.getKey());
assertFilter(entry.getValue(), act);
}
}
private void assertFilter(VendorFilter expected, VendorFilter actual){
assertEquals(expected.isDisable(), actual.isDisable());
assertEquals(expected.isSkipIllegal(), actual.isSkipIllegal());
assertEquals(expected.isDontBuy(), actual.isDontBuy());
assertEquals(expected.isDontSell(), actual.isDontSell());
assertEquals(expected.getBuyExcludes(), actual.getBuyExcludes());
assertEquals(expected.getSellExcludes(), actual.getSellExcludes());
}
@After
public void tearDown() throws Exception {
file.delete();
}
}