import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
/**
 * Wraps a response from the lightblue client library which may or may not be successful in a
 * type which allows easily querying whether or not the response was successful and getting at
 * the right type of response.
 */
static LightblueResponse fromClientResponse(
        com.redhat.lightblue.client.response.LightblueResponse response) {
    if (response instanceof LightblueErrorResponse) {
        LightblueErrorResponse errorResponse = (LightblueErrorResponse) response;

        DataError[] dataErrors = Optional.ofNullable(errorResponse.getDataErrors())
                .orElse(new DataError[0]);
        Error[] lightblueErrors = Optional.ofNullable(errorResponse.getLightblueErrors())
                .orElse(new Error[0]);

        if (dataErrors.length + lightblueErrors.length > 0) {
            return new FailedLightblueResponse(errorResponse, dataErrors, lightblueErrors);
        }
    }

    if (response instanceof LightblueDataResponse) {
        return new SuccessLightblueResponse((LightblueDataResponse) response);
    }

    throw new IllegalArgumentException("LightblueResponse was neither a data response nor an " +
            "error response.");
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public void configure() throws Exception {
    from("timer:" + deleterLockResourceId + "?period=" + deleteInterval.toMillis())
    .routeId(deleterLockResourceId)
    .routePolicy(new LockingRoutePolicy(deleterLockResourceId, lockStrategy))
    .process(exchange -> {
        Instant tooOld = clock.instant().minus(deleteOlderThan);

        log.debug("Deleting {} entities with {} before {}", entityName, entityDateField, tooOld);

        DataDeleteRequest deleteRequest = new DataDeleteRequest(entityName, entityVersion);
        deleteRequest.where(Query.withValue(entityDateField, Query.BinOp.lt, Date.from(tooOld)));

        LightblueDataResponse response = client.data(deleteRequest);

        log.info("Deleted {} {} entities with {} before {}",
                response.parseModifiedCount(), entityName, entityDateField, tooOld);
    });
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Test
public void testBulkData() throws Exception {
    DataBulkRequest request = new DataBulkRequest();

    for (int x = 0; x < 100; x++) {
        DataInsertRequest insert = new DataInsertRequest(Country.objectType, Country.objectVersion);
        insert.create(new Country(String.valueOf(x), "123" + x, "456" + x, null));
        insert.returns(Projection.includeField("name"));

        request.add(insert);
    }

    DefaultLightblueBulkDataResponse bulkResp = getLightblueClient().bulkData(request);

    assertNotNull(bulkResp);

    //Responses should be in the same order.
    int n = 0;
    for (LightblueDataResponse response : bulkResp.getResponses()) {
        assertNotNull(response);
        assertEquals(String.valueOf(n), response.parseProcessed(Country.class).getName());
        n++;
    }
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Test
public void testWithIdentityManager() throws Exception {
    lightblue.changeIdentityManager(
            new FakeIdentityManager().add("fakeuser", "fakepassword"));

    Country c = new Country();
    c.setName("Poland");
    c.setIso2Code("PL");
    c.setIso3Code("POL");

    DataInsertRequest insert = new DataInsertRequest(Country.objectType, Country.objectVersion);
    insert.create(c);
    insert.returns(Projection.includeFieldRecursively("*"));

    LightblueDataResponse insertResponse = lightblue.getLightblueClient("fakeuser", "fakepassword").data(insert);

    assertEquals(1, insertResponse.parseModifiedCount());
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
private boolean migrationJobsExist() {
    LOGGER.debug("Checking if there are migration jobs for {}", migrationConfiguration.getConfigurationName());
    DataFindRequest req = new DataFindRequest("migrationJob", null);
    req.where(Query.and(Query.withValue("configurationName", Query.eq, migrationConfiguration.getConfigurationName()),
            Query.withValue("generated", Query.eq, false),
            Query.withValue("status", Query.eq, MigrationJob.STATE_AVAILABLE)));
    req.select(Projection.includeField("_id"));
    req.range(1, 1);
    try {
        LightblueDataResponse resp = lbClient.data(req);
        return resp.parseMatchCount() > 0;
    } catch (Exception e) {
        LOGGER.error("Cannot query migration jobs:{}", e, e);
        return true;
    }
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public <T> T data(LightblueDataRequest lightblueRequest, Class<T> type)
        throws LightblueParseException, LightblueResponseException, LightblueHttpClientException, LightblueException {
    LightblueDataResponse response = data(lightblueRequest);

    return response.parseProcessed(type);
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Test
public void testBulkFind() throws LightblueException, LightblueParseException {
    Country country = insertPL();

    DataFindRequest request = new DataFindRequest(Country.objectType, Country.objectVersion);
    request.select(Projection.includeField("*"));
    request.where(Query.withValue("iso2Code", Query.eq, "PL"));

    DataFindRequest request2 = new DataFindRequest(Country.objectType, Country.objectVersion);
    request2.select(Projection.includeField("*"));
    request2.where(Query.withValue("name", Query.eq, "Poland"));

    DataFindRequest request3 = new DataFindRequest(Country.objectType, Country.objectVersion);
    request3.select(Projection.includeField("*"));
    request3.where(Query.withValue("name", Query.eq, "Russia"));

    DataBulkRequest bulkRequest = new DataBulkRequest();
    bulkRequest.add(request);
    bulkRequest.add(request2);
    bulkRequest.add(request3);
    System.out.println(bulkRequest);
    LightblueBulkDataResponse bulkResponse = client.bulkData(bulkRequest);
    List<LightblueDataResponse> responses = bulkResponse.getResponses();

    assertEquals(3, responses.size());
    assertEquals(1, responses.get(0).parseMatchCount());
    assertEquals(1, responses.get(1).parseMatchCount());
    assertEquals(0, responses.get(2).parseMatchCount());

    Country c1 = responses.get(0).parseProcessed(Country.class);
    Country c2 = responses.get(1).parseProcessed(Country.class);

    assertEquals("PL", c1.getIso2Code());
    assertEquals("PL", c2.getIso2Code());

    assertEquals(responses.get(0), bulkResponse.getResponse(request));
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Test
public void test() throws Exception {
    Country c = new Country();
    c.setName("Poland");
    c.setIso2Code("PL");
    c.setIso3Code("POL");

    DataInsertRequest insert = new DataInsertRequest(Country.objectType, Country.objectVersion);
    insert.create(c);
    insert.returns(Projection.includeFieldRecursively("*"));

    LightblueDataResponse insertResponse = lightblue.getLightblueClient().data(insert);

    assertEquals(1, insertResponse.parseModifiedCount());
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
private int countMigrationJobs(String configurationName, Date startDate, Date endDate) throws LightblueException {
    DataFindRequest findJobs = new DataFindRequest(MigrationJob.ENTITY_NAME);
    findJobs.where(
        Query.and(
            Query.withValue("configurationName", Query.eq, configurationName),
            Query.withValue("scheduledDate", Query.gte, startDate),
            Query.withValue("scheduledDate", Query.lte, endDate)
        )
    );
    findJobs.select(new Projection[]{Projection.excludeFieldRecursively("*")}, 0, 0);

    LightblueDataResponse response = lightblueClient.data(findJobs);
    return response.parseMatchCount();
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public LightblueDataResponse getSuccess() {
    // TODO: maybe dif exception?
    throw new LightblueResponseException(errors);
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
SuccessLightblueResponse(LightblueDataResponse response) {
    this.response = response;
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public LightblueDataResponse getSuccess() {
    return response;
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
BulkDataResponses(Map<CRUDRequest, LightblueDataResponse> responseMap) {
    super(responseMap);
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public LightblueDataResponse data(LightblueDataRequest request) throws LightblueException {
    return responseOnceFlushedOrLightblueException(() -> delegate.data(request));
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
protected LightblueDataResponse run() throws Exception {
    return client.data(request);
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public LightblueDataResponse data(LightblueDataRequest lightblueRequest) {
    return new DataHystrixCommand(lightblueRequest, groupKey, commandKey).execute();
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
@Override
public LightblueDataResponse data(LightblueDataRequest lightblueRequest) {
    data = true;
    return null;
}
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
public static void main(String[] args) throws LightblueException {

        LightblueClientConfiguration p = PropertiesLightblueClientConfiguration
                .fromPath(Paths.get("/home/mpatercz/redhat/lightblue-certs/client/lightblue-client-dev.properties"));
//                .fromPath(Paths.get("/home/mpatercz/redhat/lightblue-certs/client/lightblue-client-devunit.properties"));

        LightblueClient client = new LightblueHttpClient(p);

        DataFindRequest r = new DataFindRequest("subscription");
        r.select(new Projection[] { Projection.includeField("_id"),
                Projection.array("subscriptionProducts", Query.withValue("inactiveDate", Query.eq, Literal.value(null))) });
        r.where(Query.withValue("_id=0"));


//        StreamingDataFindRequest sR = new StreamingDataFindRequest(r);

//        System.out.println(sR);

//        str.run(new ForEachDoc() {
//
//            @Override
//            public boolean processDocument(StreamDoc doc) {
//                System.out.println(doc.doc.toString());
//                System.out.println("size="+((ArrayNode)doc.doc.get("subscriptionProducts")).size());
//                return true;
//            }
//        });

        LightblueDataResponse response = client.data(r);
        System.out.println(response.getText());




    }
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
/**
 * Returns the response if it was successful as a {@link LightblueDataResponse} matching the
 * successful lightblue response schema. If the response was not successful, then an unchecked
 * {@link LightblueResponseException} is thrown with the lightblue errors in the response.
 *
 * <p>You should query if the response was successful or not first with {@link #isSuccess()},
 * unless all you would do is throw an exception if it failed. In that case, you could just call
 * {@code getSuccess()} unconditionally and let the exception propagate.
 *
 * @throws LightblueResponseException if this response is not a successful one. Check if the
 * response is successful first with {@link #isSuccess()}.
 */
LightblueDataResponse getSuccess() throws LightblueResponseException;
 

import com.redhat.lightblue.client.response.LightblueDataResponse; //导入依赖的package包/类
LightblueDataResponse data(LightblueDataRequest lightblueRequest) throws LightblueException;