1 | import axios from 'axios';
|
2 | import get from 'lodash.get';
|
3 | import isnil from 'lodash.isnil';
|
4 | import sha1 from 'sha1';
|
5 | import Semaphore from '@chriscdn/promise-semaphore';
|
6 |
|
7 | var formDataFactory = {
|
8 | createFormData() {
|
9 | {
|
10 | return new FormData()
|
11 | }
|
12 | }
|
13 | };
|
14 |
|
15 | function getInstance(baseURL) {
|
16 |
|
17 | const instance = axios.create({
|
18 | baseURL
|
19 | });
|
20 |
|
21 | instance.interceptors.response.use(response => {
|
22 | const otcsticket = get(response, 'headers.otcsticket');
|
23 |
|
24 | if (otcsticket) {
|
25 | instance.defaults.headers.common['OTCSTicket'] = otcsticket;
|
26 | }
|
27 | return response
|
28 | }, error => {
|
29 | return Promise.reject(error)
|
30 | });
|
31 |
|
32 | return instance
|
33 | }
|
34 |
|
35 | function axiosFactory(options) {
|
36 | const instance = getInstance(options.baseURL);
|
37 |
|
38 | const username = get(options, 'username');
|
39 | const password = get(options, 'password');
|
40 | const otcsticket = get(options, 'otcsticket');
|
41 |
|
42 | if (otcsticket) {
|
43 |
|
44 | instance.defaults.headers.common['OTCSTicket'] = otcsticket;
|
45 |
|
46 | } else if (username && password) {
|
47 |
|
48 | instance.interceptors.request.use(async request => {
|
49 |
|
50 | if (request.headers.common['OTCSTicket']) {
|
51 |
|
52 | return request
|
53 |
|
54 | } else {
|
55 |
|
56 | const formData = formDataFactory.createFormData();
|
57 |
|
58 | formData.append('username', username);
|
59 | formData.append('password', password);
|
60 |
|
61 | let response = await axios.post(`${options.baseURL}/api/v1/auth/`, formData);
|
62 |
|
63 | request.headers.common['OTCSTicket'] = get(response, 'data.ticket');
|
64 |
|
65 | return request
|
66 | }
|
67 | });
|
68 | } else {
|
69 | throw 'You must provide an otcsticket or username and password.'
|
70 | }
|
71 |
|
72 | return instance
|
73 | }
|
74 |
|
75 | var auth = axiosFactory;
|
76 |
|
77 | const SubTypes = {
|
78 | FOLDER: 0,
|
79 | DOCUMENT: 144
|
80 | };
|
81 |
|
82 | var nodes = session => ({
|
83 |
|
84 | addablenodetypes(dataid) {
|
85 | return session.get(`api/v1/nodes/${dataid}/addablenodetypes`)
|
86 | },
|
87 |
|
88 | async addDocument(parent_id, fileHandler, fileName = null) {
|
89 |
|
90 | const url = 'api/v1/nodes';
|
91 |
|
92 | const formData = formDataFactory.createFormData();
|
93 |
|
94 | formData.append('type', SubTypes.DOCUMENT);
|
95 | formData.append('parent_id', parent_id);
|
96 |
|
97 | {
|
98 |
|
99 |
|
100 | let name = fileName || fileHandler.name;
|
101 |
|
102 | formData.append('file', fileHandler, name);
|
103 | formData.append('name', name);
|
104 |
|
105 | return session.post(url, formData)
|
106 | }
|
107 | },
|
108 |
|
109 | addItem(type, parent_id, name, params = {}) {
|
110 | return session.postForm('api/v2/nodes', {
|
111 | type,
|
112 | parent_id,
|
113 | name,
|
114 | ...params
|
115 | })
|
116 | },
|
117 |
|
118 | node(dataid, params = {}) {
|
119 | return session.getCached(`api/v2/nodes/${dataid}`, { params })
|
120 | },
|
121 |
|
122 | ancestors(dataid, params = {}) {
|
123 | return session.get(`api/v1/nodes/${dataid}/ancestors`, { params })
|
124 | },
|
125 |
|
126 | volumeInfo(objType) {
|
127 | return session.get(`api/v1/volumes/${objType}`)
|
128 | },
|
129 |
|
130 | volumes() {
|
131 | return session.get('api/v2/volumes')
|
132 | },
|
133 |
|
134 | addFolder(parent_id, name, params = {}) {
|
135 | return this.addItem(SubTypes.FOLDER, parent_id, name, params)
|
136 | },
|
137 |
|
138 | children(dataid, params = {}) {
|
139 |
|
140 | return session.get(`api/v2/nodes/${dataid}/nodes`, { params })
|
141 | },
|
142 |
|
143 | delete(dataid) {
|
144 | return session.delete(`api/v1/nodes/${dataid}`)
|
145 | },
|
146 |
|
147 | download(dataid, version = 'v1', filePath) {
|
148 |
|
149 | {
|
150 | return Promise.reject('Not implemented yet')
|
151 | }
|
152 | }
|
153 |
|
154 | });
|
155 |
|
156 | var workflow = session => ({
|
157 |
|
158 | start(map_id) {
|
159 | return this.draftprocesses(map_id)
|
160 | .then(response => get(response, 'data.results.draftprocess_id'))
|
161 | .then(draftprocess_id => this.draftprocesses_update(draftprocess_id))
|
162 | },
|
163 |
|
164 | draftprocesses(workflow_id) {
|
165 | return session.postForm('api/v2/draftprocesses', {workflow_id})
|
166 | },
|
167 |
|
168 | draftprocesses_update(draftprocess_id) {
|
169 | return session.get('api/v1/forms/draftprocesses/update', {
|
170 | params: {
|
171 | draftprocess_id
|
172 | }
|
173 | })
|
174 | },
|
175 |
|
176 | draftprocesses_put(draftprocess_id, body) {
|
177 | return session.putForm(`api/v2/draftprocesses/${draftprocess_id}`, { body })
|
178 | }
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 | });
|
190 |
|
191 | var rhcore = session => ({
|
192 | scriptNode(id, params = {}) {
|
193 | return session.get(`api/v1/rhcore/${id}`, {
|
194 | params
|
195 | })
|
196 | }
|
197 | });
|
198 |
|
199 | var members = session => ({
|
200 |
|
201 | USER: 0,
|
202 | GROUP: 1,
|
203 |
|
204 | userQuery(query, options = {}, version = 'v2') {
|
205 | const params = {
|
206 | limit: 20,
|
207 | where_type: JSON.stringify([this.USER, this.GROUP]),
|
208 | query,
|
209 | ...options
|
210 | };
|
211 |
|
212 | return session.get(`api/${version}/members`, { params })
|
213 | },
|
214 |
|
215 | member(id, version = 'v2') {
|
216 | return session.getCached(`api/${version}/members/${id}`)
|
217 | }
|
218 |
|
219 | });
|
220 |
|
221 | var versions = session => ({
|
222 |
|
223 | async addVersion(dataid, fileHandler, options = {}) {
|
224 |
|
225 | const url = `api/v1/nodes/${dataid}/versions`;
|
226 |
|
227 |
|
228 |
|
229 | {
|
230 |
|
231 |
|
232 |
|
233 | const params = {
|
234 | file: {
|
235 | file: fileHandler,
|
236 | name: fileHandler.name
|
237 | },
|
238 | ...options
|
239 | };
|
240 |
|
241 | return session.postForm(url, params)
|
242 |
|
243 |
|
244 |
|
245 | }
|
246 | },
|
247 |
|
248 | async list(dataid) {
|
249 | const url = `api/v1/nodes/${dataid}/versions`;
|
250 | return session.get(url)
|
251 | },
|
252 |
|
253 | async version(dataid, version_number='latest') {
|
254 |
|
255 | const url = `api/v1/nodes/${dataid}/versions/${version_number}`;
|
256 | return session.get(url)
|
257 | }
|
258 |
|
259 | });
|
260 |
|
261 | var webreports = session => ({
|
262 |
|
263 | run(dataid, params = {}) {
|
264 | const url = `api/v1/nodes/${dataid}/output`;
|
265 | return session.get(url, { params })
|
266 | }
|
267 |
|
268 | });
|
269 |
|
270 | const semaphore = new Semaphore();
|
271 |
|
272 | let getCache = {};
|
273 |
|
274 | var Session_1 = class Session {
|
275 |
|
276 | constructor(options) {
|
277 | this.axios = auth(options);
|
278 | }
|
279 |
|
280 | get nodes() {
|
281 |
|
282 | if (this._nodes == null) {
|
283 | this._nodes = nodes(this);
|
284 | }
|
285 |
|
286 | return this._nodes
|
287 | }
|
288 |
|
289 | get workflow() {
|
290 |
|
291 | if (this._workflow == null) {
|
292 | this._workflow = workflow(this);
|
293 | }
|
294 |
|
295 | return this._workflow
|
296 | }
|
297 |
|
298 | get rhcore() {
|
299 |
|
300 | if (this._rhcore == null) {
|
301 | this._rhcore = rhcore(this);
|
302 | }
|
303 |
|
304 | return this._rhcore
|
305 | }
|
306 |
|
307 | get members() {
|
308 |
|
309 | if (this._members == null) {
|
310 | this._members = members(this);
|
311 | }
|
312 |
|
313 | return this._members
|
314 | }
|
315 |
|
316 | get webreports() {
|
317 |
|
318 | if (this._webreports == null) {
|
319 | this._webreports = webreports(this);
|
320 | }
|
321 |
|
322 | return this._webreports
|
323 | }
|
324 |
|
325 | get versions() {
|
326 |
|
327 | if (this._versions == null) {
|
328 | this._versions = versions(this);
|
329 | }
|
330 |
|
331 | return this._versions
|
332 | }
|
333 |
|
334 | _isObject(value) {
|
335 | return value && typeof value === 'object' && value.constructor === Object
|
336 | }
|
337 |
|
338 | _objectToForm(obj) {
|
339 |
|
340 | const formData = formDataFactory.createFormData();
|
341 |
|
342 | for (let [key, value] of Object.entries(obj)) {
|
343 | if (value && value.name && value.file) {
|
344 | formData.append(key, value.file, value.name);
|
345 | } else if (Array.isArray(value) || this._isObject(value)) {
|
346 | formData.append(key, JSON.stringify(value));
|
347 | } else if (!isnil(value)) {
|
348 |
|
349 | formData.append(key, value);
|
350 | }
|
351 | }
|
352 |
|
353 | return formData
|
354 | }
|
355 |
|
356 | get(...args) {
|
357 | return this.axios.get(...args)
|
358 | }
|
359 |
|
360 | async getCached(...args) {
|
361 | const key = sha1(JSON.stringify(args));
|
362 |
|
363 | try {
|
364 | await semaphore.acquire(key);
|
365 |
|
366 | if (!getCache[key]) {
|
367 | getCache[key] = this.get(...args);
|
368 | }
|
369 | } finally {
|
370 | semaphore.release(key);
|
371 | }
|
372 |
|
373 | return getCache[key]
|
374 | }
|
375 |
|
376 | putForm(url, params) {
|
377 | const formData = this._objectToForm(params);
|
378 | return this.put(url, formData)
|
379 | }
|
380 |
|
381 | postForm(url, params) {
|
382 | const formData = this._objectToForm(params);
|
383 | return this.post(url, formData)
|
384 | }
|
385 |
|
386 | patchForm(url, params) {
|
387 | const formData = this._objectToForm(params);
|
388 | return this.patch(url, formData)
|
389 | }
|
390 |
|
391 | post(...args) {
|
392 | return this.axios.post(...args)
|
393 | }
|
394 |
|
395 | put(...args) {
|
396 | return this.axios.put(...args)
|
397 | }
|
398 |
|
399 | delete(...args) {
|
400 | return this.axios.delete(...args)
|
401 | }
|
402 |
|
403 | options(...args) {
|
404 | return this.axios.options(...args)
|
405 | }
|
406 |
|
407 | patch(...args) {
|
408 | return this.axios.patch(...args)
|
409 | }
|
410 |
|
411 | };
|
412 |
|
413 | var auth_1 = auth;
|
414 | var Session_1$1 = Session_1;
|
415 |
|
416 | var src = {
|
417 | auth: auth_1,
|
418 | Session: Session_1$1
|
419 | };
|
420 |
|
421 | export default src;
|
422 | export { Session_1$1 as Session, auth_1 as auth };
|
423 |
|