com.google.api.client.util.GenericData Java Examples

/**
 * Login an exiting Kickflip User and make it active.
 *
 * @param username The Kickflip user's username
 * @param password The Kickflip user's password
 * @param cb       This callback will receive a User in {@link io.kickflip.sdk.api.KickflipCallback#onSuccess(io.kickflip.sdk.api.json.Response)}
 *                 or an Exception {@link io.kickflip.sdk.api.KickflipCallback#onError(io.kickflip.sdk.exception.KickflipException)}.
 */
public void loginUser(String username, final String password, final KickflipCallback cb) {
    GenericData data = new GenericData();
    data.put("username", username);
    data.put("password", password);

    post(GET_USER_PRIVATE, new UrlEncodedContent(data), User.class, new KickflipCallback() {
        @Override
        public void onSuccess(final Response response) {
            if (VERBOSE)
                Log.i(TAG, "loginUser response: " + response);
            storeNewUserResponse((User) response, password);
            postResponseToCallback(cb, response);
        }

        @Override
        public void onError(final KickflipException error) {
            Log.w(TAG, "loginUser Error: " + error);
            postExceptionToCallback(cb, error);
        }
    });
}
 

/**
 * Get public user info
 *
 * @param username The Kickflip user's username
 * @param cb       This callback will receive a User in {@link io.kickflip.sdk.api.KickflipCallback#onSuccess(io.kickflip.sdk.api.json.Response)}
 *                 or an Exception {@link io.kickflip.sdk.api.KickflipCallback#onError(io.kickflip.sdk.exception.KickflipException)}.
 */
public void getUserInfo(String username, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    data.put("username", username);

    post(GET_USER_PUBLIC, new UrlEncodedContent(data), User.class, new KickflipCallback() {
        @Override
        public void onSuccess(final Response response) {
            if (VERBOSE)
                Log.i(TAG, "getUserInfo response: " + response);
            postResponseToCallback(cb, response);
        }

        @Override
        public void onError(final KickflipException error) {
            Log.w(TAG, "getUserInfo Error: " + error);
            postExceptionToCallback(cb, error);
        }
    });
}
 

/**
 * Start a new Stream owned by the given User. Must be called after
 * {@link io.kickflip.sdk.api.KickflipApiClient#createNewUser(KickflipCallback)}
 * Delivers stream endpoint destination data via a {@link io.kickflip.sdk.api.KickflipCallback}.
 *
 * @param user The Kickflip User on whose behalf this request is performed.
 * @param cb   This callback will receive a Stream subclass in {@link io.kickflip.sdk.api.KickflipCallback#onSuccess(io.kickflip.sdk.api.json.Response)}
 *             depending on the Kickflip account type. Implementors should
 *             check if the response is instanceof HlsStream, StartRtmpStreamResponse, etc.
 */
private void startStreamWithUser(User user, Stream stream, final KickflipCallback cb) {
    checkNotNull(user);
    checkNotNull(stream);
    GenericData data = new GenericData();
    data.put("uuid", user.getUUID());
    data.put("private", stream.isPrivate());
    if (stream.getTitle() != null) {
        data.put("title", stream.getTitle());
    }
    if (stream.getDescription() != null) {
        data.put("description", stream.getDescription());
    }
    if (stream.getExtraInfo() != null) {
        data.put("extra_info", new Gson().toJson(stream.getExtraInfo()));
    }
    post(START_STREAM, new UrlEncodedContent(data), HlsStream.class, cb);
}
 

public MultipartFormDataContent addUrlEncodedContent(String name, String value) {
    GenericData data = new GenericData();
    data.put(value, "");

    Part part = new Part();
    part.setContent(new UrlEncodedContent(data));
    part.setName(name);

    this.addPart(part);

    return this;
}
 

/**
 * Get a List of {@link io.kickflip.sdk.api.json.Stream}s near a geographic location.
 * <p/>
 * This method searches all public recordings made by Users of your Kickflip app.
 *
 * @param location The target Location
 * @param radius   The target Radius in meters
 * @param cb       A callback to receive the resulting List of Streams
 */
