box / box-java-sdk-gen / #10

Committed 14 Mar 2025 01:22PM UTC coverage: 35.216%. First build

Build # #10

Build Type

Pull #249

github

Committed by

web-flow

Commit Message

Merge c6d8adf2d into 965b357ff

Pull Request Pull Request #249: feat: Support upload with preflight check (box/box-codegen#676)

Run Details

69 of 141 new or added lines in 6 files covered. (48.94%)

15237 of 43267 relevant lines covered (35.22%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.0

/src/main/java/com/box/sdkgen/managers/uploads/UploadsManager.java

package com.box.sdkgen.managers.uploads;

import static com.box.sdkgen.internal.utils.UtilsManager.convertToString;
import static com.box.sdkgen.internal.utils.UtilsManager.entryOf;
import static com.box.sdkgen.internal.utils.UtilsManager.mapOf;
import static com.box.sdkgen.internal.utils.UtilsManager.mergeMaps;
import static com.box.sdkgen.internal.utils.UtilsManager.prepareParams;

import com.box.sdkgen.box.errors.BoxSDKError;
import com.box.sdkgen.networking.auth.Authentication;
import com.box.sdkgen.networking.fetchoptions.FetchOptions;
import com.box.sdkgen.networking.fetchoptions.MultipartItem;
import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
import com.box.sdkgen.networking.fetchresponse.FetchResponse;
import com.box.sdkgen.networking.network.NetworkSession;
import com.box.sdkgen.schemas.files.Files;
import com.box.sdkgen.schemas.uploadurl.UploadUrl;
import com.box.sdkgen.serialization.json.JsonManager;
import java.util.Arrays;
import java.util.Map;

public class UploadsManager {

  public Authentication auth;

  public NetworkSession networkSession;

  public UploadsManager() {
    this.networkSession = new NetworkSession();
  }

  protected UploadsManager(UploadsManagerBuilder builder) {
    this.auth = builder.auth;
    this.networkSession = builder.networkSession;
  }

  public Files uploadFileVersion(String fileId, UploadFileVersionRequestBody requestBody) {
    return uploadFileVersion(
        fileId, requestBody, new UploadFileVersionQueryParams(), new UploadFileVersionHeaders());
  }

  public Files uploadFileVersion(
      String fileId,
      UploadFileVersionRequestBody requestBody,
      UploadFileVersionQueryParams queryParams) {
    return uploadFileVersion(fileId, requestBody, queryParams, new UploadFileVersionHeaders());
  }

  public Files uploadFileVersion(
      String fileId, UploadFileVersionRequestBody requestBody, UploadFileVersionHeaders headers) {
    return uploadFileVersion(fileId, requestBody, new UploadFileVersionQueryParams(), headers);
  }

  public Files uploadFileVersion(
      String fileId,
      UploadFileVersionRequestBody requestBody,
      UploadFileVersionQueryParams queryParams,
      UploadFileVersionHeaders headers) {
    Map<String, String> queryParamsMap =
        prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));
    Map<String, String> headersMap =
        prepareParams(
            mergeMaps(
                mapOf(
                    entryOf("if-match", convertToString(headers.getIfMatch())),
                    entryOf("content-md5", convertToString(headers.getContentMd5()))),
                headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.FetchOptionsBuilder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getUploadUrl(),
                            "/2.0/files/",
                            convertToString(fileId),
                            "/content"),
                        "POST")
                    .params(queryParamsMap)
                    .headers(headersMap)
                    .multipartData(
                        Arrays.asList(
                            new MultipartItem.MultipartItemBuilder("attributes")
                                .data(JsonManager.serialize(requestBody.getAttributes()))
                                .build(),
                            new MultipartItem.MultipartItemBuilder("file")
                                .fileStream(requestBody.getFile())
                                .fileName(requestBody.getFileFileName())
                                .contentType(requestBody.getFileContentType())
                                .build()))
                    .contentType("multipart/form-data")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), Files.class);
  }

  public UploadUrl preflightFileUploadCheck() {
    return preflightFileUploadCheck(
        new PreflightFileUploadCheckRequestBody(), new PreflightFileUploadCheckHeaders());
  }

  public UploadUrl preflightFileUploadCheck(PreflightFileUploadCheckRequestBody requestBody) {
    return preflightFileUploadCheck(requestBody, new PreflightFileUploadCheckHeaders());
  }

  public UploadUrl preflightFileUploadCheck(PreflightFileUploadCheckHeaders headers) {
    return preflightFileUploadCheck(new PreflightFileUploadCheckRequestBody(), headers);
  }

  public UploadUrl preflightFileUploadCheck(
      PreflightFileUploadCheckRequestBody requestBody, PreflightFileUploadCheckHeaders headers) {
    Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.FetchOptionsBuilder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getBaseUrl(),
                            "/2.0/files/content"),
                        "OPTIONS")
                    .headers(headersMap)
                    .data(JsonManager.serialize(requestBody))
                    .contentType("application/json")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), UploadUrl.class);
  }

  public Files uploadFile(UploadFileRequestBody requestBody) {
    return uploadFile(requestBody, new UploadFileQueryParams(), new UploadFileHeaders());
  }

  public Files uploadFile(UploadFileRequestBody requestBody, UploadFileQueryParams queryParams) {
    return uploadFile(requestBody, queryParams, new UploadFileHeaders());
  }

  public Files uploadFile(UploadFileRequestBody requestBody, UploadFileHeaders headers) {
    return uploadFile(requestBody, new UploadFileQueryParams(), headers);
  }

  public Files uploadFile(
      UploadFileRequestBody requestBody,
      UploadFileQueryParams queryParams,
      UploadFileHeaders headers) {
    Map<String, String> queryParamsMap =
        prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));
    Map<String, String> headersMap =
        prepareParams(
            mergeMaps(
                mapOf(entryOf("content-md5", convertToString(headers.getContentMd5()))),
                headers.getExtraHeaders()));
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.FetchOptionsBuilder(
                        String.join(
                            "",
                            this.networkSession.getBaseUrls().getUploadUrl(),
                            "/2.0/files/content"),
                        "POST")
                    .params(queryParamsMap)
                    .headers(headersMap)
                    .multipartData(
                        Arrays.asList(
                            new MultipartItem.MultipartItemBuilder("attributes")
                                .data(JsonManager.serialize(requestBody.getAttributes()))
                                .build(),
                            new MultipartItem.MultipartItemBuilder("file")
                                .fileStream(requestBody.getFile())
                                .fileName(requestBody.getFileFileName())
                                .contentType(requestBody.getFileContentType())
                                .build()))
                    .contentType("multipart/form-data")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), Files.class);
  }

  public Files uploadWithPreflightCheck(UploadWithPreflightCheckRequestBody requestBody) {
    return uploadWithPreflightCheck(
        requestBody,
        new UploadWithPreflightCheckQueryParams(),
        new UploadWithPreflightCheckHeaders());
  }

  public Files uploadWithPreflightCheck(
      UploadWithPreflightCheckRequestBody requestBody,
      UploadWithPreflightCheckQueryParams queryParams) {
    return uploadWithPreflightCheck(
        requestBody, queryParams, new UploadWithPreflightCheckHeaders());
  }

  public Files uploadWithPreflightCheck(
      UploadWithPreflightCheckRequestBody requestBody, UploadWithPreflightCheckHeaders headers) {
    return uploadWithPreflightCheck(
        requestBody, new UploadWithPreflightCheckQueryParams(), headers);
  }

  public Files uploadWithPreflightCheck(
      UploadWithPreflightCheckRequestBody requestBody,
      UploadWithPreflightCheckQueryParams queryParams,
      UploadWithPreflightCheckHeaders headers) {
    Map<String, String> queryParamsMap =
        prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));
    Map<String, String> headersMap =
        prepareParams(
            mergeMaps(
                mapOf(entryOf("content-md5", convertToString(headers.getContentMd5()))),
                headers.getExtraHeaders()));
    UploadUrl preflightUploadUrl =
        this.preflightFileUploadCheck(
            new PreflightFileUploadCheckRequestBody.PreflightFileUploadCheckRequestBodyBuilder()
                .name(requestBody.getAttributes().getName())
                .size(requestBody.getAttributes().getSize())
                .parent(
                    new PreflightFileUploadCheckRequestBodyParentField
                            .PreflightFileUploadCheckRequestBodyParentFieldBuilder()
                        .id(requestBody.getAttributes().getParent().getId())
                        .build())
                .build(),
            new PreflightFileUploadCheckHeaders.PreflightFileUploadCheckHeadersBuilder()
                .extraHeaders(headers.getExtraHeaders())
                .build());
    if (preflightUploadUrl.getUploadUrl() == null
        || !(preflightUploadUrl.getUploadUrl().contains("http"))) {
      throw new BoxSDKError("Unable to get preflight upload URL");
    }
    FetchResponse response =
        this.networkSession
            .getNetworkClient()
            .fetch(
                new FetchOptions.FetchOptionsBuilder(preflightUploadUrl.getUploadUrl(), "POST")
                    .params(queryParamsMap)
                    .headers(headersMap)
                    .multipartData(
                        Arrays.asList(
                            new MultipartItem.MultipartItemBuilder("attributes")
                                .data(JsonManager.serialize(requestBody.getAttributes()))
                                .build(),
                            new MultipartItem.MultipartItemBuilder("file")
                                .fileStream(requestBody.getFile())
                                .fileName(requestBody.getFileFileName())
                                .contentType(requestBody.getFileContentType())
                                .build()))
                    .contentType("multipart/form-data")
                    .responseFormat(ResponseFormat.JSON)
                    .auth(this.auth)
                    .networkSession(this.networkSession)
                    .build());
    return JsonManager.deserialize(response.getData(), Files.class);
  }

  public Authentication getAuth() {
    return auth;
  }

  public NetworkSession getNetworkSession() {
    return networkSession;
  }

  public static class UploadsManagerBuilder {

    protected Authentication auth;

    protected NetworkSession networkSession;

    public UploadsManagerBuilder auth(Authentication auth) {
      this.auth = auth;
      return this;
    }

    public UploadsManagerBuilder networkSession(NetworkSession networkSession) {
      this.networkSession = networkSession;
      return this;
    }

    public UploadsManager build() {
      return new UploadsManager(this);
    }
  }
}

