Gallardo7761/miarma-backend-vertx
Archived
1
1
Fork 0
Code Issues Pull Requests Actions Packages Releases 2 Activity

add: login working

Browse Source
This commit is contained in:
Jose
2025-12-21 08:33:58 +01:00
parent 5136a67fba
commit af675a32b8
24 changed files with 628 additions and 929 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
microservices/core/src/main/java/net/miarma/api/microservices/core/dao/UserDAO.java
View File

@@ -32,9 +32,11 @@ public class UserDAO implements DataAccessObject<UserEntity, UUID> {
Promise<UserEntity> promise = Promise.promise();
String query = QueryBuilder
.select(UserEntity.class)
.where(Map.of("user_id", id.toString()))
.where(Map.of("user_id", id))
.build();
System.out.println(query);
db.executeOne(query, UserEntity.class,
promise::complete,
promise::fail

12
microservices/core/src/main/java/net/miarma/api/microservices/core/entities/CredentialEntity.java
View File

@@ -1,14 +1,17 @@
package net.miarma.api.microservices.core.entities;
import java.time.LocalDateTime;
import java.util.UUID;
import com.google.gson.annotations.SerializedName;
import io.vertx.sqlclient.Row;
import net.miarma.api.backlib.annotations.APIDontReturn;
import net.miarma.api.backlib.annotations.Table;
import java.util.UUID;
import java.time.LocalDateTime;
import net.miarma.api.backlib.db.AbstractEntity;
@Table("credentials")
public class CredentialEntity {
public class CredentialEntity extends AbstractEntity {
@SerializedName("credential_id")
private UUID credentialId;
@@ -34,7 +37,8 @@ public class CredentialEntity {
@SerializedName("updated_at")
private LocalDateTime updatedAt;
public CredentialEntity() {}
public CredentialEntity() { }
public CredentialEntity(Row row) { super(row); }
public UUID getCredentialId() {
return credentialId;

22
microservices/core/src/main/java/net/miarma/api/microservices/core/entities/UserEntity.java
View File

@@ -3,6 +3,8 @@ package net.miarma.api.microservices.core.entities;
import java.time.LocalDateTime;
import java.util.UUID;
import com.google.gson.annotations.SerializedName;
import io.vertx.sqlclient.Row;
import net.miarma.api.backlib.annotations.Table;
import net.miarma.api.backlib.db.AbstractEntity;
@@ -11,14 +13,24 @@ import net.miarma.api.microservices.core.enums.CoreUserGlobalStatus;
@Table("users")
public class UserEntity extends AbstractEntity {
@SerializedName("user_id")
private UUID userId;
private String userName;
private String email;
@SerializedName("display_name")
private String displayName;
private String avatar;
@SerializedName("global_status")
private CoreUserGlobalStatus globalStatus;
@SerializedName("global_role")
private CoreUserGlobalRole globalRole;
@SerializedName("created_at")
private LocalDateTime createdAt;
@SerializedName("updated_at")
private LocalDateTime updatedAt;
public UserEntity() { }
@@ -27,12 +39,6 @@ public class UserEntity extends AbstractEntity {
public UUID getUserId() { return userId; }
public void setUserId(UUID userId) { this.userId = userId; }
public String getUserName() { return userName; }
public void setUserName(String userName) { this.userName = userName; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getDisplayName() { return displayName; }
public void setDisplayName(String displayName) { this.displayName = displayName; }

146
microservices/core/src/main/java/net/miarma/api/microservices/core/handlers/AuthHandler.java Normal file
View File

@@ -0,0 +1,146 @@
package net.miarma.api.microservices.core.handlers;
import java.util.UUID;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.google.gson.Gson;
import io.vertx.core.Vertx;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.RoutingContext;
import net.miarma.api.backlib.config.ConfigManager;
import net.miarma.api.backlib.gson.GsonProvider;
import net.miarma.api.backlib.http.ApiStatus;
import net.miarma.api.backlib.security.JWTManager;
import net.miarma.api.backlib.util.EventBusUtil;
import net.miarma.api.backlib.util.JsonUtil;
import net.miarma.api.microservices.core.entities.UserEntity;
@SuppressWarnings("unused")
public class AuthHandler {
private final Gson GSON = GsonProvider.get();
private final Vertx vertx;
private final String AUTH_EVENT_BUS = ConfigManager.getInstance()
.getStringProperty("eventbus.auth.address");
public AuthHandler(Vertx vertx) {
this.vertx = vertx;
}
public void login(RoutingContext ctx) {
vertx.eventBus().request(AUTH_EVENT_BUS, ctx.body().asJsonObject().put("action", "login"))
.onSuccess(reply -> JsonUtil.sendJson(ctx, ApiStatus.OK, reply.body()))
.onFailure(err -> EventBusUtil.handleReplyError(ctx, err));
}
public void loginValidate(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "loginValidate")
.put("userId", body.getInteger("userId"))
.put("password", body.getString("password"));
vertx.eventBus().request(AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void validateToken(RoutingContext ctx) {
String authHeader = ctx.request().getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
String token = authHeader.substring(7);
JsonObject request = new JsonObject()
.put("action", "validateToken")
.put("token", token);
vertx.eventBus().request(AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded() && Boolean.TRUE.equals(ar.result().body())) {
JsonUtil.sendJson(ctx, ApiStatus.OK, true, "Valid token");
} else {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, false, "Invalid token");
}
});
} else {
JsonUtil.sendJson(ctx, ApiStatus.BAD_REQUEST, null, "Missing or invalid Authorization header");
}
}
public void refreshToken(RoutingContext ctx) {
String tokenHeader = ctx.request().getHeader("Authorization");
if (tokenHeader == null || !tokenHeader.startsWith("Bearer ")) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Missing or invalid Authorization header");
return;
}
String token = tokenHeader.substring("Bearer ".length());
JWTManager jwt = JWTManager.getInstance();
try {
DecodedJWT decoded = jwt.decode(token);
String userIdStr = decoded.getClaim("userId").asString();
if (userIdStr == null) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Invalid token claims");
return;
}
UUID userId = UUID.fromString(userIdStr);
vertx.eventBus().request(AUTH_EVENT_BUS, new JsonObject()
.put("action", "getUserById")
.put("userId", userId.toString()), ar -> {
if (ar.succeeded()) {
JsonObject userJson = (JsonObject) ar.result().body();
UserEntity user = GSON.fromJson(userJson.encode(), UserEntity.class);
String newToken = jwt.generateToken(
user.getDisplayName(),
user.getUserId(),
user.getGlobalRole(),
0,
false
);
JsonUtil.sendJson(ctx, ApiStatus.OK, new JsonObject().put("token", newToken));
} else {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "User not found or service unavailable");
}
});
} catch (Exception e) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Invalid token format");
}
}
public void changePassword(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "changePassword")
.put("userId", body.getInteger("userId"))
.put("newPassword", body.getString("newPassword"));
vertx.eventBus().request(AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, true, "Updated");
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void register(RoutingContext ctx) {
vertx.eventBus().request(AUTH_EVENT_BUS, ctx.body().asJsonObject().put("action", "register"))
.onSuccess(reply -> JsonUtil.sendJson(ctx, ApiStatus.CREATED, null))
.onFailure(err -> EventBusUtil.handleReplyError(ctx, err));
}
}

64
microservices/core/src/main/java/net/miarma/api/microservices/core/handlers/UserDataHandler.java
View File

@@ -1,10 +1,10 @@
package net.miarma.api.microservices.core.handlers;
import java.util.UUID;
import com.google.gson.Gson;
import io.vertx.core.Future;
import io.vertx.ext.web.RoutingContext;
import io.vertx.sqlclient.Pool;
import net.miarma.api.backlib.Constants;
import net.miarma.api.backlib.gson.GsonProvider;
import net.miarma.api.backlib.http.ApiStatus;
import net.miarma.api.backlib.http.QueryParams;
@@ -15,7 +15,7 @@ import net.miarma.api.microservices.core.services.UserService;
@SuppressWarnings("unused")
public class UserDataHandler {
private final Gson GSON = GsonProvider.get();
private final Gson GSON = GsonProvider.get();
private final UserService userService;
public UserDataHandler(Pool pool) {
@@ -23,52 +23,32 @@ public class UserDataHandler {
}
public void getAll(RoutingContext ctx) {
QueryParams params = QueryParams.from(ctx);
userService.getAll(params)
.onSuccess(users -> JsonUtil.sendJson(ctx, ApiStatus.OK, users)).onFailure(err -> {
ApiStatus status = ApiStatus.fromException(err);
JsonUtil.sendJson(ctx, status, null, err.getMessage());
});
userService.getAll(QueryParams.from(ctx))
.onSuccess(users -> JsonUtil.sendJson(ctx, ApiStatus.OK, users))
.onFailure(err -> JsonUtil.sendJson(ctx, ApiStatus.fromException(err), null, err.getMessage()));
}
public void getById(RoutingContext ctx) {
Integer userId = Integer.parseInt(ctx.pathParam("user_id"));
userService.getById(userId)
.onSuccess(user -> JsonUtil.sendJson(ctx, ApiStatus.OK, user)).onFailure(err -> {
ApiStatus status = ApiStatus.fromException(err);
JsonUtil.sendJson(ctx, status, null, err.getMessage());
});
}
public void create(RoutingContext ctx) {
UserEntity user = GSON.fromJson(ctx.body().asString(), UserEntity.class);
userService.register(user)
.onSuccess(result -> JsonUtil.sendJson(ctx, ApiStatus.CREATED, result)).onFailure(err -> {
ApiStatus status = ApiStatus.fromException(err);
JsonUtil.sendJson(ctx, status, null, err.getMessage());
});
Future.succeededFuture(ctx.pathParam("user_id"))
.map(UUID::fromString)
.compose(userService::getById)
.onSuccess(user -> JsonUtil.sendJson(ctx, ApiStatus.OK, user))
.onFailure(err -> JsonUtil.sendJson(ctx, ApiStatus.BAD_REQUEST, null, "Invalid UUID format"));
}
public void update(RoutingContext ctx) {
UserEntity user = GSON.fromJson(ctx.body().asString(), UserEntity.class);
userService.update(user)
.onSuccess(result -> JsonUtil.sendJson(ctx, ApiStatus.NO_CONTENT, result)).onFailure(err -> {
ApiStatus status = ApiStatus.fromException(err);
JsonUtil.sendJson(ctx, status, null, err.getMessage());
});
Future.succeededFuture(ctx.body().asString())
.map(body -> GSON.fromJson(body, UserEntity.class))
.compose(userService::update)
.onSuccess(result -> JsonUtil.sendJson(ctx, ApiStatus.OK, result))
.onFailure(err -> JsonUtil.sendJson(ctx, ApiStatus.BAD_REQUEST, null, "Invalid user data"));
}
public void delete(RoutingContext ctx) {
Integer userId = Integer.parseInt(ctx.pathParam("user_id"));
userService.delete(userId)
.onSuccess(result -> JsonUtil.sendJson(ctx, ApiStatus.NO_CONTENT, result)).onFailure(err -> {
ApiStatus status = ApiStatus.fromException(err);
JsonUtil.sendJson(ctx, status, null, err.getMessage());
});
Future.succeededFuture(ctx.pathParam("user_id"))
.map(UUID::fromString)
.compose(userService::delete)
.onSuccess(v -> JsonUtil.sendJson(ctx, ApiStatus.NO_CONTENT, null))
.onFailure(err -> JsonUtil.sendJson(ctx, ApiStatus.BAD_REQUEST, null, "Invalid UUID format"));
}
}
}

162
microservices/core/src/main/java/net/miarma/api/microservices/core/handlers/UserLogicHandler.java
View File

@@ -1,162 +1,26 @@
package net.miarma.api.microservices.core.handlers;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.UUID;
import io.vertx.core.Vertx;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.RoutingContext;
import net.miarma.api.backlib.Constants;
import net.miarma.api.backlib.config.ConfigManager;
import net.miarma.api.backlib.http.ApiStatus;
import net.miarma.api.backlib.security.JWTManager;
import net.miarma.api.backlib.util.EventBusUtil;
import net.miarma.api.backlib.util.JsonUtil;
import net.miarma.api.microservices.core.entities.UserEntity;
public class UserLogicHandler {
private final String CORE_EVENT_BUS = ConfigManager.getInstance()
.getStringProperty("eventbus.core.address");
private final Vertx vertx;
public UserLogicHandler(Vertx vertx) {
this.vertx = vertx;
}
public void login(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "login")
.put("email", body.getString("email", null))
.put("userName", body.getString("userName", null))
.put("password", body.getString("password"))
.put("keepLoggedIn", body.getBoolean("keepLoggedIn", false));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonObject result = (JsonObject) ar.result().body();
result.put("tokenTime", System.currentTimeMillis());
JsonUtil.sendJson(ctx, ApiStatus.OK, result);
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void loginValidate(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "loginValidate")
.put("userId", body.getInteger("userId"))
.put("password", body.getString("password"));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void register(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "register")
.put("userName", body.getString("userName"))
.put("email", body.getString("email"))
.put("displayName", body.getString("displayName"))
.put("password", body.getString("password"));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.CREATED, null);
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void changePassword(RoutingContext ctx) {
JsonObject body = ctx.body().asJsonObject();
JsonObject request = new JsonObject()
.put("action", "changePassword")
.put("userId", body.getInteger("userId"))
.put("newPassword", body.getString("newPassword"));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, true, "Updated");
} else {
EventBusUtil.handleReplyError(ctx, ar.cause());
}
});
}
public void validateToken(RoutingContext ctx) {
String authHeader = ctx.request().getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
String token = authHeader.substring(7);
JsonObject request = new JsonObject()
.put("action", "validateToken")
.put("token", token);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
if (ar.succeeded() && Boolean.TRUE.equals(ar.result().body())) {
JsonUtil.sendJson(ctx, ApiStatus.OK, true, "Valid token");
} else {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, false, "Invalid token");
}
});
} else {
JsonUtil.sendJson(ctx, ApiStatus.BAD_REQUEST, null, "Missing or invalid Authorization header");
}
}
public void refreshToken(RoutingContext ctx) {
String tokenHeader = ctx.request().getHeader("Authorization");
if (tokenHeader == null || !tokenHeader.startsWith("Bearer ")) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Missing or invalid Authorization header");
return;
}
String token = tokenHeader.substring("Bearer ".length());
JWTManager jwt = JWTManager.getInstance();
try {
DecodedJWT decoded = jwt.decodeWithoutVerification(token);
int userId = decoded.getClaim("userId").asInt();
if (userId == -1) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Invalid token");
return;
}
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, new JsonObject()
.put("action", "getUserById")
.put("userId", userId), ar -> {
if (ar.succeeded()) {
JsonObject userJson = (JsonObject) ar.result().body();
UserEntity user = Constants.GSON.fromJson(userJson.encode(), UserEntity.class);
String newToken = jwt.generateToken(user.getUser_name(), user.getUser_id(), user.getGlobal_role(), false);
JsonUtil.sendJson(ctx, ApiStatus.OK, new JsonObject().put("token", newToken));
} else {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "User not found");
}
});
} catch (Exception e) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Invalid token");
}
}
public void getInfo(RoutingContext ctx) {
String authHeader = ctx.request().getHeader("Authorization");
@@ -166,9 +30,9 @@ public class UserLogicHandler {
}
String token = authHeader.substring(7);
int userId = net.miarma.api.backlib.security.JWTManager.getInstance().getUserId(token);
UUID userId = JWTManager.getInstance().extractUserId(token);
if (userId <= 0) {
if (userId == null) {
JsonUtil.sendJson(ctx, ApiStatus.UNAUTHORIZED, null, "Invalid token");
return;
}
@@ -177,7 +41,7 @@ public class UserLogicHandler {
.put("action", "getInfo")
.put("userId", userId);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
@@ -193,7 +57,7 @@ public class UserLogicHandler {
.put("action", "userExists")
.put("userId", userId);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
@@ -209,7 +73,7 @@ public class UserLogicHandler {
.put("action", "getStatus")
.put("userId", userId);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
@@ -225,7 +89,7 @@ public class UserLogicHandler {
.put("action", "getRole")
.put("userId", userId);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
@@ -241,7 +105,7 @@ public class UserLogicHandler {
.put("action", "getAvatar")
.put("userId", userId);
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.OK, ar.result().body());
} else {
@@ -258,7 +122,7 @@ public class UserLogicHandler {
.put("userId", body.getInteger("userId"))
.put("status", body.getInteger("status"));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.NO_CONTENT, null);
} else {
@@ -275,7 +139,7 @@ public class UserLogicHandler {
.put("userId", body.getInteger("userId"))
.put("role", body.getInteger("role"));
vertx.eventBus().request(Constants.AUTH_EVENT_BUS, request, ar -> {
vertx.eventBus().request(CORE_EVENT_BUS, request, ar -> {
if (ar.succeeded()) {
JsonUtil.sendJson(ctx, ApiStatus.NO_CONTENT, null);
} else {

44
microservices/core/src/main/java/net/miarma/api/microservices/core/routing/CoreDataRouter.java
View File

@@ -4,32 +4,30 @@ import io.vertx.core.Vertx;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.sqlclient.Pool;
import net.miarma.api.backlib.Constants.CoreUserRole;
import net.miarma.api.microservices.core.enums.CoreUserGlobalRole;
import net.miarma.api.microservices.core.handlers.FileDataHandler;
import net.miarma.api.microservices.core.handlers.UserDataHandler;
import net.miarma.api.microservices.core.services.UserService;
import net.miarma.api.microservices.core.routing.middlewares.CoreAuthGuard;
import net.miarma.api.microservices.core.services.UserService;
public class CoreDataRouter {
public static void mount(Router router, Vertx vertx, Pool pool) {
UserDataHandler hUserData = new UserDataHandler(pool);
FileDataHandler hFileData = new FileDataHandler(pool);
UserService userService = new UserService(pool);
CoreAuthGuard authGuard = new CoreAuthGuard(userService);
router.route().handler(BodyHandler.create());
public static void mount(Router router, Vertx vertx, Pool pool) {
UserDataHandler hUserData = new UserDataHandler(pool);
FileDataHandler hFileData = new FileDataHandler(pool);
UserService userService = new UserService(pool);
CoreAuthGuard authGuard = new CoreAuthGuard(userService);
router.route().handler(BodyHandler.create());
router.get(CoreEndpoints.USERS).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserData::getAll);
router.get(CoreEndpoints.USER).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserData::getById);
router.post(CoreEndpoints.USERS).handler(hUserData::create);
router.put(CoreEndpoints.USER).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserData::update);
router.delete(CoreEndpoints.USER).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserData::delete);
router.get(CoreEndpoints.FILES).handler(authGuard.check()).handler(hFileData::getAll);
router.get(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::getById);
router.post(CoreEndpoints.FILE_UPLOAD).handler(authGuard.check()).handler(hFileData::create);
router.put(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::update);
router.delete(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::delete);
}
}
router.get(CoreEndpoints.USERS).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserData::getAll);
router.get(CoreEndpoints.USER).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserData::getById);
router.put(CoreEndpoints.USER).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserData::update);
router.delete(CoreEndpoints.USER).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserData::delete);
router.get(CoreEndpoints.FILES).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hFileData::getAll);
router.get(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::getById);
router.post(CoreEndpoints.FILE_UPLOAD).handler(authGuard.check()).handler(hFileData::create);
router.put(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::update);
router.delete(CoreEndpoints.FILE).handler(authGuard.check()).handler(hFileData::delete);
}
}

67
microservices/core/src/main/java/net/miarma/api/microservices/core/routing/CoreEndpoints.java
View File

@@ -1,39 +1,36 @@
package net.miarma.api.microservices.core.routing;
import net.miarma.api.backlib.Constants;
import net.miarma.api.backlib.config.ConfigManager;
public class CoreEndpoints {
/*
* RUTAS DE LA API DE DATOS
* DE NEGOCIO DEL SSO
*/
// Usuarios
public static final String USERS = Constants.CORE_PREFIX + "/users"; // GET, POST, PUT, DELETE
public static final String USER = Constants.CORE_PREFIX + "/users/:user_id"; // GET, PUT, DELETE
public static final String USER_STATUS = Constants.CORE_PREFIX + "/users/:user_id/status"; // GET, PUT
public static final String USER_ROLE = Constants.CORE_PREFIX + "/users/:user_id/role"; // GET, PUT
public static final String USER_EXISTS = Constants.CORE_PREFIX + "/users/:user_id/exists"; // GET
public static final String USER_AVATAR = Constants.CORE_PREFIX + "/users/:user_id/avatar"; // GET, PUT
public static final String USER_INFO = Constants.CORE_PREFIX + "/users/me"; // GET
// Archivos
public static final String FILES = Constants.CORE_PREFIX + "/files"; // GET, POST
public static final String FILE = Constants.CORE_PREFIX + "/files/:file_id"; // GET, PUT, DELETE
public static final String FILE_UPLOAD = Constants.CORE_PREFIX + "/files/upload"; // POST
public static final String FILE_DOWNLOAD = Constants.CORE_PREFIX + "/files/:file_id/download"; // GET
public static final String USER_FILES = Constants.CORE_PREFIX + "/files/myfiles"; // GET
/*
* RUTAS DE LA API DE LOGICA
* DE NEGOCIO DEL SSO
*/
public static final String LOGIN = Constants.AUTH_PREFIX + "/login"; // POST
public static final String LOGIN_VALID = Constants.AUTH_PREFIX + "/login/validate"; // POST
public static final String REGISTER = Constants.AUTH_PREFIX + "/register"; // POST
public static final String CHANGE_PASSWORD = Constants.AUTH_PREFIX + "/change-password"; // POST
public static final String VALIDATE_TOKEN = Constants.AUTH_PREFIX + "/validate-token"; // POST
public static final String REFRESH_TOKEN = Constants.AUTH_PREFIX + "/refresh-token"; // POST
public static final String SCREENSHOT = Constants.CORE_PREFIX + "/screenshot"; // GET
}
private static final ConfigManager config = ConfigManager.getInstance();
private static final String CORE = config.getApiPrefix("core");
private static final String AUTH = config.getApiPrefix("auth");
/* API DE DATOS (UserDataHandler / FileDataHandler) */
public static final String USERS = CORE + "/users";
public static final String USER = CORE + "/users/:user_id";
public static final String FILES = CORE + "/files";
public static final String FILE = CORE + "/files/:file_id";
public static final String FILE_UPLOAD = CORE + "/files/upload";
/* API DE LÓGICA (AuthHandler / UserLogicHandler / FileLogicHandler) */
public static final String LOGIN = AUTH + "/login";
public static final String LOGIN_VALID = AUTH + "/login/validate";
public static final String REGISTER = AUTH + "/register";
public static final String CHANGE_PASSWORD = AUTH + "/change-password";
public static final String VALIDATE_TOKEN = AUTH + "/validate-token";
public static final String REFRESH_TOKEN = AUTH + "/refresh-token";
public static final String USER_INFO = CORE + "/users/me";
public static final String USER_STATUS = CORE + "/users/:user_id/status";
public static final String USER_ROLE = CORE + "/users/:user_id/role";
public static final String USER_EXISTS = CORE + "/users/:user_id/exists";
public static final String USER_AVATAR = CORE + "/users/:user_id/avatar";
public static final String FILE_DOWNLOAD = CORE + "/files/:file_id/download";
public static final String USER_FILES = CORE + "/files/myfiles";
public static final String SCREENSHOT = CORE + "/screenshot";
}

56
microservices/core/src/main/java/net/miarma/api/microservices/core/routing/CoreLogicRouter.java
View File

@@ -4,41 +4,45 @@ import io.vertx.core.Vertx;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.sqlclient.Pool;
import net.miarma.api.backlib.Constants.CoreUserRole;
import net.miarma.api.microservices.core.enums.CoreUserGlobalRole;
import net.miarma.api.microservices.core.handlers.AuthHandler;
import net.miarma.api.microservices.core.handlers.FileLogicHandler;
import net.miarma.api.microservices.core.handlers.ScreenshotHandler;
import net.miarma.api.microservices.core.handlers.UserLogicHandler;
import net.miarma.api.microservices.core.services.UserService;
import net.miarma.api.microservices.core.routing.middlewares.CoreAuthGuard;
import net.miarma.api.microservices.core.services.UserService;
public class CoreLogicRouter {
public static void mount(Router router, Vertx vertx, Pool pool) {
UserLogicHandler hUserLogic = new UserLogicHandler(vertx);
FileLogicHandler hFileLogic = new FileLogicHandler(vertx);
ScreenshotHandler hScreenshot = new ScreenshotHandler(vertx);
public static void mount(Router router, Vertx vertx, Pool pool) {
UserLogicHandler hUserLogic = new UserLogicHandler(vertx);
FileLogicHandler hFileLogic = new FileLogicHandler(vertx);
AuthHandler hAuth = new AuthHandler(vertx);
ScreenshotHandler hScreenshot = new ScreenshotHandler(vertx);
UserService userService = new UserService(pool);
CoreAuthGuard authGuard = new CoreAuthGuard(userService);
router.route().handler(BodyHandler.create());
router.post(CoreEndpoints.LOGIN).handler(hUserLogic::login);
router.get(CoreEndpoints.USER_INFO).handler(authGuard.check()).handler(hUserLogic::getInfo);
router.post(CoreEndpoints.REGISTER).handler(hUserLogic::register);
router.post(CoreEndpoints.CHANGE_PASSWORD).handler(authGuard.check()).handler(hUserLogic::changePassword);
router.post(CoreEndpoints.LOGIN_VALID).handler(hUserLogic::loginValidate);
router.get(CoreEndpoints.VALIDATE_TOKEN).handler(hUserLogic::validateToken);
router.get(CoreEndpoints.REFRESH_TOKEN).handler(hUserLogic::refreshToken);
router.post(CoreEndpoints.LOGIN).handler(hAuth::login);
router.post(CoreEndpoints.REGISTER).handler(hAuth::register);
router.post(CoreEndpoints.LOGIN_VALID).handler(hAuth::loginValidate);
router.get(CoreEndpoints.VALIDATE_TOKEN).handler(authGuard.check()).handler(hAuth::validateToken);
router.get(CoreEndpoints.REFRESH_TOKEN).handler(hAuth::refreshToken);
router.post(CoreEndpoints.CHANGE_PASSWORD).handler(authGuard.check()).handler(hAuth::changePassword);
router.get(CoreEndpoints.USER_INFO).handler(authGuard.check()).handler(hUserLogic::getInfo);
router.get(CoreEndpoints.USER_EXISTS).handler(authGuard.check()).handler(hUserLogic::exists);
router.get(CoreEndpoints.USER_STATUS).handler(authGuard.check()).handler(hUserLogic::getStatus);
router.put(CoreEndpoints.USER_STATUS).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserLogic::updateStatus);
router.get(CoreEndpoints.USER_ROLE).handler(authGuard.check()).handler(hUserLogic::getRole);
router.put(CoreEndpoints.USER_ROLE).handler(authGuard.check(CoreUserRole.ADMIN)).handler(hUserLogic::updateRole);
router.get(CoreEndpoints.USER_AVATAR).handler(authGuard.check()).handler(hUserLogic::getAvatar);
router.get(CoreEndpoints.FILE_DOWNLOAD).handler(authGuard.check()).handler(hFileLogic::downloadFile);
router.get(CoreEndpoints.USER_FILES).handler(authGuard.check()).handler(hFileLogic::getUserFiles);
router.get(CoreEndpoints.SCREENSHOT).handler(hScreenshot::getScreenshot);
}
}
router.get(CoreEndpoints.USER_STATUS).handler(authGuard.check()).handler(hUserLogic::getStatus);
router.put(CoreEndpoints.USER_STATUS).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserLogic::updateStatus);
router.get(CoreEndpoints.USER_ROLE).handler(authGuard.check()).handler(hUserLogic::getRole);
router.put(CoreEndpoints.USER_ROLE).handler(authGuard.check(CoreUserGlobalRole.ADMIN)).handler(hUserLogic::updateRole);
router.get(CoreEndpoints.USER_AVATAR).handler(authGuard.check()).handler(hUserLogic::getAvatar);
router.get(CoreEndpoints.FILE_DOWNLOAD).handler(authGuard.check()).handler(hFileLogic::downloadFile);
router.get(CoreEndpoints.USER_FILES).handler(authGuard.check()).handler(hFileLogic::getUserFiles);
router.get(CoreEndpoints.SCREENSHOT).handler(hScreenshot::getScreenshot);
}
}

