| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.nlpcraft.client.impl; |
| |
| import com.google.gson.Gson; |
| import com.google.gson.GsonBuilder; |
| import com.google.gson.JsonDeserializer; |
| import com.google.gson.JsonElement; |
| import com.google.gson.JsonObject; |
| import org.apache.commons.lang3.tuple.Pair; |
| import org.apache.http.HttpEntity; |
| import org.apache.http.client.ResponseHandler; |
| import org.apache.http.client.config.RequestConfig; |
| import org.apache.http.client.methods.HttpPost; |
| import org.apache.http.entity.StringEntity; |
| import org.apache.http.impl.client.CloseableHttpClient; |
| import org.apache.http.util.EntityUtils; |
| import org.apache.logging.log4j.LogManager; |
| import org.apache.logging.log4j.Logger; |
| import org.apache.nlpcraft.client.NCClient; |
| import org.apache.nlpcraft.client.NCClientException; |
| import org.apache.nlpcraft.client.NCCompany; |
| import org.apache.nlpcraft.client.NCFeedback; |
| import org.apache.nlpcraft.client.NCNewCompany; |
| import org.apache.nlpcraft.client.NCProbe; |
| import org.apache.nlpcraft.client.NCResult; |
| import org.apache.nlpcraft.client.NCUser; |
| import org.apache.nlpcraft.client.impl.beans.NCAskBean; |
| import org.apache.nlpcraft.client.impl.beans.NCAskSyncBean; |
| import org.apache.nlpcraft.client.impl.beans.NCCheckBean; |
| import org.apache.nlpcraft.client.impl.beans.NCCompanyBean; |
| import org.apache.nlpcraft.client.impl.beans.NCCompanyTokenResetBean; |
| import org.apache.nlpcraft.client.impl.beans.NCErrorMessageBean; |
| import org.apache.nlpcraft.client.impl.beans.NCFeedbackAddBean; |
| import org.apache.nlpcraft.client.impl.beans.NCFeedbackAllBean; |
| import org.apache.nlpcraft.client.impl.beans.NCProbesAllBean; |
| import org.apache.nlpcraft.client.impl.beans.NCRequestStateBean; |
| import org.apache.nlpcraft.client.impl.beans.NCSigninBean; |
| import org.apache.nlpcraft.client.impl.beans.NCStatusResponseBean; |
| import org.apache.nlpcraft.client.impl.beans.NCTokenCreationBean; |
| import org.apache.nlpcraft.client.impl.beans.NCUserAddBean; |
| import org.apache.nlpcraft.client.impl.beans.NCUserBean; |
| import org.apache.nlpcraft.client.impl.beans.NCUsersAllBean; |
| |
| // |
| // TODO: |
| // These import statements need to be fixed once |
| // the main project is migrated over ASF and released on maven. |
| // For now - they are pulling/relying on "old" 'org.nlpcraft' artifact. |
| // |
| import org.nlpcraft.probe.embedded.NCEmbeddedProbe; |
| import org.nlpcraft.probe.embedded.NCEmbeddedResult; |
| |
| import java.io.IOException; |
| import java.lang.reflect.Type; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.function.Consumer; |
| import java.util.function.Function; |
| import java.util.function.Supplier; |
| import java.util.stream.Collectors; |
| |
| /** |
| * Client implementation. |
| */ |
| @SuppressWarnings("JavaDoc") |
| public class NCClientImpl implements NCClient { |
| private static final String STATUS_API_OK = "API_OK"; |
| |
| private static final Gson gson = |
| new GsonBuilder().registerTypeAdapter( |
| NCRequestStateBean.class, |
| (JsonDeserializer<NCRequestStateBean>) (e, type, ctx) -> { |
| JsonObject o = e.getAsJsonObject(); |
| NCRequestStateBean b = new NCRequestStateBean(); |
| |
| b.setSrvReqId(o.get("srvReqId").getAsString()); |
| b.setTxt(o.get("txt").getAsString()); |
| b.setUsrId(o.get("usrId").getAsLong()); |
| b.setMdlId(o.get("mdlId").getAsString()); |
| b.setProbeId(convert(o, "probeId", JsonElement::getAsString)); |
| b.setResType(convert(o, "resType", JsonElement::getAsString)); |
| b.setResBody( |
| convert(o, "resBody", (resBody) -> resBody == null ? |
| null : |
| resBody.isJsonObject() ? |
| resBody.getAsJsonObject().toString() : |
| resBody.getAsString()) |
| ); |
| b.setStatus(o.get("status").getAsString()); |
| b.setErrorCode(convert(o, "errorCode", JsonElement::getAsInt)); |
| b.setError(convert(o, "error", JsonElement::getAsString)); |
| b.setLogHolder(convert(o, "logHolder", (logHolder) -> logHolder.getAsJsonObject().toString())); |
| |
| return b; |
| }).create(); |
| |
| private static final Logger log = LogManager.getLogger(NCClientImpl.class); |
| private static final String AUTH_ERR = "NC_INVALID_ACCESS_TOKEN"; |
| |
| private Supplier<CloseableHttpClient> httpCliGen; |
| private RequestConfig reqCfg; |
| private String baseUrl; |
| private String email; |
| private String pwd; |
| private Boolean cancelOnExit; |
| private Boolean embeddedProbe; |
| |
| private CloseableHttpClient httpCli; |
| private String acsTok; |
| private volatile boolean started = false; |
| |
| private final Map<String, NCEmbeddedResult> embeddedResMap = new ConcurrentHashMap<>(); |
| private final Object mux = new Object(); |
| |
| private static<T> T convert(JsonObject o, String name, Function<JsonElement, T> converter) { |
| JsonElement e = o.get(name); |
| |
| return e != null ? converter.apply(e) : null; |
| } |
| |
| @Override |
| public String getClientUserEmail() { |
| return email; |
| } |
| |
| @Override |
| public String getClientUserPassword() { |
| return pwd; |
| } |
| |
| @Override |
| public boolean isClientEmbeddedMode() { |
| return embeddedProbe; |
| } |
| |
| @Override |
| public boolean isClientCancelOnExit() { |
| return cancelOnExit; |
| } |
| |
| @Override |
| public String getClientBaseUrl() { |
| return baseUrl; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public Supplier<CloseableHttpClient> getClientSupplier() { |
| return httpCliGen; |
| } |
| |
| /** |
| * |
| * @param httpCliGen |
| */ |
| public void setClientSupplier(Supplier<CloseableHttpClient> httpCliGen) { |
| this.httpCliGen = httpCliGen; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public RequestConfig getRequestConfig() { |
| return reqCfg; |
| } |
| |
| /** |
| * |
| * @param reqCfg |
| */ |
| public void setRequestConfig(RequestConfig reqCfg) { |
| this.reqCfg = reqCfg; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public String getBaseUrl() { |
| return baseUrl; |
| } |
| |
| /** |
| * |
| * @param baseUrl |
| */ |
| public void setBaseUrl(String baseUrl) { |
| this.baseUrl = baseUrl; |
| } |
| |
| /** |
| * |
| * @param embeddedProbe |
| */ |
| public void setEmbeddedProbe(Boolean embeddedProbe) { |
| this.embeddedProbe = embeddedProbe; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public Boolean isEmbeddedProbe() { |
| return embeddedProbe; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public String getEmail() { |
| return email; |
| } |
| |
| /** |
| * |
| * @param email |
| */ |
| public void setEmail(String email) { |
| this.email = email; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public String getPassword() { |
| return pwd; |
| } |
| |
| /** |
| * |
| * @param pwd |
| */ |
| public void setPassword(String pwd) { |
| this.pwd = pwd; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public Boolean isCancelOnExit() { |
| return cancelOnExit; |
| } |
| |
| /** |
| * |
| * @param cancelOnExit |
| */ |
| public void setCancelOnExit(Boolean cancelOnExit) { |
| this.cancelOnExit = cancelOnExit; |
| } |
| |
| /** |
| * |
| * @throws IOException |
| * @throws NCClientException |
| */ |
| public void initialize() throws IOException, NCClientException { |
| httpCli = httpCliGen.get(); |
| |
| if (reqCfg == null) |
| reqCfg = RequestConfig.DEFAULT; |
| |
| if (embeddedProbe) { |
| Consumer<NCEmbeddedResult> embeddedCb = (NCEmbeddedResult res) -> { |
| embeddedResMap.put(res.getServerRequestId(), res); |
| |
| synchronized (mux) { |
| mux.notifyAll(); |
| } |
| }; |
| |
| NCEmbeddedProbe.registerCallback(embeddedCb); |
| } |
| |
| acsTok = restSignin(); |
| |
| started = true; |
| } |
| |
| /** |
| * |
| * @param r |
| * @throws NCClientException |
| */ |
| private static void checkStatus(NCStatusResponseBean r) throws NCClientException { |
| checkStatus(r.getStatus()); |
| } |
| |
| /** |
| * |
| * @param status |
| */ |
| private static void checkStatus(String status) { |
| if (!status.equals(STATUS_API_OK)) |
| throw new NCClientException(String.format("Unexpected message status: %s", status)); |
| } |
| |
| /** |
| * |
| * @param js |
| * @param type |
| * @param <T> |
| * @return |
| * @throws NCClientException |
| */ |
| private <T extends NCStatusResponseBean> T checkAndExtract(String js, Type type) throws NCClientException { |
| T t = gson.fromJson(js, type); |
| |
| checkStatus(t.getStatus()); |
| |
| return t; |
| } |
| |
| /** |
| * |
| * @param url |
| * @param ps |
| * @return |
| * @throws NCClientException |
| * @throws IOException |
| * @throws IllegalStateException |
| */ |
| @SafeVarargs |
| private final String post(String url, Pair<String, Object>... ps) throws NCClientException, IOException { |
| if (!started) |
| throw new IllegalStateException("Client is not initialized."); |
| |
| List<Pair<String, ?>> psList = |
| Arrays.stream(ps).filter(p -> p != null && p.getRight() != null).collect(Collectors.toList()); |
| |
| try { |
| return postPlain(url, psList); |
| } |
| catch (NCClientException e) { |
| if (!AUTH_ERR.equals(e.getServerCode())) |
| throw e; |
| |
| try { |
| log.debug("Reconnect attempt because token is invalid."); |
| |
| acsTok = restSignin(); |
| |
| log.debug("Reconnected OK."); |
| |
| // Replaces token. |
| return postPlain(url, psList.stream(). |
| map(p -> p.getLeft().equals("acsTok") ? Pair.of("acsTok", acsTok) : p). |
| collect(Collectors.toList())); |
| } |
| catch (NCClientException e1) { |
| throw e; |
| } |
| } |
| } |
| |
| /** |
| * |
| * @param url |
| * @param ps |
| * @return |
| * @throws NCClientException |
| * @throws IOException |
| */ |
| private String postPlain(String url, List<Pair<String, ?>> ps) throws NCClientException, IOException { |
| HttpPost post = new HttpPost(baseUrl + url); |
| |
| try { |
| post.setConfig(reqCfg); |
| |
| StringEntity entity = new StringEntity( |
| gson.toJson(ps.stream().collect(Collectors.toMap(Pair::getKey, Pair::getValue))), |
| "UTF-8" |
| ); |
| |
| post.setHeader("Content-Type", "application/json"); |
| post.setEntity(entity); |
| |
| ResponseHandler<String> h = resp -> { |
| int code = resp.getStatusLine().getStatusCode(); |
| |
| HttpEntity e = resp.getEntity(); |
| |
| String js = e != null ? EntityUtils.toString(e) : null; |
| |
| if (js == null) |
| throw new NCClientException(String.format("Unexpected empty response [code=%d]", code)); |
| |
| if (code == 200) |
| return js; |
| |
| NCErrorMessageBean err; |
| |
| try { |
| err = gson.fromJson(js, NCErrorMessageBean.class); |
| } |
| catch (Exception e1) { |
| throw new NCClientException(String.format("Unexpected server error [code=%d]", code)); |
| } |
| |
| throw new NCClientException(err.getMessage(), err.getCode()); |
| }; |
| |
| return httpCli.execute(post, h); |
| } |
| finally { |
| post.releaseConnection(); |
| } |
| } |
| |
| /** |
| * @param v |
| * @param name |
| * @throws IllegalArgumentException |
| */ |
| private void notNull(String v, String name) throws IllegalArgumentException { |
| if (v == null || v.trim().isEmpty()) |
| throw new IllegalArgumentException(String.format("Parameter cannot be null or empty: '%s'", name)); |
| } |
| |
| /** |
| * @param v |
| * @param name |
| * @throws IllegalArgumentException |
| */ |
| private void notNull(Object v, String name) throws IllegalArgumentException { |
| if (v == null) |
| throw new IllegalArgumentException(String.format("Parameter cannot be null: '%s'", name)); |
| } |
| |
| /** |
| * |
| * @return |
| * @throws IOException |
| * @throws NCClientException |
| */ |
| private String restSignin() throws IOException, NCClientException { |
| NCSigninBean b = |
| checkAndExtract( |
| postPlain( |
| "/signin", |
| Arrays.asList( |
| Pair.of("email", email), |
| Pair.of("passwd", pwd) |
| ) |
| ), |
| NCSigninBean.class |
| ); |
| |
| return b.getAccessToken(); |
| } |
| |
| |
| @Override |
| public long addUser( |
| String email, |
| String passwd, |
| String firstName, |
| String lastName, |
| String avatarUrl, |
| boolean isAdmin, |
| Map<String, String> properties, |
| String extId |
| ) throws NCClientException, IOException { |
| notNull(email, "email"); |
| notNull(passwd, "passwd"); |
| notNull(firstName, "firstName"); |
| notNull(lastName, "lastName"); |
| |
| NCUserAddBean b = |
| checkAndExtract( |
| post( |
| "user/add", |
| Pair.of("acsTok", acsTok), |
| Pair.of("email", email), |
| Pair.of("passwd", passwd), |
| Pair.of("firstName", firstName), |
| Pair.of("lastName", lastName), |
| Pair.of("isAdmin", isAdmin), |
| Pair.of("avatarUrl", avatarUrl), |
| Pair.of("properties", properties), |
| Pair.of("extId", extId) |
| ), |
| NCUserAddBean.class |
| ); |
| |
| return b.getId(); |
| } |
| |
| @Override |
| public void deleteUser(Long id, String extId) throws NCClientException, IOException { |
| checkStatus( |
| gson.fromJson( |
| post( |
| "user/delete", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id), |
| Pair.of("extId", extId) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public void updateUser( |
| long id, String firstName, String lastName, String avatarUrl, Map<String, String> properties |
| ) throws NCClientException, IOException { |
| notNull(firstName, "firstName"); |
| notNull(lastName, "lastName"); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "user/update", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id), |
| Pair.of("firstName", firstName), |
| Pair.of("lastName", lastName), |
| Pair.of("avatarUrl", avatarUrl), |
| Pair.of("properties", properties) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public void updateUserAdmin(Long id, boolean admin) throws NCClientException, IOException { |
| checkStatus( |
| gson.fromJson( |
| post( |
| "user/admin", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id), |
| Pair.of("admin", admin) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public NCUser getUser(Long id, String extId) throws NCClientException, IOException { |
| return |
| checkAndExtract( |
| post( |
| "user/get", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id), |
| Pair.of("extId", extId) |
| ), |
| NCUserBean.class |
| ); |
| } |
| |
| @Override |
| public void resetUserPassword(Long id, String newPasswd) throws NCClientException, IOException { |
| notNull(newPasswd, "newPasswd"); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "user/passwd/reset", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id), |
| Pair.of("newPasswd", newPasswd) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public List<NCUser> getAllUsers() throws NCClientException, IOException { |
| NCUsersAllBean b = |
| checkAndExtract( |
| post( |
| "user/all", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCUsersAllBean.class |
| ); |
| |
| return new ArrayList<>(b.getUsers()); |
| } |
| |
| @Override |
| public List<NCProbe> getProbes() throws NCClientException, IOException { |
| NCProbesAllBean b = |
| checkAndExtract( |
| post( |
| "probe/all", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCProbesAllBean.class |
| ); |
| |
| return new ArrayList<>(b.getProbes()); |
| } |
| |
| @Override |
| public void clearConversation(String mdlId, Long usrId, String usrExtId) throws NCClientException, IOException { |
| notNull(mdlId, "mdlId"); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "clear/conversation", |
| Pair.of("acsTok", acsTok), |
| Pair.of("mdlId", mdlId), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public void clearDialog(String mdlId, Long usrId, String usrExtId) throws NCClientException, IOException { |
| notNull(mdlId, "mdlId"); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "clear/dialog", |
| Pair.of("acsTok", acsTok), |
| Pair.of("mdlId", mdlId), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public void close() throws IOException, NCClientException { |
| if (cancelOnExit) |
| cancel(null, null, null); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "signout", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| |
| started = false; |
| } |
| |
| @Override |
| public String ask(String mdlId, String txt, String data, boolean enableLog, Long usrId, String usrExtId) |
| throws NCClientException, IOException { |
| notNull(mdlId, "mdlId"); |
| notNull(txt, "txt"); |
| |
| NCAskBean b = |
| checkAndExtract( |
| post( |
| "ask", |
| Pair.of("acsTok", acsTok), |
| Pair.of("txt", txt), |
| Pair.of("mdlId", mdlId), |
| Pair.of("data", data), |
| Pair.of("enableLog", enableLog), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCAskBean.class |
| ); |
| |
| return b.getServerRequestId(); |
| } |
| |
| @Override |
| public NCResult askSync( |
| String mdlId, String txt, String data, boolean enableLog, Long usrId, String usrExtId |
| ) throws NCClientException, IOException { |
| notNull(mdlId, "mdlId"); |
| notNull(txt, "txt"); |
| |
| if (embeddedProbe) { |
| String srvReqId = ask(mdlId, txt, data, enableLog, usrId, usrExtId); |
| int timeout = reqCfg.getSocketTimeout(); |
| long maxTime = System.currentTimeMillis() + timeout; |
| |
| while (true) { |
| NCEmbeddedResult res = embeddedResMap.get(srvReqId); |
| |
| if (res != null) |
| return new NCResult() { |
| @Override |
| public String getServerRequestId() { |
| return res.getServerRequestId(); |
| } |
| |
| @Override |
| public String getText() { |
| return res.getOriginalText(); |
| } |
| |
| @Override |
| public long getUserId() { |
| return res.getUserId(); |
| } |
| |
| @Override |
| public String getModelId() { |
| return res.getModelId(); |
| } |
| |
| @Override |
| public String getProbeId() { |
| return res.getProbeId(); |
| } |
| |
| @Override |
| public boolean isReady() { |
| return true; |
| } |
| |
| @Override |
| public String getResultType() { |
| return res.getType(); |
| } |
| |
| @Override |
| public String getResultBody() { |
| return res.getBody(); |
| } |
| |
| @Override |
| public Integer getErrorCode() { |
| return res.getErrorCode() == 0 ? null : res.getErrorCode(); |
| } |
| |
| @Override |
| public String getErrorMessage() { |
| return res.getErrorMessage(); |
| } |
| |
| @Override |
| public String getLogHolder() { |
| return res.getLogHolder(); |
| } |
| }; |
| |
| long sleepTime = maxTime - System.currentTimeMillis(); |
| |
| if (sleepTime <= 0) |
| throw new NCClientException(String.format("Request timeout: %d", timeout)); |
| |
| synchronized (mux) { |
| try { |
| mux.wait(sleepTime); |
| } |
| catch (InterruptedException e) { |
| throw new NCClientException("Result wait thread interrupted.", e); |
| } |
| } |
| } |
| } |
| |
| NCAskSyncBean b = |
| checkAndExtract( |
| post( |
| "ask/sync", |
| Pair.of("acsTok", acsTok), |
| Pair.of("txt", txt), |
| Pair.of("mdlId", mdlId), |
| Pair.of("data", data), |
| Pair.of("enableLog", enableLog), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCAskSyncBean.class |
| ); |
| |
| return b.getState(); |
| } |
| |
| @Override |
| public long addFeedback(String srvReqId, double score, String comment, Long usrId, String usrExtId) |
| throws NCClientException, IOException { |
| notNull(srvReqId, "srvReqId"); |
| |
| NCFeedbackAddBean b = |
| checkAndExtract( |
| post( |
| "feedback/add", |
| Pair.of("acsTok", acsTok), |
| Pair.of("srvReqId", srvReqId), |
| Pair.of("score", score), |
| Pair.of("comment", comment), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCFeedbackAddBean.class |
| ); |
| |
| return b.getId(); |
| } |
| |
| @Override |
| public void deleteFeedback(Long id) throws NCClientException, IOException { |
| checkStatus( |
| gson.fromJson( |
| post( |
| "feedback/delete", |
| Pair.of("acsTok", acsTok), |
| Pair.of("id", id) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public List<NCFeedback> getAllFeedback(String srvReqId, Long usrId, String usrExtId) throws NCClientException, IOException { |
| NCFeedbackAllBean b = |
| checkAndExtract( |
| post( |
| "feedback/all", |
| Pair.of("acsTok", acsTok), |
| Pair.of("srvReqId", srvReqId), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCFeedbackAllBean.class |
| ); |
| |
| return new ArrayList<>(b.getFeedback()); |
| } |
| |
| @Override |
| public List<NCResult> check(Set<String> srvReqIds, Integer maxRows, Long usrId, String usrExtId) throws NCClientException, IOException { |
| NCCheckBean b = |
| checkAndExtract( |
| post( |
| "check", |
| Pair.of("acsTok", acsTok), |
| Pair.of("srvReqIds", srvReqIds), |
| Pair.of("maxRows", maxRows), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCCheckBean.class |
| ); |
| |
| return new ArrayList<>(b.getStates()); |
| } |
| |
| @Override |
| public void cancel(Set<String> srvReqIds, Long usrId, String usrExtId) throws NCClientException, IOException { |
| checkStatus( |
| gson.fromJson( |
| post( |
| "cancel", |
| Pair.of("acsTok", acsTok), |
| Pair.of("srvReqIds", srvReqIds), |
| Pair.of("usrId", usrId), |
| Pair.of("usrExtId", usrExtId) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public NCNewCompany addCompany(String name, String website, String country, String region, String city, |
| String address, String postalCode, String adminEmail, String adminPasswd, String adminFirstName, |
| String adminLastName, String adminAvatarUrl) throws IOException, NCClientException { |
| notNull(name, "name"); |
| notNull(adminEmail, "adminEmail"); |
| notNull(adminPasswd, "adminPasswd"); |
| notNull(adminFirstName, "adminFirstName"); |
| notNull(adminLastName, "adminLastName"); |
| |
| return |
| checkAndExtract( |
| post( |
| "company/add", |
| Pair.of("acsTok", acsTok), |
| Pair.of("name", name), |
| Pair.of("website", website), |
| Pair.of("country", country), |
| Pair.of("region", region), |
| Pair.of("city", city), |
| Pair.of("address", address), |
| Pair.of("postalCode", postalCode), |
| |
| Pair.of("adminEmail", adminEmail), |
| Pair.of("adminPasswd", adminPasswd), |
| Pair.of("adminFirstName", adminFirstName), |
| Pair.of("adminLastName", adminLastName), |
| Pair.of("postalCode", adminAvatarUrl) |
| ), |
| NCTokenCreationBean.class |
| ); |
| } |
| |
| @Override |
| public NCCompany getCompany() throws IOException, NCClientException { |
| return |
| checkAndExtract( |
| post( |
| "company/get", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCCompanyBean.class |
| ); |
| } |
| |
| @Override |
| public void updateCompany( |
| String name, |
| String website, |
| String country, |
| String region, |
| String city, |
| String address, |
| String postalCode |
| ) throws IOException, NCClientException { |
| notNull(name, "name"); |
| |
| checkStatus( |
| gson.fromJson( |
| post( |
| "company/update", |
| Pair.of("acsTok", acsTok), |
| Pair.of("name", name), |
| Pair.of("website", website), |
| Pair.of("country", country), |
| Pair.of("region", region), |
| Pair.of("city", city), |
| Pair.of("address", address), |
| Pair.of("postalCode", postalCode) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| |
| @Override |
| public String resetCompanyToken() throws IOException, NCClientException { |
| NCCompanyTokenResetBean b = |
| checkAndExtract( |
| post( |
| "company/token/reset", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCCompanyTokenResetBean.class |
| ); |
| |
| return b.getToken(); |
| } |
| |
| @Override |
| public void deleteCompany() throws IOException, NCClientException { |
| checkStatus( |
| gson.fromJson( |
| post( |
| "company/delete", |
| Pair.of("acsTok", acsTok) |
| ), |
| NCStatusResponseBean.class |
| ) |
| ); |
| } |
| } |