1	package com.box.sdkgen.managers.uploads;
2
3	import static com.box.sdkgen.internal.utils.UtilsManager.convertToString;
4	import static com.box.sdkgen.internal.utils.UtilsManager.entryOf;
5	import static com.box.sdkgen.internal.utils.UtilsManager.mapOf;
6	import static com.box.sdkgen.internal.utils.UtilsManager.mergeMaps;
7	import static com.box.sdkgen.internal.utils.UtilsManager.prepareParams;
8
9	import com.box.sdkgen.box.errors.BoxSDKError;
10	import com.box.sdkgen.networking.auth.Authentication;
11	import com.box.sdkgen.networking.fetchoptions.FetchOptions;
12	import com.box.sdkgen.networking.fetchoptions.MultipartItem;
13	import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
14	import com.box.sdkgen.networking.fetchresponse.FetchResponse;
15	import com.box.sdkgen.networking.network.NetworkSession;
16	import com.box.sdkgen.schemas.files.Files;
17	import com.box.sdkgen.schemas.uploadurl.UploadUrl;
18	import com.box.sdkgen.serialization.json.JsonManager;
19	import java.util.Arrays;
20	import java.util.Map;
21
22	public class UploadsManager {
23
24	public Authentication auth;
25
26	public NetworkSession networkSession;
27
28	public UploadsManager() {	×
29	this.networkSession = new NetworkSession();	×
30	}	×
31
32	protected UploadsManager(UploadsManagerBuilder builder) {	1✔
33	this.auth = builder.auth;	1✔
34	this.networkSession = builder.networkSession;	1✔
35	}	1✔
36
37	public Files uploadFileVersion(String fileId, UploadFileVersionRequestBody requestBody) {
38	return uploadFileVersion(	1✔
39	fileId, requestBody, new UploadFileVersionQueryParams(), new UploadFileVersionHeaders());
40	}
41
42	public Files uploadFileVersion(
43	String fileId,
44	UploadFileVersionRequestBody requestBody,
45	UploadFileVersionQueryParams queryParams) {
46	return uploadFileVersion(fileId, requestBody, queryParams, new UploadFileVersionHeaders());	×
47	}
48
49	public Files uploadFileVersion(
50	String fileId, UploadFileVersionRequestBody requestBody, UploadFileVersionHeaders headers) {
51	return uploadFileVersion(fileId, requestBody, new UploadFileVersionQueryParams(), headers);	×
52	}
53
54	public Files uploadFileVersion(
55	String fileId,
56	UploadFileVersionRequestBody requestBody,
57	UploadFileVersionQueryParams queryParams,
58	UploadFileVersionHeaders headers) {
59	Map<String, String> queryParamsMap =	1✔
60	prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));	1✔
61	Map<String, String> headersMap =	1✔
62	prepareParams(	1✔
63	mergeMaps(	1✔
64	mapOf(	1✔
65	entryOf("if-match", convertToString(headers.getIfMatch())),	1✔
66	entryOf("content-md5", convertToString(headers.getContentMd5()))),	1✔
67	headers.getExtraHeaders()));	1✔
68	FetchResponse response =	1✔
69	this.networkSession
70	.getNetworkClient()	1✔
71	.fetch(	1✔
72	new FetchOptions.FetchOptionsBuilder(
73	String.join(	1✔
74	"",
75	this.networkSession.getBaseUrls().getUploadUrl(),	1✔
76	"/2.0/files/",
77	convertToString(fileId),	1✔
78	"/content"),
79	"POST")
80	.params(queryParamsMap)	1✔
81	.headers(headersMap)	1✔
82	.multipartData(	1✔
83	Arrays.asList(	1✔
84	new MultipartItem.MultipartItemBuilder("attributes")
85	.data(JsonManager.serialize(requestBody.getAttributes()))	1✔
86	.build(),	1✔
87	new MultipartItem.MultipartItemBuilder("file")
88	.fileStream(requestBody.getFile())	1✔
89	.fileName(requestBody.getFileFileName())	1✔
90	.contentType(requestBody.getFileContentType())	1✔
91	.build()))	1✔
92	.contentType("multipart/form-data")	1✔
93	.responseFormat(ResponseFormat.JSON)	1✔
94	.auth(this.auth)	1✔
95	.networkSession(this.networkSession)	1✔
96	.build());	1✔
97	return JsonManager.deserialize(response.getData(), Files.class);	1✔
98	}
99
100	public UploadUrl preflightFileUploadCheck() {
101	return preflightFileUploadCheck(	×
102	new PreflightFileUploadCheckRequestBody(), new PreflightFileUploadCheckHeaders());
103	}
104
105	public UploadUrl preflightFileUploadCheck(PreflightFileUploadCheckRequestBody requestBody) {
106	return preflightFileUploadCheck(requestBody, new PreflightFileUploadCheckHeaders());	1✔
107	}
108
109	public UploadUrl preflightFileUploadCheck(PreflightFileUploadCheckHeaders headers) {
110	return preflightFileUploadCheck(new PreflightFileUploadCheckRequestBody(), headers);	×
111	}
112
113	public UploadUrl preflightFileUploadCheck(
114	PreflightFileUploadCheckRequestBody requestBody, PreflightFileUploadCheckHeaders headers) {
115	Map<String, String> headersMap = prepareParams(mergeMaps(mapOf(), headers.getExtraHeaders()));	1✔
116	FetchResponse response =	1✔
117	this.networkSession
118	.getNetworkClient()	1✔
119	.fetch(	1✔
120	new FetchOptions.FetchOptionsBuilder(
121	String.join(	1✔
122	"",
123	this.networkSession.getBaseUrls().getBaseUrl(),	1✔
124	"/2.0/files/content"),
125	"OPTIONS")
126	.headers(headersMap)	1✔
127	.data(JsonManager.serialize(requestBody))	1✔
128	.contentType("application/json")	1✔
129	.responseFormat(ResponseFormat.JSON)	1✔
130	.auth(this.auth)	1✔
131	.networkSession(this.networkSession)	1✔
132	.build());	1✔
133	return JsonManager.deserialize(response.getData(), UploadUrl.class);	1✔
134	}
135
136	public Files uploadFile(UploadFileRequestBody requestBody) {
137	return uploadFile(requestBody, new UploadFileQueryParams(), new UploadFileHeaders());	1✔
138	}
139
140	public Files uploadFile(UploadFileRequestBody requestBody, UploadFileQueryParams queryParams) {
141	return uploadFile(requestBody, queryParams, new UploadFileHeaders());	×
142	}
143
144	public Files uploadFile(UploadFileRequestBody requestBody, UploadFileHeaders headers) {
145	return uploadFile(requestBody, new UploadFileQueryParams(), headers);	×
146	}
147
148	public Files uploadFile(
149	UploadFileRequestBody requestBody,
150	UploadFileQueryParams queryParams,
151	UploadFileHeaders headers) {
152	Map<String, String> queryParamsMap =	1✔
153	prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));	1✔
154	Map<String, String> headersMap =	1✔
155	prepareParams(	1✔
156	mergeMaps(	1✔
157	mapOf(entryOf("content-md5", convertToString(headers.getContentMd5()))),	1✔
158	headers.getExtraHeaders()));	1✔
159	FetchResponse response =	1✔
160	this.networkSession
161	.getNetworkClient()	1✔
162	.fetch(	1✔
163	new FetchOptions.FetchOptionsBuilder(
164	String.join(	1✔
165	"",
166	this.networkSession.getBaseUrls().getUploadUrl(),	1✔
167	"/2.0/files/content"),
168	"POST")
169	.params(queryParamsMap)	1✔
170	.headers(headersMap)	1✔
171	.multipartData(	1✔
172	Arrays.asList(	1✔
173	new MultipartItem.MultipartItemBuilder("attributes")
174	.data(JsonManager.serialize(requestBody.getAttributes()))	1✔
175	.build(),	1✔
176	new MultipartItem.MultipartItemBuilder("file")
177	.fileStream(requestBody.getFile())	1✔
178	.fileName(requestBody.getFileFileName())	1✔
179	.contentType(requestBody.getFileContentType())	1✔
180	.build()))	1✔
181	.contentType("multipart/form-data")	1✔
182	.responseFormat(ResponseFormat.JSON)	1✔
183	.auth(this.auth)	1✔
184	.networkSession(this.networkSession)	1✔
185	.build());	1✔
186	return JsonManager.deserialize(response.getData(), Files.class);	1✔
187	}
188
189	public Files uploadWithPreflightCheck(UploadWithPreflightCheckRequestBody requestBody) {
190	return uploadWithPreflightCheck(	1✔
191	requestBody,
192	new UploadWithPreflightCheckQueryParams(),
193	new UploadWithPreflightCheckHeaders());
194	}
195
196	public Files uploadWithPreflightCheck(
197	UploadWithPreflightCheckRequestBody requestBody,
198	UploadWithPreflightCheckQueryParams queryParams) {
NEW 199	return uploadWithPreflightCheck(	×
200	requestBody, queryParams, new UploadWithPreflightCheckHeaders());
201	}
202
203	public Files uploadWithPreflightCheck(
204	UploadWithPreflightCheckRequestBody requestBody, UploadWithPreflightCheckHeaders headers) {
NEW 205	return uploadWithPreflightCheck(	×
206	requestBody, new UploadWithPreflightCheckQueryParams(), headers);
207	}
208
209	public Files uploadWithPreflightCheck(
210	UploadWithPreflightCheckRequestBody requestBody,
211	UploadWithPreflightCheckQueryParams queryParams,
212	UploadWithPreflightCheckHeaders headers) {
213	Map<String, String> queryParamsMap =	1✔
214	prepareParams(mapOf(entryOf("fields", convertToString(queryParams.getFields()))));	1✔
215	Map<String, String> headersMap =	1✔
216	prepareParams(	1✔
217	mergeMaps(	1✔
218	mapOf(entryOf("content-md5", convertToString(headers.getContentMd5()))),	1✔
219	headers.getExtraHeaders()));	1✔
220	UploadUrl preflightUploadUrl =	1✔
221	this.preflightFileUploadCheck(	1✔
222	new PreflightFileUploadCheckRequestBody.PreflightFileUploadCheckRequestBodyBuilder()
223	.name(requestBody.getAttributes().getName())	1✔
224	.size(requestBody.getAttributes().getSize())	1✔
225	.parent(	1✔
226	new PreflightFileUploadCheckRequestBodyParentField
227	.PreflightFileUploadCheckRequestBodyParentFieldBuilder()
228	.id(requestBody.getAttributes().getParent().getId())	1✔
229	.build())	1✔
230	.build(),	1✔
231	new PreflightFileUploadCheckHeaders.PreflightFileUploadCheckHeadersBuilder()
232	.extraHeaders(headers.getExtraHeaders())	1✔
233	.build());	1✔
234	if (preflightUploadUrl.getUploadUrl() == null	1✔
235	\|\| !(preflightUploadUrl.getUploadUrl().contains("http"))) {	1✔
NEW 236	throw new BoxSDKError("Unable to get preflight upload URL");	×
237	}
238	FetchResponse response =	1✔
239	this.networkSession
240	.getNetworkClient()	1✔
241	.fetch(	1✔
242	new FetchOptions.FetchOptionsBuilder(preflightUploadUrl.getUploadUrl(), "POST")	1✔
243	.params(queryParamsMap)	1✔
244	.headers(headersMap)	1✔
245	.multipartData(	1✔
246	Arrays.asList(	1✔
247	new MultipartItem.MultipartItemBuilder("attributes")
248	.data(JsonManager.serialize(requestBody.getAttributes()))	1✔
249	.build(),	1✔
250	new MultipartItem.MultipartItemBuilder("file")
251	.fileStream(requestBody.getFile())	1✔
252	.fileName(requestBody.getFileFileName())	1✔
253	.contentType(requestBody.getFileContentType())	1✔
254	.build()))	1✔
255	.contentType("multipart/form-data")	1✔
256	.responseFormat(ResponseFormat.JSON)	1✔
257	.auth(this.auth)	1✔
258	.networkSession(this.networkSession)	1✔
259	.build());	1✔
260	return JsonManager.deserialize(response.getData(), Files.class);	1✔
261	}
262
263	public Authentication getAuth() {
264	return auth;	×
265	}
266
267	public NetworkSession getNetworkSession() {
268	return networkSession;	×
269	}
270
271	public static class UploadsManagerBuilder {	1✔
272
273	protected Authentication auth;
274
275	protected NetworkSession networkSession;
276
277	public UploadsManagerBuilder auth(Authentication auth) {
278	this.auth = auth;	1✔
279	return this;	1✔
280	}
281
282	public UploadsManagerBuilder networkSession(NetworkSession networkSession) {
283	this.networkSession = networkSession;	1✔
284	return this;	1✔
285	}
286
287	public UploadsManager build() {
288	return new UploadsManager(this);	1✔
289	}
290	}
291	}

box / box-java-sdk-gen / #10

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous