Example usage for io.vertx.core.json JsonArray JsonArray

List of usage examples for io.vertx.core.json JsonArray JsonArray

Introduction

In this page you can find the example usage for io.vertx.core.json JsonArray JsonArray.

Prototype

public JsonArray(Buffer buf) 

Source Link

Document

Create an instance from a Buffer of JSON.

Usage

From source file:io.knotx.knot.service.service.ServiceEngine.java

License:Apache License

private JsonObject buildResultObject(AdapterResponse adapterResponse) {
    JsonObject object = new JsonObject();

    String rawData = adapterResponse.getResponse().getBody().toString().trim();

    if (rawData.charAt(0) == '[') {
        object.put(RESULT_NAMESPACE_KEY, new JsonArray(rawData));
    } else if (rawData.charAt(0) == '{') {
        object.put(RESULT_NAMESPACE_KEY, new JsonObject(rawData));
    } else {/* w  w w  .  j  a  v  a  2s  .co m*/
        throw new DecodeException("Result is neither Json Array nor Json Object");
    }
    object.put(RESPONSE_NAMESPACE_KEY, new JsonObject().put("statusCode",
            Integer.toString(adapterResponse.getResponse().getStatusCode())));
    return object;
}

From source file:io.mewbase.bson.BsonArray.java

License:Open Source License

/**
 * Convert this into a JsonArray
 *
 * @return  the equivalent JsonArray
 */
public JsonArray toJsonArray() {
    return new JsonArray(list);
}

From source file:io.reactiverse.pgclient.impl.codec.DataTypeCodec.java

License:Apache License

private static Json textDecodeJSONB(int index, int len, ByteBuf buff) {

    // Try to do without the intermediary String (?)
    CharSequence cs = buff.getCharSequence(index, len, StandardCharsets.UTF_8);
    Object value = null;//from   ww w  .j av a  2 s. c o m
    String s = cs.toString();
    int pos = 0;
    while (pos < s.length() && Character.isWhitespace(s.charAt(pos))) {
        pos++;
    }
    if (pos == s.length()) {
        return null;
    } else if (s.charAt(pos) == '{') {
        value = new JsonObject(s);
    } else if (s.charAt(pos) == '[') {
        value = new JsonArray(s);
    } else {
        try {
            JsonNode jsonNode = io.vertx.core.json.Json.mapper.readTree(s);
            if (jsonNode.isNumber()) {
                value = jsonNode.numberValue();
            } else if (jsonNode.isBoolean()) {
                value = jsonNode.booleanValue();
            } else if (jsonNode.isTextual()) {
                value = jsonNode.textValue();
            }
        } catch (IOException e) {
            // do nothing
        }
    }
    return Json.create(value);
}

From source file:io.rebind.vertx.orientdb.model.RecordConverter.java

License:Apache License

public static void toJson(Record obj, JsonObject json) {
    if (obj.getConnections() != null) {
        json.put("connections", new JsonArray(obj.getConnections().stream().map(item -> item.toJson())
                .collect(java.util.stream.Collectors.toList())));
    }/*from   w ww  .  ja  v a 2 s . co  m*/
    if (obj.getProperties() != null) {
        json.put("properties", obj.getProperties());
    }
    if (obj.getRid() != null) {
        json.put("rid", obj.getRid());
    }
    if (obj.getVersion() != null) {
        json.put("version", obj.getVersion());
    }
}

From source file:io.rebind.vertx.orientdb.OrientDBServiceVertxProxyHandler.java

License:Apache License

