Feature/edge dashboard app

core/httpserver/src/main/java/com/nubeiot/core/http/HttpServer.java

@@ -177,10 +177,12 @@ private void initStaticWebRouter(Router mainRouter, StaticWebConfig webConfig) {
             return;
         }
         final StaticHandler staticHandler = StaticHandler.create();
+        String webDir;
         if (webConfig.isInResource()) {
-            staticHandler.setWebRoot(webConfig.getWebRoot());
+            webDir = webConfig.getWebRoot();
+            staticHandler.setWebRoot(webDir);
         } else {
-            String webDir = FileUtils.createFolder(dataDir, webConfig.getWebRoot());
+            webDir = FileUtils.createFolder(dataDir, webConfig.getWebRoot());
             logger.info("Static web dir {}", webDir);
             staticHandler.setEnableRangeSupport(true)
                          .setSendVaryHeader(true)
@@ -191,6 +193,7 @@ private void initStaticWebRouter(Router mainRouter, StaticWebConfig webConfig) {
         }
         mainRouter.route(Urls.combinePath(webConfig.getWebPath(), ApiConstants.WILDCARDS_ANY_PATH))
                   .handler(staticHandler);
+        mainRouter.route("/*").handler(ctx -> ctx.response().sendFile(Urls.combinePath(webDir, "index.html")));
     }
 
     private Router initRestRouter(Router mainRouter, RestConfig restConfig) {

dashboard/server/src/main/java/com/nubeiot/dashboard/controllers/MenuController.java

@@ -1,6 +1,5 @@
 package com.nubeiot.dashboard.controllers;
 
-import static com.nubeiot.dashboard.Role.ADMIN;
 import static com.nubeiot.dashboard.constants.Collection.MENU;
 import static com.nubeiot.dashboard.utils.UserUtils.getRole;
 
@@ -80,16 +79,18 @@ private Future<ResponseData> handleMenuForUserGroup(RoutingContext ctx, MongoCli
         Future<ResponseData> future = Future.future();
         JsonObject user = ctx.user().principal();
 
-        Single.just(getRole(user)).flatMap(role -> {
-                if (role == Role.SUPER_ADMIN || role == ADMIN) {
-                    String siteId = ctx.request().getParam("id");
-                    return mongoClient.rxFindOne(MENU, new JsonObject().put("site_id", siteId), null)
-                        .map(menu -> menu != null ? menu : new JsonObject());
-                } else {
-                    throw HttpException.forbidden();
-                }
-        }).subscribe(menu -> future.complete(ResponseDataWriter.serializeResponseData(menu.toString())),
-                       throwable -> future.complete(ResponseDataConverter.convert(throwable)));
+        Single.just(getRole(user))
+              .flatMap(role -> {
+                  if (role == Role.SUPER_ADMIN || role == Role.ADMIN || role == Role.MANAGER) {
+                      String siteId = ctx.request().getParam("id");
+                      return mongoClient.rxFindOne(MENU, new JsonObject().put("site_id", siteId), null)
+                                        .map(menu -> menu != null ? menu : new JsonObject());
+                  } else {
+                      throw HttpException.forbidden();
+                  }
+              })
+              .subscribe(menu -> future.complete(ResponseDataWriter.serializeResponseData(menu.toString())),
+                         throwable -> future.complete(ResponseDataConverter.convert(throwable)));
         return future;
     }
 
@@ -129,8 +130,8 @@ private void handleMenuPutRecord(RoutingContext ctx, MongoClient mongoClient, St
         JsonObject query = new JsonObject().put("site_id", siteId).put("id", id).put("menu.id", menuId);
         JsonObject update = new JsonObject().put("$set", new JsonObject().put("menu.$", body));
         mongoClient.rxUpdateCollection(collection, query, update)
-            .subscribe(ignored -> future.complete(new ResponseData()),
-                       throwable -> future.complete(ResponseDataHelper.internalServerError(throwable.getMessage())));
+                   .subscribe(ignored -> future.complete(new ResponseData()), throwable -> future.complete(
+                       ResponseDataHelper.internalServerError(throwable.getMessage())));
     }
 
     private Future<ResponseData> handleDelete(RoutingContext ctx, MongoClient mongoClient, String collection) {
@@ -168,8 +169,8 @@ private void handleMenuDeleteRecord(RoutingContext ctx, MongoClient mongoClient,
         JsonObject update = new JsonObject().put("$pull",
                                                  new JsonObject().put("menu", new JsonObject().put("id", menuId)));
         mongoClient.rxUpdateCollection(collection, query, update)
-            .subscribe(ignored -> future.complete(new ResponseData()),
-                       throwable -> future.complete(ResponseDataHelper.internalServerError(throwable.getMessage())));
+                   .subscribe(ignored -> future.complete(new ResponseData()), throwable -> future.complete(
+                       ResponseDataHelper.internalServerError(throwable.getMessage())));
     }
 
 }

dashboard/server/src/main/java/com/nubeiot/dashboard/controllers/MultiTenantUserController.java

@@ -13,6 +13,7 @@
 import static com.nubeiot.dashboard.utils.DispatchUtils.dispatchRequests;
 import static com.nubeiot.dashboard.utils.UserUtils.getCompanyId;
 import static com.nubeiot.dashboard.utils.UserUtils.getRole;
+import static com.nubeiot.dashboard.utils.UserUtils.getSiteId;
 import static com.nubeiot.dashboard.utils.UserUtils.hasClientLevelRole;
 import static com.nubeiot.dashboard.utils.UserUtils.hasUserLevelRole;
 
@@ -759,7 +760,10 @@ private Future<ResponseData> handleGetUsers(RoutingContext ctx, MongoClient mong
                 userRepresentation(mongoClient, getUserQuery, future);
             }, throwable -> future.complete(ResponseDataConverter.convert(throwable)));
         } else if (role == Role.MANAGER) {
-            userRepresentation(mongoClient, new JsonObject().put("associated_company_id", companyId), future);
+            JsonObject roleFilter = new JsonObject().put("$in", new JsonArray().add(Role.USER.toString())
+                                                                               .add(Role.GUEST.toString()));
+            userRepresentation(mongoClient, new JsonObject().put("site_id", getSiteId(user)).put("role", roleFilter),
+                               future);
         } else {
             future.complete(ResponseDataHelper.forbidden());
         }