public void getStreamsByLocation(Location location, int radius, int pageNumber, int itemsPerPage, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    data.put("uuid", getActiveUser().getUUID());
    data.put("lat", location.getLatitude());
    data.put("lon", location.getLongitude());
    if (radius != 0) {
        data.put("radius", radius);
    }
    post(SEARCH_GEO, new UrlEncodedContent(data), StreamList.class, cb);
}
 

/**
 * Set the current active user's meta info. Pass a null argument to leave it as-is.
 *
 * @param newPassword the user's new password
 * @param email       the user's new email address
 * @param displayName The desired display name
 * @param extraInfo   Arbitrary String data to associate with this user.
 * @param cb          This callback will receive a User in {@link io.kickflip.sdk.api.KickflipCallback#onSuccess(io.kickflip.sdk.api.json.Response)}
 *                    or an Exception {@link io.kickflip.sdk.api.KickflipCallback#onError(io.kickflip.sdk.exception.KickflipException)}.
 */
public void setUserInfo(final String newPassword, String email, String displayName, Map extraInfo, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    final String finalPassword;
    if (newPassword != null){
        data.put("new_password", newPassword);
        finalPassword = newPassword;
    } else {
        finalPassword = getPasswordForActiveUser();
    }
    if (email != null) data.put("email", email);
    if (displayName != null) data.put("display_name", displayName);
    if (extraInfo != null) data.put("extra_info", new Gson().toJson(extraInfo));

    post(EDIT_USER, new UrlEncodedContent(data), User.class, new KickflipCallback() {
        @Override
        public void onSuccess(final Response response) {
            if (VERBOSE)
                Log.i(TAG, "setUserInfo response: " + response);
            storeNewUserResponse((User) response, finalPassword);
            postResponseToCallback(cb, response);
        }

        @Override
        public void onError(final KickflipException error) {
            Log.w(TAG, "setUserInfo Error: " + error);
            postExceptionToCallback(cb, error);
        }
    });
}
 

/**
 * Stop a Stream owned by the given Kickflip User.
 *
 * @param cb This callback will receive a Stream subclass in #onSuccess(response)
 *           depending on the Kickflip account type. Implementors should
 *           check if the response is instanceof HlsStream, etc.
 */
private void stopStream(User user, Stream stream, final KickflipCallback cb) {
    checkNotNull(stream);
    // TODO: Add start / stop lat lon to Stream?
    GenericData data = new GenericData();
    data.put("stream_id", stream.getStreamId());
    data.put("uuid", user.getUUID());
    if (stream.getLatitude() != 0) {
        data.put("lat", stream.getLatitude());
    }
    if (stream.getLongitude() != 0) {
        data.put("lon", stream.getLongitude());
    }
    post(STOP_STREAM, new UrlEncodedContent(data), HlsStream.class, cb);
}
 

/**
 * Send Stream Metadata for a {@link io.kickflip.sdk.api.json.Stream}.
 * The target Stream must be owned by the User created with {@link io.kickflip.sdk.api.KickflipApiClient#createNewUser(KickflipCallback)}
 * from this KickflipApiClient.
 *
 * @param stream the {@link io.kickflip.sdk.api.json.Stream} to get Meta data for
 * @param cb     A callback to receive the updated Stream upon request completion
 */
public void setStreamInfo(Stream stream, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    data.put("stream_id", stream.getStreamId());
    data.put("uuid", getActiveUser().getUUID());
    if (stream.getTitle() != null) {
        data.put("title", stream.getTitle());
    }
    if (stream.getDescription() != null) {
        data.put("description", stream.getDescription());
    }
    if (stream.getExtraInfo() != null) {
        data.put("extra_info", new Gson().toJson(stream.getExtraInfo()));
    }
    if (stream.getLatitude() != 0) {
        data.put("lat", stream.getLatitude());
    }
    if (stream.getLongitude() != 0) {
        data.put("lon", stream.getLongitude());
    }
    if (stream.getCity() != null) {
        data.put("city", stream.getCity());
    }
    if (stream.getState() != null) {
        data.put("state", stream.getState());
    }
    if (stream.getCountry() != null) {
        data.put("country", stream.getCountry());
    }

    if (stream.getThumbnailUrl() != null) {
        data.put("thumbnail_url", stream.getThumbnailUrl());
    }

    data.put("private", stream.isPrivate());
    data.put("deleted", stream.isDeleted());

    post(SET_META, new UrlEncodedContent(data), Stream.class, cb);
}
 