public void handle(Message<JsonObject> msg) {
    try {//from w w  w.j a v  a 2 s. c o  m
        JsonObject json = msg.body();
        String action = msg.headers().get("action");
        if (action == null) {
            throw new IllegalStateException("action not specified");
        }
        accessed();
        switch (action) {

        case "addVertex": {
            service.addVertex((java.lang.String) json.getValue("iClassName"),
                    (java.lang.String) json.getValue("iClusterName"),
                    (io.vertx.core.json.JsonObject) json.getValue("properties"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(res.result() == null ? null : res.result().toJson());
                        }
                    });
            break;
        }
        case "updateVertex": {
            service.updateVertex((java.lang.String) json.getValue("id"),
                    (io.vertx.core.json.JsonObject) json.getValue("properties"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(res.result() == null ? null : res.result().toJson());
                        }
                    });
            break;
        }
        case "removeVertex": {
            service.removeVertex((java.lang.String) json.getValue("id"), res -> {
                if (res.failed()) {
                    msg.fail(-1, res.cause().getMessage());
                } else {
                    msg.reply(res.result() == null ? null : res.result().toJson());
                }
            });
            break;
        }
        case "getVertex": {
            service.getVertex((java.lang.String) json.getValue("id"), res -> {
                if (res.failed()) {
                    msg.fail(-1, res.cause().getMessage());
                } else {
                    msg.reply(res.result() == null ? null : res.result().toJson());
                }
            });
            break;
        }
        case "getVerticesOfClass": {
            service.getVerticesOfClass((java.lang.String) json.getValue("iClassName"), res -> {
                if (res.failed()) {
                    msg.fail(-1, res.cause().getMessage());
                } else {
                    msg.reply(new JsonArray(
                            res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                }
            });
            break;
        }
        case "getVertices": {
            service.getVertices((java.lang.String) json.getValue("iClassName"),
                    (io.vertx.core.json.JsonObject) json.getValue("vertexQuery"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(new JsonArray(
                                    res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                        }
                    });
            break;
        }
        case "getRelatedVertices": {
            service.getRelatedVertices((java.lang.String) json.getValue("sourceId"),
                    (java.lang.String) json.getValue("label"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(new JsonArray(
                                    res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                        }
                    });
            break;
        }
        case "addEdge": {
            service.addEdge((java.lang.String) json.getValue("sourceId"),
                    (java.lang.String) json.getValue("destinationId"),
                    (java.lang.String) json.getValue("label"),
                    (io.vertx.core.json.JsonObject) json.getValue("properties"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(res.result() == null ? null : res.result().toJson());
                        }
                    });
            break;
        }
        case "removeEdge": {
            service.removeEdge((java.lang.String) json.getValue("id"), res -> {
                if (res.failed()) {
                    msg.fail(-1, res.cause().getMessage());
                } else {
                    msg.reply(res.result() == null ? null : res.result().toJson());
                }
            });
            break;
        }
        case "removeEdges": {
            service.removeEdges((java.lang.String) json.getValue("sourceId"),
                    (java.lang.String) json.getValue("destinationId"),
                    (java.lang.String) json.getValue("label"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(new JsonArray(
                                    res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                        }
                    });
            break;
        }
        case "getEdges": {
            service.getEdges((java.lang.String) json.getValue("sourceId"),
                    (java.lang.String) json.getValue("destinationId"),
                    (java.lang.String) json.getValue("label"), res -> {
                        if (res.failed()) {
                            msg.fail(-1, res.cause().getMessage());
                        } else {
                            msg.reply(new JsonArray(
                                    res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                        }
                    });
            break;
        }
        case "getEdge": {
            service.getEdge((io.vertx.core.json.JsonObject) json.getValue("edgeQuery"), res -> {
                if (res.failed()) {
                    msg.fail(-1, res.cause().getMessage());
                } else {
                    msg.reply(new JsonArray(
                            res.result().stream().map(Record::toJson).collect(Collectors.toList())));
                }
            });
            break;
        }
        case "close": {
            service.close();
            break;
        }
        default: {
            throw new IllegalStateException("Invalid action: " + action);
        }
        }
    } catch (Throwable t) {
        msg.fail(-1, t.getMessage());
        throw t;
    }
}

From source file:net.kuujo.vertigo.network.impl.ComponentConfigImpl.java

License:Apache License

@Override
public JsonObject toJson() {
    JsonObject json = new JsonObject();
    json.put(COMPONENT_NAME, name);/*from  w ww.  j a v  a 2 s  .c om*/
    json.put(COMPONENT_IDENTIFIER, identifier);
    json.put(COMPONENT_CONFIG, config);
    json.put(COMPONENT_WORKER, worker);
    json.put(COMPONENT_MULTI_THREADED, multiThreaded);
    json.put(COMPONENT_STATEFUL, stateful);
    json.put(COMPONENT_REPLICAS, replicas);
    json.put(COMPONENT_RESOURCES,
            new JsonArray(Arrays.asList(resources.toArray(new String[resources.size()]))));
    JsonObject input = new JsonObject();
    for (InputPortConfig port : this.input.getPorts()) {
        input.put(port.getName(), port.toJson());
    }
    json.put(COMPONENT_INPUT, input);
    JsonObject output = new JsonObject();
    for (OutputPortConfig port : this.output.getPorts()) {
        output.put(port.getName(), port.toJson());
    }
    json.put(COMPONENT_OUTPUT, output);
    return json;
}

From source file:net.sf.sgsimulator.sgsrest.vertx.services.GridLabSimulatorService.java

License:Open Source License

/**
 * @formatter:on/*  w w w. j a  v  a  2s  .c o m*/
 */

public JsonArray getAppliedOrdersSince(long timestamp) {
    return new JsonArray(this.gldes.getSimulator().getAppliedOrdersSince(new Date(timestamp)));
}

From source file:org.bdlions.server.AuthServer.java

@Override
public void start() {

    HttpServer server = vertx.createHttpServer();

    Router router = Router.router(vertx);

    router.route("/").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        response.end("Authentication server");
    });/* w w w.  j  a  va  2s .  c o m*/

    //adding a new sim with services
    router.route("/addsim*").handler(BodyHandler.create());
    router.post("/addsim").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //sim no
        String simNo = routingContext.request().getParam("sim_no");
        //web server identifier
        String identifier = routingContext.request().getParam("identifier");
        //description of the sim
        String description = routingContext.request().getParam("description");
        //status of the sim
        String statusStr = routingContext.request().getParam("status");
        //sim service list
        String simServiceList = routingContext.request().getParam("sim_service_list");
        int status = 0;
        try {
            status = Integer.parseInt(statusStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = new SIMInfo();
            simInfo.setSimNo(simNo);
            simInfo.setIdentifier(identifier);
            simInfo.setDescription(description);
            simInfo.setStatus(status);
            JsonArray simServiceArray = new JsonArray(simServiceList);
            for (int counter = 0; counter < simServiceArray.size(); counter++) {
                JsonObject simServiceObject = new JsonObject(simServiceArray.getValue(counter).toString());
                String serviceIdStr = simServiceObject.getString("serviceId");
                String categoryIdStr = simServiceObject.getString("categoryId");
                String currentBalanceStr = simServiceObject.getString("currentBalance");
                double currentBalance = 0;
                try {
                    currentBalance = Double.parseDouble(currentBalanceStr);
                } catch (Exception ex) {
                    logger.error(ex.getMessage());
                }
                SIMServiceInfo simServiceInfo = new SIMServiceInfo();
                simServiceInfo.setCurrentBalance(currentBalance);
                simServiceInfo.setId(Integer.parseInt(serviceIdStr));
                simServiceInfo.setCategoryId(Integer.parseInt(categoryIdStr));
                simInfo.getSimServiceList().add(simServiceInfo);
            }
            simManager.addSIM(simInfo);
            resultEvent.setResponseCode(simManager.getResponseCode());
            resultEvent.setResult(simInfo);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    //edit sim info
    router.route("/editsim*").handler(BodyHandler.create());
    router.post("/editsim").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //based on the identifier validate that given sim_no is valid for this identifier
        String simNo = routingContext.request().getParam("sim_no");
        String identifier = routingContext.request().getParam("identifier");
        String description = routingContext.request().getParam("description");
        String statusStr = routingContext.request().getParam("status");

        int status = 0;
        try {
            status = Integer.parseInt(statusStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = new SIMInfo();
            simInfo.setSimNo(simNo);
            simInfo.setIdentifier(identifier);
            simInfo.setDescription(description);
            simInfo.setStatus(status);
            simManager.updateSIMInfo(simInfo);
            resultEvent.setResponseCode(simManager.getResponseCode());
            resultEvent.setResult(simInfo);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_SERVER_EXCEPTION);
            logger.error(ex.getMessage());
        }
        if (status == 0) {
            //stopping mqtt future client for this sim
            try {
                TransactionInfo transactionInfo = new TransactionInfo();
                transactionInfo.setServiceId(-1);
                transactionInfo.setCellNumber(simNo);
                BufferManager bufferManager = new BufferManager();
                bufferManager.setLocalServerIdentifier(identifier);
                bufferManager.processBuffer(transactionInfo, Transactions.BUFFER_PROCESS_TYPE_MQTT_STOP_SIM);
            } catch (Exception ex) {
                logger.debug(ex.toString());
            }

        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    //return sim with service details
    router.route("/getsimserviceinfo*").handler(BodyHandler.create());
    router.post("/getsimserviceinfo").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //sim no
        String simNo = routingContext.request().getParam("sim_no");
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = simManager.getSIMServiceInfo(simNo);
            if (simInfo != null) {
                resultEvent.setResponseCode(ResponseCodes.SUCCESS);
                resultEvent.setResult(simInfo);
            } else {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_SIMNO);
            }
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_SERVER_EXCEPTION);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    //return all sims
    router.route("/getallsims*").handler(BodyHandler.create());
    router.post("/getallsims").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //identifier of a webserver
        String identifier = routingContext.request().getParam("identifier");
        try {
            SIMManager simManager = new SIMManager();
            List<SIMInfo> simList = simManager.getAllSIMs(identifier);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(simList);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_IDENTIFIER);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getallsimsservices*").handler(BodyHandler.create());
    router.post("/getallsims").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String identifier = routingContext.request().getParam("identifier");
        try {
            SIMManager simManager = new SIMManager();
            List<SIMInfo> simList = simManager.getAllSIMsServices(identifier);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(simList);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_IDENTIFIER);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/checksimbalance*").handler(BodyHandler.create());
    router.post("/checksimbalance").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String simNo = routingContext.request().getParam("sim_no");
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = simManager.getSIMServiceInfo(simNo);
            simManager.generateSIMBalance(simInfo);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getsimmessages*").handler(BodyHandler.create());
    router.post("/getsimmessages").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String simNo = routingContext.request().getParam("sim_no");
        String startTimeStr = routingContext.request().getParam("start_time");
        String endTimeStr = routingContext.request().getParam("end_time");
        String offsetStr = routingContext.request().getParam("offset");
        String limitStr = routingContext.request().getParam("limit");
        int startTime = 0;
        int endTime = 0;
        int offset = 0;
        int limit = 0;
        try {
            startTime = Integer.parseInt(startTimeStr);
            endTime = Integer.parseInt(endTimeStr);
            offset = Integer.parseInt(offsetStr);
            limit = Integer.parseInt(limitStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        try {
            SIMSMSListInfo simSMSListInfo = new SIMSMSListInfo();
            SIMManager simManager = new SIMManager();
            //setting total messages of this sim
            simSMSListInfo.setCounter(simManager.getSIMTotalMessages(simNo, startTime, endTime));
            List<SIMSMSInfo> simSMSList;
            if (limit != 0) {
                simSMSList = simManager.getSIMMessages(simNo, startTime, endTime, offset, limit);
            } else {
                simSMSList = simManager.getAllSIMMessages(simNo, startTime, endTime);
            }
            //setting sim sms list
            simSMSListInfo.setSimSMSList(simSMSList);
            resultEvent.setResult(simSMSListInfo);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/registersubscriber*").handler(BodyHandler.create());
    router.post("/registersubscriber").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        try {
            Database db = Database.getInstance();
            Connection connection = db.getConnection();
            if (connection == null) {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_DB_SETUP_EXCEPTION);
                logger.info("Db connection not set.");
            } else {
                String userName = routingContext.request().getParam("username");
                String maxMembers = routingContext.request().getParam("maxmembers");
                String APIKey = routingContext.request().getParam("apikey");

                try {
                    UserInfo userInfo = new UserInfo();
                    userInfo.setReferenceUserName(userName);
                    userInfo.setMaxMembers(Integer.parseInt(maxMembers));
                    userInfo.setRegistrationDate(1449141369);
                    //right now we are setting a default expired time
                    userInfo.setExpiredDate(2140000000);
                    //right now are not restricting/validating ip address
                    userInfo.setIpAddress("192.168.1.30");

                    UserServiceInfo userServiceInfo = new UserServiceInfo();
                    userServiceInfo.setServiceId(Services.SERVICE_TYPE_ID_BKASH_CASHIN);
                    userServiceInfo.setAPIKey(APIKey);
                    userServiceInfo.setRegistrationDate(1449141369);
                    userServiceInfo.setExpiredDate(2140000000);
                    //right now we have not implement call back function
                    userServiceInfo.setCallbackFunction("callback30");
                    List<UserServiceInfo> userServiceInfoList = new ArrayList<>();
                    userServiceInfoList.add(userServiceInfo);

                    AuthManager authManager = new AuthManager();
                    authManager.createSubscriber(userInfo, userServiceInfoList);
                    int responseCode = authManager.getResponseCode();
                    resultEvent.setResponseCode(responseCode);
                } catch (Exception ex) {
                    resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_MEMBER_COUNTER);
                    logger.error(ex.getMessage());
                }
            }
        } catch (DBSetupException | SQLException ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_DB_SETUP_EXCEPTION);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getsubscriberinfo*").handler(BodyHandler.create());
    router.post("/getsubscriberinfo").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        try {
            Database db = Database.getInstance();
            Connection connection = db.getConnection();
            if (connection == null) {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_DB_SETUP_EXCEPTION);
                logger.info("Db connection not set.");
            } else {
                String userName = routingContext.request().getParam("username");
                try {
                    UserInfo userInfo = new UserInfo();
                    userInfo.setSubscriberReferenceUserName(userName);

                    AuthManager authManager = new AuthManager();
                    userInfo = authManager.getSubscriberInfo(userInfo);
                    int responseCode = authManager.getResponseCode();
                    resultEvent.setResponseCode(responseCode);
                    if (responseCode == ResponseCodes.SUCCESS) {
                        resultEvent.setResult(userInfo);
                    }
                } catch (Exception ex) {
                    resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_MEMBER_COUNTER);
                    logger.error(ex.getMessage());
                }
            }
        } catch (DBSetupException | SQLException ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_DB_SETUP_EXCEPTION);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/registermember*").handler(BodyHandler.create());
    router.post("/registermember").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String userName = routingContext.request().getParam("username");
        String subscriberName = routingContext.request().getParam("subscribername");

        UserInfo userInfo = new UserInfo();
        userInfo.setReferenceUserName(userName);
        userInfo.setSubscriberReferenceUserName(subscriberName);
        //right now are not restricting/validating ip address
        userInfo.setIpAddress("192.168.1.30");

        try {
            AuthManager authManager = new AuthManager();
            authManager.createUser(userInfo);
            int responseCode = authManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
        } catch (UnRegisterIPException ex) {
            //Right now we are skipping ipaddress validation
        } catch (SubscriptionExpireException ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_SUBSCRIPTION_PERIOD_EXPIRED);
            logger.error(ex.getMessage());
        } catch (MaxMemberRegException ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_MAXINUM_MEMBERS_CREATION_REACHED);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getsessioninfo").handler((RoutingContext routingContext) -> {
        String result = "";
        UserInfo userInfo = new UserInfo();
        userInfo.setReferenceUserName("ru31");
        userInfo.setIpAddress("192.168.1.30");

        try {
            AuthManager authManager = new AuthManager();
            result = authManager.getSessionInfo(userInfo, "64hedl981o0suvld9r79kklta2");
        } catch (SubscriptionExpireException | ServiceExpireException ex) {

        }
        HttpServerResponse response = routingContext.response();
        response.end(result);
    });

    router.route("/addsubscriberpayment*").handler(BodyHandler.create());
    router.post("/addsubscriberpayment").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String APIKey = routingContext.request().getParam("APIKey");
        String amount = routingContext.request().getParam("amount");

        TransactionInfo transactionInfo = new TransactionInfo();
        transactionInfo.setAPIKey(APIKey);
        try {
            transactionInfo.setBalanceIn(Long.parseLong(amount));

            TransactionManager transactionManager = new TransactionManager();
            transactionManager.addUserPayment(transactionInfo);
            int responseCode = transactionManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
            if (responseCode == ResponseCodes.SUCCESS) {
                transactionInfo.setTransactionId(transactionManager.getTransactionId());
                resultEvent.setResult(transactionInfo);
            }
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getdeshboardinfolist*").handler(BodyHandler.create());
    router.post("/getdeshboardinfolist").handler((RoutingContext routingContext) -> {
        JSONObject resultInfos = new JSONObject();
        ResultEvent resultEvent = new ResultEvent();
        String startUnixTime = routingContext.request().getParam("start_time");
        String endUnixTime = routingContext.request().getParam("end_time");
        try {
            //generate summary info
            JSONObject summaryInfo = new JSONObject();
            summaryInfo.put("total_amount", 600000);
            summaryInfo.put("total_profit", 50000);
            summaryInfo.put("total_subscriber", 50);

            //generate survice rank list by volumn
            // return service rank list by acending order by volumn
            JSONObject serviceRankInfoByVolumn1 = new JSONObject();
            serviceRankInfoByVolumn1.put("service_id", "101");
            serviceRankInfoByVolumn1.put("total_amount", 30000);
            serviceRankInfoByVolumn1.put("total_profit", 5000);
            JSONObject serviceRankInfoByVolumn2 = new JSONObject();
            serviceRankInfoByVolumn2.put("service_id", "1");
            serviceRankInfoByVolumn2.put("total_amount", 20000);
            serviceRankInfoByVolumn2.put("total_profit", 1000);
            JSONObject serviceRankInfoByVolumn3 = new JSONObject();
            serviceRankInfoByVolumn3.put("service_id", "3");
            serviceRankInfoByVolumn3.put("total_amount", 10000);
            serviceRankInfoByVolumn3.put("total_profit", 500);

            List<JSONObject> serviceRankByVolumnList = new ArrayList<>();
            serviceRankByVolumnList.add(serviceRankInfoByVolumn1);
            serviceRankByVolumnList.add(serviceRankInfoByVolumn2);
            serviceRankByVolumnList.add(serviceRankInfoByVolumn3);

            //generate survice profit rank list by volumn
            JSONObject serviceProfitRank1 = new JSONObject();
            serviceProfitRank1.put("service_id", "101");
            serviceProfitRank1.put("service_percentage", "30");
            JSONObject serviceProfitRank2 = new JSONObject();
            serviceProfitRank2.put("service_id", "1");
            serviceProfitRank2.put("service_percentage", "10");
            JSONObject serviceProfitRank3 = new JSONObject();
            serviceProfitRank3.put("service_id", "2");
            serviceProfitRank3.put("service_percentage", "10");
            JSONObject serviceProfitRank4 = new JSONObject();
            serviceProfitRank4.put("service_id", "3");
            serviceProfitRank4.put("service_percentage", "15");
            JSONObject serviceProfitRank5 = new JSONObject();
            serviceProfitRank5.put("service_id", "4");
            serviceProfitRank5.put("service_percentage", "10");
            JSONObject serviceProfitRank6 = new JSONObject();
            serviceProfitRank6.put("service_id", "102");
            serviceProfitRank6.put("service_percentage", "15");
            JSONObject serviceProfitRank7 = new JSONObject();
            serviceProfitRank7.put("service_id", "103");
            serviceProfitRank7.put("service_percentage", "1");

            List<JSONObject> serviceProfitRankList = new ArrayList<>();
            serviceProfitRankList.add(serviceProfitRank1);
            serviceProfitRankList.add(serviceProfitRank2);
            serviceProfitRankList.add(serviceProfitRank3);
            serviceProfitRankList.add(serviceProfitRank4);
            serviceProfitRankList.add(serviceProfitRank5);
            serviceProfitRankList.add(serviceProfitRank6);
            serviceProfitRankList.add(serviceProfitRank7);

            //generate Top customer rank list by volumn
            JSONObject customerInfo1 = new JSONObject();
            customerInfo1.put("user_name", "Nazmul Hasan");
            customerInfo1.put("amount_percentage", "50");
            JSONObject customerInfo2 = new JSONObject();
            customerInfo2.put("user_name", "Alamgir Kabir");
            customerInfo2.put("amount_percentage", "30");
            JSONObject customerInfo3 = new JSONObject();
            customerInfo3.put("user_name", "Rashida Sultana");
            customerInfo3.put("amount_percentage", "20");

            List<JSONObject> topCustomerList = new ArrayList<>();
            topCustomerList.add(customerInfo1);
            topCustomerList.add(customerInfo2);
            topCustomerList.add(customerInfo3);

            resultInfos.put("summaryInfo", summaryInfo);
            resultInfos.put("serviceRankByVolumnList", serviceRankByVolumnList);
            resultInfos.put("topCustomerList", topCustomerList);
            resultInfos.put("serviceProfitRankList", serviceProfitRankList);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(resultInfos);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultInfos.toString());
    });

    router.route("/getServiceRanklistByVolumn*").handler(BodyHandler.create());
    router.post("/getServiceRanklistByVolumn").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        List<JSONObject> serviceRankByVolumnList = new ArrayList<>();
        String startDate = routingContext.request().getParam("start_date");
        String endDate = routingContext.request().getParam("end_date");
        try {

            //generate survice rank list by volumn
            // return service rank list by acending order by volumn
            JSONObject serviceRankInfoByVolumn1 = new JSONObject();
            serviceRankInfoByVolumn1.put("service_id", "102");
            serviceRankInfoByVolumn1.put("total_amount", 7000);
            serviceRankInfoByVolumn1.put("total_profit", 100);
            JSONObject serviceRankInfoByVolumn2 = new JSONObject();
            serviceRankInfoByVolumn2.put("service_id", "1");
            serviceRankInfoByVolumn2.put("total_amount", 2000);
            serviceRankInfoByVolumn2.put("total_profit", 2000);
            JSONObject serviceRankInfoByVolumn3 = new JSONObject();
            serviceRankInfoByVolumn3.put("service_id", "2");
            serviceRankInfoByVolumn3.put("total_amount", 30000);
            serviceRankInfoByVolumn3.put("total_profit", 500);

            //                List<JSONObject> serviceRankByVolumnList = new ArrayList<>();
            serviceRankByVolumnList.add(serviceRankInfoByVolumn1);
            serviceRankByVolumnList.add(serviceRankInfoByVolumn2);
            serviceRankByVolumnList.add(serviceRankInfoByVolumn3);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(serviceRankByVolumnList);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(serviceRankByVolumnList.toString());
    });
    router.route("/getCustomerList*").handler(BodyHandler.create());
    router.post("/getCustomerList").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        List<JSONObject> topCustomerList = new ArrayList<>();
        String startDate = routingContext.request().getParam("start_date");
        String endDate = routingContext.request().getParam("end_date");
        String serviceId = routingContext.request().getParam("service_id");
        try {

            //generate Top customer rank list by volumn
            JSONObject customerInfo1 = new JSONObject();
            customerInfo1.put("user_name", "Rashida sultana");
            customerInfo1.put("amount_percentage", "60");
            JSONObject customerInfo2 = new JSONObject();
            customerInfo2.put("user_name", "Alamgir Kabir");
            customerInfo2.put("amount_percentage", "30");
            JSONObject customerInfo3 = new JSONObject();
            customerInfo3.put("user_name", "Nazmul Hasan");
            customerInfo3.put("amount_percentage", "20");

            //                List<JSONObject> topCustomerList = new ArrayList<>();
            topCustomerList.add(customerInfo1);
            topCustomerList.add(customerInfo2);
            topCustomerList.add(customerInfo3);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(topCustomerList);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(topCustomerList.toString());
    });

    router.route("/getbaseurl*").handler(BodyHandler.create());
    router.post("/getbaseurl").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String opCode = routingContext.request().getParam("code");
        try {
            AuthManager authManager = new AuthManager();
            String baseURL = authManager.getBaseURLOPCode(opCode);
            if (baseURL != null && !baseURL.equals("")) {
                resultEvent.setResponseCode(ResponseCodes.SUCCESS);
                resultEvent.setResult(baseURL);
            } else {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_OP_CODE);
                logger.error("baseURL request for invalid op code : " + opCode);
            }
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_SERVER_EXCEPTION);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    router.route("/getServiceProfitList*").handler(BodyHandler.create());
    router.post("/getServiceProfitList").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        List<JSONObject> serviceProfitRankList = new ArrayList<>();
        String startDate = routingContext.request().getParam("start_date");
        String endDate = routingContext.request().getParam("end_date");
        try {

            JSONObject serviceProfitRank1 = new JSONObject();
            serviceProfitRank1.put("service_id", "101");
            serviceProfitRank1.put("service_percentage", "20");
            JSONObject serviceProfitRank2 = new JSONObject();
            serviceProfitRank2.put("service_id", "1");
            serviceProfitRank2.put("service_percentage", "20");
            JSONObject serviceProfitRank3 = new JSONObject();
            serviceProfitRank3.put("service_id", "2");
            serviceProfitRank3.put("service_percentage", "10");
            JSONObject serviceProfitRank4 = new JSONObject();
            serviceProfitRank4.put("service_id", "3");
            serviceProfitRank4.put("service_percentage", "15");
            JSONObject serviceProfitRank5 = new JSONObject();
            serviceProfitRank5.put("service_id", "4");
            serviceProfitRank5.put("service_percentage", "5");
            JSONObject serviceProfitRank6 = new JSONObject();
            serviceProfitRank6.put("service_id", "102");
            serviceProfitRank6.put("service_percentage", "15");
            JSONObject serviceProfitRank7 = new JSONObject();
            serviceProfitRank7.put("service_id", "103");
            serviceProfitRank7.put("service_percentage", "10");

            serviceProfitRankList.add(serviceProfitRank1);
            serviceProfitRankList.add(serviceProfitRank2);
            serviceProfitRankList.add(serviceProfitRank3);
            serviceProfitRankList.add(serviceProfitRank4);
            serviceProfitRankList.add(serviceProfitRank5);
            serviceProfitRankList.add(serviceProfitRank6);
            serviceProfitRankList.add(serviceProfitRank7);
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            resultEvent.setResult(serviceProfitRankList);

        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(serviceProfitRankList.toString());
    });
    server.requestHandler(router::accept).listen(4040);
}

