Initial startup

.gitignore

@@ -1,5 +1,6 @@
 ### Trader files
 trader.conf
+trader.db
 
 ### virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*

logging.properties

@@ -0,0 +1,26 @@
+# logging.properties
+# LogUtil.readConfiguration("logging.properties");
+
+# -------------------------------------
+# Trader
+# -------------------------------------
+
+handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler
+java.util.logging.ConsoleHandler.level = ALL
+java.util.logging.ConsoleHandler.formatter = zutil.log.CompactLogFormatter
+java.util.logging.FileHandler.level = ALL
+java.util.logging.FileHandler.formatter = zutil.log.CompactLogFormatter
+
+# Libs
+
+zutil.level = ALL
+zutil.db.bean.level = INFO
+zutil.net.http.page.HttpFilePage.level = INFO
+
+# Hal Core
+
+se.koc.trader.level = ALL
+
+# -------------------------------------
+# Plugins
+# -------------------------------------

src/main/java/se/koc/trader/TraderContext.java

@@ -26,24 +26,22 @@ import java.util.logging.Logger;
 public class TraderContext {
     private static final Logger logger = LogUtil.getLogger();
 
-    private static final String CONF_FILE       = "trader.conf";
-    private static final String DB_FILE         = "trader.db";
-    private static final String DEFAULT_DB_FILE = "/resource/trader-default.db";
-
-    public static final String PROPERTY_DB_VERSION = "trader.db_version";
-    public static final String PROPERTY_HTTP_PORT  = "trader.http_port";
-
     public static final String RESOURCE_ROOT;
     static {
-        if (FileUtil.find("build/resources/") != null)
-            RESOURCE_ROOT = "build/resources";
-        else if (FileUtil.find("resource/resource/") != null)
-            RESOURCE_ROOT = "resource";
+        if (FileUtil.find("src/main/resources") != null)
+            RESOURCE_ROOT = "src/main/resources";
         else
             RESOURCE_ROOT = ".";
     }
     public static final String RESOURCE_WEB_ROOT = RESOURCE_ROOT + "/web";
 
+    private static final String CONF_FILE       = "trader.conf";
+    private static final String DB_FILE         = "trader.db";
+    private static final String DEFAULT_DB_FILE = RESOURCE_ROOT + "/trader-default.db";
+
+    public static final String PROPERTY_DB_VERSION = "trader.db_version";
+    public static final String PROPERTY_HTTP_PORT  = "trader.http_port";
+
     private static DBConnection db;
     private static UserMessageManager messageManager = new UserMessageManager();
 

src/main/java/se/koc/trader/TraderServer.java

@@ -1,8 +1,10 @@
 package se.koc.trader;
 
-import se.koc.trader.api.AlertEndpoint;
+import se.koc.trader.endpoint.AlertEndpoint;
+import se.koc.trader.api.TraderApiEndpoint;
+import se.koc.trader.daemon.TraderMarketUpdateManager;
 import se.koc.trader.struct.PluginConfig;
-import se.koc.trader.web.TraderPage;
+import se.koc.trader.api.TraderPage;
 import zutil.db.DBConnection;
 import zutil.io.file.FileUtil;
 import zutil.log.LogUtil;
@@ -54,12 +56,19 @@ public class TraderServer {
         for (PluginData plugin : getAllPlugins()) {
             PluginConfig pluginConfig = PluginConfig.getPluginConfig(db, plugin.getName());
 
-            if (pluginConfig != null && !pluginConfig.isEnabled() && !plugin.getName().equals("Hal-Core")) {
+            if (pluginConfig != null && !pluginConfig.isEnabled() && !plugin.getName().equals("Trader-Core")) {
                 logger.info("Disabling plugin '" + plugin.getName() + "'.");
                 plugin.setEnabled(false);
             }
         }
 
+        // ------------------------------------
+        // Initialize Daemons
+        // ------------------------------------
+
+        TraderMarketUpdateManager marketUpdateManager = new TraderMarketUpdateManager();
+        marketUpdateManager.initialize(daemonExecutor);
+
         // ------------------------------------
         // Init http server
         // ------------------------------------
@@ -71,9 +80,9 @@ public class TraderServer {
         TraderPage.getRootNav().createSubNav("Settings").setWeight(200);
 
         http.setDefaultPage(new HttpFilePage(FileUtil.find(TraderContext.RESOURCE_WEB_ROOT)));
-        http.setPage("/", new HttpRedirectPage("/map"));
+        http.setPage("/", new HttpRedirectPage("/symbol_overview"));
         http.setPage(AlertEndpoint.getInstance().getPath(), AlertEndpoint.getInstance());
-        for (Iterator<TraderPage> it = pluginManager.getSingletonIterator(TraderPage.class); it.hasNext(); )
+        for (Iterator<TraderPage> it = pluginManager.getSingletonIterator(TraderApiEndpoint.class); it.hasNext(); )
             registerPage(it.next());
         for (Iterator<TraderPage> it = pluginManager.getSingletonIterator(TraderPage.class); it.hasNext(); )
             registerPage(it.next());

src/main/java/se/koc/trader/api/AlertEndpoint.java

@@ -1,29 +0,0 @@
-package se.koc.trader.api;
-
-import zutil.parser.DataNode;
-
-import java.util.Map;
-
-public class AlertEndpoint extends TraderAPI {
-    private static final String API_PATH = "/api/alert";
-
-    private static AlertEndpoint instance;
-
-
-    private AlertEndpoint() {
-        super(API_PATH);
-    }
-
-
-    @Override
-    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
-        return null;
-    }
-
-
-    public static AlertEndpoint getInstance() {
-        if (instance == null)
-            instance = new AlertEndpoint();
-        return instance;
-    }
-}

src/main/java/se/koc/trader/api/BotEndpoint.java

@@ -1,22 +0,0 @@
-package se.koc.trader.api;
-
-import se.koc.trader.TraderContext;
-import se.koc.trader.web.TraderPage;
-import zutil.parser.DataNode;
-import zutil.parser.Templator;
-
-import java.util.Map;
-
-public class BotEndpoint extends TraderAPI {
-    private static final String API_PATH = "/api/bot/.*";
-
-    public BotEndpoint() {
-        super(API_PATH);
-    }
-
-
-    @Override
-    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
-        return null;
-    }
-}

src/main/java/se/koc/trader/api/MarketEndpoint.java

@@ -1,18 +0,0 @@
-package se.koc.trader.api;
-
-import zutil.parser.DataNode;
-
-import java.util.Map;
-
-public class MarketEndpoint extends TraderAPI {
-    private static final String API_PATH = "/api/market/.*";
-
-    public MarketEndpoint() {
-        super(API_PATH);
-    }
-
-    @Override
-    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
-        return null;
-    }
-}

src/main/java/se/koc/trader/api/TraderApiEndpoint.java

@@ -5,7 +5,6 @@ import zutil.net.http.HttpHeader;
 import zutil.net.http.HttpPage;
 import zutil.net.http.HttpPrintStream;
 import zutil.parser.DataNode;
-import zutil.parser.Templator;
 import zutil.parser.json.JSONWriter;
 
 import java.io.IOException;
@@ -16,13 +15,13 @@ import java.util.logging.Logger;
 /**
  * A interface defining a Hal json endpoint
  */
-public abstract class TraderAPI implements HttpPage {
+public abstract class TraderApiEndpoint implements HttpPage {
     private static final Logger logger = LogUtil.getLogger();
 
     private String path;
 
 
-    public TraderAPI(String path) {
+    public TraderApiEndpoint(String path) {
         this.path = path;
     }
 

src/main/java/se/koc/trader/api/TraderDaemon.java

@@ -0,0 +1,17 @@
+package se.koc.trader.api;
+
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * Defines a standalone process that will run parallel to the main application
+ */
+public interface TraderDaemon extends Runnable {
+
+    /**
+     * Setup the execution of the daemon with the provided executor.
+     *
+     * @param executor the scheduler provided for the daemon to setup its execution.
+     */
+    void initiate(ScheduledExecutorService executor);
+
+}

src/main/java/se/koc/trader/api/TraderPage.java

@@ -1,6 +1,7 @@
-package se.koc.trader.web;
+package se.koc.trader.api;
 
 import se.koc.trader.TraderContext;
+import se.koc.trader.endpoint.AlertEndpoint;
 import zutil.io.file.FileUtil;
 import zutil.net.http.HttpHeader;
 import zutil.net.http.HttpPage;
@@ -13,8 +14,9 @@ import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 
-public abstract class TraderPage implements HttpPage{
-    private static final String TEMPLATE = TraderContext.RESOURCE_WEB_ROOT + "/main_index.tmpl";
+public abstract class TraderPage implements HttpPage {
+    private static final String TEMPLATE_MAIN = TraderContext.RESOURCE_WEB_ROOT + "/main.tmpl";
+    private static final String TEMPLATE_ALERT = TraderContext.RESOURCE_WEB_ROOT + "/main_alerts.tmpl";
     private static Navigation rootNav = Navigation.createRootNav();
     private static Navigation userNav = Navigation.createRootNav();
 
@@ -41,11 +43,11 @@ public abstract class TraderPage implements HttpPage{
                 msg.decreaseTTL();
             }
 
-            Templator tmpl = new Templator(FileUtil.find(TEMPLATE));
+            Templator tmpl = new Templator(FileUtil.find(TEMPLATE_MAIN));
             tmpl.set("rootNav", rootNav.createPagedNavInstance(header).getSubNavs());
             tmpl.set("userNav", userNav.createPagedNavInstance(header).getSubNavs());
             tmpl.set("content", httpRespond(session, cookie, request));
-            tmpl.set("alerts", messages);
+            tmpl.set("alerts", AlertEndpoint.getInstance().generateAlerts());
 
             tmpl.set("showSubNav", showSubNav);
             if (showSubNav) {

src/main/java/se/koc/trader/daemon/TraderMarketUpdateManager.java

@@ -0,0 +1,45 @@
+package se.koc.trader.daemon;
+
+import se.koc.trader.TraderContext;
+import se.koc.trader.exchange.ExchangeConfig;
+import se.koc.trader.exchange.ExchangeMarket;
+import se.koc.trader.struct.Symbol;
+import zutil.db.DBConnection;
+import zutil.log.LogUtil;
+
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This manager will pull updates from all configured exchanges.
+ */
+public class TraderMarketUpdateManager implements Runnable {
+    private static final Logger logger = LogUtil.getLogger();
+
+    private static final int MARKET_UPDATE_INTERVAL = 60 * 1000; // in milliseconds
+
+
+    public void initialize(ScheduledExecutorService scheduler) {
+        scheduler.scheduleAtFixedRate(this, 10_000, MARKET_UPDATE_INTERVAL, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void run() {
+        try {
+            DBConnection db = TraderContext.getDB();
+            List<Symbol> symbols = Symbol.getSymbols(db);
+
+            for (Symbol symbol : symbols) {
+                ExchangeConfig exchange = symbol.getExchangeConfig();
+                ExchangeMarket market = exchange.getExchangeMarket();
+
+
+            }
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, "Trader market updated thread has crashed during update.", e);
+        }
+    }
+}

src/main/java/se/koc/trader/endpoint/AlertEndpoint.java

@@ -0,0 +1,72 @@
+package se.koc.trader.endpoint;
+
+import se.koc.trader.TraderContext;
+import se.koc.trader.api.TraderApiEndpoint;
+import zutil.io.file.FileUtil;
+import zutil.log.LogUtil;
+import zutil.parser.DataNode;
+import zutil.parser.Templator;
+import zutil.ui.UserMessageManager;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class AlertEndpoint extends TraderApiEndpoint {
+    private static final Logger logger = LogUtil.getLogger();
+    private static final String TEMPLATE = TraderContext.RESOURCE_WEB_ROOT + "/main_alerts.tmpl";
+    private static final String API_PATH = "/api/alert";
+
+    private static AlertEndpoint instance;
+
+
+    private AlertEndpoint() {
+        super(API_PATH);
+    }
+
+
+    public String getUrl() {
+        return "/" + API_PATH;
+    }
+
+
+    public Templator generateAlerts() {
+        try {
+            List<UserMessageManager.UserMessage> messages = TraderContext.getMessageManager().getMessages();
+            TraderContext.getMessageManager().decreaseTTL();
+
+            Templator tmpl = new Templator(FileUtil.find(TEMPLATE));
+            tmpl.set("serviceUrl", getUrl());
+            tmpl.set("alerts", messages);
+            return tmpl;
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, null, e);
+        }
+        return null;
+    }
+
+    @Override
+    protected DataNode jsonRespond(Map<String, Object> session, Map<String, String> cookie, Map<String, String> request) throws Exception {
+        if (request.containsKey("action")) {
+            if (request.get("action").equals("dismiss")) {
+                // parse alert id
+                int id = Integer.parseInt(request.get("id"));
+                //  Find alert
+                UserMessageManager.UserMessage msg = TraderContext.getMessageManager().get(id);
+                if (msg != null)
+                    msg.dismiss();
+            }
+        }
+
+        return new DataNode(DataNode.DataType.Map);
+    }
+
+
+    public static AlertEndpoint getInstance() {
+        if (instance == null)
+            instance = new AlertEndpoint();
+        return instance;
+    }
+}

src/main/java/se/koc/trader/exchange/ExchangeConfig.java

@@ -0,0 +1,32 @@
+package se.koc.trader.exchange;
+
+import zutil.db.bean.DBBean;
+
+/**
+ * Configuration related to a exchange, e.g. connection information or account information.
+ */
+@DBBean.DBTable("exchange")
+public abstract class ExchangeConfig extends DBBean {
+    private String name;
+
+
+    // ----------------------------------------------------
+    // Abstract methods
+    // ----------------------------------------------------
+
+    public abstract ExchangeMarket getExchangeMarket();
+
+    public abstract ExchangeOrder getExchangeOrder();
+
+    // ----------------------------------------------------
+    // Common logic
+    // ----------------------------------------------------
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/se/koc/trader/exchange/ExchangeMarket.java

@@ -1,4 +1,13 @@
 package se.koc.trader.exchange;
 
+import se.koc.trader.struct.Symbol;
+
+import java.util.List;
+
 public interface ExchangeMarket {
+
+    /**
+     * @return a List of all symbols supported by this exchange, symbols are defined by "{baseAsset}/{quoteAsset}"
+     */
+    List<Symbol> getSymbols();
 }

src/main/java/se/koc/trader/exchange/ExchangeOrder.java

@@ -1,4 +1,4 @@
 package se.koc.trader.exchange;
 
-public interface ExchangeTrader {
+public interface ExchangeOrder {
 }

src/main/java/se/koc/trader/exchange/binance/BinanceExchange.java

@@ -0,0 +1,21 @@
+package se.koc.trader.exchange.binance;
+
+import se.koc.trader.exchange.ExchangeConfig;
+import se.koc.trader.exchange.ExchangeMarket;
+import se.koc.trader.exchange.ExchangeOrder;
+
+public class BinanceExchange extends ExchangeConfig {
+    private BinanceMarket market;
+
+    @Override
+    public ExchangeMarket getExchangeMarket() {
+        if (market == null)
+            market = new BinanceMarket();
+        return market;
+    }
+
+    @Override
+    public ExchangeOrder getExchangeOrder() {
+        return null;
+    }
+}

src/main/java/se/koc/trader/exchange/binance/BinanceMarket.java

@@ -8,12 +8,12 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.List;
 
-public class BinanceMarketImpl implements ExchangeMarket {
+public class BinanceMarket implements ExchangeMarket {
 
     private BinanceRestAPI rest;
 
 
-    public BinanceMarketImpl() {
+    public BinanceMarket() {
         try {
             rest = RESTClientFactory.createClient(new URL("https://api.binance.com"), BinanceRestAPI.class);
         } catch (MalformedURLException e) {
@@ -22,9 +22,12 @@ public class BinanceMarketImpl implements ExchangeMarket {
     }
 
 
+    public long getServerTime() {
+        return rest.getServerTime().getLong("serverTime");
+    }
 
-
-    public List<Symbol> getSigns() {
+    @Override
+    public List<Symbol> getSymbols() {
         return null; // /api/v3/ticker/price
     }
 

src/main/java/se/koc/trader/exchange/binance/BinanceRestAPI.java

@@ -30,10 +30,10 @@ public interface BinanceRestAPI extends WSInterface {
      * Test connectivity to the Rest API and get the current server time.
      * <p></p><pre>GET /api/v3/time</pre>
      *
-     * @return the current server time in EPOC
+     * @return the current server time in EPOC, e.g. <pre>{"serverTime": 1499827319559}</pre>
      */
     @WSPath("/api/v3/time")
-    long getServerTime();
+    DataNode getServerTime();
 
     /**
      * Current exchange trading rules and symbol information.

src/main/java/se/koc/trader/exchange/binance/plugin.json

@@ -1,8 +1,8 @@
 {
 	"version": 0.1,
 	"name": "Exchange-Binance",
-	"description": "Plugin contains core logic for running Trader.",
+	"description": "Plugin contains core Binance connectivity.",
 	"interfaces": [
-		{"se.koc.trader.exchange.ExchangeMarket": "se.koc.trader.exchange.binance.BinanceMarketImpl"}
+		{"se.koc.trader.exchange.ExchangeConfig": "se.koc.trader.exchange.binance.BinanceExchange"}
 	]
 }

src/main/java/se/koc/trader/page/SymbolConfigPage.java

@@ -0,0 +1,90 @@
+package se.koc.trader.page;
+
+import se.koc.trader.TraderContext;
+import se.koc.trader.api.TraderPage;
+import se.koc.trader.struct.Symbol;
+import zutil.ObjectUtil;
+import zutil.db.DBConnection;
+import zutil.io.file.FileUtil;
+import zutil.log.LogUtil;
+import zutil.parser.Templator;
+
+import java.util.Map;
+import java.util.logging.Logger;
+
+import static zutil.ui.UserMessageManager.*;
+
+
+public class SymbolConfigPage extends TraderPage {
+    private static final Logger logger = LogUtil.getLogger();
+    private static final String TEMPLATE = TraderContext.RESOURCE_WEB_ROOT + "/symbol_config.tmpl";
+
+
+    public SymbolConfigPage() {
+        super("symbol_config");
+        super.getRootNav().createSubNav("Settings").createSubNav(this.getId(), "Symbol Settings").setWeight(200);
+    }
+
+    @Override
+    public Templator httpRespond(
+            Map<String, Object> session,
+            Map<String, String> cookie,
+            Map<String, String> request)
+            throws Exception{
+
+        DBConnection db = TraderContext.getDB();
+
+        // Save new input
+        if (request.containsKey("action")) {
+            int id = (ObjectUtil.isEmpty(request.get("id")) ? -1 : Integer.parseInt(request.get("id")));
+            Symbol symbol = null;
+
+            if (id >= 0)
+                symbol = Symbol.getSymbol(db, id);
+
+            switch(request.get("action")) {
+                // Local Sensors
+                case "create_symbol":
+                    logger.info("Creating symbol: " + request.get("name"));
+                    symbol = new Symbol();
+
+                case "modify_symbol":
+                    if (symbol != null) {
+                        logger.info("Modifying sensor: " + symbol.getName());
+                        symbol.setName(request.get("name"));
+                        symbol.save(db);
+
+                        TraderContext.getMessageManager().add(new UserMessage(
+                                MessageLevel.SUCCESS, "Successfully saved symbol: "+symbol.getName(), MessageTTL.ONE_VIEW));
+                    } else {
+                        logger.warning("Unknown sensor id: " + id);
+                        TraderContext.getMessageManager().add(new UserMessage(
+                                MessageLevel.ERROR, "Unknown sensor id: " + id, MessageTTL.ONE_VIEW));
+                    }
+                    break;
+
+                case "remove_symbol":
+                    if (symbol != null) {
+                        logger.warning("Removing sensor: " + symbol.getName());
+                        symbol.delete(db);
+
+                        TraderContext.getMessageManager().add(new UserMessage(
+                                MessageLevel.SUCCESS, "Successfully removed sensor: " + symbol.getName(), MessageTTL.ONE_VIEW));
+                    } else {
+                        logger.warning("Unknown sensor id: " + id);
+                        TraderContext.getMessageManager().add(new UserMessage(
+                                MessageLevel.ERROR, "Unknown sensor id: " + id, MessageTTL.ONE_VIEW));
+                    }
+                    break;
+            }
+        }
+
+        // Output
+        Templator tmpl = new Templator(FileUtil.find(TEMPLATE));
+        tmpl.set("symbols", Symbol.getSymbols(db));
+
+        return tmpl;
+
+    }
+
+}

src/main/java/se/koc/trader/page/SymbolOverviewPage.java

@@ -0,0 +1,51 @@
+package se.koc.trader.page;
+
+import se.koc.trader.TraderContext;
+import se.koc.trader.api.TraderPage;
+import se.koc.trader.struct.Symbol;
+import zutil.ObjectUtil;
+import zutil.db.DBConnection;
+import zutil.io.file.FileUtil;
+import zutil.parser.Templator;
+
+import java.util.List;
+import java.util.Map;
+
+
+public class SymbolOverviewPage extends TraderPage {
+    private static final int HISTORY_LIMIT = 200;
+    private static final String OVERVIEW_TEMPLATE = TraderContext.RESOURCE_WEB_ROOT + "/symbol_overview.tmpl";
+    private static final String DETAIL_TEMPLATE   = TraderContext.RESOURCE_WEB_ROOT + "/symbol_detail.tmpl";
+
+
+    public SymbolOverviewPage() {
+        super("symbol_overview");
+        super.getRootNav().createSubNav("Market").createSubNav(this.getId(), "Symbols");
+    }
+
+    @Override
+    public Templator httpRespond(
+            Map<String, Object> session,
+            Map<String, String> cookie,
+            Map<String, String> request)
+            throws Exception{
+
+        DBConnection db = TraderContext.getDB();
+        int id = (ObjectUtil.isEmpty(request.get("id")) ? -1 : Integer.parseInt(request.get("id")));
+
+        if (id >= 0) {
+            Symbol symbol = Symbol.getSymbol(db, id);
+
+            Templator tmpl = new Templator(FileUtil.find(DETAIL_TEMPLATE));
+            tmpl.set("symbol", symbol);
+            return tmpl;
+        } else {
+            List<Symbol> sensors = Symbol.getSymbols(db);
+
+            Templator tmpl = new Templator(FileUtil.find(OVERVIEW_TEMPLATE));
+            tmpl.set("symbols", sensors);
+            return tmpl;
+        }
+    }
+
+}

src/main/java/se/koc/trader/plugin.json

@@ -3,7 +3,9 @@
 	"name": "Trader-Core",
 	"description": "Plugin contains core logic for running Trader.",
 	"interfaces": [
-		{"se.koc.trader.api.TraderAPI": "se.hal.page.SensorOverviewWebPage"},
-		{"se.koc.trader.api.TraderAPI": "se.hal.page.SensorConfigWebPage"}
+		{"se.koc.trader.api.TraderDaemon": "se.hal.page.SensorOverviewWebPage"},
+
+		{"se.koc.trader.api.TraderPage": "se.koc.trader.page.SymbolConfigPage"},
+		{"se.koc.trader.api.TraderPage": "se.koc.trader.page.SymbolOverviewPage"}
 	]
 }

src/main/java/se/koc/trader/signal/Analytics.java

@@ -0,0 +1,9 @@
+package se.koc.trader.signal;
+
+/**
+ * Generic interface representing historical analytics.
+ */
+public class Analytics {
+
+
+}

src/main/java/se/koc/trader/signal/MovingAverage.java

@@ -0,0 +1,4 @@
+package se.koc.trader.signal;
+
+public class MovingAverage {
+}

src/main/java/se/koc/trader/signal/SmothedMovingAverage.java

@@ -0,0 +1,4 @@
+package se.koc.trader.signal;
+
+public class SmothedMovingAverage {
+}

src/main/java/se/koc/trader/signal/WeightedMovingAverage.java

@@ -0,0 +1,4 @@
+package se.koc.trader.signal;
+
+public class WeightedMovingAverage {
+}

src/main/java/se/koc/trader/struct/Symbol.java

@@ -1,17 +1,41 @@
 package se.koc.trader.struct;
 
+import se.koc.trader.exchange.ExchangeConfig;
+import zutil.db.DBConnection;
 import zutil.db.bean.DBBean;
 
+import java.sql.SQLException;
+import java.util.List;
+
 /**
  * A data class referencing a symbol
  */
 @DBBean.DBTable("symbol")
 public class Symbol extends DBBean {
+    private String name;
     private String baseAsset;
     private String quoteAsset;
     private double price;
     private long priceTimestamp;
 
+    private ExchangeConfig exchangeConfig;
+
+
+    public static List<Symbol> getSymbols(DBConnection db) throws SQLException {
+        return DBBean.load(db, Symbol.class);
+    }
+
+    public static Symbol getSymbol(DBConnection db, long id) throws SQLException {
+        return DBBean.load(db, Symbol.class, id);
+    }
+
+
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
 
     public String getBaseAsset() {
         return baseAsset;
@@ -41,8 +65,17 @@ public class Symbol extends DBBean {
         this.priceTimestamp = priceTimestamp;
     }
 
+    public ExchangeConfig getExchangeConfig() {
+        return exchangeConfig;
+    }
+    public void setExchangeConfig(ExchangeConfig exchangeConfig) {
+        this.exchangeConfig = exchangeConfig;
+    }
 
+
+
+    @Override
     public String toString() {
-        return baseAsset + "/" +quoteAsset;
+        return baseAsset + "/" + quoteAsset;
     }
 }

src/main/resources/web/css/bootstrap-switch.css

@@ -0,0 +1,195 @@
+/* ========================================================================
+ * bootstrap-switch - v3.3.2
+ * http://www.bootstrap-switch.org
+ * ========================================================================
+ * Copyright 2012-2013 Mattia Larentis
+ *
+ * ========================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================================
+ */
+
+.bootstrap-switch {
+  display: inline-block;
+  direction: ltr;
+  cursor: pointer;
+  border-radius: 4px;
+  border: 1px solid;
+  border-color: #cccccc;
+  position: relative;
+  text-align: left;
+  overflow: hidden;
+  line-height: 8px;
+  z-index: 0;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  vertical-align: middle;
+  -webkit-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
+  -o-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
+  transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
+}
+.bootstrap-switch .bootstrap-switch-container {
+  display: inline-block;
+  top: 0;
+  border-radius: 4px;
+  -webkit-transform: translate3d(0, 0, 0);
+  transform: translate3d(0, 0, 0);
+}
+.bootstrap-switch .bootstrap-switch-handle-on,
+.bootstrap-switch .bootstrap-switch-handle-off,
+.bootstrap-switch .bootstrap-switch-label {
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  cursor: pointer;
+  display: inline-block !important;
+  height: 100%;
+  padding: 6px 12px;
+  font-size: 14px;
+  line-height: 20px;
+}
+.bootstrap-switch .bootstrap-switch-handle-on,
+.bootstrap-switch .bootstrap-switch-handle-off {
+  text-align: center;
+  z-index: 1;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-primary,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-primary {
+  color: #fff;
+  background: #337ab7;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-info,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-info {
+  color: #fff;
+  background: #5bc0de;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-success,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-success {
+  color: #fff;
+  background: #5cb85c;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-warning,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-warning {
+  background: #f0ad4e;
+  color: #fff;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-danger,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-danger {
+  color: #fff;
+  background: #d9534f;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-default,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-default {
+  color: #000;
+  background: #eeeeee;
+}
+.bootstrap-switch .bootstrap-switch-label {
+  text-align: center;
+  margin-top: -1px;
+  margin-bottom: -1px;
+  z-index: 100;
+  color: #333333;
+  background: #ffffff;
+}
+.bootstrap-switch .bootstrap-switch-handle-on {
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}
+.bootstrap-switch .bootstrap-switch-handle-off {
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch input[type='radio'],
+.bootstrap-switch input[type='checkbox'] {
+  position: absolute !important;
+  top: 0;
+  left: 0;
+  margin: 0;
+  z-index: -1;
+  opacity: 0;
+  filter: alpha(opacity=0);
+}
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-label {
+  padding: 1px 5px;
+  font-size: 12px;
+  line-height: 1.5;
+}
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-label {
+  padding: 5px 10px;
+  font-size: 12px;
+  line-height: 1.5;
+}
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-label {
+  padding: 6px 16px;
+  font-size: 18px;
+  line-height: 1.3333333;
+}
+.bootstrap-switch.bootstrap-switch-disabled,
+.bootstrap-switch.bootstrap-switch-readonly,
+.bootstrap-switch.bootstrap-switch-indeterminate {
+  cursor: default !important;
+}
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-label {
+  opacity: 0.5;
+  filter: alpha(opacity=50);
+  cursor: default !important;
+}
+.bootstrap-switch.bootstrap-switch-animate .bootstrap-switch-container {
+  -webkit-transition: margin-left 0.5s;
+  -o-transition: margin-left 0.5s;
+  transition: margin-left 0.5s;
+}
+.bootstrap-switch.bootstrap-switch-inverse .bootstrap-switch-handle-on {
+  border-bottom-left-radius: 0;
+  border-top-left-radius: 0;
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-inverse .bootstrap-switch-handle-off {
+  border-bottom-right-radius: 0;
+  border-top-right-radius: 0;
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-focused {
+  border-color: #66afe9;
+  outline: 0;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6);
+}
+.bootstrap-switch.bootstrap-switch-on .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-off .bootstrap-switch-label {
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-off .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-on .bootstrap-switch-label {
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}

src/main/resources/web/js/bootstrap-switch.js

@@ -0,0 +1,744 @@
+/* ========================================================================
+ * bootstrap-switch - v3.3.2
+ * http://www.bootstrap-switch.org
+ * ========================================================================
+ * Copyright 2012-2013 Mattia Larentis
+ *
+ * ========================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================================
+ */
+
+(function() {
+  var slice = [].slice;
+
+  (function($, window) {
+    "use strict";
+    var BootstrapSwitch;
+    BootstrapSwitch = (function() {
+      function BootstrapSwitch(element, options) {
+        if (options == null) {
+          options = {};
+        }
+        this.$element = $(element);
+        this.options = $.extend({}, $.fn.bootstrapSwitch.defaults, {
+          state: this.$element.is(":checked"),
+          size: this.$element.data("size"),
+          animate: this.$element.data("animate"),
+          disabled: this.$element.is(":disabled"),
+          readonly: this.$element.is("[readonly]"),
+          indeterminate: this.$element.data("indeterminate"),
+          inverse: this.$element.data("inverse"),
+          radioAllOff: this.$element.data("radio-all-off"),
+          onColor: this.$element.data("on-color"),
+          offColor: this.$element.data("off-color"),
+          onText: this.$element.data("on-text"),
+          offText: this.$element.data("off-text"),
+          labelText: this.$element.data("label-text"),
+          handleWidth: this.$element.data("handle-width"),
+          labelWidth: this.$element.data("label-width"),
+          baseClass: this.$element.data("base-class"),
+          wrapperClass: this.$element.data("wrapper-class")
+        }, options);
+        this.prevOptions = {};
+        this.$wrapper = $("<div>", {
+          "class": (function(_this) {
+            return function() {
+              var classes;
+              classes = ["" + _this.options.baseClass].concat(_this._getClasses(_this.options.wrapperClass));
+              classes.push(_this.options.state ? _this.options.baseClass + "-on" : _this.options.baseClass + "-off");
+              if (_this.options.size != null) {
+                classes.push(_this.options.baseClass + "-" + _this.options.size);
+              }
+              if (_this.options.disabled) {
+                classes.push(_this.options.baseClass + "-disabled");
+              }
+              if (_this.options.readonly) {
+                classes.push(_this.options.baseClass + "-readonly");
+              }
+              if (_this.options.indeterminate) {
+                classes.push(_this.options.baseClass + "-indeterminate");
+              }
+              if (_this.options.inverse) {
+                classes.push(_this.options.baseClass + "-inverse");
+              }
+              if (_this.$element.attr("id")) {
+                classes.push(_this.options.baseClass + "-id-" + (_this.$element.attr("id")));
+              }
+              return classes.join(" ");
+            };
+          })(this)()
+        });
+        this.$container = $("<div>", {
+          "class": this.options.baseClass + "-container"
+        });
+        this.$on = $("<span>", {
+          html: this.options.onText,
+          "class": this.options.baseClass + "-handle-on " + this.options.baseClass + "-" + this.options.onColor
+        });
+        this.$off = $("<span>", {
+          html: this.options.offText,
+          "class": this.options.baseClass + "-handle-off " + this.options.baseClass + "-" + this.options.offColor
+        });
+        this.$label = $("<span>", {
+          html: this.options.labelText,
+          "class": this.options.baseClass + "-label"
+        });
+        this.$element.on("init.bootstrapSwitch", (function(_this) {
+          return function() {
+            return _this.options.onInit.apply(element, arguments);
+          };
+        })(this));
+        this.$element.on("switchChange.bootstrapSwitch", (function(_this) {
+          return function(e) {
+            if (false === _this.options.onSwitchChange.apply(element, arguments)) {
+              if (_this.$element.is(":radio")) {
+                return $("[name='" + (_this.$element.attr('name')) + "']").trigger("previousState.bootstrapSwitch", true);
+              } else {
+                return _this.$element.trigger("previousState.bootstrapSwitch", true);
+              }
+            }
+          };
+        })(this));
+        this.$container = this.$element.wrap(this.$container).parent();
+        this.$wrapper = this.$container.wrap(this.$wrapper).parent();
+        this.$element.before(this.options.inverse ? this.$off : this.$on).before(this.$label).before(this.options.inverse ? this.$on : this.$off);
+        if (this.options.indeterminate) {
+          this.$element.prop("indeterminate", true);
+        }
+        this._init();
+        this._elementHandlers();
+        this._handleHandlers();
+        this._labelHandlers();
+        this._formHandler();
+        this._externalLabelHandler();
+        this.$element.trigger("init.bootstrapSwitch", this.options.state);
+      }
+
+      BootstrapSwitch.prototype._constructor = BootstrapSwitch;
+
+      BootstrapSwitch.prototype.setPrevOptions = function() {
+        return this.prevOptions = $.extend(true, {}, this.options);
+      };
+
+      BootstrapSwitch.prototype.state = function(value, skip) {
+        if (typeof value === "undefined") {
+          return this.options.state;
+        }
+        if (this.options.disabled || this.options.readonly) {
+          return this.$element;
+        }
+        if (this.options.state && !this.options.radioAllOff && this.$element.is(":radio")) {
+          return this.$element;
+        }
+        if (this.$element.is(":radio")) {
+          $("[name='" + (this.$element.attr('name')) + "']").trigger("setPreviousOptions.bootstrapSwitch");
+        } else {
+          this.$element.trigger("setPreviousOptions.bootstrapSwitch");
+        }
+        if (this.options.indeterminate) {
+          this.indeterminate(false);
+        }
+        value = !!value;
+        this.$element.prop("checked", value).trigger("change.bootstrapSwitch", skip);
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleState = function(skip) {
+        if (this.options.disabled || this.options.readonly) {
+          return this.$element;
+        }
+        if (this.options.indeterminate) {
+          this.indeterminate(false);
+          return this.state(true);
+        } else {
+          return this.$element.prop("checked", !this.options.state).trigger("change.bootstrapSwitch", skip);
+        }
+      };
+
+      BootstrapSwitch.prototype.size = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.size;
+        }
+        if (this.options.size != null) {
+          this.$wrapper.removeClass(this.options.baseClass + "-" + this.options.size);
+        }
+        if (value) {
+          this.$wrapper.addClass(this.options.baseClass + "-" + value);
+        }
+        this._width();
+        this._containerPosition();
+        this.options.size = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.animate = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.animate;
+        }
+        value = !!value;
+        if (value === this.options.animate) {
+          return this.$element;
+        }
+        return this.toggleAnimate();
+      };
+
+      BootstrapSwitch.prototype.toggleAnimate = function() {
+        this.options.animate = !this.options.animate;
+        this.$wrapper.toggleClass(this.options.baseClass + "-animate");
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.disabled = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.disabled;
+        }
+        value = !!value;
+        if (value === this.options.disabled) {
+          return this.$element;
+        }
+        return this.toggleDisabled();
+      };
+
+      BootstrapSwitch.prototype.toggleDisabled = function() {
+        this.options.disabled = !this.options.disabled;
+        this.$element.prop("disabled", this.options.disabled);
+        this.$wrapper.toggleClass(this.options.baseClass + "-disabled");
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.readonly = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.readonly;
+        }
+        value = !!value;
+        if (value === this.options.readonly) {
+          return this.$element;
+        }
+        return this.toggleReadonly();
+      };
+
+      BootstrapSwitch.prototype.toggleReadonly = function() {
+        this.options.readonly = !this.options.readonly;
+        this.$element.prop("readonly", this.options.readonly);
+        this.$wrapper.toggleClass(this.options.baseClass + "-readonly");
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.indeterminate = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.indeterminate;
+        }
+        value = !!value;
+        if (value === this.options.indeterminate) {
+          return this.$element;
+        }
+        return this.toggleIndeterminate();
+      };
+
+      BootstrapSwitch.prototype.toggleIndeterminate = function() {
+        this.options.indeterminate = !this.options.indeterminate;
+        this.$element.prop("indeterminate", this.options.indeterminate);
+        this.$wrapper.toggleClass(this.options.baseClass + "-indeterminate");
+        this._containerPosition();
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.inverse = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.inverse;
+        }
+        value = !!value;
+        if (value === this.options.inverse) {
+          return this.$element;
+        }
+        return this.toggleInverse();
+      };
+
+      BootstrapSwitch.prototype.toggleInverse = function() {
+        var $off, $on;
+        this.$wrapper.toggleClass(this.options.baseClass + "-inverse");
+        $on = this.$on.clone(true);
+        $off = this.$off.clone(true);
+        this.$on.replaceWith($off);
+        this.$off.replaceWith($on);
+        this.$on = $off;
+        this.$off = $on;
+        this.options.inverse = !this.options.inverse;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onColor = function(value) {
+        var color;
+        color = this.options.onColor;
+        if (typeof value === "undefined") {
+          return color;
+        }
+        if (color != null) {
+          this.$on.removeClass(this.options.baseClass + "-" + color);
+        }
+        this.$on.addClass(this.options.baseClass + "-" + value);
+        this.options.onColor = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.offColor = function(value) {
+        var color;
+        color = this.options.offColor;
+        if (typeof value === "undefined") {
+          return color;
+        }
+        if (color != null) {
+          this.$off.removeClass(this.options.baseClass + "-" + color);
+        }
+        this.$off.addClass(this.options.baseClass + "-" + value);
+        this.options.offColor = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onText;
+        }
+        this.$on.html(value);
+        this._width();
+        this._containerPosition();
+        this.options.onText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.offText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.offText;
+        }
+        this.$off.html(value);
+        this._width();
+        this._containerPosition();
+        this.options.offText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.labelText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.labelText;
+        }
+        this.$label.html(value);
+        this._width();
+        this.options.labelText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.handleWidth = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.handleWidth;
+        }
+        this.options.handleWidth = value;
+        this._width();
+        this._containerPosition();
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.labelWidth = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.labelWidth;
+        }
+        this.options.labelWidth = value;
+        this._width();
+        this._containerPosition();
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.baseClass = function(value) {
+        return this.options.baseClass;
+      };
+
+      BootstrapSwitch.prototype.wrapperClass = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.wrapperClass;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.wrapperClass;
+        }
+        this.$wrapper.removeClass(this._getClasses(this.options.wrapperClass).join(" "));
+        this.$wrapper.addClass(this._getClasses(value).join(" "));
+        this.options.wrapperClass = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.radioAllOff = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.radioAllOff;
+        }
+        value = !!value;
+        if (value === this.options.radioAllOff) {
+          return this.$element;
+        }
+        this.options.radioAllOff = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onInit = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onInit;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.onInit;
+        }
+        this.options.onInit = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onSwitchChange = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onSwitchChange;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.onSwitchChange;
+        }
+        this.options.onSwitchChange = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.destroy = function() {
+        var $form;
+        $form = this.$element.closest("form");
+        if ($form.length) {
+          $form.off("reset.bootstrapSwitch").removeData("bootstrap-switch");
+        }
+        this.$container.children().not(this.$element).remove();
+        this.$element.unwrap().unwrap().off(".bootstrapSwitch").removeData("bootstrap-switch");
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype._width = function() {
+        var $handles, handleWidth;
+        $handles = this.$on.add(this.$off);
+        $handles.add(this.$label).css("width", "");
+        handleWidth = this.options.handleWidth === "auto" ? Math.max(this.$on.width(), this.$off.width()) : this.options.handleWidth;
+        $handles.width(handleWidth);
+        this.$label.width((function(_this) {
+          return function(index, width) {
+            if (_this.options.labelWidth !== "auto") {
+              return _this.options.labelWidth;
+            }
+            if (width < handleWidth) {
+              return handleWidth;
+            } else {
+              return width;
+            }
+          };
+        })(this));
+        this._handleWidth = this.$on.outerWidth();
+        this._labelWidth = this.$label.outerWidth();
+        this.$container.width((this._handleWidth * 2) + this._labelWidth);
+        return this.$wrapper.width(this._handleWidth + this._labelWidth);
+      };
+
+      BootstrapSwitch.prototype._containerPosition = function(state, callback) {
+        if (state == null) {
+          state = this.options.state;
+        }
+        this.$container.css("margin-left", (function(_this) {
+          return function() {
+            var values;
+            values = [0, "-" + _this._handleWidth + "px"];
+            if (_this.options.indeterminate) {
+              return "-" + (_this._handleWidth / 2) + "px";
+            }
+            if (state) {
+              if (_this.options.inverse) {
+                return values[1];
+              } else {
+                return values[0];
+              }
+            } else {
+              if (_this.options.inverse) {
+                return values[0];
+              } else {
+                return values[1];
+              }
+            }
+          };
+        })(this));
+        if (!callback) {
+          return;
+        }
+        return setTimeout(function() {
+          return callback();
+        }, 50);
+      };
+
+      BootstrapSwitch.prototype._init = function() {
+        var init, initInterval;
+        init = (function(_this) {
+          return function() {
+            _this.setPrevOptions();
+            _this._width();
+            return _this._containerPosition(null, function() {
+              if (_this.options.animate) {
+                return _this.$wrapper.addClass(_this.options.baseClass + "-animate");
+              }
+            });
+          };
+        })(this);
+        if (this.$wrapper.is(":visible")) {
+          return init();
+        }
+        return initInterval = window.setInterval((function(_this) {
+          return function() {
+            if (_this.$wrapper.is(":visible")) {
+              init();
+              return window.clearInterval(initInterval);
+            }
+          };
+        })(this), 50);
+      };
+
+      BootstrapSwitch.prototype._elementHandlers = function() {
+        return this.$element.on({
+          "setPreviousOptions.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              return _this.setPrevOptions();
+            };
+          })(this),
+          "previousState.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              _this.options = _this.prevOptions;
+              if (_this.options.indeterminate) {
+                _this.$wrapper.addClass(_this.options.baseClass + "-indeterminate");
+              }
+              return _this.$element.prop("checked", _this.options.state).trigger("change.bootstrapSwitch", true);
+            };
+          })(this),
+          "change.bootstrapSwitch": (function(_this) {
+            return function(e, skip) {
+              var state;
+              e.preventDefault();
+              e.stopImmediatePropagation();
+              state = _this.$element.is(":checked");
+              _this._containerPosition(state);
+              if (state === _this.options.state) {
+                return;
+              }
+              _this.options.state = state;
+              _this.$wrapper.toggleClass(_this.options.baseClass + "-off").toggleClass(_this.options.baseClass + "-on");
+              if (!skip) {
+                if (_this.$element.is(":radio")) {
+                  $("[name='" + (_this.$element.attr('name')) + "']").not(_this.$element).prop("checked", false).trigger("change.bootstrapSwitch", true);
+                }
+                return _this.$element.trigger("switchChange.bootstrapSwitch", [state]);
+              }
+            };
+          })(this),
+          "focus.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              e.preventDefault();
+              return _this.$wrapper.addClass(_this.options.baseClass + "-focused");
+            };
+          })(this),
+          "blur.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              e.preventDefault();
+              return _this.$wrapper.removeClass(_this.options.baseClass + "-focused");
+            };
+          })(this),
+          "keydown.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              if (!e.which || _this.options.disabled || _this.options.readonly) {
+                return;
+              }
+              switch (e.which) {
+                case 37:
+                  e.preventDefault();
+                  e.stopImmediatePropagation();
+                  return _this.state(false);
+                case 39:
+                  e.preventDefault();
+                  e.stopImmediatePropagation();
+                  return _this.state(true);
+              }
+            };
+          })(this)
+        });
+      };
+
+      BootstrapSwitch.prototype._handleHandlers = function() {
+        this.$on.on("click.bootstrapSwitch", (function(_this) {
+          return function(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            _this.state(false);
+            return _this.$element.trigger("focus.bootstrapSwitch");
+          };
+        })(this));
+        return this.$off.on("click.bootstrapSwitch", (function(_this) {
+          return function(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            _this.state(true);
+            return _this.$element.trigger("focus.bootstrapSwitch");
+          };
+        })(this));
+      };
+
+      BootstrapSwitch.prototype._labelHandlers = function() {
+        return this.$label.on({
+          "click": function(e) {
+            return e.stopPropagation();
+          },
+          "mousedown.bootstrapSwitch touchstart.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              if (_this._dragStart || _this.options.disabled || _this.options.readonly) {
+                return;
+              }
+              e.preventDefault();
+              e.stopPropagation();
+              _this._dragStart = (e.pageX || e.originalEvent.touches[0].pageX) - parseInt(_this.$container.css("margin-left"), 10);
+              if (_this.options.animate) {
+                _this.$wrapper.removeClass(_this.options.baseClass + "-animate");
+              }
+              return _this.$element.trigger("focus.bootstrapSwitch");
+            };
+          })(this),
+          "mousemove.bootstrapSwitch touchmove.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              var difference;
+              if (_this._dragStart == null) {
+                return;
+              }
+              e.preventDefault();
+              difference = (e.pageX || e.originalEvent.touches[0].pageX) - _this._dragStart;
+              if (difference < -_this._handleWidth || difference > 0) {
+                return;
+              }
+              _this._dragEnd = difference;
+              return _this.$container.css("margin-left", _this._dragEnd + "px");
+            };
+          })(this),
+          "mouseup.bootstrapSwitch touchend.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              var state;
+              if (!_this._dragStart) {
+                return;
+              }
+              e.preventDefault();
+              if (_this.options.animate) {
+                _this.$wrapper.addClass(_this.options.baseClass + "-animate");
+              }
+              if (_this._dragEnd) {
+                state = _this._dragEnd > -(_this._handleWidth / 2);
+                _this._dragEnd = false;
+                _this.state(_this.options.inverse ? !state : state);
+              } else {
+                _this.state(!_this.options.state);
+              }
+              return _this._dragStart = false;
+            };
+          })(this),
+          "mouseleave.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              return _this.$label.trigger("mouseup.bootstrapSwitch");
+            };
+          })(this)
+        });
+      };
+
+      BootstrapSwitch.prototype._externalLabelHandler = function() {
+        var $externalLabel;
+        $externalLabel = this.$element.closest("label");
+        return $externalLabel.on("click", (function(_this) {
+          return function(event) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (event.target === $externalLabel[0]) {
+              return _this.toggleState();
+            }
+          };
+        })(this));
+      };
+
+      BootstrapSwitch.prototype._formHandler = function() {
+        var $form;
+        $form = this.$element.closest("form");
+        if ($form.data("bootstrap-switch")) {
+          return;
+        }
+        return $form.on("reset.bootstrapSwitch", function() {
+          return window.setTimeout(function() {
+            return $form.find("input").filter(function() {
+              return $(this).data("bootstrap-switch");
+            }).each(function() {
+              return $(this).bootstrapSwitch("state", this.checked);
+            });
+          }, 1);
+        }).data("bootstrap-switch", true);
+      };
+
+      BootstrapSwitch.prototype._getClasses = function(classes) {
+        var c, cls, i, len;
+        if (!$.isArray(classes)) {
+          return [this.options.baseClass + "-" + classes];
+        }
+        cls = [];
+        for (i = 0, len = classes.length; i < len; i++) {
+          c = classes[i];
+          cls.push(this.options.baseClass + "-" + c);
+        }
+        return cls;
+      };
+
+      return BootstrapSwitch;
+
+    })();
+    $.fn.bootstrapSwitch = function() {
+      var args, option, ret;
+      option = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+      ret = this;
+      this.each(function() {
+        var $this, data;
+        $this = $(this);
+        data = $this.data("bootstrap-switch");
+        if (!data) {
+          $this.data("bootstrap-switch", data = new BootstrapSwitch(this, option));
+        }
+        if (typeof option === "string") {
+          return ret = data[option].apply(data, args);
+        }
+      });
+      return ret;
+    };
+    $.fn.bootstrapSwitch.Constructor = BootstrapSwitch;
+    return $.fn.bootstrapSwitch.defaults = {
+      state: true,
+      size: null,
+      animate: true,
+      disabled: false,
+      readonly: false,
+      indeterminate: false,
+      inverse: false,
+      radioAllOff: false,
+      onColor: "primary",
+      offColor: "default",
+      onText: "ON",
+      offText: "OFF",
+      labelText: "&nbsp;",
+      handleWidth: "auto",
+      labelWidth: "auto",
+      baseClass: "bootstrap-switch",
+      wrapperClass: "wrapper",
+      onInit: function() {},
+      onSwitchChange: function() {}
+    };
+  })(window.jQuery, window);
+
+}).call(this);