/**
 * Get a List of {@link io.kickflip.sdk.api.json.Stream}s containing a keyword.
 * <p/>
 * This method searches all public recordings made by Users of your Kickflip app.
 *
 * @param keyword The String keyword to query
 * @param cb      A callback to receive the resulting List of Streams
 */
public void getStreamsByKeyword(String keyword, int pageNumber, int itemsPerPage, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    addPaginationData(pageNumber, itemsPerPage, data);
    data.put("uuid", getActiveUser().getUUID());
    if (keyword != null) {
        data.put("keyword", keyword);
    }
    post(SEARCH_KEYWORD, new UrlEncodedContent(data), StreamList.class, cb);
}
 

/**
 * Get a List of {@link io.kickflip.sdk.api.json.Stream} objects created by the given Kickflip User.
 *
 * @param username the target Kickflip username
 * @param cb       A callback to receive the resulting List of Streams
 */
public void getStreamsByUsername(String username, int pageNumber, int itemsPerPage, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    addPaginationData(pageNumber, itemsPerPage, data);
    data.put("uuid", getActiveUser().getUUID());
    data.put("username", username);
    post(SEARCH_USER, new UrlEncodedContent(data), StreamList.class, cb);
}
 

/**
 * Sets all instance variables to values for a successful request. Tests that require failed
 * requests or null/empty values should mutate the instance variables accordingly.
 */
@Before
public void setUp() throws Exception {
  MockitoAnnotations.initMocks(this);

  requestMethod = "POST";
  url = "http://www.foo.com/bar";
  reportServiceLogger = new ReportServiceLogger(loggerDelegate);

  requestFactory = new NetHttpTransport().createRequestFactory();
  // Constructs the request headers and adds headers that should be scrubbed
  rawRequestHeaders =
      ReportServiceLogger.SCRUBBED_HEADERS
          .stream()
          .collect(Collectors.toMap(h -> h, h -> "foo" + h));
  // Adds headers that should not be scrubbed.
  rawRequestHeaders.put("clientCustomerId", "123-456-7890");
  rawRequestHeaders.put("someOtherHeader", "SomeOtherValue");

  GenericData postData = new GenericData();
  postData.put("__rdquery", "SELECT CampaignId FROM CAMPAIGN_PERFORMANCE_REPORT");

  httpRequest =
      requestFactory.buildPostRequest(new GenericUrl(url), new UrlEncodedContent(postData));

  for (Entry<String, String> rawHeaderEntry : rawRequestHeaders.entrySet()) {
    String key = rawHeaderEntry.getKey();
    if ("authorization".equalsIgnoreCase(key)) {
      httpRequest
          .getHeaders()
          .setAuthorization(Collections.<String>singletonList(rawHeaderEntry.getValue()));
    } else {
      httpRequest.getHeaders().put(key, rawHeaderEntry.getValue());
    }
  }

  httpRequest.getResponseHeaders().setContentType("text/csv; charset=UTF-8");
  httpRequest.getResponseHeaders().put("someOtherResponseHeader", "foo");
  httpRequest
      .getResponseHeaders()
      .put("multiValueHeader", Arrays.<String>asList("value1", "value2"));
}
 

/**
 * Returns whether or not this type is a Google Java client library entity.
 */
public static boolean isJavaClientEntity(TypeToken<?> type) {
  return type.isSubtypeOf(GenericData.class);
}
 

private void addPaginationData(int pageNumber, int itemsPerPage, GenericData target) {
    target.put("results_per_page", itemsPerPage);
    target.put("page", pageNumber);
}
 