dashboard/server/src/main/java/com/nubeiot/dashboard/controllers/MultiTenantUserGroupController.java

@@ -118,7 +118,7 @@ private Future<ResponseData> handleGetUserGroups(RoutingContext ctx, MongoClient
                     return byAdminCompanyGetManagerSelectionListQuery(mongoClient, companyId).flatMap(
                         query -> mongoClient.rxFind(USER_GROUP, query));
                 } else if (role == Role.MANAGER) {
-                    return mongoClient.rxFind(USER_GROUP, new JsonObject().put("associated_company_id", companyId));
+                    return mongoClient.rxFind(USER_GROUP, new JsonObject().put("site_id", getSiteId(user)));
                 } else {
                     return mongoClient.rxFind(USER_GROUP, new JsonObject().put("_id", user.getString("group_id")));
                 }

edge/connector/dashboard/README.md

@@ -0,0 +1,64 @@
+# Edge Dashboard App
+
+This is an `App` for installing `Edge Dashboard`.
+
+## Basic Concept 
+A Java server which wraps the `Edge Dashboard`'s built static files inside a folder for serving it as frontend resource.
+
+## Installation example
+`POST`: `http://{{edge_gateway_api}}/api/services`
+```
+{
+  "metadata": {
+    "group_id": "com.nubeiot.edge.connector",
+    "artifact_id": "dashboard",
+    "service_name": "edge-connector-dashboard",
+    "version": "1.0.0-SNAPSHOT"
+  }
+}
+```
+
+## Endpoints
+
+Have some endpoint:
+
+- `GET (http://{{edge_dashboard_api}}/api/edge-dashboard/connection)`: For getting dynamic connection details
+
+`Output:`
+```
+{
+    "records": [
+        {
+            "id": 1,
+            "gateway_schema": "http",
+            "gateway_host": "localhost",
+            "gateway_port": 8380,
+            "gateway_api": "/gw2",
+            "gateway_root_api": "/api",
+            "nodered_schema": "http",
+            "nodered_host": "localhost",
+            "nodered_port": 1880,
+            "created_at": "2019-11-27T17:58:08.042Z",
+            "modified_at": "2019-11-27T17:58:33.152Z"
+        }
+    ]
+}
+```
+
+`------------------------------------------------------------------------------`
+- `PATCH (http://{{edge_dashboard_api}}/api/edge-dashboard/connection/1)`: For patch connection detail:
+
+`Body:`
+```
+{
+    "gateway_schema": "http",
+    "gateway_host": "localhost",
+    "gateway_api": "/gw",
+    "gateway_port": 8380,
+    "gateway_root_api": "/api",
+    "nodered_schema": "http",
+    "nodered_host": "localhost",
+    "nodered_port": 1880
+}
+```
+

edge/connector/dashboard/build.gradle

