sequence call

BaseService.java

    protected static class Pair<A, B> {
        public A a;
        public B b;

        public Pair() {
        }

        public Pair(A a, B b) {
            this.a = a;
            this.b = b;
        }
    }

    private static class SequenceCallPair<T> extends Pair<T,F.Promise<WS.Response>>{}

    protected static interface POSTSequenceCaller<Bean,T>{
        public F.Promise<WS.Response> onSequenceCall(Bean bean,T param,final String token);
        public T[] beanToParams(Bean bean);
    }

    protected static <Bean,T> Result sequenceCallMDMViaPost(final Class<Bean> requestBeanClass,
                                                          final POSTSequenceCaller<Bean, T> caller){
        return handlePOST(new DefaultPOSTHandler<Bean>(requestBeanClass)
                .bodyHandler(new DefaultPOSTHandler.POSTBodyHandler<Bean>() {
                    @Override
                    public Result handle(final Bean bean, final String token) {
                        //NOTE: change userName to userNames
                        final T[] params = caller.beanToParams(bean);
                        if (params == null || params.length == 0){
                            return requestCorrupted();
                        }
                        final List<SequenceCallPair<T>> callTuples = new ArrayList<SequenceCallPair<T>>();
                        for (T param : params) {
                            SequenceCallPair<T> pair = new SequenceCallPair<T>();
                            pair.a = param;
                            callTuples.add(pair);
                        }
                        List<F.Promise<WS.Response>> promiseList = new ArrayList<F.Promise<WS.Response>>(callTuples.size());
                        for (SequenceCallPair<T> pair : callTuples) {
                            F.Promise<WS.Response> mdmResponse =
                                    caller.onSequenceCall(bean,pair.a,token);
                            pair.b = mdmResponse;
                            promiseList.add(mdmResponse);
                        }
                        //noinspection unchecked
                        F.Promise<WS.Response>[] promises = new F.Promise[callTuples.size()];
                        promiseList.toArray(promises);
                        //noinspection unchecked
                        F.Promise<Result> resultPromise = F.Promise.sequence(promises).map(new F.Function<List<WS.Response>, Result>() {
                            @Override
                            public Result apply(List<WS.Response> responses) throws Throwable {
                                //the result bean
                                SequenceCallResponseBean<T> bean = new SequenceCallResponseBean<T>();
                                List<SequenceCallResponseBean.SequenceCallItemInfo<T>> callItemInfos =
                                        new ArrayList<SequenceCallResponseBean.SequenceCallItemInfo<T>>();

                                boolean resultOk = true;
                                for (SequenceCallPair<T> pair : callTuples) {

                                    SequenceCallResponseBean.SequenceCallItemInfo<T> callItemInfo = new SequenceCallResponseBean.SequenceCallItemInfo<T>();
                                    callItemInfo.setParam(pair.a);
                                    //set the result and the error info
                                    if (pair.b == null) {
                                        resultOk = false;
                                        continue;
                                    } else {
                                        JsonNode jsonNode = pair.b.get().asJson();
                                        if (isOK(jsonNode)) {
                                            //pair 's user name is delete ok
                                            callItemInfo.setResult(0);
                                        } else {
                                            //pair is delete error
                                            resultOk = false;
                                            callItemInfo.setResult(-1);
                                            callItemInfo.setInfo(RpcHelpers.getErrorInfo(jsonNode));
                                        }
                                    }
                                    callItemInfos.add(callItemInfo);
                                }
                                bean.setResult(resultOk ? 0 : -1);
                                bean.setCallItemInfos(callItemInfos);
                                return ok(bean);
                            }
                        });
                        return async(resultPromise);
                    }
                }));
    }


    protected static interface GETSequenceCaller{
        public String queryKey();
        public String[] queryValueToParams(final String queryValue);
        public F.Promise<WS.Response> onSequenceCall(final String token,final String param);
    }

    protected static Result sequenceCallMDMViaGET(final GETSequenceCaller caller){
        return handleGET(new DefaultGETHandler(caller.queryKey())
                .queryHandler(new DefaultGETHandler.QueryHandler() {
                    @Override
                    public Result handle(final String queryValue, final String token) {
                        //code for delete on the server side
                        String[] params = caller.queryValueToParams(queryValue);
                        if (params == null || params.length == 0) {
                            return requestCorrupted();
                        }
                        final List<SequenceCallPair<String>> callTuples = new ArrayList<SequenceCallPair<String>>();
                        for (String param : params) {
                            SequenceCallPair<String> pair = new SequenceCallPair<String>();
                            pair.a = param;
                            callTuples.add(pair);
                        }
                        List<F.Promise<WS.Response>> promiseList = new ArrayList<F.Promise<WS.Response>>(callTuples.size());
                        for (SequenceCallPair<String> pair : callTuples) {
                            F.Promise<WS.Response> mdmResponse =
                                    caller.onSequenceCall(token,pair.a);
                            pair.b = mdmResponse;
                            promiseList.add(mdmResponse);
                        }
                        //noinspection unchecked
                        F.Promise<WS.Response>[] promises = new F.Promise[callTuples.size()];
                        promiseList.toArray(promises);
                        //noinspection unchecked
                        F.Promise<Result> resultPromise = F.Promise.sequence(promises).map(new F.Function<List<WS.Response>, Result>() {
                            @Override
                            public Result apply(List<WS.Response> responses) throws Throwable {
                                //the result bean
                                SequenceCallResponseBean<String> bean = new SequenceCallResponseBean<String>();
                                List<SequenceCallResponseBean.SequenceCallItemInfo<String>> callItemInfos =
                                        new ArrayList<SequenceCallResponseBean.SequenceCallItemInfo<String>>();

                                boolean resultOk = true;
                                for (SequenceCallPair<String> pair : callTuples) {

                                    SequenceCallResponseBean.SequenceCallItemInfo<String> callItemInfo = new SequenceCallResponseBean.SequenceCallItemInfo<String>();
                                    callItemInfo.setParam(pair.a);
                                    //set the result and the error info
                                    if (pair.b == null) {
                                        resultOk = false;
                                        continue;
                                    } else {
                                        JsonNode jsonNode = pair.b.get().asJson();
                                        if (isOK(jsonNode)) {
                                            //pair 's user name is delete ok
                                            callItemInfo.setResult(0);
                                        } else {
                                            //pair is delete error
                                            resultOk = false;
                                            callItemInfo.setResult(-1);
                                            callItemInfo.setInfo(RpcHelpers.getErrorInfo(jsonNode));
                                        }
                                    }
                                    callItemInfos.add(callItemInfo);
                                }
                                bean.setResult(resultOk ? 0 : -1);
                                bean.setCallItemInfos(callItemInfos);
                                return ok(bean);
                            }
                        });
                        return async(resultPromise);
                    }
                }));
    }