src/main/resources/web/js/trader.js

@@ -0,0 +1,110 @@
+// --------------------------------------------------------
+//                      Autostart
+// --------------------------------------------------------
+
+$(function(){
+    $(".toggle-switch").bootstrapSwitch();
+
+    $(".timestamp").relTimestamp();
+});
+
+// --------------------------------------------------------
+// JQuery helper functions
+// --------------------------------------------------------
+
+// $.attr() # returns all attributes of an element
+(function(old) {
+    $.fn.attr = function() {
+        if(arguments.length === 0) {
+            if(this.length === 0) {
+                return null;
+            }
+
+            var obj = {};
+            $.each(this[0].attributes, function() {
+                if(this.specified) {
+                    obj[this.name] = this.value;
+                }
+            });
+            return obj;
+        }
+
+        return old.apply(this, arguments);
+    };
+})($.fn.attr);
+
+// --------------------------------------------------------
+// Timestamps
+// --------------------------------------------------------
+
+// Converts all timestamps to human readable time and date
+
+$.fn.relTimestamp = function() {
+    return this.each(function() {
+        var timestamp = parseInt($(this).text());
+        var timestampNow = Date.now();
+        var timeDiff = timestampNow - timestamp;
+
+        if(timeDiff < 10 * 60 * 1000) // less than 10 min
+            $(this).text(moment(timestamp).fromNow());
+        else if(timeDiff < 24 * 60 * 60 * 1000) // less than 24 hours
+            $(this).text(moment(timestamp).fromNow() + " ("+moment(timestamp).format("HH:mm")+")");
+        else
+            $(this).text(moment(timestamp).format("YYYY-MM-DD HH:mm"));
+        return this;
+    });
+};
+
+// --------------------------------------------------------
+// Dynamic forms
+// --------------------------------------------------------
+
+var dynamicConf = {};
+
+function initDynamicModalForm(modalId, formTemplateId = null, templateID = null){
+    // read in all configurations into global variable (to skip naming issues)
+    if (formTemplateId != null) {
+        dynamicConf[formTemplateId] = [];
+        $("#"+templateID+" div").each(function(){
+            dynamicConf[formTemplateId][$(this).attr("id")] = $(this).html();
+        });
+        // Update dynamic inputs
+        $("#"+modalId+" select[name=type]").change(function(){
+            $("#"+modalId+" #"+formTemplateId).html(dynamicConf[formTemplateId][$(this).val()]);
+        });
+    }
+
+    // click event
+    $("#"+modalId).on('show.bs.modal', function (event) {
+        var button = $(event.relatedTarget);
+        var modal = $(this);
+
+        // Reset all inputs
+        if (formTemplateId != null)
+            modal.find("#"+formTemplateId).empty(); // clear form div
+
+        // select dynamic form
+        var selector = modal.find("select[name=type]");
+        selector.val(button.data("type"));
+        selector.change(); // Update dynamic inputs
+        // set dynamic form data
+        $.each(button.attr(), function(fieldName, value) {
+            if(fieldName.startsWith("data-")) {
+                fieldName = fieldName.substring(5);
+                // case insensitive search
+                input = modal.find("input").filter(function() {
+                       return this.name.toLowerCase() == fieldName;
+                });
+                if (input.attr("type") == "checkbox") { // special handling for checkboxes
+                    input.attr("value", "true");
+                    if (value=="true") input.attr("checked", "true");
+                    else               input.removeAttr("checked");
+                    // Add default false value as a unchecked checkbox is not included in the post
+                    input.parent().prepend("<input type='hidden' name='"+input.attr("name")+"' value='false' />");
+                } else {
+                    input.val(value);
+                }
+            }
+        });
+    });
+}