From source file:org.bdlions.server.ServiceAPIServer.java

@Override
public void start() {
    HttpServer server = vertx.createHttpServer();
    Router router = Router.router(vertx);

    router.route("/").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        response.end("ServiceAPI server");
    });//w  w w  .  j a va 2  s  .c  o m

    //router.route("/addtransaction").handler((RoutingContext routingContext) -> {
    router.route("/addtransaction*").handler(BodyHandler.create());
    router.post("/addtransaction").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        ResultEvent resultEvent = new ResultEvent();
        String userId = "";
        String sessionId = "";
        //validate userId and sessionId from the hashmap

        String APIKey = routingContext.request().getParam("APIKey");
        String amount = routingContext.request().getParam("amount");
        String cellNumber = routingContext.request().getParam("cell_no");
        String packageId = routingContext.request().getParam("package_id");
        String description = routingContext.request().getParam("description");
        String liveTestFlag = routingContext.request().getParam("livetestflag");
        TransactionInfo transactionInfo = new TransactionInfo();
        transactionInfo.setAPIKey(APIKey);
        transactionInfo.setCellNumber(cellNumber);
        transactionInfo.setDescription(description);
        transactionInfo.setLiveTestFlag(liveTestFlag);
        transactionInfo.setEditable(Boolean.TRUE);
        try {
            transactionInfo.setPackageId(Integer.parseInt(packageId));
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_OPERATOR_PACKAGE_ID);
            logger.error(ex.getMessage());
            response.end(resultEvent.toString());
            return;
        }
        try {
            transactionInfo.setBalanceOut(Double.parseDouble(amount));
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
            response.end(resultEvent.toString());
            return;
        }

        //for web server test transaction we are returning back from here
        if (transactionInfo.getLiveTestFlag().equals(Transactions.TRANSACTION_FLAG_WEBSERVER_TEST)) {
            resultEvent.setResponseCode(ResponseCodes.SUCCESS);
            transactionInfo.setTransactionId(Utils.getTransactionId());
            resultEvent.setResult(transactionInfo);
            response.end(resultEvent.toString());
            return;
        }

        BufferManager bufferManager = new BufferManager();
        bufferManager.processBuffer(transactionInfo, Transactions.BUFFER_PROCESS_TYPE_ADD_TRANSACTION);
        int responseCode = bufferManager.getTransactionManager().getResponseCode();

        resultEvent.setResponseCode(responseCode);
        if (responseCode == ResponseCodes.SUCCESS) {
            transactionInfo.setTransactionId(bufferManager.getTransactionManager().getTransactionId());
            resultEvent.setResult(transactionInfo);
        }
        response.end(resultEvent.toString());
    });

    router.route("/addmultipletransactions*").handler(BodyHandler.create());
    router.post("/addmultipletransactions").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        HttpServerResponse response = routingContext.response();
        List<TransactionInfo> transactionInfoList = new ArrayList<>();
        String transactionList = routingContext.request().getParam("transction_list");
        String liveTestFlag = routingContext.request().getParam("livetestflag");
        JsonArray transactionArray = new JsonArray(transactionList);
        BufferManager bufferManager = new BufferManager();
        for (int counter = 0; counter < transactionArray.size(); counter++) {
            JsonObject jsonObject = new JsonObject(transactionArray.getValue(counter).toString());
            String id = jsonObject.getString("id");
            String cellNo = jsonObject.getString("cell_no");
            String APIKey = jsonObject.getString("APIKey");
            String packageId = jsonObject.getString("operator_type_id");
            String amount = jsonObject.getString("amount");

            TransactionInfo transactionInfo = new TransactionInfo();
            transactionInfo.setEditable(Boolean.TRUE);
            transactionInfo.setAPIKey(APIKey);
            try {
                transactionInfo.setPackageId(Integer.parseInt(packageId));
            } catch (Exception ex) {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_OPERATOR_PACKAGE_ID);
                logger.error(ex.getMessage());
                response.end(resultEvent.toString());
                return;
            }
            try {
                transactionInfo.setBalanceOut(Double.parseDouble(amount));
            } catch (Exception ex) {
                resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
                logger.error(ex.getMessage());
                response.end(resultEvent.toString());
                return;
            }
            transactionInfo.setLiveTestFlag(liveTestFlag);
            transactionInfo.setCellNumber(cellNo);
            transactionInfo.setReferenceId(id);
            //for web server test transaction we are returning back from here
            if (transactionInfo.getLiveTestFlag().equals(Transactions.TRANSACTION_FLAG_WEBSERVER_TEST)) {
                transactionInfo.setTransactionId(Utils.getTransactionId());
            } else {
                //transactionInfo.setTransactionId(Utils.getTransactionId());                
                //UserServiceInfo userServiceInfo = transactionManager.getUserServiceInfo(APIKey);
                //transactionInfo.setServiceId(userServiceInfo.getServiceId());
                //transactionManager.addTransaction(transactionInfo);
                bufferManager.processBuffer(transactionInfo, Transactions.BUFFER_PROCESS_TYPE_ADD_TRANSACTION);
                int responseCode = bufferManager.getTransactionManager().getResponseCode();
                if (responseCode == ResponseCodes.SUCCESS) {
                    transactionInfo.setTransactionId(bufferManager.getTransactionManager().getTransactionId());
                }
                //what will you do if response code is not success?                    
            }
            transactionInfoList.add(transactionInfo);
        }
        resultEvent.setResult(transactionInfoList);
        resultEvent.setResponseCode(ResponseCodes.SUCCESS);

        response.end(resultEvent.toString());
    });

    router.route("/updatetransactioninfo*").handler(BodyHandler.create());
    router.post("/updatetransactioninfo").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        ResultEvent resultEvent = new ResultEvent();
        String transactionId = routingContext.request().getParam("transaction_id");
        String amount = routingContext.request().getParam("amount");
        String cellNumber = routingContext.request().getParam("cell_no");
        TransactionInfo transactionInfo = new TransactionInfo();
        transactionInfo.setTransactionId(transactionId);
        transactionInfo.setCellNumber(cellNumber);
        transactionInfo.setEditable(Boolean.TRUE);
        try {
            transactionInfo.setBalanceOut(Double.parseDouble(amount));
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_INVALID_AMOUNT);
            logger.error(ex.getMessage());
            response.end(resultEvent.toString());
            return;
        }

        BufferManager bufferManager = new BufferManager();
        bufferManager.processBuffer(transactionInfo, Transactions.BUFFER_PROCESS_TYPE_UPDATE_TRANSACTION);
        int responseCode = bufferManager.getTransactionManager().getResponseCode();
        resultEvent.setResponseCode(responseCode);
        if (responseCode == ResponseCodes.SUCCESS) {
            resultEvent.setResult(transactionInfo);
        }
        response.end(resultEvent.toString());
    });

    //updating transaction acknowledge status from local server
    router.route("/transactionstatusack*").handler(BodyHandler.create());
    router.post("/transactionstatusack").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //our system transaction id
        String transactionId = routingContext.request().getParam("transactionid");
        //transaction status id
        String statusIdStr = routingContext.request().getParam("statusid");
        System.out.println("Updating transaction status ack ----------------transactionId:" + transactionId
                + ",statusIdStr:" + statusIdStr);
        int statusId = 0;
        try {
            statusId = Integer.parseInt(statusIdStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        //updating transaction status acknowledgement
        try {
            TransactionInfo transactionInfo = new TransactionInfo();
            transactionInfo.setTransactionId(transactionId);
            transactionInfo.setTransactionStatusId(statusId);

            TransactionManager transactionManager = new TransactionManager();
            transactionManager.updateTransactionStatusAck(transactionInfo);

            int responseCode = transactionManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_UPDATE_TRANSACTION_STATUS_ACK_FAILED);
            logger.error(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    //updating transaction status with other parameters for ussd call at local server
    router.route("/updatetransactionstatus*").handler(BodyHandler.create());
    router.post("/updatetransactionstatus").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //our system transaction id
        String transactionId = routingContext.request().getParam("transactionid");
        //transaction status id
        String statusIdStr = routingContext.request().getParam("statusid");
        // transaction id from operator
        String trxIdOperator = routingContext.request().getParam("trxidoperator");
        //sender cell number
        String senderCellNumber = routingContext.request().getParam("sendercellnumber");
        //sim service id of sender
        String serviceIdStr = routingContext.request().getParam("serviceid");
        //current balance of sender
        String balanceStr = routingContext.request().getParam("balance");

        System.out.println("Updating transaction status----------------transactionId:" + transactionId
                + ",statusIdStr:" + statusIdStr + ",trxIdOperator:" + trxIdOperator + ",senderCellNumber:"
                + senderCellNumber + ",serviceIdStr:" + serviceIdStr + ",balanceStr:" + balanceStr);

        int statusId = 0;
        try {
            statusId = Integer.parseInt(statusIdStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        double balance = 0;
        try {
            balance = Double.parseDouble(balanceStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }

        int serviceId = 0;
        try {
            serviceId = Integer.parseInt(serviceIdStr);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        //updating transaction status with sender cell number and operator transaction id
        try {
            TransactionInfo transactionInfo = new TransactionInfo();
            transactionInfo.setTransactionId(transactionId);
            transactionInfo.setTransactionStatusId(statusId);
            transactionInfo.setSenderCellNumber(senderCellNumber);
            transactionInfo.setTrxIdOperator(trxIdOperator);

            TransactionManager transactionManager = new TransactionManager();
            transactionManager.updateTransactionStatus(transactionInfo);

            int responseCode = transactionManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_UPDATE_TRANSACTION_STATUS_FAILED);
            logger.error(ex.getMessage());
        }
        //updating sim current balance
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = new SIMInfo();
            simInfo.setSimNo(senderCellNumber);
            SIMServiceInfo simServiceInfo = new SIMServiceInfo();
            simServiceInfo.setCurrentBalance(balance);
            simServiceInfo.setId(serviceId);
            simInfo.getSimServiceList().add(simServiceInfo);
            simManager.updateSIMServiceBalanceInfo(simInfo);

            int responseCode = simManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }

        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());

    });

    router.route("/updatestktransactionstatus*").handler(BodyHandler.create());
    router.post("/updatestktransactionstatus").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        String serviceIdStr = routingContext.request().getParam("serviceId");
        //expected format of cell number 8801711123456
        String senderCellNumber = routingContext.request().getParam("sendercellnumber");
        String currentBalanceStr = routingContext.request().getParam("currentbalance");
        String APIKey = routingContext.request().getParam("apikey");
        //expected format of cell number 01711123456
        String cellNumber = routingContext.request().getParam("cellnumber");
        String balanceStr = routingContext.request().getParam("balance");
        //transaction id from operators
        String transactionId = routingContext.request().getParam("transactionid");
        String statusIdStr = routingContext.request().getParam("statusid");
        String sender = routingContext.request().getParam("sender");
        String sms = routingContext.request().getParam("sms");
        System.out.println("Updating stk transaction status----------------serviceIdStr:" + serviceIdStr
                + ",senderCellNumber:" + senderCellNumber + ",currentBalanceStr:" + currentBalanceStr
                + ",APIKey:" + APIKey + ",cellNumber:" + cellNumber + ",balanceStr:" + balanceStr
                + ",transactionId:" + transactionId + ",statusIdStr:" + statusIdStr + ",sender:" + sender
                + ",sms:" + sms);
        int serviceId = 0;
        try {
            serviceId = Integer.parseInt(serviceIdStr);
        } catch (Exception ex) {
            logger.debug("Invalid serviceId at updatestktransactionstatus-senderCellNumber:" + senderCellNumber
                    + ",currentBalance:" + currentBalanceStr + ",APIKey:" + APIKey + ",cellNumber:" + cellNumber
                    + ",balance:" + balanceStr + ",transactionId:" + transactionId + ",statusId:" + statusIdStr
                    + ",serviceId:" + serviceIdStr);
            logger.debug(ex.getMessage());
        }
        int statusId = 0;
        try {
            statusId = Integer.parseInt(statusIdStr);
        } catch (Exception ex) {
            logger.debug("Invalid statusId at updatestktransactionstatus-senderCellNumber:" + senderCellNumber
                    + ",currentBalance:" + currentBalanceStr + ",APIKey:" + APIKey + ",cellNumber:" + cellNumber
                    + ",balance:" + balanceStr + ",transactionId:" + transactionId + ",statusId:" + statusIdStr
                    + ",serviceId:" + serviceIdStr);
            logger.debug(ex.getMessage());
        }
        double currentBalance = 0;
        try {
            currentBalance = Double.parseDouble(currentBalanceStr);
        } catch (Exception ex) {
            logger.debug("Invalid current balance at updatestktransactionstatus-senderCellNumber:"
                    + senderCellNumber + ",currentBalance:" + currentBalanceStr + ",APIKey:" + APIKey
                    + ",cellNumber:" + cellNumber + ",balance:" + balanceStr + ",transactionId:" + transactionId
                    + ",statusId:" + statusIdStr + ",serviceId:" + serviceIdStr);
            logger.debug(ex.getMessage());
        }
        double balance = 0;
        try {
            balance = Double.parseDouble(balanceStr);
        } catch (Exception ex) {
            logger.debug("Invalid balance at updatestktransactionstatus-senderCellNumber:" + senderCellNumber
                    + ",currentBalance:" + currentBalanceStr + ",APIKey:" + APIKey + ",cellNumber:" + cellNumber
                    + ",balance:" + balanceStr + ",transactionId:" + transactionId + ",statusId:" + statusIdStr
                    + ",serviceId:" + serviceIdStr);
            logger.debug(ex.getMessage());
        }

        try {
            TransactionInfo transactionInfo = new TransactionInfo();
            //updating transaction info
            transactionInfo.setSenderCellNumber(senderCellNumber);
            transactionInfo.setAPIKey(APIKey);
            transactionInfo.setCellNumber(cellNumber);
            transactionInfo.setBalanceOut(balance);
            transactionInfo.setTrxIdOperator(transactionId);
            transactionInfo.setTransactionStatusId(statusId);

            TransactionManager transactionManager = new TransactionManager();
            transactionManager.updateLSSTKTransactionStatus(transactionInfo);
            int responseCode = transactionManager.getResponseCode();
            if (responseCode == ResponseCodes.SUCCESS) {
                try {
                    //updating SIM current balance for this service
                    SIMManager simManager = new SIMManager();
                    SIMInfo simInfo = new SIMInfo();
                    simInfo.setSimNo(senderCellNumber);
                    SIMServiceInfo simServiceInfo = new SIMServiceInfo();
                    simServiceInfo.setCurrentBalance(currentBalance);
                    simServiceInfo.setId(serviceId);
                    simInfo.getSimServiceList().add(simServiceInfo);
                    simManager.updateSIMServiceBalanceInfo(simInfo);

                    responseCode = simManager.getResponseCode();
                    resultEvent.setResponseCode(responseCode);

                    SIMSMSInfo simSMSInfo = new SIMSMSInfo();
                    simSMSInfo.setSimNo(senderCellNumber);
                    simSMSInfo.setSender(sender);
                    simSMSInfo.setSms(sms);
                    simManager.addSIMMessage(simSMSInfo);
                } catch (Exception ex) {
                    resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_SIM_BALANCE_UPDATE_FAILED);
                    logger.error(ex.getMessage());
                }
            }
            resultEvent.setResponseCode(responseCode);
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_UPDATE_TRANSACTION_STATUS_FAILED);
            logger.error(ex.getMessage());
        }

        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());

    });

    //this method will update sim balance of a service
    router.route("/updatesimbalance*").handler(BodyHandler.create());
    router.post("/updatesimbalance").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //sim service id
        String serviceIdStr = routingContext.request().getParam("serviceid");
        //8801711123456
        String senderCellNumber = routingContext.request().getParam("sendercellnumber");
        //current balance of the sim under the sim service
        String balanceStr = routingContext.request().getParam("balance");
        //sms sender title
        String sender = routingContext.request().getParam("sender");
        //sms text
        String sms = routingContext.request().getParam("sms");
        System.out.println(
                "Updating sim balance----------------serviceIdStr:" + serviceIdStr + ",senderCellNumber:"
                        + senderCellNumber + ",balanceStr:" + balanceStr + ",sender:" + sender + ",sms:" + sms);
        double balance = 0;
        try {
            balance = Double.parseDouble(balanceStr);
        } catch (Exception ex) {
            logger.debug(
                    "Invalid balance at updatesimbalance-senderCellNumber:" + senderCellNumber + ",balance:"
                            + balanceStr + ",serviceId:" + serviceIdStr + ",sender:" + sender + ",sms:" + sms);
            logger.debug(ex.getMessage());
        }
        int serviceId = 0;
        try {
            serviceId = Integer.parseInt(serviceIdStr);
        } catch (Exception ex) {
            logger.debug(
                    "Invalid serviceId at updatesimbalance-senderCellNumber:" + senderCellNumber + ",balance:"
                            + balanceStr + ",serviceId:" + serviceIdStr + ",sender:" + sender + ",sms:" + sms);
            logger.debug(ex.getMessage());
        }
        try {
            SIMManager simManager = new SIMManager();
            SIMInfo simInfo = new SIMInfo();
            simInfo.setSimNo(senderCellNumber);
            SIMServiceInfo simServiceInfo = new SIMServiceInfo();
            simServiceInfo.setCurrentBalance(balance);
            simServiceInfo.setId(serviceId);
            simInfo.getSimServiceList().add(simServiceInfo);
            simManager.updateSIMServiceBalanceInfo(simInfo);

            int responseCode = simManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
            //saving sim sms if exists (there will sms for stk feature)
            if (sender != null && !sender.isEmpty() && sms != null && !sms.isEmpty()) {
                SIMSMSInfo simSMSInfo = new SIMSMSInfo();
                simSMSInfo.setSimNo(senderCellNumber);
                simSMSInfo.setSender(sender);
                simSMSInfo.setSms(sms);
                simManager.addSIMMessage(simSMSInfo);
            }
        } catch (Exception ex) {
            logger.debug(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });

    //this method will update sim balance of a service
    router.route("/savesimsms*").handler(BodyHandler.create());
    router.post("/savesimsms").handler((RoutingContext routingContext) -> {
        ResultEvent resultEvent = new ResultEvent();
        //expected format is 8801711123456
        String senderCellNumber = routingContext.request().getParam("sendercellnumber");
        //sms sender title
        String sender = routingContext.request().getParam("sender");
        //sms text
        String sms = routingContext.request().getParam("sms");
        System.out.println("Saving sim sms----------------senderCellNumber:" + senderCellNumber + ",sender:"
                + sender + ",sms:" + sms);
        try {
            SIMManager simManager = new SIMManager();
            SIMSMSInfo simSMSInfo = new SIMSMSInfo();
            simSMSInfo.setSimNo(senderCellNumber);
            simSMSInfo.setSender(sender);
            simSMSInfo.setSms(sms);
            simManager.addSIMMessage(simSMSInfo);
            int responseCode = simManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
        } catch (Exception ex) {
            logger.debug(ex.getMessage());
        }
        HttpServerResponse response = routingContext.response();
        response.end(resultEvent.toString());
    });
    /**
     * post method to send bulk sms
     * @param cellnumberlist, cell number list
     * @param sms, sms body
     * @param APIKey, APIKey
     * @param livetestflag, flag of transaction
    */
    router.route("/sendsms*").handler(BodyHandler.create());
    router.post("/sendsms").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        ResultEvent resultEvent = new ResultEvent();
        SMSTransactionInfo smsTransactionInfo = new SMSTransactionInfo();
        String cellNumberList = routingContext.request().getParam("cellnumberlist");
        String sms = routingContext.request().getParam("sms");
        String APIKey = routingContext.request().getParam("APIKey");
        String liveTestFlag = routingContext.request().getParam("livetestflag");
        smsTransactionInfo.setLiveTestFlag(liveTestFlag);
        smsTransactionInfo.setSms(sms);
        smsTransactionInfo.setAPIKey(APIKey);
        JsonArray cellNumberArray = new JsonArray(cellNumberList);
        //JsonArray ja = new JsonArray();
        for (int counter = 0; counter < cellNumberArray.size(); counter++) {
            JsonObject jsonObject = new JsonObject(cellNumberArray.getValue(counter).toString());
            String id = jsonObject.getString("id");
            String cellNo = jsonObject.getString("cell_no");
            smsTransactionInfo.getCellNumberList().add(cellNo);

            //System.out.println(id);
            //System.out.println(cellNo);

            //JsonObject jO = new JsonObject();
            //jO.put("id", id);
            //jO.put("cell_no", cellNo);

            //ja.add(jO);
        }
        try {
            TransactionManager transactionManager = new TransactionManager();
            transactionManager.addSMSTransaction(smsTransactionInfo);
            int responseCode = transactionManager.getResponseCode();
            resultEvent.setResponseCode(responseCode);
            if (responseCode == ResponseCodes.SUCCESS) {
                smsTransactionInfo.setTransactionId(transactionManager.getTransactionId());
                resultEvent.setResult(smsTransactionInfo);
            }
        } catch (Exception ex) {
            resultEvent.setResponseCode(ResponseCodes.ERROR_CODE_WEBSERVICE_PROCESS_EXCEPTION);
            logger.error(ex.toString());
        }
        response.end(resultEvent.toString());
    });

    router.route("/sendemail*").handler(BodyHandler.create());
    router.post("/sendemail").handler((RoutingContext routingContext) -> {
        HttpServerResponse response = routingContext.response();
        ResultEvent resultEvent = new ResultEvent();
        String receiverEmail = routingContext.request().getParam("email");
        String message = routingContext.request().getParam("message");
        Email email = new Email();
        email.sendEmail(receiverEmail, message);
        response.end(resultEvent.toString());
    });

    server.requestHandler(router::accept).listen(3030);
}