/**
 * Create a new Kickflip User.
 * The User created as a result of this request is cached and managed by this KickflipApiClient
 * throughout the life of the host Android application installation.
 * <p/>
 * The other methods of this client will be performed on behalf of the user created by this request,
 * unless noted otherwise.
 *
 * @param username    The desired username for this Kickflip User. Will be altered if not unique for this Kickflip app.
 * @param password    The password for this Kickflip user.
 * @param email       The email address for this Kickflip user.
 * @param displayName The display name for this Kickflip user.
 * @param extraInfo   Map data to be associated with this Kickflip User.
 * @param cb          This callback will receive a User in {@link io.kickflip.sdk.api.KickflipCallback#onSuccess(io.kickflip.sdk.api.json.Response)}
 *                    or an Exception {@link io.kickflip.sdk.api.KickflipCallback#onError(io.kickflip.sdk.exception.KickflipException)}.
 */
public void createNewUser(String username, String password, String email, String displayName, Map extraInfo, final KickflipCallback cb) {
    GenericData data = new GenericData();
    if (username != null) {
        data.put("username", username);
    }

    final String finalPassword;
    if (password != null) {
        finalPassword = password;
    } else {
        finalPassword = generateRandomPassword();
    }
    data.put("password", finalPassword);

    if (displayName != null) {
        data.put("display_name", displayName);
    }
    if (email != null) {
        data.put("email", email);
    }
    if (extraInfo != null) {
        data.put("extra_info", new Gson().toJson(extraInfo));
    }

    post(NEW_USER, new UrlEncodedContent(data), User.class, new KickflipCallback() {
        @Override
        public void onSuccess(final Response response) {
            if (VERBOSE)
                Log.i(TAG, "createNewUser response: " + response);
            storeNewUserResponse((User) response, finalPassword);
            postResponseToCallback(cb, response);
        }

        @Override
        public void onError(final KickflipException error) {
            Log.w(TAG, "createNewUser Error: " + error);
            postExceptionToCallback(cb, error);
        }
    });
}
 

public String activateBundleRevision(Bundle bundle) throws IOException {

		BundleActivationConfig deployment2 = new BundleActivationConfig();

		try {

			HttpHeaders headers = new HttpHeaders();
			headers.setAccept("application/json");

			GenericUrl url = new GenericUrl(format("%s/%s/organizations/%s/environments/%s/%s/%s/revisions/%d/deployments",
					profile.getHostUrl(),
					profile.getApi_version(),
					profile.getOrg(),
					profile.getEnvironment(),
					bundle.getType().getPathName(),
					bundle.getName(),
					bundle.getRevision()));

			GenericData data = new GenericData();
			data.set("override", Boolean.valueOf(getProfile().isOverride()).toString());

			//Fix for https://github.com/apigee/apigee-deploy-maven-plugin/issues/18
			if (profile.getDelayOverride() != 0) {
				data.set("delay", profile.getDelayOverride());
			}

			HttpRequest deployRestRequest = requestFactory.buildPostRequest(url, new UrlEncodedContent(data));
			deployRestRequest.setReadTimeout(0);
			deployRestRequest.setHeaders(headers);


			HttpResponse response = null;
			response = executeAPI(profile, deployRestRequest);

			if (getProfile().isOverride()) {
				SeamLessDeploymentStatus deployment3 = response.parseAs(SeamLessDeploymentStatus.class);
				Iterator<BundleActivationConfig> iter = deployment3.environment.iterator();
				while (iter.hasNext()) {
					BundleActivationConfig config = iter.next();
					if (config.environment.equalsIgnoreCase(profile.getEnvironment())) {
						if (!config.state.equalsIgnoreCase("deployed")) {
							log.info("Waiting to assert bundle activation.....");
							Thread.sleep(10);
							Long deployedRevision = getDeployedRevision(bundle);
							if (bundle.getRevision() != null && bundle.getRevision().equals(deployedRevision)) {
								log.info("Deployed revision is: " + bundle.getRevision());
								return "deployed";
							} else
								log.error("Deployment failed to activate");
							throw new MojoExecutionException("Deployment failed: Bundle did not activate within expected time. Please check deployment status manually before trying again");
						} else {
							log.info(PrintUtil.formatResponse(response, gson.toJson(deployment3)));
						}
					}
				}

			}

			deployment2 = response.parseAs(BundleActivationConfig.class);
			if (log.isInfoEnabled()) {
				log.info(PrintUtil.formatResponse(response, gson.toJson(deployment2)));
				log.info("Deployed revision is:{}", deployment2.revision);
			}
			applyDelay();

		} catch (Exception e) {
			log.error(e.getMessage());
			throw new IOException(e);
		}

		return deployment2.state;

	}
 