@@ -0,0 +1,15 @@
+import com.nubeiot.buildscript.jooq.JooqGenerateTask
+
+dependencies {
+    compile project(':core:base')
+    compile project(':core:httpserver')
+    compile project(':core:sql')
+    compile project.deps.database.h2
+}
+
+task jooqGen(type: JooqGenerateTask) {
+    packageName = "com.nubeiot.edge.connector.dashboard.model"
+    enumTypes = project(':core:sql').ext.enumTypes
+    dbTypes = project(':core:sql').ext.dbTypes
+    javaTypes = project(':core:sql').ext.javaTypes
+}

edge/connector/dashboard/gradle.properties

@@ -0,0 +1,6 @@
+title=EdgeDashboardServer
+executable=true
+standalone=false
+mainClass=com.nubeiot.core.NubeLauncher
+mainVerticle=com.nubeiot.edge.connector.dashboard.EdgeDashboardServerVerticle
+serviceDescriptor=edge-connector-dashboard

edge/connector/dashboard/src/main/java/com/nubeiot/edge/connector/dashboard/EdgeDashboardConnectionConfig.java

@@ -0,0 +1,39 @@
+package com.nubeiot.edge.connector.dashboard;
+
+import com.fasterxml.jackson.databind.PropertyNamingStrategy.SnakeCaseStrategy;
+import com.fasterxml.jackson.databind.annotation.JsonNaming;
+import com.nubeiot.core.IConfig;
+import com.nubeiot.core.NubeConfig.AppConfig;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter(value = AccessLevel.PACKAGE)
+@JsonNaming(value = SnakeCaseStrategy.class)
+@NoArgsConstructor(access = AccessLevel.PACKAGE)
+public class EdgeDashboardConnectionConfig implements IConfig {
+
+    public static final String NAME = "__edge_dashboard_connection__";
+
+    private String gatewaySchema = "http";
+    private String gatewayHost = "localhost";
+    private int gatewayPort = 8080;
+    private String gatewayApi = "/gw";
+    private String gatewayRootApi = "/api";
+    private String noderedSchema = "http";
+    private String noderedHost = "localhost";
+    private int noderedPort = 1880;
+
+    @Override
+    public String key() {
+        return NAME;
+    }
+
+    @Override
+    public Class<? extends IConfig> parent() { return AppConfig.class; }
+
+}
+

edge/connector/dashboard/src/main/java/com/nubeiot/edge/connector/dashboard/EdgeDashboardEntityHandler.java

@@ -0,0 +1,68 @@
+package com.nubeiot.edge.connector.dashboard;
+
+import static com.nubeiot.edge.connector.dashboard.model.tables.TblDashboardConnection.TBL_DASHBOARD_CONNECTION;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.Optional;
+
+import org.jooq.Configuration;
+
+import io.reactivex.Single;
+import io.vertx.core.Vertx;
+import io.vertx.core.json.JsonObject;
+
+import com.nubeiot.core.IConfig;
+import com.nubeiot.core.event.EventAction;
+import com.nubeiot.core.event.EventMessage;
+import com.nubeiot.core.sql.AbstractEntityHandler;
+import com.nubeiot.core.utils.DateTimes;
+import com.nubeiot.edge.connector.dashboard.model.tables.daos.TblDashboardConnectionDao;
+import com.nubeiot.edge.connector.dashboard.model.tables.interfaces.ITblDashboardConnection;
+import com.nubeiot.edge.connector.dashboard.model.tables.pojos.TblDashboardConnection;
+
+public class EdgeDashboardEntityHandler extends AbstractEntityHandler {
+
+    private final TblDashboardConnectionDao connectionDao;
+
+    protected EdgeDashboardEntityHandler(Configuration configuration, Vertx vertx) {
+        super(configuration, vertx);
+        connectionDao = dao(TblDashboardConnectionDao.class);
+    }
+
+    @Override
+    public boolean isNew() {
+        return isNew(TBL_DASHBOARD_CONNECTION);
+    }
+
+    @Override
+    public Single<EventMessage> initData() {
+        EdgeDashboardConnectionConfig config = IConfig.from(
+            sharedData(EdgeDashboardServerVerticle.SHARED_EDGE_DASHBOARD_CONNECTION_CONFIG),
+            EdgeDashboardConnectionConfig.class);
+        ITblDashboardConnection dashboardConnection = new TblDashboardConnection().fromJson(config.toJson());
+        OffsetDateTime now = DateTimes.now();
+        return connectionDao.insert((TblDashboardConnection) dashboardConnection.setCreatedAt(now).setModifiedAt(now))
+                            .map(i -> EventMessage.success(EventAction.INIT, dashboardConnection.toJson()));
+    }
+
+    @Override
+    public Single<EventMessage> migrate() {
+        return Single.just(EventMessage.success(EventAction.MIGRATE, new JsonObject()));
+    }
+
+    Single<List<TblDashboardConnection>> findDashboardConnectionRecords() {
+        return connectionDao.findAll();
+    }
+
+    Single<Optional<TblDashboardConnection>> findDashboardConnectionRecord(String value) {
+        return connectionDao.findOneById(Byte.parseByte(value));
+    }
+
+    Single<Integer> updateRecord(JsonObject record) {
+        TblDashboardConnection dashboardConnection = (TblDashboardConnection) new TblDashboardConnection().fromJson(
+            record);
+        return connectionDao.update(dashboardConnection);
+    }
+
+}

