/**
* Upload file.
*
* @param fileContent File to upload.
* @param fileName File name to upload. Name has to be spelled exactly as written here.
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> uploadFileAsync(
InputStream fileContent,
String fileName,
final ServiceCallback<InputStream> serviceCallback) {
if (fileContent == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter fileContent is required and cannot be null."));
return null;
}
if (fileName == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter fileName is required and cannot be null."));
return null;
}
Call<ResponseBody> call = service.uploadFile(fileContent, fileName);
call.enqueue(
new ServiceResponseCallback<InputStream>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(uploadFileDelegate(response, retrofit));
} catch (ServiceException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* POST method with subscriptionId modeled in credentials. Set the credential subscriptionId to
* '1234-5678-9012-3456' to succeed.
*
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @throws IllegalArgumentException thrown if callback is null
* @return the {@link Call} object
*/
public ServiceCall postSwaggerGlobalValidAsync(final ServiceCallback<Void> serviceCallback)
throws IllegalArgumentException {
if (serviceCallback == null) {
throw new IllegalArgumentException("ServiceCallback is required for async calls.");
}
if (this.client.getSubscriptionId() == null) {
serviceCallback.failure(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
return null;
}
Call<ResponseBody> call =
service.postSwaggerGlobalValid(
this.client.getSubscriptionId(), this.client.getAcceptLanguage());
final ServiceCall serviceCall = new ServiceCall(call);
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
try {
serviceCallback.success(postSwaggerGlobalValidDelegate(response));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return serviceCall;
}
/**
* Put complex types with array property which is empty.
*
* @param complexBody Please put an empty array
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @throws IllegalArgumentException thrown if callback is null
* @return the {@link Call} object
*/
public ServiceCall putEmptyAsync(
ArrayWrapper complexBody, final ServiceCallback<Void> serviceCallback)
throws IllegalArgumentException {
if (serviceCallback == null) {
throw new IllegalArgumentException("ServiceCallback is required for async calls.");
}
if (complexBody == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter complexBody is required and cannot be null."));
return null;
}
Validator.validate(complexBody, serviceCallback);
Call<ResponseBody> call = service.putEmpty(complexBody);
final ServiceCall serviceCall = new ServiceCall(call);
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
try {
serviceCallback.success(putEmptyDelegate(response));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return serviceCall;
}
/**
* Gets the current usage count and the limit for the resources under the subscription.
*
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @throws IllegalArgumentException thrown if callback is null
* @return the {@link Call} object
*/
public ServiceCall listAsync(final ServiceCallback<UsageListResultInner> serviceCallback)
throws IllegalArgumentException {
if (serviceCallback == null) {
throw new IllegalArgumentException("ServiceCallback is required for async calls.");
}
if (this.client.subscriptionId() == null) {
serviceCallback.failure(
new IllegalArgumentException(
"Parameter this.client.subscriptionId() is required and cannot be null."));
return null;
}
if (this.client.apiVersion() == null) {
serviceCallback.failure(
new IllegalArgumentException(
"Parameter this.client.apiVersion() is required and cannot be null."));
return null;
}
Call<ResponseBody> call =
service.list(
this.client.subscriptionId(),
this.client.apiVersion(),
this.client.acceptLanguage(),
this.client.userAgent());
final ServiceCall serviceCall = new ServiceCall(call);
call.enqueue(
new ServiceResponseCallback<UsageListResultInner>(serviceCallback) {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
try {
serviceCallback.success(listDelegate(response));
} catch (CloudException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return serviceCall;
}
/**
* Test implicitly required path parameter.
*
* @param pathParameter the String value
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> getRequiredPathAsync(
String pathParameter, final ServiceCallback<Error> serviceCallback) {
if (pathParameter == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter pathParameter is required and cannot be null."));
return null;
}
Call<ResponseBody> call = service.getRequiredPath(pathParameter);
call.enqueue(
new ServiceResponseCallback<Error>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(getRequiredPathDelegate(response, retrofit));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* Put min datetime value 0001-01-01T00:00:00Z.
*
* @param datetimeBody the DateTime value
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> putUtcMinDateTimeAsync(
DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
if (datetimeBody == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter datetimeBody is required and cannot be null."));
return null;
}
Call<ResponseBody> call = service.putUtcMinDateTime(datetimeBody);
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(putUtcMinDateTimeDelegate(response, retrofit));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* Test implicitly required query parameter.
*
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> getRequiredGlobalQueryAsync(
final ServiceCallback<Error> serviceCallback) {
if (this.client.getRequiredGlobalQuery() == null) {
serviceCallback.failure(
new IllegalArgumentException(
"Parameter this.client.getRequiredGlobalQuery() is required and cannot be null."));
return null;
}
Call<ResponseBody> call = service.getRequiredGlobalQuery(this.client.getRequiredGlobalQuery());
call.enqueue(
new ServiceResponseCallback<Error>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(getRequiredGlobalQueryDelegate(response, retrofit));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* POST method with subscriptionId modeled in the method. pass in subscription id =
* '1234-5678-9012-3456' to succeed.
*
* @param subscriptionId This should appear as a method parameter, use value '1234-5678-9012-3456'
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> postMethodLocalValidAsync(
String subscriptionId, final ServiceCallback<Void> serviceCallback) {
if (subscriptionId == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter subscriptionId is required and cannot be null."));
return null;
}
Call<ResponseBody> call =
service.postMethodLocalValid(subscriptionId, this.client.getAcceptLanguage());
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(postMethodLocalValidDelegate(response, retrofit));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* GET method with api-version modeled in global settings.
*
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
*/
public Call<ResponseBody> getMethodGlobalValidAsync(final ServiceCallback<Void> serviceCallback) {
if (this.client.getApiVersion() == null) {
serviceCallback.failure(
new ServiceException(
new IllegalArgumentException(
"Parameter this.client.getApiVersion() is required and cannot be null.")));
}
Call<ResponseBody> call =
service.getMethodGlobalValid(this.client.getApiVersion(), this.client.getAcceptLanguage());
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(getMethodGlobalValidDelegate(response, retrofit));
} catch (ServiceException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}
/**
* Put complex types that are polymorphic and have recursive references.
*
* @param complexBody Please put a salmon that looks like this: { "fishtype": "salmon", "species":
* "king", "length": 1, "age": 1, "location": "alaska", "iswild": true, "siblings": [ {
* "fishtype": "shark", "species": "predator", "length": 20, "age": 6, "siblings": [ {
* "fishtype": "salmon", "species": "coho", "length": 2, "age": 2, "location": "atlantic",
* "iswild": true, "siblings": [ { "fishtype": "shark", "species": "predator", "length": 20,
* "age": 6 }, { "fishtype": "sawshark", "species": "dangerous", "length": 10, "age": 105 } ]
* }, { "fishtype": "sawshark", "species": "dangerous", "length": 10, "age": 105 } ] }, {
* "fishtype": "sawshark", "species": "dangerous", "length": 10, "age": 105 } ] }
* @param serviceCallback the async ServiceCallback to handle successful and failed responses.
* @return the {@link Call} object
*/
public Call<ResponseBody> putValidAsync(
Fish complexBody, final ServiceCallback<Void> serviceCallback) {
if (complexBody == null) {
serviceCallback.failure(
new IllegalArgumentException("Parameter complexBody is required and cannot be null."));
return null;
}
Validator.validate(complexBody, serviceCallback);
Call<ResponseBody> call = service.putValid(complexBody);
call.enqueue(
new ServiceResponseCallback<Void>(serviceCallback) {
@Override
public void onResponse(Response<ResponseBody> response, Retrofit retrofit) {
try {
serviceCallback.success(putValidDelegate(response, retrofit));
} catch (ErrorException | IOException exception) {
serviceCallback.failure(exception);
}
}
});
return call;
}