implement editing orders of track

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

@@ -94,6 +94,14 @@ public class RouteTrackController {
         MainController.getProfile().routeProperty().removeListener(routeListener);
     }
 
+    private void updateRoute(RouteModel newRoute){
+        if (MainController.getProfile().getRoute() == route){
+            MainController.getProfile().setRoute(newRoute);
+        } else {
+            setRoute(newRoute);
+        }
+    }
+
     public void setRoute(RouteModel route){
         if (this.route != null){
             this.route.currentEntryProperty().removeListener(currentEntryListener);
@@ -194,11 +202,7 @@ public class RouteTrackController {
                     RouteModel newRoute = route.set(startIndex, path.get());
                     newRoute.addAll(startIndex, notAdded);
                     newRoute.addAll(startIndex, oldMissions);
-                    if (MainController.getProfile().getRoute() == route){
+                    updateRoute(newRoute);
-                        MainController.getProfile().setRoute(newRoute);
-                    } else {
-                        setRoute(newRoute);
-                    }
                 }
             });
         } else {
@@ -237,22 +241,69 @@ public class RouteTrackController {
         if (!ModelFabric.isFake(toSystem)){
             if (route != null){
                 if (!ModelFabric.isFake(toStation)){
-                    setRoute(route.add(toStation));
+                    updateRoute(route.add(toStation));
                 } else {
-                    setRoute(route.add(toSystem));
+                    updateRoute(route.add(toSystem));
                 }
             } else {
                 RouteModel r;
+                ProfileModel profile = MainController.getProfile();
                 if (!ModelFabric.isFake(toStation)){
-                    r = RouteModel.asRoute(toStation);
+                    r = RouteModel.asRoute(toStation, profile);
                 } else {
-                    r = RouteModel.asRoute(toSystem);
+                    r = RouteModel.asRoute(toSystem, profile);
                 }
-                setRoute(r);
+                updateRoute(r);
             }
         }
     }
 
+    @FXML
+    private void addOrder(){
+        if (route != null){
+            final int startIndex = trackNode.getActive();
+            RouteEntryModel entry = route.get(startIndex);
+            if (entry.isTransit()) return;
+            StationModel seller = entry.getStation();
+            if (ModelFabric.isFake(seller)) return;
+            if (startIndex != route.getJumps()){
+                Collection<StationModel> buyers = route.getStations(startIndex);
+                route.getMarket().getOrders(seller, buyers, route.getBalance(startIndex), orders -> {
+                    Optional<OrderModel> order = Screeners.showOrders(orders);
+                    if (order.isPresent()){
+                        route.add(startIndex, order.get());
+                    }
+                });
+            } else {
+                route.getMarket().getOrders(seller, route.getBalance(startIndex), orders -> {
+                    Optional<OrderModel> order = Screeners.showOrders(orders);
+                    if (order.isPresent()){
+                        updateRoute(route.add(order.get()));
+                    }
+                });
+            }
+        }
+    }
+
+    @FXML
+    private void removeOrder(){
+        if (route != null){
+            final int index = trackNode.getActive();
+            OrderModel order = buyOrders.getSelectionModel().getSelectedItem();
+            if (order != null){
+                route.remove(index, order);
+            }
+        }
+    }
+
+    @FXML
+    private void clearOrders(){
+        if (route != null){
+            final int index = trackNode.getActive();
+            route.clearOrders(index);
+        }
+    }
+
     @FXML
     private void setActive(){
         MainController.getProfile().setRoute(route);
@@ -260,7 +311,7 @@ public class RouteTrackController {
 
     @FXML
     private void clear(){
-        setRoute(null);
+        updateRoute(null);
     }
 
     @FXML

client/src/main/java/ru/trader/model/MarketModel.java

@@ -23,8 +23,11 @@ import ru.trader.view.support.Localization;
 import ru.trader.view.support.autocomplete.StationsProvider;
 import ru.trader.view.support.autocomplete.SystemsProvider;
 
+import java.util.Collection;
+import java.util.List;
 import java.util.Optional;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 
 public class MarketModel {
@@ -171,16 +174,8 @@ public class MarketModel {
         return BindingsHelper.observableList(analyzer.getVendors(filter), modeler::get);
     }
 
-    public void getOrders(SystemModel from, double balance, Consumer<ObservableList<OrderModel>> result) {
+    public void getOrders(StationModel from, double balance, Consumer<ObservableList<OrderModel>> result) {
-        getOrders(from, ModelFabric.NONE_STATION, ModelFabric.NONE_SYSTEM, ModelFabric.NONE_STATION, balance, result);
+        getOrders(ModelFabric.NONE_SYSTEM, from, ModelFabric.NONE_SYSTEM, ModelFabric.NONE_STATION, balance, result);
-    }
-
-    public void getOrders(SystemModel from, SystemModel to, double balance, Consumer<ObservableList<OrderModel>> result) {
-        getOrders(from, ModelFabric.NONE_STATION, to, ModelFabric.NONE_STATION, balance, result);
-    }
-
-    public void getOrders(StationModel from, StationModel to, double balance, Consumer<ObservableList<OrderModel>> result) {
-        getOrders(from.getSystem(), from, to.getSystem(), to, balance, result);
     }
 
     public void getOrders(SystemModel from, StationModel stationFrom, SystemModel to, StationModel stationTo, double balance, Consumer<ObservableList<OrderModel>> result) {
@@ -202,6 +197,22 @@ public class MarketModel {
         });
     }
 
+    public void getOrders(StationModel seller, Collection<StationModel> buyers, double balance, Consumer<ObservableList<OrderModel>> result) {
+        ProgressController progress = new ProgressController(Screeners.getMainScreen(), Localization.getString("analyzer.orders.title"));
+        Profile profile = Profile.clone(ModelFabric.get(MainController.getProfile()));
+        profile.setBalance(balance);
+        List<Vendor> vendors = buyers.stream().map(ModelFabric::get).collect(Collectors.toList());
+        OrdersSearchTask task = new OrdersSearchTask(this, ModelFabric.get(seller), vendors, profile);
+        progress.run(task, order -> {
+            ObservableList<OrderModel> res = BindingsHelper.observableList(order, modeler::get);
+            if (Platform.isFxApplicationThread()) {
+                result.accept(res);
+            } else {
+                Platform.runLater(() -> result.accept(res));
+            }
+        });
+    }
+
     public void getTop(double balance, Consumer<ObservableList<OrderModel>> result){
         getOrders(ModelFabric.NONE_SYSTEM, ModelFabric.NONE_STATION, ModelFabric.NONE_SYSTEM, ModelFabric.NONE_STATION, balance, result);
     }

client/src/main/java/ru/trader/model/RouteModel.java

@@ -162,6 +162,21 @@ public class RouteModel {
         return copyFill(route);
     }
 
+    public void add(int offset, OrderModel order){
+        _route.add(offset, ModelFabric.get(order));
+        refresh(offset);
+    }
+
+    public void remove(int offset, OrderModel order){
+        _route.remove(offset, ModelFabric.get(order));
+        refresh(offset);
+    }
+
+    public void clearOrders(int offset){
+        _route.removeAllOrders(offset);
+        refresh(offset);
+    }
+
     public RouteModel add(SystemModel system){
         RouteEntryModel last = entries.get(entries.size()-1);
         StationModel fromStation = last.getStation();
@@ -205,11 +220,7 @@ public class RouteModel {
                 _route.reserve(reserves);
                 mission.setReserves(reserves);
                 completeIndex = RouteReserve.getCompleteIndex(reserves, offset);
-                for (RouteEntryModel entry : entries) {
+                refresh();
-                    entry.sellOrders().clear();
-                    entry.refresh(market);
-                }
-                fillSellOrders();
             }
         } else
         if (mission.isDelivery()){
@@ -455,6 +466,15 @@ public class RouteModel {
         return getCurrentEntry() == entries.size()-1;
     }
 
+    private void refresh(int index){
+        RouteEntryModel entry = get(index);
+        entry.refresh(market);
+        for (RouteEntryModel e : entries) {
+            e.sellOrders().clear();
+        }
+        fillSellOrders();
+    }
+
     private void refresh(){
         for (RouteEntryModel entry : entries) {
             entry.sellOrders().clear();
@@ -463,13 +483,13 @@ public class RouteModel {
         fillSellOrders();
     }
 
-    public static RouteModel asRoute(SystemModel system){
+    public static RouteModel asRoute(SystemModel system, ProfileModel profile){
-        Route route = Route.singletone(ModelFabric.get(system).asTransit());
+        Route route = Route.singletone(ModelFabric.get(system).asTransit(), profile.getBalance(), profile.getShipCargo());
         return new RouteModel(route, system.getMarket());
     }
 
-    public static RouteModel asRoute(StationModel station){
+    public static RouteModel asRoute(StationModel station, ProfileModel profile){
-        Route route = Route.singletone(ModelFabric.get(station));
+        Route route = Route.singletone(ModelFabric.get(station), profile.getBalance(), profile.getShipCargo());
         return new RouteModel(route, station.getMarket());
     }
 

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

@@ -7,12 +7,14 @@ import ru.trader.core.Vendor;
 import ru.trader.model.MarketModel;
 
 import java.util.Collection;
+import java.util.Collections;
 
 public class OrdersSearchTask extends AnalyzerTask<Collection<Order>>{
     private final Place from;
     private final Vendor stationFrom;
     private final Place to;
     private final Vendor stationTo;
+    private final Collection<Vendor> vendors;
 
     public OrdersSearchTask(MarketModel market, Place from, Vendor stationFrom, Place to, Vendor stationTo, Profile profile) {
         super(market, profile);
@@ -20,11 +22,23 @@ public class OrdersSearchTask extends AnalyzerTask<Collection<Order>>{
         this.stationFrom = stationFrom;
         this.to = to;
         this.stationTo = stationTo;
+        this.vendors = Collections.emptyList();
     }
 
+    public OrdersSearchTask(MarketModel market, Vendor seller, Collection<Vendor> buyers, Profile profile) {
+        super(market, profile);
+        this.from = null;
+        this.stationFrom = seller;
+        this.to = null;
+        this.stationTo = null;
+        this.vendors = buyers;
+    }
+
+
     @Override
     protected Collection<Order> call() throws Exception {
         Collection<Order> orders;
+        if (vendors.isEmpty()){
             if (stationFrom != null){
                 if (stationTo != null){
                     orders = analyzer.getOrders(stationFrom, stationTo);
@@ -50,6 +64,13 @@ public class OrdersSearchTask extends AnalyzerTask<Collection<Order>>{
                     }
                 }
             }
+        } else {
+            if (stationFrom != null){
+                orders = analyzer.getOrders(Collections.singleton(stationFrom), vendors, 0);
+            } else {
+                orders = Collections.emptyList();
+            }
+        }
         return orders;
     }
 }

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

@@ -39,7 +39,14 @@
                 </VBox>
                 <VBox>
                     <Label text="Купить:" />
+                    <HBox spacing="4">
                         <ListView fx:id="buyOrders"/>
+                        <VBox spacing="4" alignment="TOP_RIGHT">
+                            <Button prefWidth="30" onAction="#addOrder"><graphic><Glyph text="FontAwesome|PLUS"/></graphic></Button>
+                            <Button prefWidth="30" onAction="#removeOrder"><graphic><Glyph text="FontAwesome|MINUS"/></graphic></Button>
+                            <Button prefWidth="30" onAction="#clearOrders"><graphic><Glyph text="FontAwesome|TRASH"/></graphic></Button>
+                        </VBox>
+                    </HBox>
                 </VBox>
             </HBox>
             <VBox fx:id="missionsGroup" maxHeight="120">

core/src/main/java/ru/trader/analysis/Route.java

@@ -3,6 +3,7 @@ package ru.trader.analysis;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import ru.trader.core.Order;
 import ru.trader.core.TransitVendor;
 import ru.trader.core.Vendor;
 
@@ -115,6 +116,27 @@ public class Route implements Comparable<Route> {
         updateStats();
     }
 
+    public void add(int index, Order order){
+        LOG.trace("Add order {} to route {}, index = {}", order, this, index);
+        RouteEntry entry = entries.get(index);
+        entry.add(order);
+        updateStats();
+    }
+
+    public void remove(int index, Order order){
+        LOG.trace("Remove order {} from route {}, index = {}", order, this, index);
+        RouteEntry entry = entries.get(index);
+        entry.remove(order);
+        updateStats();
+    }
+
+    public void removeAllOrders(int index){
+        LOG.trace("Remove all orders from route {}, index = {}", this, index);
+        RouteEntry entry = entries.get(index);
+        entry.clear();
+        updateStats();
+    }
+
     public void addAll(Collection<RouteEntry> entries){
         LOG.trace("Add {} entries {} to route {}", entries, this);
         this.entries.addAll(entries);
@@ -313,12 +335,15 @@ public class Route implements Comparable<Route> {
         };
     }
 
-    public static Route singletone(Vendor root){
+    public static Route singletone(Vendor root, double balance, long cargo){
         RouteEntry entry = new RouteEntry(root, 0,0,0);
         if (!(root instanceof TransitVendor)){
             entry.setLand(true);
         }
-        return new Route(entry);
+        Route route = new Route(entry);
+        route.setBalance(balance);
+        route.setCargo(cargo);
+        return route;
     }
 
     public static Route clone(Route route){

core/src/main/java/ru/trader/analysis/RouteEntry.java

@@ -94,6 +94,14 @@ public class RouteEntry {
         orders.add(fixedWrap(order));
     }
 
+    void remove(Order order){
+        orders.removeIf(o -> o.fixed && o.equals(order));
+    }
+
+    void clear(){
+        orders.removeIf(o -> o.fixed);
+    }
+
     void addAll(Collection<Order> orders){
         orders.forEach(this::add);
     }

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

@@ -139,7 +139,7 @@ public class MarketAnalyzer {
         return res;
     }
 
-    private Collection<Order> getOrders(Collection<Vendor> sellers, Collection<Vendor> buyers, double lowProfit) {
+    public Collection<Order> getOrders(Collection<Vendor> sellers, Collection<Vendor> buyers, double lowProfit) {
         List<Order> res = new ArrayList<>();
         callback.start(sellers.size());
         for (Vendor seller : sellers) {