Example usage for io.vertx.core.eventbus Message body

Introduction

In this page you can find the example usage for io.vertx.core.eventbus Message body.

Prototype

@CacheReturn
T body();

Source Link

Document

The body of the message.

Usage

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

@Override
public void handle(Message<JsonObject> message) {
    String action = getOrElse(message.body().getString("action"), "");
    if (action.startsWith("manual-") && !Importer.getInstance().isReady()) {
        eventQueue.add(message);//  ww  w .  j  a va 2 s .c o  m
        return;
    }
    switch (action) {
    case "manual-create-structure":
        manual.createStructure(message);
        break;
    case "manual-update-structure":
        manual.updateStructure(message);
        break;
    case "manual-create-class":
        manual.createClass(message);
        break;
    case "manual-update-class":
        manual.updateClass(message);
        break;
    case "manual-create-user":
        manual.createUser(message);
        break;
    case "manual-update-user":
        manual.updateUser(message);
        break;
    case "manual-add-user":
        manual.addUser(message);
        break;
    case "manual-remove-user":
        manual.removeUser(message);
        break;
    case "manual-delete-user":
        manual.deleteUser(message);
        break;
    case "manual-restore-user":
        manual.restoreUser(message);
        break;
    case "manual-create-function":
        manual.createFunction(message);
        break;
    case "manual-delete-function":
        manual.deleteFunction(message);
        break;
    case "manual-create-function-group":
        manual.createFunctionGroup(message);
        break;
    case "manual-delete-function-group":
        manual.deleteFunctionGroup(message);
        break;
    case "manual-create-group":
        manual.createGroup(message);
        break;
    case "manual-delete-group":
        manual.deleteGroup(message);
        break;
    case "manual-add-group-users":
        manual.addGroupUsers(message);
        break;
    case "manual-remove-group-users":
        manual.removeGroupUsers(message);
        break;
    case "manual-relative-student":
        manual.relativeStudent(message);
        break;
    case "manual-unlink-relative-student":
        manual.unlinkRelativeStudent(message);
        break;
    case "manual-add-user-function":
        manual.addUserFunction(message);
        break;
    case "manual-add-head-teacher":
        manual.addUserHeadTeacherManual(message);
        break;
    case "manual-update-head-teacher":
        manual.updateUserHeadTeacherManual(message);
        break;
    case "manual-remove-user-function":
        manual.removeUserFunction(message);
        break;
    case "manual-add-user-group":
        manual.addUserGroup(message);
        break;
    case "manual-remove-user-group":
        manual.removeUserGroup(message);
        break;
    case "manual-create-tenant":
        manual.createOrUpdateTenant(message);
        break;
    case "manual-structure-attachment":
        manual.structureAttachment(message);
        break;
    case "manual-structure-detachment":
        manual.structureDetachment(message);
        break;
    case "transition":
        launchTransition(message, null);
        break;
    case "import":
        launchImport(message);
        break;
    case "export":
        launchExport(message);
        break;
    case "validate":
        launchImportValidation(message, null);
        break;
    case "ignore-duplicate":
        duplicateUsers.ignoreDuplicate(message);
        break;
    case "list-duplicate":
        duplicateUsers.listDuplicates(message);
        break;
    case "merge-duplicate":
        duplicateUsers.mergeDuplicate(message);
        break;
    case "merge-by-keys":
        duplicateUsers.mergeBykeys(message);
        break;
    case "mark-duplicates":
        duplicateUsers.markDuplicates(message);
        break;
    case "automerge-duplicates":
        duplicateUsers.autoMergeDuplicatesInStructure(new Handler<AsyncResult<JsonArray>>() {
            @Override
            public void handle(AsyncResult<JsonArray> event) {
                logger.info("auto merged : " + event.succeeded());
            }
        });
        break;
    case "manual-init-timetable-structure":
        AbstractTimetableImporter.initStructure(eb, message);
        break;
    case "manual-edt":
        EDTImporter.launchImport(edtUtils, config.getString("mode", "prod"), message, postImport);
        break;
    case "manual-udt":
        UDTImporter.launchImport(vertx, message, postImport, config.getBoolean("udt-user-creation", true));
        break;
    case "reinit-logins":
        Validator.initLogin(neo4j, vertx);
        break;
    default:
        sendError(message, "invalid.action");
    }
    checkEventQueue();
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void launchImportValidation(final Message<JsonObject> message, final Handler<Report> handler) {
    logger.info(message.body().encodePrettily());
    final String acceptLanguage = getOrElse(message.body().getString("language"), "fr");
    final String source = getOrElse(message.body().getString("feeder"), defaultFeed);

    // TODO make validator factory
    final ImportValidator v;
    switch (source) {
    case "CSV":
        v = new CsvValidator(vertx, acceptLanguage, config.getJsonObject("csvMappings", new JsonObject()));
        break;// w  w  w .  j  a v  a2s  .  c o m
    case "AAF":
    case "AAF1D":
        final Report report = new Report(acceptLanguage);
        if (handler != null) {
            handler.handle(report);
        } else {
            sendOK(message, new JsonObject().put("result", report.getResult()));
        }
        return;
    default:
        sendError(message, "invalid.type");
        return;
    }

    final String structureExternalId = message.body().getString("structureExternalId");
    final boolean preDelete = getOrElse(message.body().getBoolean("preDelete"), false);
    String path = message.body().getString("path");
    if (path == null && !"CSV".equals(source)) {
        path = config.getString("import-files");
    }
    v.validate(path, new Handler<JsonObject>() {
        @Override
        public void handle(final JsonObject result) {
            final Report r = (Report) v;
            if (preDelete && structureExternalId != null && !r.containsErrors()) {
                final JsonArray externalIds = r.getUsersExternalId();
                final JsonArray profiles = r.getResult().getJsonArray(Report.PROFILES);
                new User.PreDeleteTask(0).findMissingUsersInStructure(structureExternalId, source, externalIds,
                        profiles, new Handler<Message<JsonObject>>() {
                            @Override
                            public void handle(Message<JsonObject> event) {
                                final JsonArray res = event.body().getJsonArray("result");
                                if ("ok".equals(event.body().getString("status")) && res != null) {
                                    for (Object o : res) {
                                        if (!(o instanceof JsonObject))
                                            continue;
                                        JsonObject j = (JsonObject) o;
                                        String filename = j.getString("profile");
                                        r.addUser(filename,
                                                j.put("state", r.translate(Report.State.DELETED.name())).put(
                                                        "translatedProfile",
                                                        r.translate(j.getString("profile"))));
                                    }
                                    r.getResult().put("usersExternalIds", externalIds);
                                } else {
                                    r.addError("error.find.preDelete");
                                }
                                if (handler != null) {
                                    handler.handle(r);
                                } else {
                                    sendOK(message, new JsonObject().put("result", r.getResult()));
                                }
                            }
                        });
            } else {
                if (handler != null) {
                    handler.handle(r);
                } else {
                    sendOK(message, new JsonObject().put("result", r.getResult()));
                }
            }
        }
    });
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void launchExport(final Message<JsonObject> message) {
    if (exporter == null) {
        sendError(message, "exporter.not.found");
        return;//w w  w.ja v a  2  s . c o  m
    }
    try {
        final long start = System.currentTimeMillis();
        exporter.export(new Handler<Message<JsonObject>>() {
            @Override
            public void handle(Message<JsonObject> m) {
                logger.info("Elapsed time " + (System.currentTimeMillis() - start) + " ms.");
                logger.info(m.body().encode());
                message.reply(m.body());
                eb.publish(USER_REPOSITORY,
                        new JsonObject().put("action", "exported").put("exportFormat", exporter.getName()));
            }
        });
    } catch (Exception e) {
        sendError(message, e.getMessage(), e);
    }
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void launchTransition(final Message<JsonObject> message, final Handler<Message<JsonObject>> handler) {
    if (GraphData.isReady()) {
        final String structureExternalId = message.body().getString("structureExternalId");
        Transition transition = new Transition(vertx,
                getOrElse(config.getLong("delayBetweenStructure"), 5000l));
        transition.launch(structureExternalId, new Handler<Message<JsonObject>>() {
            @Override//  w w w .  j ava  2  s .c o  m
            public void handle(Message<JsonObject> m) {
                if (m != null && "ok".equals(m.body().getString("status"))) {
                    AbstractTimetableImporter.transition(structureExternalId);
                    if (handler != null) {
                        handler.handle(m);
                    } else {
                        sendOK(message, m.body());
                    }
                } else if (m != null) {
                    logger.error(m.body().getString("message"));
                    if (handler != null) {
                        handler.handle(m);
                    } else {
                        sendError(message, m.body().getString("message"));
                    }
                } else {
                    logger.error("Transition return null value.");
                    if (handler != null) {
                        handler.handle(new ResultMessage().error("transition.error"));
                    } else {
                        sendError(message, "Transition return null value.");
                    }
                }
                GraphData.clear();
                checkEventQueue();
            }
        });
    } else {
        eventQueue.add(message);
    }
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void launchImport(final Message<JsonObject> message) {
    final String source = getOrElse(message.body().getString("feeder"), defaultFeed);
    final Feed feed = feeds.get(source);
    if (feed == null) {
        sendError(message, "invalid.feeder");
        return;/*from   w  w  w  .ja  va2s .  c  o  m*/
    }

    final boolean preDelete = getOrElse(message.body().getBoolean("preDelete"), false);
    final String structureExternalId = message.body().getString("structureExternalId");

    if (message.body().getBoolean("transition", false)) {
        launchTransition(message, new Handler<Message<JsonObject>>() {
            @Override
            public void handle(Message<JsonObject> event) {
                if ("ok".equals(event.body().getString("status"))) {
                    validateAndImport(message, feed, preDelete, structureExternalId, source);
                } else {
                    sendError(message, "transition.error");
                }
            }
        });
    } else {
        validateAndImport(message, feed, preDelete, structureExternalId, source);
    }
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void validateAndImport(final Message<JsonObject> message, final Feed feed, final boolean preDelete,
        final String structureExternalId, final String source) {
    launchImportValidation(message, new Handler<Report>() {
        @Override//from  w ww.j ava2 s. c o m
        public void handle(final Report report) {
            if (report != null && !report.containsErrors()) {
                doImport(message, feed, new Handler<Report>() {
                    @Override
                    public void handle(final Report importReport) {
                        if (importReport == null) {
                            sendError(message, "import.error");
                            return;
                        }
                        final JsonObject ir = importReport.getResult();
                        final JsonArray existingUsers = ir.getJsonArray("usersExternalIds");
                        final JsonArray profiles = ir.getJsonArray(Report.PROFILES);
                        if (preDelete && structureExternalId != null && existingUsers != null
                                && existingUsers.size() > 0 && !importReport.containsErrors()) {
                            new User.PreDeleteTask(0).preDeleteMissingUsersInStructure(structureExternalId,
                                    source, existingUsers, profiles, new Handler<Message<JsonObject>>() {
                                        @Override
                                        public void handle(Message<JsonObject> event) {
                                            if (!"ok".equals(event.body().getString("status"))) {
                                                importReport.addError("preDelete.error");
                                            }
                                            sendOK(message,
                                                    new JsonObject().put("result", importReport.getResult()));
                                        }
                                    });
                        } else {
                            sendOK(message, new JsonObject().put("result", importReport.getResult()));
                        }
                    }
                });
            } else if (report != null) {
                sendOK(message, new JsonObject().put("result", report.getResult()));
            } else {
                sendError(message, "validation.error");
            }
        }
    });
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void doImport(final Message<JsonObject> message, final Feed feed, final Handler<Report> h) {

    final String acceptLanguage = getOrElse(message.body().getString("language"), "fr");

    final String importPath = message.body().getString("path");
    final boolean executePostImport = getOrElse(message.body().getBoolean("postImport"), true);

    final Importer importer = Importer.getInstance();
    if (importer.isReady()) {
        final long start = System.currentTimeMillis();
        importer.init(neo4j, feed.getSource(), acceptLanguage, new Handler<Message<JsonObject>>() {
            @Override/*from w  w  w  .j  a  v  a  2 s.c  o m*/
            public void handle(Message<JsonObject> res) {
                if (!"ok".equals(res.body().getString("status"))) {
                    logger.error(res.body().getString("message"));
                    h.handle(new Report(acceptLanguage).addError("init.importer.error"));
                    importer.clear();
                    checkEventQueue();
                    return;
                }
                final Report report = importer.getReport();
                try {
                    Handler<Message<JsonObject>> handler = new Handler<Message<JsonObject>>() {
                        @Override
                        public void handle(Message<JsonObject> m) {
                            if (m != null && "ok".equals(m.body().getString("status"))) {
                                logger.info(m.body().encode());
                                if (executePostImport) {
                                    postImport.execute(feed.getSource());
                                }
                            } else {
                                Validator.initLogin(neo4j, vertx);
                                if (m != null) {
                                    logger.error(m.body().getString("message"));
                                    report.addError(m.body().getString("message"));
                                } else if (report.getResult().getJsonObject("errors").size() < 1) {
                                    logger.error("Import return null value.");
                                    report.addError("import.error");
                                }
                            }
                            report.setUsersExternalId(new fr.wseduc.webutils.collections.JsonArray(
                                    new ArrayList<>(importer.getUserImportedExternalId())));
                            h.handle(report);
                            final long endTime = System.currentTimeMillis();
                            report.setEndTime(endTime);
                            report.setStartTime(start);
                            report.sendEmails(vertx, config, feed.getSource());
                            logger.info("Elapsed time " + (endTime - start) + " ms.");
                            importer.clear();
                            checkEventQueue();
                        }
                    };
                    if (importPath != null && !importPath.trim().isEmpty()) {
                        feed.launch(importer, importPath, handler);
                    } else {
                        feed.launch(importer, handler);
                    }
                } catch (Exception e) {
                    Validator.initLogin(neo4j, vertx);
                    importer.clear();
                    h.handle(report.addError("import.error"));
                    logger.error(e.getMessage(), e);
                    checkEventQueue();
                }
            }
        });
    } else {
        eventQueue.add(message);
    }
}

---

From source file:org.entcore.feeder.Feeder.java

License:Open Source License

private void checkEventQueue() {
    Message<JsonObject> event = eventQueue.poll();
    if (event != null) {
        switch (getOrElse(event.body().getString("action"), "")) {
        case "import":
            launchImport(event);// w w  w . j a  va 2 s.  c  om
            break;
        case "transition":
            launchTransition(event, null);
            break;
        default:
            handle(event);
        }
    }
}

---

From source file:org.entcore.feeder.ManualFeeder.java

License:Open Source License

public void createStructure(final Message<JsonObject> message) {
    JsonObject struct = getMandatoryObject("data", message);
    if (struct == null)
        return;//w ww .  ja  v  a 2  s  .c om
    if (struct.getString("externalId") == null) {
        struct.put("externalId", UUID.randomUUID().toString());
    }
    final String error = structureValidator.validate(struct);
    if (error != null) {
        logger.error(error);
        sendError(message, error);
    } else {
        String query = "CREATE (s:Structure {props}) " + "WITH s " + "MATCH (p:Profile) "
                + "CREATE p<-[:HAS_PROFILE]-(g:Group:ProfileGroup {name : s.name+'-'+p.name, displayNameSearchField: {groupSearchField}})-[:DEPENDS]->s "
                + "SET g.id = id(g)+'-'+timestamp() " + "RETURN DISTINCT s.id as id ";
        JsonObject params = new JsonObject()
                .put("groupSearchField", Validator.sanitize(struct.getString("name"))).put("props", struct);
        neo4j.execute(query, params, new Handler<Message<JsonObject>>() {
            @Override
            public void handle(Message<JsonObject> m) {
                message.reply(m.body());
            }
        });
    }
}

---

From source file:org.entcore.feeder.ManualFeeder.java

License:Open Source License

public void createClass(final Message<JsonObject> message) {
    JsonObject c = getMandatoryObject("data", message);
    if (c == null)
        return;//from  w  w  w  . j ava  2 s. c om
    String structureId = getMandatoryString("structureId", message);
    if (structureId == null)
        return;
    if (c.getString("externalId") == null || c.getString("externalId").isEmpty()) {
        c.put("externalId", structureId + "$" + c.getString("name"));
    }
    final String error = classValidator.validate(c);
    if (error != null) {
        logger.error(error);
        sendError(message, error);
    } else {
        String query = "MATCH (s:Structure { id : {structureId}}) " + "CREATE s<-[:BELONGS]-(c:Class {props}) "
                + "SET c.externalId = s.externalId + '$' + c.name " + "WITH s, c "
                + "MATCH s<-[:DEPENDS]-(g:ProfileGroup)-[:HAS_PROFILE]->(p:Profile) "
                + "CREATE c<-[:DEPENDS]-(pg:Group:ProfileGroup {name : c.name+'-'+p.name, displayNameSearchField: {groupSearchField}})-[:DEPENDS]->g "
                + "SET pg.id = id(pg)+'-'+timestamp() " + "RETURN DISTINCT c.id as id ";
        JsonObject params = new JsonObject().put("structureId", structureId)
                .put("groupSearchField", Validator.sanitize(c.getString("name"))).put("props", c);
        neo4j.execute(query, params, new Handler<Message<JsonObject>>() {
            @Override
            public void handle(Message<JsonObject> m) {
                message.reply(m.body());
            }
        });
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• »