From source file:org.eclipse.hono.deviceregistry.FileBasedRegistrationService.java

License:Open Source License

Future<Void> loadRegistrationData() {
    Future<Void> result = Future.future();

    if (getConfig().getFilename() == null) {
        result.fail(new IllegalStateException("device identity filename is not set"));
    } else {/*from  w  ww  .j a v  a2  s.c  o  m*/

        final FileSystem fs = vertx.fileSystem();
        log.debug("trying to load device registration information from file {}", getConfig().getFilename());
        if (fs.existsBlocking(getConfig().getFilename())) {
            final AtomicInteger deviceCount = new AtomicInteger();
            fs.readFile(getConfig().getFilename(), readAttempt -> {
                if (readAttempt.succeeded()) {
                    JsonArray allObjects = new JsonArray(new String(readAttempt.result().getBytes()));
                    for (Object obj : allObjects) {
                        JsonObject tenant = (JsonObject) obj;
                        String tenantId = tenant.getString(FIELD_TENANT);
                        log.debug("loading devices for tenant [{}]", tenantId);
                        Map<String, JsonObject> deviceMap = new HashMap<>();
                        for (Object deviceObj : tenant.getJsonArray(ARRAY_DEVICES)) {
                            JsonObject device = (JsonObject) deviceObj;
                            String deviceId = device.getString(FIELD_DEVICE_ID);
                            log.debug("loading device [{}]", deviceId);
                            deviceMap.put(deviceId, device.getJsonObject(FIELD_DATA));
                            deviceCount.incrementAndGet();
                        }
                        identities.put(tenantId, deviceMap);
                    }
                    log.info("successfully loaded {} device identities from file [{}]", deviceCount.get(),
                            getConfig().getFilename());
                    result.complete();
                } else {
                    log.warn("could not load device identities from file [{}]", getConfig().getFilename());
                    result.fail(readAttempt.cause());
                }
            });
        } else {
            log.debug("device identity file [{}] does not exist (yet)", getConfig().getFilename());
            result.complete();
        }
    }
    return result;
}