private void serialize(boolean isJsonString, Object value) throws IOException {
  if (value == null) {
    return;
  }
  Class<?> valueClass = value.getClass();
  if (Data.isNull(value)) {
    writeNull();
  } else if (value instanceof String) {
    writeString((String) value);
  } else if (value instanceof Number) {
    if (isJsonString) {
      writeString(value.toString());
    } else if (value instanceof BigDecimal) {
      writeNumber((BigDecimal) value);
    } else if (value instanceof BigInteger) {
      writeNumber((BigInteger) value);
    } else if (value instanceof Long) {
      writeNumber((Long) value);
    } else if (value instanceof Float) {
      float floatValue = ((Number) value).floatValue();
      Preconditions.checkArgument(!Float.isInfinite(floatValue) && !Float.isNaN(floatValue));
      writeNumber(floatValue);
    } else if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
      writeNumber(((Number) value).intValue());
    } else {
      double doubleValue = ((Number) value).doubleValue();
      Preconditions.checkArgument(!Double.isInfinite(doubleValue) && !Double.isNaN(doubleValue));
      writeNumber(doubleValue);
    }
  } else if (value instanceof Boolean) {
    writeBoolean((Boolean) value);
  } else if (value instanceof DateTime) {
    writeString(((DateTime) value).toStringRfc3339());
  } else if ((value instanceof Iterable<?> || valueClass.isArray())
      && !(value instanceof Map<?, ?>)
      && !(value instanceof GenericData)) {
    writeStartArray();
    for (Object o : Types.iterableOf(value)) {
      serialize(isJsonString, o);
    }
    writeEndArray();
  } else if (valueClass.isEnum()) {
    String name = FieldInfo.of((Enum<?>) value).getName();
    if (name == null) {
      writeNull();
    } else {
      writeString(name);
    }
  } else {
    writeStartObject();
    // only inspect fields of POJO (possibly extends GenericData) but not generic Map
    boolean isMapNotGenericData = value instanceof Map<?, ?> && !(value instanceof GenericData);
    ClassInfo classInfo = isMapNotGenericData ? null : ClassInfo.of(valueClass);
    for (Map.Entry<String, Object> entry : Data.mapOf(value).entrySet()) {
      Object fieldValue = entry.getValue();
      if (fieldValue != null) {
        String fieldName = entry.getKey();
        boolean isJsonStringForField;
        if (isMapNotGenericData) {
          isJsonStringForField = isJsonString;
        } else {
          Field field = classInfo.getField(fieldName);
          isJsonStringForField = field != null && field.getAnnotation(JsonString.class) != null;
        }
        writeFieldName(fieldName);
        serialize(isJsonStringForField, fieldValue);
      }
    }
    writeEndObject();
  }
}
 

/**
 * Parses the next field from the given JSON parser into the given destination object.
 *
 * @param context destination context stack (possibly empty)
 * @param destination destination object instance or {@code null} for none (for example empty
 *     context stack)
 * @param customizeParser optional parser customizer or {@code null} for none
 */
