@eeacms/volto-cca-policy 0.3.120 → 0.3.122

package/CHANGELOG.md

@@ -4,6 +4,39 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+### [0.3.122](https://github.com/eea/volto-cca-policy/compare/0.3.121...0.3.122) - 8 May 2026
+
+#### :bug: Bug Fixes
+
+- fix: add image fallback & improvements in RSS middleware [kreafox - [`6e6091a`](https://github.com/eea/volto-cca-policy/commit/6e6091a2e72c53fd37489fc959f5c1083e99c84e)]
+
+#### :house: Internal changes
+
+- style: Automated code fix [eea-jenkins - [`278f8b4`](https://github.com/eea/volto-cca-policy/commit/278f8b49ae0c56ce7a705a2eea8a6ff3373e6dff)]
+
+#### :house: Documentation changes
+
+- docs: update README.md [kreafox - [`5d810e1`](https://github.com/eea/volto-cca-policy/commit/5d810e1385c22d481fd14977c8c69dcecd16f70e)]
+
+### [0.3.121](https://github.com/eea/volto-cca-policy/compare/0.3.120...0.3.121) - 7 May 2026
+
+#### :rocket: New Features
+
+- feat: improve RSSFeedView [kreafox - [`a425682`](https://github.com/eea/volto-cca-policy/commit/a4256825ede073eda95707f9e09916177b426716)]
+- feat: add original file of RSSFeedView.jsx [kreafox - [`581a27f`](https://github.com/eea/volto-cca-policy/commit/581a27fd79191d6df70f94163cb511397b4445d9)]
+- feat: add volto-rss-provider dependency to package.json [kreafox - [`218c1da`](https://github.com/eea/volto-cca-policy/commit/218c1da54e019bee346535c893131e07b0bcba64)]
+- feat: sort_order handling in volto-rss-provider middleware [kreafox - [`bc6cf86`](https://github.com/eea/volto-cca-policy/commit/bc6cf86696b4798b9939e0615f3025dfe1ac742a)]
+- feat: add original file of volto-rss-provider middleware [kreafox - [`ddf4e22`](https://github.com/eea/volto-cca-policy/commit/ddf4e2256f8e75a8944fa416e07722ecd963907b)]
+
+#### :bug: Bug Fixes
+
+- fix(eslint): remove unused import and clean up useClipboard [kreafox - [`9abda41`](https://github.com/eea/volto-cca-policy/commit/9abda419ff91c3344b113dd2a8289d23f3512520)]
+- fix: remove unused import [kreafox - [`597075d`](https://github.com/eea/volto-cca-policy/commit/597075d0dde7dfe2b8ec9fe9edb0de08503e1ad6)]
+
+#### :nail_care: Enhancements
+
+- refactor: RSSFeedView [kreafox - [`a32e7ff`](https://github.com/eea/volto-cca-policy/commit/a32e7ff7c8dba96a8ab7b87f219b6f3988072b5e)]
+
 ### [0.3.120](https://github.com/eea/volto-cca-policy/compare/0.3.119...0.3.120) - 30 April 2026
 
 #### :bug: Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eeacms/volto-cca-policy",
-  "version": "0.3.120",
+  "version": "0.3.122",
   "description": "@eeacms/volto-cca-policy: Volto add-on",
   "main": "src/index.js",
   "author": "European Environment Agency: IDM2 A-Team",
@@ -41,6 +41,7 @@
     "@eeacms/volto-tabs-block": "^9.0.3",
     "@elastic/search-ui": "1.21.2",
     "@plone-collective/volto-authomatic": "2.0.1",
+    "@plone-collective/volto-rss-provider": "1.0.1",
     "@tanstack/react-table": "8.19.3",
     "d3-array": "^2.12.1",
     "jotai": "^1.6.0",

package/src/customizations/@plone-collective/volto-rss-provider/README.md

@@ -0,0 +1,5 @@
+## RSS middleware customization
+
+This customization patches the `volto-rss-provider` middleware to correctly handle reversed sorting in RSS Listing block queries.
+
+It also fixes image handling so items with small lead images or missing `preview` scales do not break the entire feed; those items remain in the RSS output, but their image enclosure is skipped.

package/src/customizations/@plone-collective/volto-rss-provider/components/RSSFeedView.jsx

@@ -0,0 +1,192 @@
+/**
+ * Document view component.
+ * @module components/theme/View/DefaultView
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import { isEqual } from 'lodash';
+import { compose } from 'redux';
+import { useDispatch, useSelector } from 'react-redux';
+import { defineMessages, injectIntl } from 'react-intl';
+import {
+  Container as SemanticContainer,
+  Segment,
+  Button,
+  Grid,
+  Label,
+  Icon,
+} from 'semantic-ui-react';
+import config from '@plone/volto/registry';
+import { getSchema } from '@plone/volto/actions';
+import { getWidget } from '@plone/volto/helpers/Widget/utils';
+import RenderBlocks from '@plone/volto/components/theme/View/RenderBlocks';
+import useClipboard from '@plone/volto/hooks/clipboard/useClipboard';
+import {
+  hasBlocksData,
+  getBaseUrl,
+  addAppURL,
+  Helmet,
+} from '@plone/volto/helpers';
+
+const messages = defineMessages({
+  rssFeed: {
+    id: 'rssFeed',
+    defaultMessage: 'RSS Feed',
+  },
+});
+
+/**
+ * Component to display the default view.
+ * @function DefaultView
+ * @param {Object} content Content object.
+ * @returns {string} Markup of the component.
+ */
+const DefaultView = (props) => {
+  const dispatch = useDispatch();
+  const { content, location } = props;
+  const { views } = config.widgets;
+  const path = getBaseUrl(location?.pathname || '');
+  const contentSchema = useSelector((state) => state.schema?.schema);
+  const [visible, setVisible] = React.useState(false);
+  const [, copy] = useClipboard(`${addAppURL(path)}/rss.xml`);
+  const fieldsetsToExclude = [
+    'categorization',
+    'dates',
+    'ownership',
+    'settings',
+  ];
+  const fieldsets = contentSchema?.fieldsets.filter(
+    (fs) => !fieldsetsToExclude.includes(fs.id),
+  );
+
+  // TL;DR: There is a flash of the non block-based view because of the reset
+  // of the content on route change. Subscribing to the content change at this
+  // level has nasty implications, so we can't watch the Redux state for loaded
+  // content flag here (because it forces an additional component update)
+  // Instead, we can watch if the content is "empty", but this has a drawback
+  // since the locking mechanism inserts a `lock` key before the content is there.
+  // So "empty" means `content` is present, but only with a `lock` key, thus the next
+  // ugly condition comes to life
+  const contentLoaded = content && !isEqual(Object.keys(content), ['lock']);
+
+  React.useEffect(() => {
+    content?.['@type'] &&
+      !hasBlocksData(content) &&
+      dispatch(getSchema(content['@type'], location.pathname));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const Container =
+    config.getComponent({ name: 'Container' }).component || SemanticContainer;
+
+  // If the content is not yet loaded, then do not show anything
+  return contentLoaded ? (
+    hasBlocksData(content) ? (
+      <Container id="page-document">
+        <Helmet
+          link={[
+            {
+              rel: 'alternate',
+              title: props.intl.formatMessage(messages.rssFeed),
+              href: `${addAppURL(path)}/rss.xml`,
+              type: 'application/rss+xml',
+            },
+          ]}
+        />
+        <Segment>
+          <Button
+            primary
+            onClick={() => {
+              copy();
+              setVisible(true);
+            }}
+          >
+            <Icon className="ri-rss-fill" />
+            RSS Feed
+          </Button>
+          {visible && (
+            <p>
+              Copied! The RSS link is{' '}
+              <a
+                href={`${addAppURL(path)}/rss.xml`}
+                target="_blank"
+                rel="noopener"
+              >
+                {' '}
+                {`${addAppURL(path)}/rss.xml`}
+              </a>
+            </p>
+          )}
+          <div style={{ marginTop: '2em' }}>
+            <RenderBlocks {...props} path={path} />
+          </div>
+        </Segment>
+      </Container>
+    ) : (
+      <Container id="page-document">
+        {fieldsets?.map((fs) => {
+          return (
+            <div className="fieldset" key={fs.id}>
+              {fs.id !== 'default' && <h2>{fs.title}</h2>}
+              {fs.fields?.map((f, key) => {
+                let field = {
+                  ...contentSchema?.properties[f],
+                  id: f,
+                  widget: getWidget(f, contentSchema?.properties[f]),
+                };
+                let Widget = views?.getWidget(field);
+                return f !== 'title' ? (
+                  <Grid celled="internally" key={key}>
+                    <Grid.Row>
+                      <Label title={field.id}>{field.title}:</Label>
+                    </Grid.Row>
+                    <Grid.Row>
+                      <Segment basic>
+                        <Widget value={content[f]} />
+                      </Segment>
+                    </Grid.Row>
+                  </Grid>
+                ) : (
+                  <Widget key={key} value={content[f]} />
+                );
+              })}
+            </div>
+          );
+        })}
+      </Container>
+    )
+  ) : null;
+};
+
+/**
+ * Property types.
+ * @property {Object} propTypes Property types.
+ * @static
+ */
+DefaultView.propTypes = {
+  /**
+   * Content of the object
+   */
+  content: PropTypes.shape({
+    /**
+     * Title of the object
+     */
+    title: PropTypes.string,
+    /**
+     * Description of the object
+     */
+    description: PropTypes.string,
+    /**
+     * Text of the object
+     */
+    text: PropTypes.shape({
+      /**
+       * Data of the text of the object
+       */
+      data: PropTypes.string,
+    }),
+  }).isRequired,
+};
+
+export default compose(injectIntl)(DefaultView);

package/src/customizations/@plone-collective/volto-rss-provider/express-middleware.js

@@ -0,0 +1,311 @@
+import express from 'express';
+import superagent from 'superagent';
+import RSS from 'rss';
+import { findBlocks } from '@plone/volto/helpers';
+import config from '@plone/volto/registry';
+
+/**
+ * Retrieves the query data (search criteria) used by the listing block of the rss_feed content type
+ * as well as the language, description, title, subjects (tags), date, max_description_length, and
+ * max_title_length of the rss_feed.
+ *
+ * The returned query object will have the following format:
+ * {
+ *   query: [
+ *     {
+ *       i: <index>,
+ *       o: <operator>,
+ *       v: <value of the search criteria>
+ *     }
+ *   ],
+ *   sort_order: 'ascending',
+ *   b_size: 25,
+ *   metadata_fields: '_all',
+ *   b_start: 0
+ * }
+ *
+ * @function getRssFeedData
+ * @param {string} apiPath - The base path for the API requests.
+ * @param {string} APISUFFIX - The suffix added to the API path depending on the environment.
+ * @param {Object} req - The incoming Express request object.
+ * @param {Object} settings - Configuration settings for the application.
+ * @return {Object} An object containing the query data, language, description, and title of the rss_feed.
+ * @throws Will throw an error if no query data is found in the listing block or if the request fails.
+ */
+async function getRssFeedData(apiPath, APISUFFIX, req, settings) {
+  const request = superagent
+    .get(
+      `${apiPath}${__DEVELOPMENT__ ? '' : APISUFFIX}${req.path.replace(
+        '/rss.xml',
+        '',
+      )}`,
+    )
+    .accept('json');
+
+  const authToken = req.universalCookies.get('auth_token');
+  if (authToken) {
+    request.set('Authorization', `Bearer ${authToken}`);
+  }
+
+  const response = await request;
+  const json = response.body;
+  const listingBlocks = findBlocks(json.blocks, 'listing');
+  const listingBlockId = Array.isArray(listingBlocks)
+    ? listingBlocks[0]
+    : listingBlocks;
+
+  const queryData = listingBlockId
+    ? json.blocks?.[listingBlockId]?.querystring
+    : null;
+  const language = json.language?.token ?? 'en';
+  const description = json.description ?? 'A Volto RSS Feed';
+  const title = json.title;
+  const subjects = json.subjects;
+  const date = json.effective;
+  const max_description_length = json.max_description_length;
+  const max_title_length = json.max_title_length;
+  if (!queryData) {
+    throw new Error('No query data found in listing block');
+  }
+
+  const normalizedQueryData = { ...queryData };
+
+  if (normalizedQueryData.sort_order != null) {
+    if (typeof normalizedQueryData.sort_order === 'boolean') {
+      normalizedQueryData.sort_order = normalizedQueryData.sort_order
+        ? 'reverse'
+        : 'ascending';
+    }
+
+    if (normalizedQueryData.sort_order === 'descending') {
+      normalizedQueryData.sort_order = 'reverse';
+    }
+  }
+
+  const query = {
+    ...normalizedQueryData,
+    ...(!normalizedQueryData.b_size && {
+      b_size: settings.defaultPageSize,
+    }),
+    query: normalizedQueryData?.query,
+    metadata_fields: '_all',
+    b_start: 0,
+  };
+
+  return {
+    query,
+    language,
+    description,
+    title,
+    subjects,
+    date,
+    max_description_length,
+    max_title_length,
+  };
+}
+
+/**
+ * Fetches the listing block items based on the provided query data.
+ *
+ * The function sends a POST request to the @querystring-search endpoint with the query data
+ * and returns the items that match the search criteria.
+ * ref: https://6.docs.plone.org/plone.restapi/docs/source/endpoints/querystringsearch.html
+ *
+ * @function fetchListingItems
+ * @param {Object} query - The query data used for fetching items.
+ * @param {string} apiPath - The base path for the API requests.
+ * @param {string} APISUFFIX - The suffix added to the API path depending on the environment.
+ * @param {string} authToken - The authentication token for authorized requests.
+ * @return {Array} An array of items that match the query criteria.
+ * @throws Will throw an error if the request fails.
+ */
+async function fetchListingItems(query, apiPath, APISUFFIX, authToken) {
+  const request = superagent
+    .post(`${apiPath}${__DEVELOPMENT__ ? '' : APISUFFIX}/@querystring-search`)
+    .send(query)
+    .accept('json');
+
+  if (authToken) {
+    request.set('Authorization', `Bearer ${authToken}`);
+  }
+
+  const response = await request;
+  return response.body.items || [];
+}
+
+function normalizeFeedURL(url, publicURL, apiPath) {
+  if (!url) return publicURL;
+
+  try {
+    const parsedUrl = new URL(url, publicURL);
+
+    if (apiPath) {
+      const apiOrigin = new URL(apiPath).origin;
+      const publicOrigin = new URL(publicURL).origin;
+
+      if (parsedUrl.origin === apiOrigin) {
+        parsedUrl.protocol = new URL(publicOrigin).protocol;
+        parsedUrl.host = new URL(publicOrigin).host;
+      }
+    }
+
+    return parsedUrl.toString();
+  } catch {
+    return url;
+  }
+}
+
+/** Truncates the text to the specified length.
+ * If the text is longer than the specified length, it will be truncated and '...' will be appended.
+ * @function truncateText
+ * @param {string} text - The text to be truncated.
+ * @param {number} maxLength - The maximum length of the text.
+ * @return {string} The truncated text.
+ */
+function truncateText(text = '', maxLength) {
+  if (!maxLength || typeof text !== 'string') return text || '';
+  return text.length > maxLength ? `${text.substring(0, maxLength)}...` : text;
+}
+
+function safeDate(value) {
+  if (!value) return undefined;
+  const d = new Date(value);
+  if (Number.isNaN(d.getTime()) || d.getTime() <= 0) return undefined;
+  return d;
+}
+
+/**
+ * Creates an Express middleware for generating an RSS feed using the listing block of the
+ * rss_feed content type.
+ *
+ * The middleware fetches the query data of the listing block, retrieves the matching items,
+ * and generates an RSS feed in XML format, which is sent as the response.
+ *
+ * @function make_rssMiddleware
+ * @return {Function} An Express middleware function for generating the RSS feed.
+ */
+function make_rssMiddleware() {
+  const { settings } = config;
+  const APISUFFIX = settings.legacyTraverse ? '' : '/++api++';
+  let apiPath = '';
+  const host = process.env.HOST || 'localhost';
+  const port = process.env.PORT || '3000';
+  const ProdapiPath = `http://${host}:${port}`;
+  if (settings.internalApiPath && __SERVER__) {
+    apiPath = settings.internalApiPath;
+  } else if (__DEVELOPMENT__ && settings.devProxyToApiPath) {
+    apiPath = settings.devProxyToApiPath;
+  } else {
+    apiPath = settings.apiPath;
+  }
+  if (apiPath === '') {
+    apiPath = ProdapiPath;
+  }
+
+  async function rssMiddleware(req, res, next) {
+    try {
+      const {
+        query,
+        language,
+        description,
+        title,
+        subjects,
+        date,
+        max_description_length,
+        max_title_length,
+      } = await getRssFeedData(apiPath, APISUFFIX, req, settings);
+      const items = await fetchListingItems(
+        query,
+        apiPath,
+        APISUFFIX,
+        req.universalCookies.get('auth_token'),
+      );
+      const feedOptions = {
+        title: truncateText(title, max_title_length),
+        description: truncateText(description, max_description_length),
+        feed_url: normalizeFeedURL(req.path, settings.publicURL, apiPath),
+        site_url: settings.publicURL,
+        generator: 'RSS Feed Generator',
+        language: language,
+        pubDate: safeDate(date),
+        categories: subjects || [],
+      };
+
+      const feed = new RSS(feedOptions);
+
+      items.forEach((item) => {
+        const link = normalizeFeedURL(item.getURL, settings.publicURL, apiPath);
+        let enclosure = undefined;
+
+        const imageData = item.image_scales?.[item.image_field]?.[0];
+        const previewDownload = imageData?.scales?.preview?.download;
+
+        if (previewDownload && imageData.size && imageData['content-type']) {
+          enclosure = {
+            url: normalizeFeedURL(
+              new URL(previewDownload, link).toString(),
+              settings.publicURL,
+              apiPath,
+            ),
+            type: imageData['content-type'],
+            size: imageData.size,
+          };
+        }
+
+        feed.item({
+          title: truncateText(item.title, max_title_length),
+          description: truncateText(
+            item.description || item.Description || '',
+            max_description_length,
+          ),
+          url: link,
+          guid: item.UID,
+          date: safeDate(item.effective || item.created || item.modified),
+          author: item.listCreators?.join(', '),
+          categories: item.Subject ? item.Subject : [],
+          enclosure: enclosure || undefined,
+        });
+      });
+
+      const xml = feed.xml({ indent: true });
+      res.setHeader('Content-Type', 'application/rss+xml; charset=utf-8');
+      res.send(xml);
+    } catch (err) {
+      if (err.response && err.response.status === 401) {
+        // Handle unauthorized errors
+        res.status(401).json({
+          error: 'Unauthorized',
+          message:
+            'You are not authorized to access the requested RSS feed. Please log in and try again.',
+        });
+      } else if (err.response && err.response.status === 404) {
+        // Handle not found errors
+        res.status(404).json({
+          error: 'Not Found',
+          message:
+            'The requested RSS feed could not be found. Please verify the URL and try again.',
+        });
+      } else {
+        // Handle other errors
+        res.status(500).json({
+          error: 'Internal Server Error',
+          message:
+            'An unexpected error occurred while generating the RSS feed. Please try again later.',
+        });
+      }
+      return;
+    }
+  }
+
+  return rssMiddleware;
+}
+
+export default function makeMiddlewares() {
+  const middleware = express.Router();
+  middleware.use(express.urlencoded({ extended: true }));
+  middleware.get('**/rss.xml', make_rssMiddleware());
+
+  middleware.id = 'rss-middleware';
+
+  return middleware;
+}