267 lines
10 KiB
Java
267 lines
10 KiB
Java
package su.xserver.iikocon.iiko;
|
||
|
||
import io.vertx.core.Future;
|
||
import io.vertx.core.Vertx;
|
||
import io.vertx.core.json.JsonArray;
|
||
import io.vertx.core.json.JsonObject;
|
||
import io.vertx.ext.web.Router;
|
||
import io.vertx.ext.web.RoutingContext;
|
||
import io.vertx.sqlclient.Row;
|
||
import io.vertx.sqlclient.Tuple;
|
||
import org.slf4j.Logger;
|
||
import org.slf4j.LoggerFactory;
|
||
import su.xserver.iikocon.handler.AdminHandler;
|
||
import su.xserver.iikocon.handler.AuthHandler;
|
||
import su.xserver.iikocon.service.DataBaseService;
|
||
import su.xserver.iikocon.service.RestaurantService;
|
||
|
||
public class IikoHandler {
|
||
|
||
private final Logger log = LoggerFactory.getLogger("[IikoHandler]");
|
||
private final DataBaseService db;
|
||
private final Vertx vertx;
|
||
private final RestaurantService restaurantService;
|
||
|
||
public IikoHandler(Vertx vertx, Router router, DataBaseService db, RestaurantService restaurantService, AuthHandler authHandler) {
|
||
this.vertx = vertx;
|
||
this.restaurantService = restaurantService;
|
||
this.db = db;
|
||
|
||
createTablesIfNotExist().onFailure(err -> {
|
||
log.error("Failed to initialize database", err);
|
||
});
|
||
|
||
router.route("/api/reports/olap/*").handler(authHandler::requireAuth);
|
||
router.get("/api/reports/olap/columns").handler(this::getColumns);
|
||
router.delete("/api/reports/olap/columns/:fieldKey").handler(AdminHandler::requireAdmin).handler(this::deleteColumn);
|
||
router.post("/api/reports/olap/initialize").handler(AdminHandler::requireAdmin).handler(this::postInitialize);
|
||
}
|
||
|
||
private void getColumns(RoutingContext ctx) {
|
||
getAllFieldsWithReportAndTags()
|
||
.onSuccess(ar -> ctx.response()
|
||
.putHeader("Content-Type", "application/json")
|
||
.end(ar.encodePrettily()))
|
||
.onFailure(err -> ctx.response()
|
||
.setStatusCode(500)
|
||
.end(err.getMessage()));
|
||
}
|
||
|
||
public void deleteColumn(RoutingContext ctx) {
|
||
String fieldKey = ctx.pathParam("fieldKey");
|
||
String sql = "DELETE FROM iiko_fields_common WHERE field_key = ?";
|
||
|
||
db.getPool().preparedQuery(sql)
|
||
.execute(Tuple.of(fieldKey))
|
||
.onSuccess(res -> {
|
||
ctx.end();
|
||
})
|
||
.onFailure(err -> ctx.response().setStatusCode(500).end(err.getMessage()));
|
||
}
|
||
|
||
private void postInitialize(RoutingContext ctx) {
|
||
JsonObject body = ctx.body().asJsonObject();
|
||
|
||
if (body == null) {
|
||
ctx.response()
|
||
.setStatusCode(400)
|
||
.end("Request body is missing or not a JSON object");
|
||
return;
|
||
}
|
||
|
||
if (!body.containsKey("restaurantId") || body.getValue("restaurantId") == null) {
|
||
ctx.response()
|
||
.setStatusCode(400)
|
||
.end("restaurantId is required");
|
||
return;
|
||
}
|
||
|
||
Integer restaurantId;
|
||
try {
|
||
restaurantId = body.getInteger("restaurantId");
|
||
if (restaurantId == null) {
|
||
throw new IllegalArgumentException("restaurantId must be a number");
|
||
}
|
||
} catch (ClassCastException e) {
|
||
ctx.response()
|
||
.setStatusCode(400)
|
||
.end("restaurantId must be a valid integer");
|
||
return;
|
||
}
|
||
|
||
restaurantService.findById(restaurantId)
|
||
.onSuccess(rest -> {
|
||
|
||
IikoOlapClient iiko = new IikoOlapClient(vertx, rest);
|
||
|
||
iiko.checkConnection()
|
||
.onSuccess(ping -> clearTables()
|
||
.onSuccess(data -> {
|
||
IikoOlapColumnsImporter importer = new IikoOlapColumnsImporter(iiko, db);
|
||
|
||
importer.fetchAndStoreAll()
|
||
.onSuccess(res -> ctx.end("OK"))
|
||
.onFailure(err -> ctx.response()
|
||
.setStatusCode(400)
|
||
.end(err.getMessage()));
|
||
})
|
||
.onFailure(err -> ctx.response()
|
||
.setStatusCode(400)
|
||
.end(err.getMessage())))
|
||
.onFailure(err -> ctx.response().setStatusCode(400).end(err.getMessage()));
|
||
})
|
||
.onFailure(err -> ctx.response()
|
||
.setStatusCode(400)
|
||
.end(err.getMessage()));
|
||
}
|
||
|
||
public Future<JsonObject> getAllFieldsWithReportAndTags() {
|
||
String sql = """
|
||
SELECT
|
||
fc.field_key,
|
||
fc.field_key_normal,
|
||
fc.name,
|
||
fc.type,
|
||
fc.type_normal,
|
||
fc.aggregation_allowed,
|
||
fc.grouping_allowed,
|
||
fc.filtering_allowed,
|
||
GROUP_CONCAT(DISTINCT rt.name ORDER BY rt.name SEPARATOR ',') AS report_names,
|
||
GROUP_CONCAT(DISTINCT t.tag_name ORDER BY t.tag_name SEPARATOR ',') AS tag_names
|
||
FROM iiko_fields_common fc
|
||
LEFT JOIN iiko_report_type_fields rtf ON fc.field_id = rtf.field_id
|
||
LEFT JOIN iiko_report_types rt ON rtf.report_type_id = rt.report_type_id
|
||
LEFT JOIN iiko_field_tags ft ON fc.field_id = ft.field_id
|
||
LEFT JOIN iiko_tags t ON ft.tag_id = t.tag_id
|
||
GROUP BY fc.field_id
|
||
ORDER BY fc.field_key
|
||
""";
|
||
|
||
return db.getPool().query(sql).execute()
|
||
.map(rows -> {
|
||
JsonArray columnsArray = new JsonArray();
|
||
for (Row row : rows) {
|
||
|
||
String reportNamesStr = row.getString("report_names");
|
||
JsonArray reportTypes = new JsonArray();
|
||
if (reportNamesStr != null && !reportNamesStr.isBlank()) {
|
||
for (String name : reportNamesStr.split(",")) {
|
||
reportTypes.add(name.trim());
|
||
}
|
||
}
|
||
|
||
String tagNamesStr = row.getString("tag_names");
|
||
JsonArray tags = new JsonArray();
|
||
if (tagNamesStr != null && !tagNamesStr.isBlank()) {
|
||
for (String tag : tagNamesStr.split(",")) {
|
||
tags.add(tag.trim());
|
||
}
|
||
}
|
||
|
||
JsonObject fieldObj = new JsonObject()
|
||
.put("fieldKey", row.getString("field_key"))
|
||
.put("fieldKeyNormal", row.getString("field_key_normal"))
|
||
.put("reportTypes", reportTypes)
|
||
.put("name", row.getString("name"))
|
||
.put("type", row.getString("type"))
|
||
.put("typeNormal", row.getString("type_normal"))
|
||
.put("aggregationAllowed", row.getBoolean("aggregation_allowed"))
|
||
.put("groupingAllowed", row.getBoolean("grouping_allowed"))
|
||
.put("filteringAllowed", row.getBoolean("filtering_allowed"))
|
||
.put("tags", tags);
|
||
|
||
columnsArray.add(fieldObj);
|
||
}
|
||
return new JsonObject().put("columns", columnsArray);
|
||
});
|
||
}
|
||
|
||
private Future<Void> createTablesIfNotExist() {
|
||
String createReportTypes = """
|
||
CREATE TABLE IF NOT EXISTS iiko_report_types (
|
||
report_type_id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(50) UNIQUE NOT NULL,
|
||
description TEXT NOT NULL
|
||
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
|
||
""";
|
||
|
||
String createFieldsCommon = """
|
||
CREATE TABLE IF NOT EXISTS iiko_fields_common (
|
||
field_id INT AUTO_INCREMENT PRIMARY KEY,
|
||
field_key VARCHAR(255) NOT NULL UNIQUE,
|
||
field_key_normal VARCHAR(255) NOT NULL,
|
||
name VARCHAR(255) NOT NULL,
|
||
type VARCHAR(50) NOT NULL,
|
||
type_normal VARCHAR(50) NOT NULL,
|
||
aggregation_allowed BOOLEAN NOT NULL DEFAULT 0,
|
||
grouping_allowed BOOLEAN NOT NULL DEFAULT 0,
|
||
filtering_allowed BOOLEAN NOT NULL DEFAULT 0
|
||
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
|
||
""";
|
||
|
||
String createReportTypeFields = """
|
||
CREATE TABLE IF NOT EXISTS iiko_report_type_fields (
|
||
report_type_id INT NOT NULL,
|
||
field_id INT NOT NULL,
|
||
PRIMARY KEY (report_type_id, field_id),
|
||
FOREIGN KEY (report_type_id) REFERENCES iiko_report_types(report_type_id) ON DELETE CASCADE,
|
||
FOREIGN KEY (field_id) REFERENCES iiko_fields_common(field_id) ON DELETE CASCADE
|
||
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
|
||
""";
|
||
|
||
String createTags = """
|
||
CREATE TABLE IF NOT EXISTS iiko_tags (
|
||
tag_id INT AUTO_INCREMENT PRIMARY KEY,
|
||
tag_name VARCHAR(100) UNIQUE NOT NULL
|
||
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
|
||
""";
|
||
|
||
String createFieldTags = """
|
||
CREATE TABLE IF NOT EXISTS iiko_field_tags (
|
||
field_id INT NOT NULL,
|
||
tag_id INT NOT NULL,
|
||
PRIMARY KEY (field_id, tag_id),
|
||
FOREIGN KEY (field_id) REFERENCES iiko_fields_common(field_id) ON DELETE CASCADE,
|
||
FOREIGN KEY (tag_id) REFERENCES iiko_tags(tag_id) ON DELETE CASCADE
|
||
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci
|
||
""";
|
||
|
||
String idxKeyNormal = "CREATE INDEX IF NOT EXISTS idx_fields_common_key_normal ON iiko_fields_common(field_key_normal)";
|
||
String idxFieldName = "CREATE INDEX IF NOT EXISTS idx_fields_common_name ON iiko_fields_common(name)";
|
||
String idxFieldTagsTag = "CREATE INDEX IF NOT EXISTS idx_field_tags_tag_id ON iiko_field_tags(tag_id)";
|
||
|
||
return db.getPool().query(createReportTypes).execute()
|
||
.compose(v -> db.getPool().query(createFieldsCommon).execute())
|
||
.compose(v -> db.getPool().query(createReportTypeFields).execute())
|
||
.compose(v -> db.getPool().query(createTags).execute())
|
||
.compose(v -> db.getPool().query(createFieldTags).execute())
|
||
.compose(v -> db.getPool().query(idxKeyNormal).execute())
|
||
.compose(v -> db.getPool().query(idxFieldName).execute())
|
||
.compose(v -> db.getPool().query(idxFieldTagsTag).execute())
|
||
.mapEmpty();
|
||
}
|
||
|
||
private Future<Void> clearTables() {
|
||
String sql = """
|
||
-- Отключаем проверку внешних ключей
|
||
SET FOREIGN_KEY_CHECKS = 0;
|
||
|
||
-- Удаляем данные из всех таблиц (порядок не важен при отключённой проверке)
|
||
DELETE FROM iiko_field_tags;
|
||
DELETE FROM iiko_report_type_fields;
|
||
DELETE FROM iiko_fields_common;
|
||
DELETE FROM iiko_tags;
|
||
DELETE FROM iiko_report_types;
|
||
|
||
-- Сбрасываем счётчики AUTO_INCREMENT (чтобы новые ID начинались с 1)
|
||
ALTER TABLE iiko_fields_common AUTO_INCREMENT = 1;
|
||
ALTER TABLE iiko_tags AUTO_INCREMENT = 1;
|
||
ALTER TABLE iiko_report_types AUTO_INCREMENT = 1;
|
||
|
||
-- Включаем проверку обратно
|
||
SET FOREIGN_KEY_CHECKS = 1;
|
||
""";
|
||
return db.getPool().query(sql).execute().mapEmpty();
|
||
}
|
||
}
|