Source: src/style.js

  1. import fetch from 'node-fetch';
  2. import WorkspaceClient from './workspace.js';
  3. import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
  4. import AboutClient from './about.js'
  6. /**
  7.  * Client for GeoServer styles
  8.  *
  9.  * @module StyleClient
  10.  */
  11. export default class StyleClient {
  12.   /**
  13.    * Creates a GeoServer REST StyleClient instance.
  14.    *
  15.    * @param {String} url The URL of the GeoServer REST API endpoint
  16.    * @param {String} auth The Basic Authentication string
  17.    */
  18.   constructor (url, auth) {
  19.     this.url = url;
  20.     this.auth = auth;
  21.   }
  23.   /**
  24.    * Returns all default styles.
  25.    *
  26.    * @throws Error if request fails
  27.    *
  28.    * @returns {Object} An object with the default styles
  29.    */
  30.   async getDefaults () {
  31.     const response = await fetch(this.url + 'styles.json', {
  32.       credentials: 'include',
  33.       method: 'GET',
  34.       headers: {
  35.         Authorization: this.auth
  36.       }
  37.     });
  39.     if (!response.ok) {
  40.       const geoServerResponse = await getGeoServerResponseText(response);
  41.       throw new GeoServerResponseError(null, geoServerResponse);
  42.     }
  43.     return response.json();
  44.   }
  46.   /**
  47.    * Returns all styles in a workspace.
  48.    *
  49.    * @param {String} workspace Workspace name to get styles for
  50.    *
  51.    * @throws Error if request fails
  52.    *
  53.    * @returns {Object} An object with all styles
  54.    */
  55.   async getInWorkspace (workspace) {
  56.     const response = await fetch(this.url + 'workspaces/' + workspace + '/styles.json', {
  57.       credentials: 'include',
  58.       method: 'GET',
  59.       headers: {
  60.         Authorization: this.auth
  61.       }
  62.     });
  64.     if (!response.ok) {
  65.       const geoServerResponse = await getGeoServerResponseText(response);
  66.       throw new GeoServerResponseError(null, geoServerResponse);
  67.     }
  68.     return response.json();
  69.   }
  71.   /**
  72.    * Returns all styles defined in workspaces.
  73.    *
  74.    * @throws Error if request fails
  75.    *
  76.    * @returns {Object[]} An array with all style objects
  77.    */
  78.   async getAllWorkspaceStyles () {
  79.     const allStyles = [];
  80.     const ws = new WorkspaceClient(this.url, this.auth);
  81.     const allWs = await ws.getAll();
  83.     if (!allWs ||
  84.       !allWs.workspaces ||
  85.       !allWs.workspaces.workspace ||
  86.       !Array.isArray(allWs.workspaces.workspace)) {
  87.       throw new GeoServerResponseError('Response of available workspaces is malformed');
  88.     }
  90.     // go over all workspaces and query the styles for
  91.     for (let i = 0; i < allWs.workspaces.workspace.length; i++) {
  92.       const ws = allWs.workspaces.workspace[i];
  93.       const wsStyles = await this.getInWorkspace(ws.name);
  95.       if (wsStyles.styles.style) {
  96.         wsStyles.styles.style.forEach(wsStyle => {
  97.           allStyles.push(wsStyle);
  98.         });
  99.       }
  100.     }
  102.     return allStyles;
  103.   }
  105.   /**
  106.    * Returns all styles as combined object (default ones and those in
  107.    * workspaces).
  108.    *
  109.    * @returns {Object[]} An array with all style objects
  110.    */
  111.   async getAll () {
  112.     const defaultStyles = await this.getDefaults();
  113.     const wsStyles = await this.getAllWorkspaceStyles();
  114.     if (
  115.       !defaultStyles ||
  116.       !defaultStyles.styles ||
  117.       !defaultStyles.styles.style ||
  118.       !Array.isArray(defaultStyles.styles.style)
  119.     ) {
  120.       throw new GeoServerResponseError('Response of default styles malformed')
  121.     }
  122.     const allStyles = defaultStyles.styles.style.concat(wsStyles);
  124.     return allStyles;
  125.   }
  127.   /**
  128.    * Publishes a new SLD style.
  129.    *
  130.    * @param {String} workspace The workspace to publish the style in
  131.    * @param {String} name Name of the style
  132.    * @param {String} sldBody SLD style (as XML text)
  133.    *
  134.    * @throws Error if request fails
  135.    */
  136.   async publish (workspace, name, sldBody) {
  137.     const response = await fetch(this.url + 'workspaces/' + workspace + '/styles?name=' + name, {
  138.       credentials: 'include',
  139.       method: 'POST',
  140.       headers: {
  141.         Authorization: this.auth,
  142.         'Content-Type': 'application/vnd.ogc.sld+xml'
  143.       },
  144.       body: sldBody
  145.     });
  147.     if (!response.ok) {
  148.       const geoServerResponse = await getGeoServerResponseText(response);
  149.       throw new GeoServerResponseError(null, geoServerResponse);
  150.     }
  151.   }
  153.   /**
  154.    * Deletes a style.
  155.    *
  156.    * @param {String} workspace The name of the workspace, can be undefined if style is not assigned to a workspace
  157.    * @param {String} name The name of the style to delete
  158.    * @param {Boolean} [recurse=false] If references to the specified style in existing layers should be deleted
  159.    * @param {Boolean} [purge=false] Whether the underlying file containing the style should be deleted on disk
  160.    */
  161.   async delete (workspace, name, recurse, purge) {
  162.     let paramPurge = false;
  163.     let paramRecurse = false;
  165.     if (purge === true) {
  166.       paramPurge = true;
  167.     }
  168.     if (recurse === true) {
  169.       paramRecurse = true;
  170.     }
  172.     let endpoint;
  174.     if (workspace) {
  175.       // delete style inside workspace
  176.       endpoint = this.url + 'workspaces/' + workspace + '/styles/' + name +
  177.                   '?' + 'purge=' + paramPurge + '&' + 'recurse=' + paramRecurse;
  178.     } else {
  179.       // delete style without workspace
  180.       endpoint = this.url + 'styles/' + name +
  181.                   '?' + 'purge=' + paramPurge + '&' + 'recurse=' + paramRecurse;
  182.     }
  184.     const response = await fetch(endpoint, {
  185.       credentials: 'include',
  186.       method: 'DELETE',
  187.       headers: {
  188.         Authorization: this.auth
  189.       }
  190.     });
  192.     if (!response.ok) {
  193.       const geoServerResponse = await getGeoServerResponseText(response);
  194.       switch (response.status) {
  195.         case 403:
  196.           throw new GeoServerResponseError(
  197.             'Deletion failed. There might be dependant layers to this style. Delete them first or call this with "recurse=false"',
  198.             geoServerResponse
  199.           );
  200.         default:
  201.           throw new GeoServerResponseError(null, geoServerResponse);
  202.       }
  203.     }
  204.   }
  206.   /**
  207.    * Assigns a style to a layer.
  208.    *
  209.    * @param {String} workspaceOfLayer The name of the layer's workspace, can be undefined
  210.    * @param {String} layerName The name of the layer to query
  211.    * @param {String} workspaceOfStyle The workspace of the style, can be undefined
  212.    * @param {String} styleName The name of the style
  213.    * @param {Boolean} [isDefaultStyle=true] If the style should be the default style of the layer
  214.    *
  215.    * @throws Error if request fails
  216.    */
  217.   async assignStyleToLayer (workspaceOfLayer, layerName, workspaceOfStyle, styleName, isDefaultStyle) {
  218.     let qualifiedName;
  219.     if (workspaceOfLayer) {
  220.       qualifiedName = `${workspaceOfLayer}:${layerName}`;
  221.     } else {
  222.       qualifiedName = layerName;
  223.     }
  224.     const styleBody = await this.getStyleInformation(workspaceOfStyle, styleName);
  226.     let url;
  227.     // we set the style as defaultStyle, unless user explicitly provides 'false'
  228.     if (isDefaultStyle !== false) {
  229.       url = this.url + 'layers/' + qualifiedName + '/styles?default=true';
  230.     } else {
  231.       url = this.url + 'layers/' + qualifiedName + '/styles';
  232.     }
  234.     const response = await fetch(url, {
  235.       credentials: 'include',
  236.       method: 'POST',
  237.       headers: {
  238.         Authorization: this.auth,
  239.         'Content-Type': 'application/json'
  240.       },
  241.       body: JSON.stringify(styleBody)
  242.     });
  244.     if (!response.ok) {
  245.       const geoServerResponse = await getGeoServerResponseText(response);
  246.       throw new GeoServerResponseError(null, geoServerResponse);
  247.     }
  248.   }
  250.   /**
  251.    * Get information about a style.
  252.    *
  253.    * @param {String} workspace The name of the workspace, can be undefined
  254.    * @param {String} styleName The name of the style
  255.    *
  256.    * @throws Error if request fails
  257.    *
  258.    * @returns {Object} An object about the style or undefined if it cannot be found
  259.    */
  260.   async getStyleInformation (workspace, styleName) {
  261.     let url;
  262.     if (workspace) {
  263.       url = this.url + 'workspaces/' + workspace + '/styles/' + styleName + '.json';
  264.     } else {
  265.       url = this.url + 'styles/' + styleName + '.json';
  266.     }
  268.     const response = await fetch(url, {
  269.       credentials: 'include',
  270.       method: 'GET',
  271.       headers: {
  272.         Authorization: this.auth
  273.       }
  274.     });
  276.     if (!response.ok) {
  277.       const grc = new AboutClient(this.url, this.auth);
  278.       if (await grc.exists()) {
  279.         // GeoServer exists, but requested item does not exist,  we return empty
  280.         return;
  281.       } else {
  282.         // There was a general problem with GeoServer
  283.         const geoServerResponse = await getGeoServerResponseText(response);
  284.         throw new GeoServerResponseError(null, geoServerResponse);
  285.       }
  286.     }
  287.     return response.json();
  288.   }
  289. }