557 lines
18 KiB
JavaScript
557 lines
18 KiB
JavaScript
import { storeGet } from '../store';
|
|
import * as Sentry from "@sentry/browser";
|
|
|
|
|
|
export class NetworkService {
|
|
static TOKEN_KEY
|
|
static REFRESH_TOKEN_KEY
|
|
|
|
static logApiError = (endpoint, status = 0, resp) => {
|
|
try {
|
|
if ([500].includes(status)) {
|
|
Sentry.init({
|
|
dsn: "https://e7b2134f7d816f663bb83e51b106a694@o4508381921738752.ingest.de.sentry.io/4508381935501392",
|
|
environment: process.env.NODE_ENV || "development"
|
|
});
|
|
|
|
const error = new Error(`Status ${status}`);
|
|
Sentry.captureException(`Error in endpoint: ${endpoint}`, {
|
|
level: 'error',
|
|
extra: {
|
|
originalError: error,
|
|
details: resp
|
|
}
|
|
});
|
|
}
|
|
} catch (err) {
|
|
console.log(err);
|
|
}
|
|
}
|
|
|
|
static postEmptyResponse = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'POST',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': storeGet.main.getToken(),
|
|
'Access-Control-Allow-Origin': '*'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.status)
|
|
else
|
|
callback()
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static putEmptyResponse = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'PUT',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': storeGet.main.getToken(),
|
|
'Access-Control-Allow-Origin': '*'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.status)
|
|
else
|
|
callback()
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static post = (url, body, callback, errorCallback, queryParams) => {
|
|
|
|
if (queryParams) {
|
|
url += '?'
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'POST',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static postMultiPart = (url, body, callback, errorCallback, queryParams) => {
|
|
|
|
if (queryParams) {
|
|
url += '?'
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'POST',
|
|
mode: 'cors',
|
|
headers: {
|
|
//'Content-Type': 'multipart/form-data',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
body: body
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static postBlob = (url, body, callback, errorCallback, queryParams) => {
|
|
|
|
if (queryParams) {
|
|
url += '?'
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'POST',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.blob(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static unauthorizedPost = (url, body, callback, errorCallback, queryParams) => {
|
|
if (queryParams) {
|
|
url += '?'
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'POST',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static patch = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'PATCH',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.response)
|
|
else
|
|
callback(data.response)
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static put = (url, body, callback, errorCallback, queryParams = null) => {
|
|
if (queryParams) {
|
|
url += '?'
|
|
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'PUT',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static unauthorizedPostEmptyResponse = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Access-Control-Allow-Origin': '*'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(data => callback(data))
|
|
.catch(err => errorCallback(err));
|
|
|
|
};
|
|
|
|
static unauthorizedPutEmptyResponse = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'PUT',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Access-Control-Allow-Origin': '*'
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(data => callback(data))
|
|
.catch(err => errorCallback(err));
|
|
|
|
};
|
|
|
|
static unauthorizedGet = (url, queryParams, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'GET',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
}
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.response)
|
|
else
|
|
callback(data.response)
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
|
|
};
|
|
|
|
static unauthorizedPatch = (url, body, callback, errorCallback) => {
|
|
fetch(url, {
|
|
method: 'PATCH',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.response)
|
|
else
|
|
callback(data.response)
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
|
|
};
|
|
|
|
static isNotBlank(value) {
|
|
return value !== null && value !== undefined && value !== ''
|
|
}
|
|
|
|
static get = (url, callback, errorCallback, queryParams = null) => {
|
|
if (queryParams) {
|
|
url += '?'
|
|
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'GET',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
signal: AbortSignal.timeout(5000)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
//console.log('status in fetch:', status)
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response);
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => {
|
|
errorCallback(err)
|
|
});
|
|
|
|
};
|
|
|
|
static getBlob = (url, callback, errorCallback, queryParams) => {
|
|
|
|
if (queryParams) {
|
|
url += '?'
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
if (queryParams[i] && this.isNotBlank(queryParams[i][0]) && this.isNotBlank(queryParams[i][1])) {
|
|
let param = queryParams[i][0] + '=' + queryParams[i][1]
|
|
|
|
if (i !== queryParams.length - 1)
|
|
param += '&'
|
|
|
|
url += param;
|
|
}
|
|
}
|
|
|
|
if (url.charAt(url.length) === '&')
|
|
url = url.substring(0, url.length - 1);
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'GET',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.blob(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
};
|
|
|
|
static promiseGet = async (url, queryParams = null) => {
|
|
const response = await fetch(url, {
|
|
method: 'GET',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
'Access-Control-Allow-Origin': '*'
|
|
}
|
|
});
|
|
|
|
const json = await response.json();
|
|
return json;
|
|
}
|
|
|
|
static deleteEmptyResponse = (url, callback, errorCallback, queryParams = null) => {
|
|
if (queryParams) {
|
|
let params = '?'
|
|
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
params += queryParams[i][0] + '=' + queryParams[i][1]
|
|
if (queryParams.length !== i + 1)
|
|
params += '&'
|
|
url += params
|
|
params = ''
|
|
}
|
|
|
|
}
|
|
|
|
fetch(url, {
|
|
method: 'DELETE',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': storeGet.main.getToken(),
|
|
'Access-Control-Allow-Origin': '*'
|
|
}
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599)
|
|
errorCallback(data.status)
|
|
else
|
|
callback()
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
}
|
|
|
|
static delete = (url, body, callback, errorCallback, queryParams = null) => {
|
|
if (queryParams) {
|
|
let params = '?'
|
|
|
|
for (let i = 0; i < queryParams.length; i++) {
|
|
params += queryParams[i][0] + '=' + queryParams[i][1]
|
|
if (queryParams.length !== i + 1)
|
|
params += '&'
|
|
url += params
|
|
params = ''
|
|
}
|
|
|
|
}
|
|
fetch(url, {
|
|
method: 'DELETE',
|
|
mode: 'cors',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'Bearer ' + storeGet.main.getToken(),
|
|
},
|
|
body: JSON.stringify(body)
|
|
})
|
|
.then(async response => {
|
|
let status = response.status;
|
|
return { response: await response.json(), status: status }
|
|
})
|
|
.then(data => {
|
|
if (data.status >= 400 && data.status <= 599) {
|
|
errorCallback(data.response)
|
|
this.logApiError(url, data.status, data.response);
|
|
} else {
|
|
callback(data.response)
|
|
}
|
|
})
|
|
.catch(err => errorCallback(err));
|
|
|
|
};
|
|
}
|