src/main/resources/web/main.tmpl

@@ -1,4 +1,3 @@
-
 <!doctype html>
 <html lang="en">
 <head>
@@ -7,21 +6,23 @@
     <meta name="description" content="">
     <title>Trader</title>
 
-    <!-- Bootstrap core CSS -->
-    <link href="css/bootstrap.min.js">
+    <!-- CSS -->
+    <link href="css/bootstrap.min.css" rel="stylesheet">
+    <link href="css/bootstrap-switch.min.css" rel="stylesheet">
+    <link href="css/trader.css" rel="stylesheet">
 
-    <!-- Favicons -->
-    <link rel="apple-touch-icon" href="/docs/5.0/assets/img/favicons/apple-touch-icon.png" sizes="180x180">
-    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon-32x32.png" sizes="32x32" type="image/png">
-    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon-16x16.png" sizes="16x16" type="image/png">
-    <link rel="manifest" href="/docs/5.0/assets/img/favicons/manifest.json">
-    <link rel="mask-icon" href="/docs/5.0/assets/img/favicons/safari-pinned-tab.svg" color="#7952b3">
-    <link rel="icon" href="/docs/5.0/assets/img/favicons/favicon.ico">
+    <!-- Javascript -->
+    <link href="css/bootstrap.min.js">
+    <link href="css/bootstrap-switch.min.js">
+    <link href="css/echarts.min.js">
+
+    <link href="css/trader.js">
+    <link href="css/trader_chart.js">
 </head>
 
 <body>
     <header class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0 shadow">
