@availity/api-axios
Version:
Wrappers for axios designed to work with the Availity portal
1,062 lines (1,034 loc) • 32.8 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
// src/api.js
import qs from "qs";
import resolveUrl from "@availity/resolve-url";
import axios from "axios";
import merge from "lodash/merge";
// src/options.js
var API_OPTIONS = {
API: {
path: "/api",
url: null,
name: null,
version: "/v1",
cache: true,
api: true,
polling: true,
pollingIntervals: [1e3, 2e3, 5e3, 1e4],
pollingMethod: "GET",
headers: {
"X-Response-Encoding-Context": "NONE"
},
sessionBust: true,
withCredentials: true
},
MS: {
path: "/ms/api/availity/internal",
url: null,
name: null,
version: null,
cache: false,
api: true,
polling: false,
pollingIntervals: [1e3, 2e3, 5e3, 1e4],
pollingMethod: "POST",
headers: {
"X-Response-Encoding-Context": "NONE"
},
sessionBust: false,
withCredentials: true
}
};
var options_default = API_OPTIONS;
// src/api.js
var AvApi = class {
constructor(config) {
if (!config) {
throw new Error("[config] must be defined");
}
const _a = config, { http } = _a, options = __objRest(_a, ["http"]);
this.http = http || axios;
this.defaultConfig = merge({}, options_default.API, options);
}
config(config = {}) {
return merge({}, this.defaultConfig, config);
}
addParams(params = {}, config = {}, newObj = true) {
const output = newObj ? __spreadValues({ params: {} }, config) : config;
if (!newObj) {
output.params = output.params || {};
}
output.params = __spreadValues(__spreadValues({}, output.params), params);
return output;
}
cacheParams(config) {
const params = {};
if (config.cacheBust) {
params.cacheBust = this.getCacheBustVal(config.cacheBust, () => Date.now());
}
if (config.pageBust) {
params.pageBust = this.getCacheBustVal(config.pageBust, () => this.getPageBust());
}
if (config.sessionBust) {
params.sessionBust = this.getCacheBustVal(config.sessionBust, () => this.getSessionBust() || this.getPageBust());
}
return this.addParams(params, config, false);
}
getSessionBust() {
return window.localStorage.getItem("avCacheBust");
}
getCacheBustVal(cacheBust, defaultFn) {
if (!cacheBust) {
return void 0;
}
if (typeof cacheBust === "boolean" && defaultFn) {
return defaultFn();
}
if (typeof cacheBust === "function") {
return cacheBust();
}
return cacheBust;
}
getPageBust() {
if (typeof this.pageBustValue === "undefined") {
this.setPageBust();
}
return this.pageBustValue;
}
setPageBust(value) {
this.pageBustValue = typeof value === "undefined" ? Date.now() : value;
}
getUrl(config, id = "") {
if (!config.api) {
return config.url;
}
const { path, version, name, url } = config;
let parts = [];
parts = name ? ["", path, version, name, id] : [url, id];
return parts.join("/").replace(/\/+/g, "/").replace(/\/$/, "");
}
getRequestUrl() {
return this.getUrl(this.config());
}
getLocation(response) {
const { config, headers = {} } = response;
const { getHeader, base } = config;
const { location, Location } = headers;
const locationUrl = getHeader ? getHeader(response, "Location") : location || Location;
return resolveUrl({ relative: locationUrl, base });
}
shouldPoll(response) {
if (!(response == null ? void 0 : response.config))
return false;
const { attempt = 0, polling, pollingIntervals = [] } = response.config;
return polling && response.status === 202 && attempt < pollingIntervals.length;
}
getQueryResultKey(data) {
return Object.keys(data).find((key) => Array.isArray(data[key]));
}
getResult(data) {
return data[this.getQueryResultKey(data)];
}
async request(config, afterResponse) {
if (config.polling) {
config.attempt = config.attempt || 0;
config.attempt += 1;
}
const response = await this.http(config);
return this.onResponse(response, afterResponse);
}
async onResponse(response, afterResponse) {
if (this.shouldPoll(response)) {
const newConfig = this.config(response.config);
const pollingUrl = this.getLocation(response);
if (pollingUrl) {
newConfig.method = this.defaultConfig.pollingMethod;
newConfig.url = pollingUrl;
newConfig.cache = false;
await new Promise((resolve) => {
setTimeout(resolve, newConfig.pollingIntervals[newConfig.attempt] || 1e3);
});
return this.request(newConfig, afterResponse);
}
}
return afterResponse ? afterResponse(response) : response;
}
async sendBeacon(data, config) {
if (!data) {
throw new Error("called method without [data]");
}
config = this.config(config);
config.method = "POST";
config.url = this.getUrl(config);
config.data = data;
const beforeFunc = this.beforeCreate || this.beforePost;
if (beforeFunc) {
config.data = beforeFunc(config.data);
}
if (navigator.sendBeacon) {
const result = navigator.sendBeacon(config.url, new Blob([config.data], {
type: "application/x-www-form-urlencoded"
}));
if (result)
return Promise.resolve();
}
return this.request(config, this.afterCreate || this.afterPost);
}
async create(data, config) {
if (!data) {
throw new Error("called method without [data]");
}
config = this.config(config);
config.method = "POST";
config.url = this.getUrl(config);
config.data = data;
const beforeFunc = this.beforeCreate || this.beforePost;
if (beforeFunc) {
config.data = beforeFunc(config.data);
}
return this.request(config, this.afterCreate || this.afterPost);
}
async post(data, config) {
return this.create(data, config);
}
async postGet(data, config) {
if (!data) {
throw new Error("called method without [data]");
}
config = this.config(config);
config.method = "POST";
config.headers = config.headers || {};
config.headers["X-HTTP-Method-Override"] = "GET";
config.headers["Content-Type"] = config.headers["Content-Type"] || "application/x-www-form-urlencoded";
config.url = this.getUrl(config);
config.data = data;
if (this.beforePostGet) {
config.data = this.beforePostGet(config.data);
}
if (typeof config.data !== "string" && config.headers["Content-Type"] === "application/x-www-form-urlencoded") {
config.data = qs.stringify(config.data, {
encode: false,
arrayFormat: "repeat",
indices: false,
allowDots: true
});
}
return this.request(config, this.afterPostGet);
}
async get(id, config) {
if (!id) {
throw new Error("called method without [id]");
}
config = this.config(config);
config.method = "GET";
config.url = this.getUrl(config, id);
config = this.cacheParams(config);
return this.request(config, this.afterGet);
}
async query(config) {
config = this.config(config);
config.method = "GET";
config.url = this.getUrl(config);
config = this.cacheParams(config);
return this.request(config, this.afterQuery);
}
async getPage(page = 1, config = {}, limit) {
var _a;
limit = limit || ((_a = config.params) == null ? void 0 : _a.limit) || 50;
const offset = (page - 1) * limit;
return this.query(this.addParams({ offset, limit }, config, false));
}
async all(config) {
const response = await this.query(config);
const key = this.getQueryResultKey(response.data);
const totalPages = Math.ceil(response.data.totalCount / response.data.limit);
const result = response.data[key] || [];
if (totalPages > 1) {
const otherPages = [];
for (let i = 0; i < totalPages - 1; i += 1) {
otherPages[i] = i + 2;
}
const pages = await Promise.all(otherPages.map(async (page) => {
const resp = await this.getPage(page, config, response.data.limit);
return resp.data[key] || [];
}));
return [...result, ...pages].flat();
}
return result;
}
async update(id, data, config) {
if (typeof id !== "string" && typeof id !== "number") {
config = data;
data = id;
id = "";
}
config = this.config(config);
config.method = "PUT";
config.url = this.getUrl(config, id);
config.data = data;
const beforeFunc = this.beforeUpdate || this.beforePut;
if (beforeFunc) {
config.data = beforeFunc(config.data);
}
return this.request(config, this.afterUpdate || this.afterPut);
}
async put(...args) {
return this.update(...args);
}
async patch(id, data, config) {
if (typeof id !== "string" && typeof id !== "number") {
config = data;
data = id;
id = "";
}
config = this.config(config);
config.method = "PATCH";
config.url = this.getUrl(config, id);
config.data = data;
const beforeFunc = this.beforePatch;
if (beforeFunc) {
config.data = beforeFunc(config.data);
}
return this.request(config, this.afterPatch);
}
async remove(id, config) {
if (typeof id !== "string" && typeof id !== "number") {
config = id;
id = "";
}
config = this.config(config);
config.method = "DELETE";
config.url = this.getUrl(config, id);
const beforeFunc = this.beforeRemove || this.beforeDelete;
if (beforeFunc) {
config = beforeFunc(config);
}
return this.request(config, this.afterRemove || this.afterDelete);
}
async delete(...args) {
return this.remove(...args);
}
};
// src/ms.js
import merge2 from "lodash/merge";
var AvMicroserviceApi = class extends AvApi {
constructor(config) {
super(config);
const _a = config, { http } = _a, options = __objRest(_a, ["http"]);
this.defaultConfig = merge2({}, options_default.MS, options);
}
getUrl(config, id = "") {
const { path, version, name, id: configId } = this.config(config);
let parts = [path, version || "", name];
if (id || configId) {
parts = [path, version || "", name, id || configId];
}
return parts.join("/").replace(/\/+/g, "/").replace(/\/$/, "");
}
getLocation(response) {
return this.getUrl(response.config);
}
};
// src/proxy.js
var AvProxyApi = class extends AvApi {
constructor(config) {
if (!(config == null ? void 0 : config.tenant)) {
throw new Error("[config.tenant] must be defined");
}
super(__spreadValues({
path: `api/v1/proxy/${config.tenant}`,
version: ""
}, config));
}
};
// src/resources/codes.js
var AvCodesApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
name: "codes"
}, config));
}
};
var avCodesApi = new AvCodesApi();
// src/resources/disclaimers.js
var AvDisclaimersApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "/api/sdk/platform",
name: "/disclaimers"
}, config));
}
async getDisclaimers(id, config) {
const queryConfig = this.addParams({ id }, config);
return this.query(queryConfig);
}
};
var avDisclaimersApi = new AvDisclaimersApi();
// src/resources/files.js
var AvFilesApi = class extends AvMicroserviceApi {
constructor(config) {
super(__spreadValues({
name: "core/vault/upload/v1",
headers: {
"Content-Type": void 0
}
}, config));
}
async uploadFile(data, config) {
if (!config.customerId || !config.clientId) {
throw new Error("[config.customerId] and [config.clientId] must be defined");
}
config = this.config(config);
config.headers["X-Availity-Customer-ID"] = config.customerId;
config.headers["X-Client-ID"] = config.clientId;
return this.create(data, config);
}
};
var avFilesApi = new AvFilesApi();
// src/resources/filesDelivery.js
var AvFilesDeliveryApi = class extends AvMicroserviceApi {
constructor(config) {
super(__spreadValues({
name: "platform/file-upload-delivery/v1/batch/deliveries",
headers: {
"Content-Type": "application/json"
},
polling: true,
pollingMethod: "GET"
}, config));
}
async uploadFilesDelivery(data, config) {
if (!config.customerId || !config.clientId) {
throw new Error("[config.customerId] and [config.clientId] must be defined");
}
config = this.config(config);
config.headers["X-Availity-Customer-ID"] = config.customerId;
config.headers["X-Client-ID"] = config.clientId;
return this.create(data || {}, config);
}
getLocation(response) {
const baseUrl = super.getLocation(response);
return `${baseUrl}/${response.data.id}`;
}
};
var avFilesDeliveryApi = new AvFilesDeliveryApi();
// src/flatten-object.js
var parseValue = (value) => value === void 0 || value === null ? value : value.toString();
var flattenObject = (ob) => Object.keys(ob).reduce((toReturn, k) => {
if (Object.prototype.toString.call(ob[k]) === "[object Date]") {
toReturn[k] = ob[k].toJSON();
} else if (ob[k] && typeof ob[k] === "object") {
const flatObject = flattenObject(ob[k]);
const isArray = Array.isArray(ob[k]);
for (const k2 of Object.keys(flatObject)) {
toReturn[`${k}${isArray ? k2.replace(/^(\d+)(\..*)?/, "[$1]$2") : `.${k2}`}`] = parseValue(flatObject[k2]);
}
} else {
toReturn[k] = parseValue(ob[k]);
}
return toReturn;
}, {});
var flatten_object_default = flattenObject;
// src/resources/logs.js
var AvLogMessagesApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
name: "log-messages"
}, config));
}
send(level, entries) {
delete entries.level;
const payload = { level, entries };
const flattened = flatten_object_default(payload);
flattened.X_Client_ID = this.clientId;
flattened.X_XSRF_TOKEN = document.cookie.replace(/(?:(?:^|.*;\s*)XSRF-TOKEN\s*=\s*([^;]*).*$)|^.*$/, "$1");
const fields = Object.keys(flattened).map((key) => {
const name = key.replace(/\[\d+]/g, "[]");
const value = flattened[key];
return `${name}=${encodeURIComponent(value)}`;
}).join("&");
return fields;
}
async debug(entries) {
return this.sendBeacon(this.send("debug", entries));
}
async info(entries) {
return this.sendBeacon(this.send("info", entries));
}
async warn(entries) {
return this.sendBeacon(this.send("warn", entries));
}
async error(entries) {
return this.sendBeacon(this.send("error", entries));
}
};
var avLogMessagesApi = new AvLogMessagesApi();
// src/resources/dma.js
var AvLogMessagesApiV2 = class extends AvMicroserviceApi {
constructor(config) {
super(__spreadValues({
name: "spc/analytics/log"
}, config));
}
send(level, entries) {
delete entries.level;
const payload = { level, entries };
const flattened = flatten_object_default(payload);
flattened.X_Client_ID = this.clientId;
flattened.X_XSRF_TOKEN = document.cookie.replace(/(?:(?:^|.*;\s*)XSRF-TOKEN\s*=\s*([^;]*).*$)|^.*$/, "$1");
const fields = Object.keys(flattened).map((key) => {
const name = key.replace(/\[\d+]/g, "[]");
const value = flattened[key];
return `${name}=${encodeURIComponent(value)}`;
}).join("&");
return fields;
}
async debug(entries) {
return this.sendBeacon(this.send("debug", entries));
}
async info(entries) {
return this.sendBeacon(this.send("info", entries));
}
async warn(entries) {
return this.sendBeacon(this.send("warn", entries));
}
async error(entries) {
return this.sendBeacon(this.send("error", entries));
}
};
var avLogMessagesApiV2 = new AvLogMessagesApiV2();
// src/resources/navigation.js
var AvNavigationApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "navigation/spaces"
}, config));
}
};
var avNavigationApi = new AvNavigationApi();
// src/resources/notifications.js
var AvNotificationsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api",
name: "notifications"
}, config));
}
async deleteByTopic(topic, config) {
const removeConfig = this.addParams({ topicId: topic }, config);
return this.remove(removeConfig);
}
};
var avNotificationsApi = new AvNotificationsApi();
// src/resources/organizations.js
import qs3 from "qs";
// src/resources/user.js
var AvUserApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "users"
}, config));
}
async me(config) {
const response = await this.get("me", config);
return response.data;
}
};
var avUserApi = new AvUserApi();
// src/resources/userPermissions.js
import qs2 from "qs";
var AvUserPermissionsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/internal",
name: "axi-user-permissions",
paramsSerializer: (params) => qs2.stringify(params, { arrayFormat: "repeat" })
}, config));
}
afterQuery(response) {
var _a;
return ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.axiUserPermissions) || [];
}
async getPermissions(permissionId, region) {
return this.query({
params: { permissionId, region }
});
}
};
var avUserPermissionsApi = new AvUserPermissionsApi();
// src/resources/organizations.js
var AvOrganizationsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "organizations"
}, config));
}
previousPermissionIds = [];
previousRegionId = "";
userPermissions = [];
async queryOrganizations(user, config) {
const queryConfig = this.addParams({ userId: user.id }, config);
return this.query(queryConfig);
}
async getOrganizations(config) {
var _a;
if ((_a = config == null ? void 0 : config.params) == null ? void 0 : _a.userId) {
return this.query(config);
}
const user = await avUserApi.me();
return this.queryOrganizations(user, config);
}
async postGet(data, config, additionalPostGetArgs) {
if (additionalPostGetArgs) {
this.region = void 0;
const { permissionIds } = additionalPostGetArgs;
if (typeof data === "string") {
const dataTemp = qs3.parse(data);
const { region } = dataTemp;
if (region) {
this.region = region;
delete dataTemp.region;
}
if (permissionIds) {
dataTemp.permissionId = permissionIds;
}
data = qs3.stringify(dataTemp, { arrayFormat: "repeat" });
} else if (typeof data === "object") {
const { region } = data;
if (region) {
this.region = region;
delete data.region;
}
if (permissionIds) {
data.permissionId = permissionIds;
}
}
const { data: organizationsData } = await super.postGet(data, config);
const { organizations, limit, offset, totalCount } = organizationsData;
const authorizedOrgs = await this.getFilteredOrganizations(additionalPostGetArgs, data);
const authorizedFilteredOrgs = organizations.filter((org) => authorizedOrgs.some((authOrg) => authOrg.id === org.id));
return {
data: {
authorizedFilteredOrgs,
totalCount,
limit,
offset
}
};
}
return super.postGet(data, config);
}
async getFilteredOrganizations(additionalPostGetArgs, data) {
const { resourceIds = [], permissionIds } = additionalPostGetArgs;
if (typeof data === "string") {
data = qs3.parse(data);
}
const { permissionId } = data;
let permissionIdsToUse = permissionIds || permissionId;
permissionIdsToUse = this.sanitizeIds(permissionIdsToUse);
const resourceIdsToUse = this.sanitizeIds(resourceIds);
const resourceIdsArray = Array.isArray(resourceIdsToUse) ? resourceIdsToUse : [resourceIdsToUse];
const permissionIdsOR = Array.isArray(permissionIdsToUse) ? permissionIdsToUse : [permissionIdsToUse];
if (this.region !== this.previousRegionId || !this.arePermissionsEqual(permissionIdsOR)) {
const {
data: { axiUserPermissions: userPermissions }
} = await avUserPermissionsApi.postGet({
permissionId: permissionIdsOR,
region: this.region
});
if (userPermissions) {
this.userPermissions = userPermissions.reduce((accum, cur) => {
accum[cur.id] = cur;
return accum;
}, {});
this.previousPermissionIds = permissionIdsOR;
this.previousRegionId = this.region;
} else {
throw new Error("avUserPermissions call failed");
}
}
const authorizedOrgs = permissionIdsOR.reduce((accum, permissionIdOR) => {
if (Array.isArray(permissionIdOR)) {
const matchedOrgs = permissionIdOR.reduce((matchedANDOrgsByPerm, permissionIdAND, index) => {
if (this.userPermissions[permissionIdAND]) {
for (const org of this.userPermissions[permissionIdAND].organizations) {
if (index === 0) {
matchedANDOrgsByPerm[org.id] = org;
} else if (matchedANDOrgsByPerm[org.id]) {
matchedANDOrgsByPerm[org.id].resources = [...matchedANDOrgsByPerm[org.id].resources, ...org.resources];
}
}
}
matchedANDOrgsByPerm = Object.keys(matchedANDOrgsByPerm).filter((orgId) => {
if (this.userPermissions[permissionIdAND]) {
return this.userPermissions[permissionIdAND].organizations.some((org) => org.id === orgId);
}
return false;
}).reduce((obj, orgId) => {
obj[orgId] = matchedANDOrgsByPerm[orgId];
return obj;
}, {});
return matchedANDOrgsByPerm;
}, {});
for (const orgId of Object.keys(matchedOrgs)) {
if (!accum[orgId]) {
accum[orgId] = matchedOrgs[orgId];
accum[orgId].match = false;
} else {
accum[orgId].resources = [...accum[orgId].resources, ...matchedOrgs[orgId].resources];
}
}
} else if (this.userPermissions[permissionIdOR]) {
for (const org of this.userPermissions[permissionIdOR].organizations) {
if (!accum[org.id]) {
accum[org.id] = org;
accum[org.id].match = false;
} else {
accum[org.id].resources = [...accum[org.id].resources, ...org.resources];
}
}
}
return accum;
}, {});
if (resourceIdsArray.length === 0) {
for (const orgId of Object.keys(authorizedOrgs)) {
authorizedOrgs[orgId].match = true;
}
} else {
resourceIdsArray.forEach((resourceIdOR) => {
if (Array.isArray(resourceIdOR)) {
for (const orgId of Object.keys(authorizedOrgs)) {
if (authorizedOrgs[orgId]) {
const isMatch = resourceIdOR.every((resId) => authorizedOrgs[orgId].resources.some((res) => res.id === resId));
if (isMatch) {
authorizedOrgs[orgId].match = true;
}
}
}
} else {
for (const orgId of Object.keys(authorizedOrgs)) {
const isMatch = authorizedOrgs[orgId].resources.some((res) => res.id === resourceIdOR);
if (isMatch || !resourceIdOR) {
authorizedOrgs[orgId].match = true;
}
}
}
});
}
return Object.keys(authorizedOrgs).reduce((accum, orgId) => {
if (authorizedOrgs[orgId].match) {
accum.push(authorizedOrgs[orgId]);
}
return accum;
}, []);
}
arePermissionsEqual(permissionId) {
const permissionArray = [];
if (typeof permissionId === "string" || typeof permissionId === "number") {
permissionArray.push(permissionId);
} else if (Array.isArray(permissionId)) {
for (const permissionOR of permissionId) {
if (Array.isArray(permissionOR)) {
for (const permissionAND of permissionOR) {
permissionArray.push(permissionAND);
}
} else {
permissionArray.push(permissionOR);
}
}
}
const prevPermissionArray = [];
if (typeof this.previousPermissionIds === "string" || typeof this.previousPermissionIds === "number") {
prevPermissionArray.push(this.previousPermissionIds);
} else if (Array.isArray(this.previousPermissionIds)) {
for (const permissionOR of this.previousPermissionIds) {
if (Array.isArray(permissionOR)) {
for (const permissionAND of permissionOR) {
prevPermissionArray.push(permissionAND);
}
} else {
prevPermissionArray.push(permissionOR);
}
}
}
const idSet = /* @__PURE__ */ new Set([...permissionArray]);
const idSetPrev = /* @__PURE__ */ new Set([...prevPermissionArray]);
const idSetCombined = /* @__PURE__ */ new Set([...permissionArray, ...prevPermissionArray]);
return idSet.size === idSetPrev.size && idSet.size === idSetCombined.size;
}
sanitizeIds(unsanitized) {
if (typeof unsanitized === "string") {
return unsanitized;
}
if (typeof unsanitized === "number") {
return `${unsanitized}`;
}
if (Array.isArray(unsanitized)) {
return unsanitized.map((dirty) => this.sanitizeIds(dirty));
}
throw new TypeError("permission/resourcesId(s) must be either an array of ids, a string, or a number");
}
};
var avOrganizationsApi = new AvOrganizationsApi();
// src/resources/pdf.js
var AvPdfApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/utils",
name: "pdfs"
}, config));
}
onPdf(response) {
window.location = response.data.links.pdf.href;
}
async getPdf(data, config) {
if (!data.applicationId || !data.fileName || !data.html) {
throw new Error("[applicationId], [fileName] and [html] must be defined");
}
const response = await this.post(data, config);
this.onPdf(response);
return response;
}
};
var avPdfApi = new AvPdfApi();
// src/resources/permissions.js
var AvPermissionsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "permissions"
}, config));
}
async getPermissions(id, region) {
return this.query({
params: { id, region }
});
}
};
var avPermissionsApi = new AvPermissionsApi();
// src/resources/providers.js
var AvProvidersApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/internal",
name: "providers"
}, config));
}
async getProviders(customerId, config) {
const queryConfig = this.addParams({ customerId }, config);
return this.query(queryConfig);
}
normalize(providers) {
const cloned = [...providers];
for (const provider of cloned) {
provider.name = provider.businessName ? provider.businessName : `${provider.lastName}, ${provider.firstName}`;
}
return cloned;
}
};
var avProvidersApi = new AvProvidersApi();
// src/resources/regions.js
var AvRegionsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "regions",
sessionBust: false,
pageBust: true
}, config));
}
afterUpdate(response) {
this.setPageBust();
return response;
}
async getRegions(config) {
var _a;
if ((_a = config == null ? void 0 : config.params) == null ? void 0 : _a.userId) {
return this.query(config);
}
const user = await avUserApi.me();
const queryConfig = this.addParams({ userId: user.id }, config);
return this.query(queryConfig);
}
async getCurrentRegion() {
return this.query({
params: {
currentlySelected: true
}
});
}
};
var avRegionsApi = new AvRegionsApi();
// src/resources/settings.js
var AvSettingsApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/utils",
name: "settings",
sessionBust: false,
pageBust: true
}, config));
}
async getApplication(applicationId, config) {
var _a;
if (!applicationId) {
throw new Error("[applicationId] must be defined");
}
if ((_a = config == null ? void 0 : config.params) == null ? void 0 : _a.userId) {
const queryConfig2 = this.addParams({ applicationId }, config);
return this.query(queryConfig2);
}
const user = await avUserApi.me();
const queryConfig = this.addParams({ applicationId, userId: user.id }, config);
return this.query(queryConfig);
}
async setApplication(applicationId, data, config) {
var _a, _b;
if (typeof applicationId !== "string" && typeof applicationId !== "number") {
config = data;
data = applicationId;
applicationId = "";
}
if (!applicationId && !((_a = data == null ? void 0 : data.scope) == null ? void 0 : _a.applicationId)) {
throw new Error("[applicationId] must be defined");
}
if ((_b = data == null ? void 0 : data.scope) == null ? void 0 : _b.userId) {
data.scope.applicationId = applicationId;
return this.update(data, config);
}
const user = await avUserApi.me();
data = data || {};
data.scope = data.scope || {};
data.scope.applicationId = applicationId;
data.scope.userId = user.id;
return this.update(data, config);
}
};
var avSettingsApi = new AvSettingsApi();
// src/resources/slotmachine.js
var AvSlotMachineApi = class extends AvMicroserviceApi {
constructor(config) {
super(__spreadValues({
name: "spc/slotmachine/graphql"
}, config));
}
query(data, variables) {
return this.create({ query: data, variables });
}
};
var avSlotMachineApi = new AvSlotMachineApi();
// src/resources/spaces.js
var AvSpacesApi = class extends AvApi {
constructor(config) {
super(__spreadValues({
path: "api/sdk/platform",
name: "spaces"
}, config));
}
parseSpaceId(query) {
const pairs = query.substr(1).split("&");
let spaceId = "";
if (Array.isArray(pairs)) {
for (const item of pairs) {
const pair = item.split("=");
const key = pair[0];
if (key === "spaceId") {
spaceId = pair[1] && decodeURIComponent(pair[1]);
}
}
}
return spaceId;
}
async getSpaceName(spaceId) {
if (!spaceId) {
throw new Error("[spaceId] must be defined");
}
const response = await this.get(spaceId);
return response.data.name;
}
};
var avSpacesApi = new AvSpacesApi();
// src/resources/webQL.js
var AvWebQLApi = class extends AvMicroserviceApi {
constructor(config) {
super(__spreadValues({
name: "spc/web/graphql"
}, config));
}
};
var avWebQLApi = new AvWebQLApi();
// src/index.js
var src_default = AvApi;
export {
AvCodesApi,
AvDisclaimersApi,
AvFilesApi,
AvFilesDeliveryApi,
AvLogMessagesApi,
AvLogMessagesApiV2,
AvMicroserviceApi,
AvNavigationApi,
AvNotificationsApi,
AvOrganizationsApi,
AvPdfApi,
AvPermissionsApi,
AvProvidersApi,
AvProxyApi,
AvRegionsApi,
AvSettingsApi,
AvSlotMachineApi,
AvSpacesApi,
AvUserApi,
AvUserPermissionsApi,
AvWebQLApi,
avCodesApi,
avDisclaimersApi,
avFilesApi,
avFilesDeliveryApi,
avLogMessagesApi,
avLogMessagesApiV2,
avNavigationApi,
avNotificationsApi,
avOrganizationsApi,
avPdfApi,
avPermissionsApi,
avProvidersApi,
avRegionsApi,
avSettingsApi,
avSlotMachineApi,
avSpacesApi,
avUserApi,
avUserPermissionsApi,
avWebQLApi,
src_default as default
};