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