private void parse(
    ArrayList<Type> context, Object destination, CustomizeJsonParser customizeParser)
    throws IOException {
  if (destination instanceof GenericJson) {
    ((GenericJson) destination).setFactory(getFactory());
  }
  JsonToken curToken = startParsingObjectOrArray();
  Class<?> destinationClass = destination.getClass();
  ClassInfo classInfo = ClassInfo.of(destinationClass);
  boolean isGenericData = GenericData.class.isAssignableFrom(destinationClass);
  if (!isGenericData && Map.class.isAssignableFrom(destinationClass)) {
    // The destination class is not a sub-class of GenericData but is of Map, so parse data
    // using parseMap.
    @SuppressWarnings("unchecked")
    Map<String, Object> destinationMap = (Map<String, Object>) destination;
    parseMap(
        null,
        destinationMap,
        Types.getMapValueParameter(destinationClass),
        context,
        customizeParser);
    return;
  }
  while (curToken == JsonToken.FIELD_NAME) {
    String key = getText();
    nextToken();
    // stop at items for feeds
    if (customizeParser != null && customizeParser.stopAt(destination, key)) {
      return;
    }
    // get the field from the type information
    FieldInfo fieldInfo = classInfo.getFieldInfo(key);
    if (fieldInfo != null) {
      // skip final fields
      if (fieldInfo.isFinal() && !fieldInfo.isPrimitive()) {
        throw new IllegalArgumentException("final array/object fields are not supported");
      }
      Field field = fieldInfo.getField();
      int contextSize = context.size();
      context.add(field.getGenericType());
      Object fieldValue =
          parseValue(
              field, fieldInfo.getGenericType(), context, destination, customizeParser, true);
      context.remove(contextSize);
      fieldInfo.setValue(destination, fieldValue);
    } else if (isGenericData) {
      // store unknown field in generic JSON
      GenericData object = (GenericData) destination;
      object.set(key, parseValue(null, null, context, destination, customizeParser, true));
    } else {
      // unrecognized field, skip value.
      if (customizeParser != null) {
        customizeParser.handleUnrecognizedKey(destination, key);
      }
      skipChildren();
    }
    curToken = nextToken();
  }
}
 

/**
 * Flag a {@link io.kickflip.sdk.api.json.Stream}. Used when the active Kickflip User does not own the Stream.
 * <p/>
 * To delete a recording the active Kickflip User owns, use
 * {@link io.kickflip.sdk.api.KickflipApiClient#setStreamInfo(io.kickflip.sdk.api.json.Stream, KickflipCallback)}
 *
 * @param stream The Stream to flag.
 * @param cb     A callback to receive the result of the flagging operation.
 */
public void flagStream(Stream stream, final KickflipCallback cb) {
    if (!assertActiveUserAvailable(cb)) return;
    GenericData data = new GenericData();
    data.put("uuid", getActiveUser().getUUID());
    data.put("stream_id", stream.getStreamId());

    post(FLAG_STREAM, new UrlEncodedContent(data), Stream.class, cb);
}
 

/**
 * Get Stream Metadata for a a public {@link io.kickflip.sdk.api.json.Stream#mStreamId}.
 * The target Stream must belong a User within your Kickflip app.
 * <p/>
 * This method is useful when digesting a Kickflip.io/<stream_id> url, where only
 * the StreamId String is known.
 *
 * @param streamId the stream Id of the given stream. This is the value that appears
 *                 in urls of form kickflip.io/<stream_id>
 * @param cb       A callback to receive the current {@link io.kickflip.sdk.api.json.Stream} upon request completion
 */
public void getStreamInfo(String streamId, final KickflipCallback cb) {
    GenericData data = new GenericData();
    data.put("stream_id", streamId);

    post(GET_META, new UrlEncodedContent(data), Stream.class, cb);
}
 

/**
 * Get Stream Metadata for a a public {@link io.kickflip.sdk.api.json.Stream}.
 * The target Stream must belong a User of your Kickflip app.
 *
 * @param stream the {@link io.kickflip.sdk.api.json.Stream} to get Meta data for
 * @param cb     A callback to receive the updated Stream upon request completion
 */
public void getStreamInfo(Stream stream, final KickflipCallback cb) {
    GenericData data = new GenericData();
    data.put("stream_id", stream.getStreamId());

    post(GET_META, new UrlEncodedContent(data), Stream.class, cb);
}