15
microservices/core/src/main/java/net/miarma/api/microservices/core/routing/middlewares/CoreAuthGuard.java
View File

@@ -1,14 +1,15 @@
package net.miarma.api.microservices.core.routing.middlewares;
import java.util.UUID;
import java.util.function.Consumer;
import io.vertx.ext.web.RoutingContext;
import net.miarma.api.backlib.Constants.CoreUserRole;
import net.miarma.api.backlib.middlewares.AbstractAuthGuard;
import net.miarma.api.microservices.core.entities.UserEntity;
import net.miarma.api.microservices.core.enums.CoreUserGlobalRole;
import net.miarma.api.microservices.core.services.UserService;
public class CoreAuthGuard extends AbstractAuthGuard<UserEntity, CoreUserRole> {
public class CoreAuthGuard extends AbstractAuthGuard<UserEntity, CoreUserGlobalRole> {
private final UserService userService;
public CoreAuthGuard(UserService userService) {
@@ -16,12 +17,12 @@ public class CoreAuthGuard extends AbstractAuthGuard<UserEntity, CoreUserRole> {
}
@Override
protected CoreUserRole parseRole(String roleStr) {
return CoreUserRole.valueOf(roleStr.toUpperCase());
protected CoreUserGlobalRole parseRole(String roleStr) {
return CoreUserGlobalRole.valueOf(roleStr.toUpperCase());
}
@Override
protected void getUserEntity(int userId, RoutingContext ctx, Consumer<UserEntity> callback) {
protected void getUserEntity(UUID userId, RoutingContext ctx, Consumer<UserEntity> callback) {
userService.getById(userId).onComplete(ar -> {
if (ar.succeeded()) callback.accept(ar.result());
else callback.accept(null);
@@ -29,8 +30,8 @@ public class CoreAuthGuard extends AbstractAuthGuard<UserEntity, CoreUserRole> {
}
@Override
protected boolean hasPermission(UserEntity user, CoreUserRole userRole) {
return user.getGlobal_role() == CoreUserRole.ADMIN;
protected boolean hasPermission(UserEntity user, CoreUserGlobalRole userRole) {
return user.getGlobalRole() == CoreUserGlobalRole.ADMIN;
}
}

4
microservices/core/src/main/java/net/miarma/api/microservices/core/services/AuthService.java
View File

@@ -35,13 +35,13 @@ public class AuthService {
public Future<JsonObject> login(String login, String plainPassword, boolean keepLoggedIn) {
return credentialDAO.getByServiceAndUsername(this.serviceId, login).compose(cred -> {
if (cred == null) {
return Future.failedFuture(new BadRequestException("Invalid credentials"));
return Future.failedFuture(new NotFoundException("User not found in this domain"));
}
if (!PasswordHasher.verify(plainPassword, cred.getPassword())) {
return Future.failedFuture(new BadRequestException("Invalid credentials"));
}
return userDAO.getById(cred.getUserId()).compose(user -> {
if (user == null) {
return Future.failedFuture(new NotFoundException("User not found"));

4
microservices/core/src/main/java/net/miarma/api/microservices/core/services/UserService.java
View File

@@ -31,7 +31,7 @@ public class UserService {
});
}
public Future<UserEntity> updateProfile(UserEntity user) {
public Future<UserEntity> update(UserEntity user) {
return userDAO.update(user);
}
@@ -49,7 +49,7 @@ public class UserService {
});
}
public Future<Boolean> deleteUser(UUID id) {
public Future<Boolean> delete(UUID id) {
return userDAO.delete(id);
}
}

227
microservices/core/src/main/java/net/miarma/api/microservices/core/verticles/CoreDataVerticle.java
View File

@@ -1,196 +1,123 @@
package net.miarma.api.microservices.core.verticles;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.sqlclient.Pool;
import net.miarma.api.backlib.Constants;
import net.miarma.api.backlib.Constants.CoreUserGlobalStatus;
import net.miarma.api.backlib.Constants.CoreUserRole;
import net.miarma.api.backlib.config.ConfigManager;
import net.miarma.api.microservices.core.entities.UserEntity;
import net.miarma.api.microservices.core.services.FileService;
import net.miarma.api.microservices.core.services.UserService;
import net.miarma.api.backlib.db.DatabaseProvider;
import net.miarma.api.backlib.util.EventBusUtil;
import net.miarma.api.backlib.util.RouterUtil;
import net.miarma.api.microservices.core.entities.UserEntity;
import net.miarma.api.microservices.core.enums.CoreUserGlobalRole;
import net.miarma.api.microservices.core.enums.CoreUserGlobalStatus;
import net.miarma.api.microservices.core.routing.CoreDataRouter;
import net.miarma.api.microservices.core.routing.CoreEndpoints;
import net.miarma.api.microservices.core.services.AuthService;
import net.miarma.api.microservices.core.services.FileService;
import net.miarma.api.microservices.core.services.UserService;
@SuppressWarnings("unused")
public class CoreDataVerticle extends AbstractVerticle {
private ConfigManager configManager;
private UserService userService;
private FileService fileService;
private AuthService authService;
@Override
public void start(Promise<Void> startPromise) {
configManager = ConfigManager.getInstance();
Pool pool = DatabaseProvider.createPool(vertx, configManager);
userService = new UserService(pool);
fileService = new FileService(pool);
authService = new AuthService(pool, 0);
Router router = Router.router(vertx);
RouterUtil.attachLogger(router);
CoreDataRouter.mount(router, vertx, pool);
registerLogicVerticleConsumer();
vertx.createHttpServer()
.requestHandler(router)
.listen(configManager.getIntProperty("sso.data.port"), res -> {
.listen(configManager.getIntProperty("core.data.port"), res -> {
if (res.succeeded()) startPromise.complete();
else startPromise.fail(res.cause());
});
}
private void registerLogicVerticleConsumer() {
vertx.eventBus().consumer(Constants.AUTH_EVENT_BUS, message -> {
String authAddress = configManager.getStringProperty("eventbus.auth.address");
vertx.eventBus().consumer(authAddress, message -> {
JsonObject body = (JsonObject) message.body();
String action = body.getString("action");
switch (action) {
case "login" -> {
String email = body.getString("email");
String userName = body.getString("userName");
String password = body.getString("password");
boolean keepLoggedIn = body.getBoolean("keepLoggedIn", false);
userService.login(email != null ? email : userName, password, keepLoggedIn)
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
try {
switch (action) {
case "login" -> {
authService.login(
body.getString("login"),
body.getString("password"),
body.getBoolean("keepLoggedIn", false)
).onSuccess(message::reply).onFailure(EventBusUtil.fail(message));
}
case "register" -> {
UserEntity profile = new UserEntity();
profile.setDisplayName(body.getString("displayName"));
authService.register(
profile,
body.getString("username"),
body.getString("email"),
body.getString("password")
).onSuccess(user -> message.reply(JsonObject.mapFrom(user)))
.onFailure(EventBusUtil.fail(message));
}
case "getInfo", "getById", "getUserById" -> {
userService.getById(UUID.fromString(body.getString("userId")))
.onSuccess(user -> message.reply(JsonObject.mapFrom(user)))
.onFailure(EventBusUtil.fail(message));
}
case "updateStatus" -> {
userService.changeStatus(
UUID.fromString(body.getString("userId")),
CoreUserGlobalStatus.fromInt(body.getInteger("status"))
).onSuccess(res -> message.reply(new JsonObject().put("message", "Status updated")))
.onFailure(EventBusUtil.fail(message));
}
case "updateRole" -> {
userService.changeRole(
UUID.fromString(body.getString("userId")),
CoreUserGlobalRole.fromInt(body.getInteger("role"))
).onSuccess(res -> message.reply(new JsonObject().put("message", "Role updated")))
.onFailure(EventBusUtil.fail(message));
}
case "getUserFiles" -> {
fileService.getUserFiles(UUID.fromString(body.getString("userId")))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
}
case "downloadFile" -> {
fileService.getById(UUID.fromString(body.getString("fileId")))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
}
default -> message.fail(404, "Action not found: " + action);
}
case "register" -> {
UserEntity user = new UserEntity();
user.setUser_name(body.getString("userName"));
user.setEmail(body.getString("email"));
user.setDisplay_name(body.getString("displayName"));
user.setPassword(body.getString("password"));
userService.register(user)
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
}
case "changePassword" -> {
Integer userId = body.getInteger("userId");
String newPassword = body.getString("newPassword");
userService.changePassword(userId, newPassword)
.onSuccess(user -> {
String userJson = Constants.GSON.toJson(user);
message.reply(new JsonObject(userJson));
})
.onFailure(EventBusUtil.fail(message));
}
case "validateToken" -> {
String token = body.getString("token");
userService.validateToken(token)
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
}
case "getInfo", "getById" -> {
Integer userId = body.getInteger("userId");
userService.getById(userId)
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
}
case "userExists" -> {
Integer userId = body.getInteger("userId");
userService.getById(userId)
.onSuccess(user -> {
Map<String, Object> result = new HashMap<>();
result.put("user_id", userId);
result.put("exists", user != null);
message.reply(result);
})
.onFailure(EventBusUtil.fail(message));
}
case "getByEmail" -> userService.getByEmail(body.getString("email"))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
case "getByUserName" -> userService.getByUserName(body.getString("userName"))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
case "getStatus" -> userService.getById(body.getInteger("userId"))
.onSuccess(user -> {
Map<String, Object> result = new HashMap<>();
result.put("user_id", user.getUser_id());
result.put("status", user.getGlobal_status());
message.reply(result);
})
.onFailure(EventBusUtil.fail(message));
case "getRole" -> userService.getById(body.getInteger("userId"))
.onSuccess(user -> {
Map<String, Object> result = new HashMap<>();
result.put("user_id", user.getUser_id());
result.put("role", user.getGlobal_role());
message.reply(result);
})
.onFailure(EventBusUtil.fail(message));
case "getAvatar" -> userService.getById(body.getInteger("userId"))
.onSuccess(user -> {
Map<String, Object> result = new HashMap<>();
result.put("user_id", user.getUser_id());
result.put("avatar", user.getAvatar());
message.reply(result);
})
.onFailure(EventBusUtil.fail(message));
case "updateStatus" -> userService.updateStatus(
body.getInteger("userId"),
CoreUserGlobalStatus.fromInt(body.getInteger("status")))
.onSuccess(res -> message.reply("Status updated successfully"))
.onFailure(EventBusUtil.fail(message));
case "updateRole" -> userService.updateRole(
body.getInteger("userId"),
CoreUserRole.fromInt(body.getInteger("role")))
.onSuccess(res -> message.reply("Role updated successfully"))
.onFailure(EventBusUtil.fail(message));
case "getUserFiles" -> fileService.getUserFiles(body.getInteger("userId"))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
case "downloadFile" -> fileService.downloadFile(body.getInteger("fileId"))
.onSuccess(message::reply)
.onFailure(EventBusUtil.fail(message));
case "getUserById" -> userService.getById(body.getInteger("userId"))
.onSuccess(user -> {
String userJson = Constants.GSON.toJson(user);
message.reply(new JsonObject(userJson));
})
.onFailure(EventBusUtil.fail(message));
case "loginValidate" -> {
Integer userId = body.getInteger("userId");
String password = body.getString("password");
userService.loginValidate(userId, password)
.onSuccess(user -> {
String userJson = Constants.GSON.toJson(user);
message.reply(new JsonObject(userJson));
})
.onFailure(EventBusUtil.fail(message));
}
default -> EventBusUtil.fail(message);
} catch (Exception e) {
message.fail(400, "Invalid data format or UUID: " + e.getMessage());
}
});
}

2
microservices/core/src/main/java/net/miarma/api/microservices/core/verticles/CoreLogicVerticle.java
View File

@@ -24,7 +24,7 @@ public class CoreLogicVerticle extends AbstractVerticle {
vertx.createHttpServer()
.requestHandler(router)
.listen(configManager.getIntProperty("sso.logic.port"), res -> {
.listen(configManager.getIntProperty("core.logic.port"), res -> {
if (res.succeeded()) startPromise.complete();
else startPromise.fail(res.cause());
});

11
microservices/core/src/main/java/net/miarma/api/microservices/core/verticles/CoreMainVerticle.java
View File

@@ -1,16 +1,19 @@
package net.miarma.api.microservices.core.verticles;
import org.slf4j.Logger;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.Promise;
import io.vertx.core.ThreadingModel;
import net.miarma.api.backlib.Constants;
import net.miarma.api.backlib.config.ConfigManager;
import net.miarma.api.backlib.log.LogAccumulator;
import net.miarma.api.backlib.log.LoggerProvider;
import net.miarma.api.backlib.util.DeploymentUtil;
public class CoreMainVerticle extends AbstractVerticle {
private final Logger LOGGER = LoggerProvider.getLogger();
private ConfigManager configManager;
@Override
@@ -20,7 +23,7 @@ public class CoreMainVerticle extends AbstractVerticle {
deployVerticles();
startPromise.complete();
} catch (Exception e) {
Constants.LOGGER.error(DeploymentUtil.failMessage(CoreMainVerticle.class, e));
LOGGER.error(DeploymentUtil.failMessage(CoreMainVerticle.class, e));
startPromise.fail(e);
}
}
@@ -35,7 +38,7 @@ public class CoreMainVerticle extends AbstractVerticle {
DeploymentUtil.successMessage(CoreDataVerticle.class),
DeploymentUtil.apiUrlMessage(
configManager.getHost(),
configManager.getIntProperty("sso.data.port")
configManager.getIntProperty("core.data.port")
)
);
LogAccumulator.add(message);
@@ -50,7 +53,7 @@ public class CoreMainVerticle extends AbstractVerticle {
DeploymentUtil.successMessage(CoreLogicVerticle.class),
DeploymentUtil.apiUrlMessage(
configManager.getHost(),
configManager.getIntProperty("sso.logic.port")
configManager.getIntProperty("core.logic.port")
)
);
LogAccumulator.add(message);