edge/connector/dashboard/src/main/java/com/nubeiot/edge/connector/dashboard/EdgeDashboardEventHandler.java

@@ -0,0 +1,55 @@
+package com.nubeiot.edge.connector.dashboard;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.reactivex.Single;
+import io.vertx.core.json.JsonObject;
+
+import com.nubeiot.core.dto.RequestData;
+import com.nubeiot.core.event.EventAction;
+import com.nubeiot.core.event.EventContractor;
+import com.nubeiot.core.event.EventListener;
+import com.nubeiot.core.exceptions.NotFoundException;
+import com.nubeiot.core.utils.DateTimes;
+import com.nubeiot.edge.connector.dashboard.model.tables.interfaces.ITblDashboardConnection;
+
+import lombok.NonNull;
+import lombok.Setter;
+
+public class EdgeDashboardEventHandler implements EventListener {
+
+    @Setter
+    EdgeDashboardEntityHandler entityHandler;
+
+    @EventContractor(action = EventAction.GET_LIST, returnType = Single.class)
+    public Single<JsonObject> get(RequestData data) {
+        return entityHandler.findDashboardConnectionRecords()
+                            .flattenAsObservable(r -> r)
+                            .flatMapSingle(r -> Single.just(r.toJson()))
+                            .toList()
+                            .map(r -> new JsonObject().put("records", r));
+    }
+
+    @EventContractor(action = EventAction.PATCH, returnType = Single.class)
+    public Single<JsonObject> patch(RequestData data) {
+        JsonObject body = data.body();
+        return entityHandler.findDashboardConnectionRecord(body.getString("id"))
+                            .map(r -> r.orElseThrow(() -> new NotFoundException("No record with given 'id' to Patch")))
+                            .map(r -> r.setModifiedAt(DateTimes.now()))
+                            .map(ITblDashboardConnection::toJson)
+                            .map(r -> {
+                                body.remove("id");
+                                return r.mergeIn(data.body());
+                            })
+                            .flatMap(r -> entityHandler.updateRecord(r).map(v -> r));
+    }
+
+    @Override
+    public @NonNull List<EventAction> getAvailableEvents() {
+        return Collections.unmodifiableList(
+            new ArrayList<>(EdgeDashboardEventModel.EDGE_DASHBOARD_CONNECTION.getEvents()));
+    }
+
+}

edge/connector/dashboard/src/main/java/com/nubeiot/edge/connector/dashboard/EdgeDashboardEventModel.java

@@ -0,0 +1,17 @@
+package com.nubeiot.edge.connector.dashboard;
+
+import com.nubeiot.core.event.EventAction;
+import com.nubeiot.core.event.EventModel;
+import com.nubeiot.core.event.EventPattern;
+
+public class EdgeDashboardEventModel {
+
+    static final EventModel EDGE_DASHBOARD_CONNECTION = EventModel.builder()
+                                                                  .address(
+                                                                      "nubeiot.edge.connector.dashboard.connection")
+                                                                  .pattern(EventPattern.REQUEST_RESPONSE)
+                                                                  .local(true)
+                                                                  .addEvents(EventAction.GET_LIST, EventAction.PATCH)
+                                                                  .build();
+
+}

edge/connector/dashboard/src/main/java/com/nubeiot/edge/connector/dashboard/EdgeDashboardRestEventApi.java

@@ -0,0 +1,16 @@
+package com.nubeiot.edge.connector.dashboard;
+
+import com.nubeiot.core.http.rest.AbstractRestEventApi;
+
+import lombok.Getter;
+
+@Getter
+final class EdgeDashboardRestEventApi extends AbstractRestEventApi {
+
+    @Override
+    public EdgeDashboardRestEventApi initRouter() {
+        addRouter(EdgeDashboardEventModel.EDGE_DASHBOARD_CONNECTION, "/edge-dashboard/connection", "/:id");
+        return this;
+    }
+
+}