-        <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="#">Company name</a>
+        <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="#">Trader</a>
         <button class="navbar-toggler position-absolute d-md-none collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#sidebarMenu" aria-controls="sidebarMenu" aria-expanded="false" aria-label="Toggle navigation">
             <span class="navbar-toggler-icon"></span>
         </button>

src/main/resources/web/main_alerts.tmpl

@@ -0,0 +1,50 @@
+{{#alerts}}
+    {{#.isError()}}
+        <div class="alert alert-danger alert-dismissible fade in" role="alert">
+            <button type="button" class="close" data-dismiss="alert" aria-label="Close" data-id="{{.getId()}}">
+                <span aria-hidden="true">&times;</span>
+            </button>
+            <span class="glyphicon glyphicon-minus-sign" aria-hidden="true"></span>
+            <strong>{{.getTitle()}}</strong> &nbsp;
+            {{#.getMessage()}}{{.getMessage()}}{{/.getMessage()}}
+        </div>
+    {{/.isError()}}
+    {{#.isWarning()}}
+        <div class="alert alert-warning alert-dismissible fade in" role="alert">
+            <button type="button" class="close" data-dismiss="alert" aria-label="Close" data-id="{{.getId()}}">
+                <span aria-hidden="true">&times;</span>
+            </button>
+            <span class="glyphicon glyphicon-warning-sign" aria-hidden="true"></span>
+            <strong>{{.getTitle()}}</strong> &nbsp;
+            {{#.getMessage()}}{{.getMessage()}}{{/.getMessage()}}
+        </div>
+    {{/.isWarning()}}
+    {{#.isSuccess()}}
+    <div class="alert alert-success alert-dismissible fade in" role="alert">
+        <button type="button" class="close" data-dismiss="alert" aria-label="Close" data-id="{{.getId()}}">
+            <span aria-hidden="true">&times;</span>
+        </button>
+        <span class="glyphicon glyphicon-ok-circle" aria-hidden="true"></span>
+        <strong>{{.getTitle()}}</strong> &nbsp;
+        {{#.getMessage()}}{{.getMessage()}}{{/.getMessage()}}
+    </div>
+    {{/.isSuccess()}}
+    {{#.isInfo()}}
+        <div class="alert alert-info alert-dismissible fade in" role="alert">
+            <button type="button" class="close" data-dismiss="alert" aria-label="Close" data-id="{{.getId()}}">
+                <span aria-hidden="true">&times;</span>
+            </button>
+            <span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span>
+            <strong>{{.getTitle()}}</strong> &nbsp;
+            {{#.getMessage()}}{{.getMessage()}}{{/.getMessage()}}
+        </div>
+    {{/.isInfo()}}
+{{/alerts}}
+
+<script>
+    $(function(){
+        $(".alert .close").click(function(event){
+            $.get("{{serviceUrl}}?action=dismiss&id="+$(this).data("id"));
+        });
+    });
+</script>

src/main/resources/web/symbol_config.tmpl

@@ -0,0 +1,89 @@
+<h1 class="page-header">Symbol Configuration</h1>
+
+<div class="col-md-12">
+    <div class="panel panel-default drop-shadow">
+        <div class="panel-heading">Symbols</div>
+        <div class="panel-body">
+
+            <table class="table table-hover table-condensed">
+                <thead>
+                    <th>Name</th>
+                    <th>Type</th>
+                    <th>Configuration</th>
+                    <th>
+                        <button class="btn btn-default btn-xs pull-right" data-toggle="modal"
+                                data-target="#symbolModal"
+                                data-action="create_symbol">
+                            <span class="glyphicon glyphicon-plus"></span>
+                        </button>
+                    </th>
+                </thead>
+                {{#symbols}}
+                <tr>
+                    <td>{{.getName()}}</td>
+                    <td>{{.getType()}}</td>
+                    <td>{{.getDeviceConfig()}}</td>
+                    <td>
+                        <form method="POST">
+                            <input type="hidden" name="id" value="{{.getId()}}">
+
+                            <div class="btn-toolbar pull-right">
+                                <button type="button" class="btn btn-default btn-xs" data-toggle="modal"
+                                        data-target="#symbolModal"
+                                        data-action="modify_symbol"
+                                        data-id="{{.getId()}}"
+                                        data-name="{{.getName()}}"
+                                        data-type="{{.getType()}}"
+                                        {{#.getDeviceConfigurator().getConfiguration()}}
+                                        data-{{.getName()}}="{{.getString()}}"
+                                        {{/.getDeviceConfigurator().getConfiguration()}}
+                                        >
+                                    <span class="glyphicon glyphicon-pencil"></span>
+                                </button>
+
+                                <button type="submit" class="btn btn-danger btn-xs" name="action" value="remove_symbol">
+                                    <span class="glyphicon glyphicon-trash"></span>
+                                </button>
+                            </div>
+                        </form>
+                    </td>
+                </tr>
+                {{/symbols}}
+            </table>
+        </div>
+    </div>
+</div>
+
+
+<!------------- MODALS --------------->
+<script>
+    $(function(){
+        initDynamicModalForm("symbolModal");
+    });
+</script>
+
+<div class="modal fade" id="symbolModal" tabindex="-1">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <button type="button" class="close" data-dismiss="modal"><span>&times;</span></button>
+                <h4 class="modal-title">Symbol</h4>
+            </div>
+            <form method="POST">
+                <div class="modal-body">
+                    <input type="hidden" id="action" name="action">
+                    <input type="hidden" id="id" name="id">
+                    <div class="form-group">
+                        <label class="control-label">Name:</label>
+                        <input type="text" class="form-control" name="name">
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="reset" class="btn btn-default" data-dismiss="modal">Cancel</button>
+                    <button type="submit" class="btn btn-primary">Save</button>
+                </div>
+            </form>
+        </div>
+    </div>
+</div>
+

src/test/java/se/koc/trader/exchange/binance/BinanceMarketTest.java

@@ -0,0 +1,22 @@
+package se.koc.trader.exchange.binance;
+
+import org.junit.jupiter.api.Test;
+import zutil.net.ws.rest.RESTClientFactory;
+
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import java.io.*;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BinanceMarketTest {
+
+    @Test
+    public void getServerTime() {
+        BinanceMarket market = new BinanceMarket();
+        assertTrue(market.getServerTime() > 0, "Unable to retrieve server time");
+    }
+
+}

src/test/java/se/koc/trader/exchange/binance/BinanceRestAPITest.java

@@ -1,28 +0,0 @@
-package se.koc.trader.exchange.binance;
-
-import org.junit.jupiter.api.Test;
-import zutil.net.ws.rest.RESTClientFactory;
-
-import java.net.MalformedURLException;
-import java.net.URL;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class BinanceRestAPITest {
-
-    public BinanceRestAPI getRestAPI() {
-        try {
-            return RESTClientFactory.createClient(new URL("https://api.binance.com"), BinanceRestAPI.class);
-        } catch (MalformedURLException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-
-
-    @Test
-    public void getServerTime() {
-        BinanceRestAPI rest = getRestAPI();
-        assertTrue(rest.getServerTime() > 0, "Unable to retrieve server time");
-    }
-}