koha-tmpl/intranet-tmpl/prog/js/vue/fetch.js

   1 import { setError } from "./messages";
   2
   3 export const fetchAgreement = async function (agreement_id) {
   4     if (!agreement_id) return;
   5     const apiUrl = "/api/v1/erm/agreements/" + agreement_id;
   6     let agreement;
   7     await fetch(apiUrl, {
   8         headers: {
   9             "x-koha-embed":
  10                 "periods,user_roles,user_roles.patron,agreement_licenses,agreement_licenses.license,agreement_relationships,agreement_relationships.related_agreement,documents,agreement_packages,agreement_packages.package,vendor",
  11         },
  12     })
  13         .then(checkError)
  14         .then(
  15             (result) => {
  16                 agreement = result;
  17             },
  18             (error) => {
  19                 setError(error);
  20             }
  21         );
  22     return agreement;
  23 };
  24
  25 export const fetchAgreements = async function () {
  26     const apiUrl = "/api/v1/erm/agreements";
  27     let agreements;
  28     await fetch(apiUrl)
  29         .then(checkError)
  30         .then(
  31             (result) => {
  32                 agreements = result;
  33             },
  34             (error) => {
  35                 setError(error);
  36             }
  37         );
  38     return agreements;
  39 };
  40
  41 export const fetchLicense = async function (license_id) {
  42     if (!license_id) return;
  43     const apiUrl = "/api/v1/erm/licenses/" + license_id;
  44     let license;
  45     await fetch(apiUrl, {
  46         headers: {
  47             "x-koha-embed": "vendor",
  48         },
  49     })
  50         .then(checkError)
  51         .then(
  52             (result) => {
  53                 license = result;
  54             },
  55             (error) => {
  56                 setError(error);
  57             }
  58         );
  59     return license;
  60 };
  61
  62 export const fetchLicenses = async function () {
  63     const apiUrl = "/api/v1/erm/licenses";
  64     let licenses;
  65     await fetch(apiUrl, {
  66         headers: {
  67             "x-koha-embed": "vendor.name",
  68         },
  69     })
  70         .then(checkError)
  71         .then(
  72             (result) => {
  73                 licenses = result;
  74             },
  75             (error) => {
  76                 setError(error);
  77             }
  78         );
  79     return licenses;
  80 };
  81
  82 export const fetchPatron = async function (patron_id) {
  83     if (!patron_id) return;
  84     const apiUrl = "/api/v1/patrons/" + patron_id;
  85     let patron;
  86     await fetch(apiUrl)
  87         .then(checkError)
  88         .then(
  89             (result) => {
  90                 patron = result;
  91             },
  92             (error) => {
  93                 setError(error);
  94             }
  95         );
  96     return patron;
  97 };
  98
  99 export const fetchVendors = async function () {
 100     const apiUrl = "/api/v1/acquisitions/vendors";
 101     let vendors;
 102     await fetch(apiUrl)
 103         .then(checkError)
 104         .then(
 105             (result) => {
 106                 vendors = result;
 107             },
 108             (error) => {
 109                 setError(error);
 110             }
 111         );
 112     return vendors;
 113 };
 114
 115 const _createEditPackage = async function (method, erm_package) {
 116     let apiUrl = "/api/v1/erm/eholdings/local/packages";
 117
 118     if (method == "PUT") {
 119         apiUrl += "/" + erm_package.package_id;
 120     }
 121     delete erm_package.package_id;
 122     delete erm_package.resources;
 123     delete erm_package.vendor;
 124     delete erm_package.resources_count;
 125     delete erm_package.is_selected;
 126
 127     erm_package.package_agreements = erm_package.package_agreements.map(
 128         ({ package_id, agreement, ...keepAttrs }) => keepAttrs
 129     );
 130
 131     const options = {
 132         method: method,
 133         body: JSON.stringify(erm_package),
 134         headers: {
 135             "Content-Type": "application/json;charset=utf-8",
 136         },
 137     };
 138
 139     let r;
 140     await fetch(apiUrl, options)
 141         .then(
 142             (response) => {
 143                 r = response;
 144             },
 145             (error) => {
 146                 setError(error);
 147             }
 148         )
 149         .catch((e) => {
 150             console.log(e);
 151         });
 152     return r;
 153 };
 154
 155 export const createPackage = function (erm_package) {
 156     return _createEditPackage("POST", erm_package);
 157 };
 158 export const editPackage = function (erm_package) {
 159     return _createEditPackage("PUT", erm_package);
 160 };
 161
 162 const _fetchPackage = async function (apiUrl, package_id) {
 163     if (!package_id) return;
 164     let erm_package;
 165     await fetch(apiUrl, {
 166         headers: {
 167             "x-koha-embed":
 168                 "package_agreements,package_agreements.agreement,resources+count,vendor",
 169         },
 170     })
 171         .then(checkError)
 172         .then(
 173             (result) => {
 174                 erm_package = result;
 175             },
 176             (error) => {
 177                 setError(error);
 178             }
 179         );
 180     return erm_package;
 181 };
 182 export const fetchLocalPackage = function (package_id) {
 183     const apiUrl = "/api/v1/erm/eholdings/local/packages/" + package_id;
 184     return _fetchPackage(apiUrl, package_id);
 185 };
 186 export const fetchEBSCOPackage = function (package_id) {
 187     const apiUrl = "/api/v1/erm/eholdings/ebsco/packages/" + package_id;
 188     return _fetchPackage(apiUrl, package_id);
 189 };
 190
 191 export const _fetchPackages = async function (apiUrl) {
 192     let packages;
 193     await fetch(apiUrl, {
 194         headers: {
 195             "x-koha-embed": "resources+count,vendor.name",
 196         },
 197     })
 198         .then(checkError)
 199         .then(
 200             (result) => {
 201                 packages = result;
 202             },
 203             (error) => {
 204                 setError(error);
 205             }
 206         );
 207     return packages;
 208 };
 209 export const fetchLocalPackages = function () {
 210     const apiUrl = "/api/v1/erm/eholdings/local/packages";
 211     return _fetchPackages(apiUrl);
 212 };
 213 export const fetchEBSCOPackages = function () {
 214     const apiUrl = "/api/v1/erm/eholdings/ebsco/packages";
 215     return _fetchPackages(apiUrl);
 216 };
 217
 218 export const fetchCountLocalPackages = async function (filters) {
 219     const q = {
 220         "me.name": { like: "%" + filters.package_name + "%" },
 221         ...(filters.content_type
 222             ? { "me.content_type": filters.content_type }
 223             : {}),
 224     };
 225
 226     const params = {
 227         _page: 1,
 228         _per_page: 1,
 229         q: JSON.stringify(q),
 230     };
 231     let count_local_packages;
 232     var apiUrl = "/api/v1/erm/eholdings/local/packages";
 233     await fetch(apiUrl + "?" + new URLSearchParams(params))
 234         //.then(checkError)
 235         .then(
 236             (response) =>
 237                 (count_local_packages = response.headers.get("X-Total-Count"))
 238         );
 239     return count_local_packages;
 240 };
 241
 242 export const _fetchTitle = async function (apiUrl, title_id) {
 243     if (!title_id) return;
 244     let title;
 245     await fetch(apiUrl, {
 246         headers: {
 247             "x-koha-embed": "resources,resources.package",
 248         },
 249     })
 250         .then(checkError)
 251         .then(
 252             (result) => {
 253                 title = result;
 254             },
 255             (error) => {
 256                 setError(error);
 257             }
 258         );
 259     return title;
 260 };
 261 export const fetchLocalTitle = function (title_id) {
 262     const apiUrl = "/api/v1/erm/eholdings/local/titles/" + title_id;
 263     return _fetchTitle(apiUrl, title_id);
 264 };
 265 export const fetchEBSCOTitle = function (title_id) {
 266     const apiUrl = "/api/v1/erm/eholdings/ebsco/titles/" + title_id;
 267     return _fetchTitle(apiUrl, title_id);
 268 };
 269
 270 export const _fetchTitles = async function (apiUrl) {
 271     let titles;
 272     await fetch(apiUrl)
 273         .then(checkError)
 274         .then(
 275             (result) => {
 276                 titles = result;
 277             },
 278             (error) => {
 279                 setError(error);
 280             }
 281         );
 282     return titles;
 283 };
 284 export const fetchLocalTitles = function () {
 285     const apiUrl = "/api/v1/erm/eholdings/local/titles";
 286     return _fetchTitles(apiUrl);
 287 };
 288 export const fetchEBSCOTitles = function () {
 289     const apiUrl = "/api/v1/erm/eholdings/ebsco/titles";
 290     return _fetchTitles(apiUrl);
 291 };
 292
 293 export const fetchCountLocalTitles = async function (filters) {
 294     const q = {
 295         "me.publication_title": {
 296             like: "%" + filters.publication_title + "%",
 297         },
 298         ...(filters.publication_type
 299             ? { "me.publication_type": filters.publication_type }
 300             : {}),
 301     };
 302     const params = {
 303         _page: 1,
 304         _per_page: 1,
 305         q: JSON.stringify(q),
 306     };
 307     let count_local_titles;
 308     var apiUrl = "/api/v1/erm/eholdings/local/titles";
 309     await fetch(apiUrl + "?" + new URLSearchParams(params))
 310         //.then(checkError)
 311         .then(
 312             (response) =>
 313                 (count_local_titles = response.headers.get("X-Total-Count"))
 314         );
 315     return count_local_titles;
 316 };
 317
 318 export const _fetchResource = async function (apiUrl, resource_id) {
 319     if (!resource_id) return;
 320     let resource;
 321     await fetch(apiUrl, {
 322         headers: {
 323             "x-koha-embed": "title,package,vendor",
 324         },
 325     })
 326         .then(checkError)
 327         .then(
 328             (result) => {
 329                 resource = result;
 330             },
 331             (error) => {
 332                 setError(error);
 333             }
 334         );
 335     return resource;
 336 };
 337 export const fetchLocalResource = function (resource_id) {
 338     const apiUrl = "/api/v1/erm/eholdings/local/resources/" + resource_id;
 339     return _fetchResource(apiUrl, resource_id);
 340 };
 341 export const fetchEBSCOResource = function (resource_id) {
 342     const apiUrl = "/api/v1/erm/eholdings/ebsco/resources/" + resource_id;
 343     return _fetchResource(apiUrl, resource_id);
 344 };
 345
 346 export const _fetchResources = async function (apiUrl) {
 347     let resources;
 348     await fetch(apiUrl)
 349         .then(checkError)
 350         .then(
 351             (result) => {
 352                 resources = result;
 353             },
 354             (error) => {
 355                 setError(error);
 356             }
 357         );
 358     return resources;
 359 };
 360
 361 export const fetchLocalResources = function () {
 362     const apiUrl = "/api/v1/erm/eholdings/local/resources";
 363     return _fetchResources(apiUrl);
 364 };
 365 export const fetchEBSCOResources = function () {
 366     const apiUrl = "/api/v1/erm/eholdings/ebsco/resources";
 367     return _fetchResources(apiUrl);
 368 };
 369
 370 function checkError(response) {
 371     if (response.status >= 200 && response.status <= 299) {
 372         return response.json();
 373     } else {
 374         console.log("Server returned an error:");
 375         console.log(response);
 376         setError("%s (%s)".format(response.statusText, response.status));
 377     }
 378 }