katello 4.5.0 → 4.6.0.rc1

data/webpack/scenes/ContentViews/Details/Versions/Compare/CVVersionCompareConfig.js

@@ -0,0 +1,314 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { urlBuilder } from 'foremanReact/common/urlHelpers';
+import { startCase } from 'lodash';
+import { TimesIcon, CheckIcon, BugIcon, SecurityIcon, EnhancementIcon } from '@patternfly/react-icons';
+import { Tooltip } from '@patternfly/react-core';
+import LongDateTime from 'foremanReact/components/common/dates/LongDateTime';
+import {
+  selectPackageGroupsComparison,
+  selectPackageGroupsComparisonStatus,
+  selectRPMPackagesComparison,
+  selectRPMPackagesComparisonStatus,
+  selectFilesComparison,
+  selectFilesComparisonStatus,
+  selectErrataComparison,
+  selectErrataComparisonStatus,
+  selectModuleStreamsComparison,
+  selectModuleStreamsComparisonStatus,
+  selectDebPackagesComparison,
+  selectDebPackagesComparisonStatus,
+  selectDockerTagsComparison,
+  selectDockerTagsComparisonStatus,
+  selectGenericContentComparison,
+  selectGenericContentComparisonStatus,
+} from '../../ContentViewDetailSelectors';
+import {
+  getPackageGroupsComparison,
+  getRPMPackagesComparison,
+  getFilesComparison,
+  getErrataComparison,
+  getModuleStreamsComparison,
+  getDebPackagesComparison,
+  getDockerTagsComparison,
+  getGenericContentComparison,
+} from '../../ContentViewDetailActions';
+
+import ContentConfig from '../../../../Content/ContentConfig';
+
+export const TableType = PropTypes.shape({
+  name: PropTypes.string,
+  getCountKey: PropTypes.func,
+  responseSelector: PropTypes.func,
+  statusSelector: PropTypes.func,
+  autocompleteEndpoint: PropTypes.string,
+  fetchItems: PropTypes.func,
+  columnHeaders:
+    PropTypes.arrayOf(PropTypes.shape({
+      title: PropTypes.string,
+      width: PropTypes.number,
+      getProperty: PropTypes.func,
+    })),
+});
+
+export default ({
+  versionOne,
+  versionTwo,
+  versionOneId,
+  versionTwoId,
+  viewBy,
+}) => {
+  const compareContent = (item, versionId) => {
+    const {
+      comparison,
+    } = item;
+
+    if (
+      Number(comparison?.[0]) === Number(versionId)
+      || Number(comparison?.[1]) === Number(versionId)) {
+      return (
+        <CheckIcon style={{ color: '#3E8635' }} />
+      );
+    }
+    return (
+      <TimesIcon style={{ color: '#6A6E73' }} />
+    );
+  };
+
+  return ([
+    {
+      name: __('RPM packages'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.rpm_count || itemVersionTwo?.rpm_count,
+      responseSelector: state =>
+        selectRPMPackagesComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectRPMPackagesComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/packages/auto_complete_search',
+      fetchItems: params => getRPMPackagesComparison(
+        versionOneId,
+        versionTwoId,
+        viewBy,
+        params,
+      ),
+      columnHeaders: [
+        {
+          title: __('Name'),
+          getProperty: item => (
+            <a href={urlBuilder(`packages/${item?.id}`, '')}>
+              {item?.nvrea}
+            </a>),
+        },
+        { title: __('Version'), getProperty: item => item?.version },
+        { title: __('Release'), getProperty: item => item?.release },
+        { title: __('Arch'), getProperty: item => item?.arch },
+        { title: __('Epoch'), getProperty: item => item?.epoch },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('RPM package groups'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.package_group_count || itemVersionTwo?.package_group_count,
+      responseSelector: state =>
+        selectPackageGroupsComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectPackageGroupsComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/package_groups/auto_complete_search',
+      fetchItems: params => getPackageGroupsComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        { title: __('Name'), getProperty: item => item?.name },
+        { title: __('Repository'), getProperty: item => item?.repository?.name },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('Files'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.file_count || itemVersionTwo?.file_count,
+      responseSelector: state => selectFilesComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectFilesComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/files/auto_complete_search',
+      fetchItems: params => getFilesComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        {
+          title: __('Name'),
+          getProperty: item => (
+            <a href={urlBuilder(`files/${item?.id}`, '')}>
+              {item?.name}
+            </a>),
+        },
+        { title: __('Path'), getProperty: item => item?.path },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('Errata'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.erratum_count || itemVersionTwo?.erratum_count,
+      responseSelector: state => selectErrataComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectErrataComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/errata/auto_complete_search',
+      fetchItems: params => getErrataComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        {
+          title: __('Errata ID'),
+          getProperty: item => (
+            <a href={urlBuilder(`errata/${item?.id}`, '')}>
+              {item?.errata_id}
+            </a>),
+        },
+        {
+          title: __('Title'),
+          getProperty: item => item?.name,
+        },
+        {
+          title: __('Type'),
+          getProperty: (item) => {
+            const errataIcons = {
+              security: SecurityIcon,
+              bugfix: BugIcon,
+              enhancement: EnhancementIcon,
+              enhancements: EnhancementIcon,
+            };
+            const ErrataIcon = errataIcons[item?.type];
+            const itemType = startCase(item?.type);
+            if (!ErrataIcon) return itemType;
+            return <><Tooltip content={itemType} ><ErrataIcon style={{ marginRight: '4px' }} /></Tooltip>{itemType}{item?.severity !== 'None' && ` - ${item.severity}`}</>;
+          },
+        },
+        {
+          title: __('Modular'),
+          getProperty: (item) => {
+            if (item?.module_streams?.length) return __('Yes');
+            return __('No');
+          },
+        },
+        {
+          title: __('Applicable Content Hosts'),
+          getProperty: item => item?.hosts_applicable_count,
+          width: 25,
+        },
+        {
+          title: __('Updated'),
+          getProperty: item => item?.updated &&
+            <LongDateTime date={item.updated} showRelativeTimeTooltip />,
+        },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('Module streams'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.module_stream_count || itemVersionTwo?.module_stream_count,
+      responseSelector: state =>
+        selectModuleStreamsComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectModuleStreamsComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/module_streams/auto_complete_search',
+      fetchItems: params => getModuleStreamsComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        {
+          title: __('Name'),
+          getProperty: item => (
+            <a href={urlBuilder(`module_streams/${item?.id}`, '')}>
+              {item?.name}
+            </a>),
+        },
+        { title: __('Stream'), getProperty: item => item?.stream },
+        { title: __('Version'), getProperty: item => item?.version },
+        { title: __('Context'), getProperty: item => item?.context },
+        { title: __('Arch'), getProperty: item => item?.arch },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('Deb packages'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.deb_count || itemVersionTwo?.deb_count,
+      responseSelector: state =>
+        selectDebPackagesComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectDebPackagesComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/debs/auto_complete_search',
+      fetchItems: params => getDebPackagesComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        {
+          title: __('Name'),
+          getProperty: item => (
+            <a href={urlBuilder(`debs/${item?.id}`, '')}>
+              {item?.name}
+            </a>),
+        },
+        { title: __('Version'), getProperty: item => item?.version },
+        { title: __('Architecture'), getProperty: item => item?.architecture },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    {
+      name: __('Container tags'),
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.docker_tag_count || itemVersionTwo?.docker_tag_count,
+      responseSelector: state =>
+        selectDockerTagsComparison(state, versionOneId, versionTwoId, viewBy),
+      statusSelector: state =>
+        selectDockerTagsComparisonStatus(state, versionOneId, versionTwoId, viewBy),
+      autocompleteEndpoint: '/docker_tags/auto_complete_search',
+      fetchItems: params => getDockerTagsComparison(versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        {
+          title: __('Name'),
+          getProperty: item => (
+            <a href={urlBuilder(`docker_tags/${item?.id}`, '')}>
+              {item?.name}
+            </a>),
+        },
+        {
+          title: __('Available Schema Versions'),
+          getProperty: (item) => {
+            if (item?.manifest_schema1) return __('Schema Version 1');
+            return __('Schema Version 2');
+          },
+        },
+        { title: __('Product Name'), getProperty: item => item?.product?.name },
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    },
+    ...ContentConfig.filter(config => !(config.names.pluralLabel === 'ostree_refs')).map(({
+      names: { pluralLowercase, pluralLabel, singularLabel },
+      columnHeaders,
+    }) => ({
+      name: pluralLowercase,
+      getCountKey: (itemVersionOne, itemVersionTwo) =>
+        itemVersionOne?.[`${singularLabel}_count`] || itemVersionTwo?.[`${singularLabel}_count`],
+      responseSelector: state =>
+        selectGenericContentComparison(state, versionOneId, versionTwoId, pluralLabel, viewBy),
+      statusSelector: state =>
+        selectGenericContentComparisonStatus(
+          state,
+          versionOneId,
+          versionTwoId,
+          pluralLabel,
+          viewBy,
+        ),
+      autocompleteEndpoint: `/${pluralLabel}/auto_complete_search`,
+      fetchItems: params =>
+        getGenericContentComparison(pluralLabel, versionOneId, versionTwoId, viewBy, params),
+      columnHeaders: [
+        ...columnHeaders,
+        { title: __(`Version ${versionOne}`), getProperty: item => compareContent(item, versionOneId) },
+        { title: __(`Version ${versionTwo}`), getProperty: item => compareContent(item, versionTwoId) },
+      ],
+    })),
+  ]);
+};

data/webpack/scenes/ContentViews/Details/Versions/Compare/CVVersionCompareHeader.js

@@ -0,0 +1,186 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { useSelector } from 'react-redux';
+import {
+  Grid, GridItem, TextContent, Text, TextVariants, Tooltip,
+  Select, SelectOption, SelectVariant, Flex, FlexItem,
+} from '@patternfly/react-core';
+import { OutlinedQuestionCircleIcon } from '@patternfly/react-icons';
+import { selectCVDetails } from '../../ContentViewDetailSelectors';
+
+const CVVersionCompareHeader = ({
+  versionOne, versionTwo, cvId, setVersionOne, setVersionTwo, selectedViewBy, setSelectedViewBy,
+}) => {
+  const toolTipContent = 'Compare the content of any two versions of this content view.';
+  const response = useSelector(state => selectCVDetails(state, cvId));
+  const { versions } = response;
+  const [isOpenSelectVersionOne, setIsOpenSelectVersionOne] = useState(false);
+  const [isOpenSelectVersionTwo, setIsOpenSelectVersionTwo] = useState(false);
+  const [isOpenSelectViewBy, setIsOpenSelectViewBy] = useState(false);
+  const viewBySelectionOptions = ['All', 'Different', 'Same'];
+
+  const clearSelectionVersionOne = () => {
+    setVersionOne(null);
+    setIsOpenSelectVersionOne(false);
+  };
+  const clearSelectionVersionTwo = () => {
+    setVersionTwo(null);
+    setIsOpenSelectVersionTwo(false);
+  };
+
+  const clearSelectionViewBy = () => {
+    setSelectedViewBy('');
+    setIsOpenSelectViewBy(false);
+  };
+  const onSelectVersionOne = (_event, selection, isPlaceholder) => {
+    if (isPlaceholder) {
+      clearSelectionVersionOne();
+    } else {
+      setVersionOne(selection);
+      setIsOpenSelectVersionOne(false);
+    }
+  };
+
+  const onSelectVersionTwo = (_event, selection, isPlaceholder) => {
+    if (isPlaceholder) {
+      clearSelectionVersionTwo();
+    } else {
+      setVersionTwo(selection);
+      setIsOpenSelectVersionTwo(false);
+    }
+  };
+
+  const onSelectViewBy = (_event, selection, isPlaceholder) => {
+    if (isPlaceholder) {
+      clearSelectionViewBy();
+    } else {
+      setSelectedViewBy(selection);
+      setIsOpenSelectViewBy(false);
+    }
+  };
+
+  const filteredVersions = selectedVersion =>
+    versions?.filter(result => Number(result.version) !== Number(selectedVersion));
+  const filteredVersionsFirstSelect = versions?.filter(result =>
+    Number(result.version) !== Number(versionTwo));
+  const filteredVersionsSecondSelect = versions?.filter(result =>
+    Number(result.version) !== Number(versionOne));
+  const selectionOptionsViewBy = viewBySelectionOptions.map(option => (
+    <SelectOption
+      key={option}
+      value={option}
+      aria-label={`View by ${option}`}
+    >
+      {__(`${option}`)}
+    </SelectOption>
+  ));
+  return (
+    <Grid hasGutter style={{ margin: '0 24px' }}>
+      <GridItem span={12} style={{ display: 'flex' }}>
+        <TextContent>
+          <Text ouiaId="cv-version-compare-button" component={TextVariants.h2}>{__('Compare')}</Text>
+        </TextContent>
+        <Tooltip aria="none" aria-live="polite" content={toolTipContent} style={{ marginLeft: 'auto' }}>
+          <OutlinedQuestionCircleIcon />
+        </Tooltip>
+      </GridItem>
+      <GridItem span={12}>
+        <Flex>
+          <FlexItem>
+            <Flex direction={{ default: 'column' }}>
+              <h3><b>{__('Versions to compare')}</b></h3>
+              <FlexItem>
+                <Flex>
+                  <FlexItem>
+                    <Select
+                      style={{ marginRight: '10px' }}
+                      variant={SelectVariant.single}
+                      placeholderText={__('Select an option')}
+                      aria-label="Select version one"
+                      ouiaId="select-version-one"
+                      onToggle={setIsOpenSelectVersionOne}
+                      onSelect={onSelectVersionOne}
+                      selections={versionOne}
+                      isOpen={isOpenSelectVersionOne}
+                      isDisabled={!filteredVersionsFirstSelect?.length}
+                    >
+                      {filteredVersions(versionTwo)?.map(({ version }) => (
+                        <SelectOption
+                          key={version}
+                          value={version}
+                        >
+                          {__('Version ')}{version}
+                        </SelectOption>
+                      ))}
+                    </Select>
+                  </FlexItem>
+                  <FlexItem>
+                    <TextContent style={{ marginRight: '10px' }}>
+                      <Text ouiaId="to-text" component={TextVariants.h4}>{__('to')}</Text>
+                    </TextContent>
+                  </FlexItem>
+                  <FlexItem>
+                    <Select
+                      variant={SelectVariant.single}
+                      placeholderText="Select an option"
+                      aria-label="Select version two"
+                      ouiaId="select-version-two"
+                      onToggle={setIsOpenSelectVersionTwo}
+                      onSelect={onSelectVersionTwo}
+                      selections={versionTwo}
+                      isOpen={isOpenSelectVersionTwo}
+                      isDisabled={!filteredVersionsSecondSelect?.length}
+                    >
+                      {filteredVersions(versionOne)?.map(({ version }) => (
+                        <SelectOption
+                          key={version}
+                          value={version}
+                        >
+                          {__('Version ')}{version}
+                        </SelectOption>
+                      ))}
+                    </Select>
+                  </FlexItem>
+                </Flex>
+              </FlexItem>
+            </Flex>
+          </FlexItem >
+          <FlexItem style={{ marginLeft: '60px' }}>
+            <Flex direction={{ default: 'column' }}>
+              <h3><b>{__('View by')}</b></h3>
+              <FlexItem>
+                <Select
+                  style={{ marginRight: '10px' }}
+                  variant={SelectVariant.single}
+                  placeholderText="Select an option"
+                  aria-label="Select view by"
+                  ouiaId="select-view-by"
+                  onToggle={setIsOpenSelectViewBy}
+                  onSelect={onSelectViewBy}
+                  selections={selectedViewBy}
+                  isOpen={isOpenSelectViewBy}
+                  isDisabled={!(filteredVersionsFirstSelect?.length
+                    && filteredVersionsSecondSelect?.length)}
+                >
+                  {selectionOptionsViewBy}
+                </Select>
+              </FlexItem>
+            </Flex>
+          </FlexItem >
+        </Flex >
+      </GridItem>
+    </Grid>
+  );
+};
+
+CVVersionCompareHeader.propTypes = {
+  versionOne: PropTypes.string.isRequired,
+  versionTwo: PropTypes.string.isRequired,
+  cvId: PropTypes.number.isRequired,
+  setVersionOne: PropTypes.func.isRequired,
+  setVersionTwo: PropTypes.func.isRequired,
+  selectedViewBy: PropTypes.string.isRequired,
+  setSelectedViewBy: PropTypes.func.isRequired,
+};
+export default CVVersionCompareHeader;

data/webpack/scenes/ContentViews/Details/Versions/Compare/CVVersionCompareTable.js

@@ -0,0 +1,74 @@
+import React, { useState } from 'react';
+import {
+  useSelector,
+} from 'react-redux';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { TableVariant, Tr, Th, Tbody, Td, Thead } from '@patternfly/react-table';
+import { TableType } from './CVVersionCompareConfig';
+import TableWrapper from '../../../../../components/Table/TableWrapper';
+
+const CVVersionCompareTable = ({
+  tableConfig: {
+    name,
+    responseSelector,
+    statusSelector,
+    autocompleteEndpoint,
+    fetchItems,
+    columnHeaders,
+    disableSearch,
+  }, versionOne, versionTwo, currentActiveKey, selectedViewBy,
+}) => {
+  const [searchQuery, updateSearchQuery] = useState('');
+
+  const response = useSelector(responseSelector);
+  const { results, ...metadata } = response;
+  const status = useSelector(statusSelector);
+  return (
+    <TableWrapper
+      {...{
+        metadata,
+        searchQuery,
+        updateSearchQuery,
+        status,
+        autocompleteEndpoint,
+        disableSearch,
+      }}
+      ouiaId="content-view-version-comparison-table"
+      fetchItems={fetchItems}
+      additionalListeners={[versionOne, versionTwo, currentActiveKey, selectedViewBy]}
+      emptySearchTitle={__(`Your search returned no matching ${name}.`)}
+      emptySearchBody={__('Try changing your search criteria.')}
+      emptyContentTitle={__(`No matching ${name} found.`)}
+      emptyContentBody=""
+      variant={TableVariant.compact}
+    >
+      <Thead>
+        <Tr>
+          {columnHeaders.map(({ title }) =>
+            <Th key={`${title}-header`}>{title}</Th>)}
+        </Tr>
+      </Thead>
+      <Tbody>
+        {results?.map(result =>
+          (
+            <Tr key={`column-${result.id}`}>
+              {columnHeaders.map(({ getProperty }, colIndex) =>
+                // eslint-disable-next-line react/no-array-index-key
+                <Td key={`cell-${colIndex}`}>{getProperty(result)} </Td>)}
+            </Tr>
+          ))}
+      </Tbody>
+    </TableWrapper>
+  );
+};
+
+CVVersionCompareTable.propTypes = {
+  tableConfig: TableType.isRequired,
+  versionOne: PropTypes.string.isRequired,
+  versionTwo: PropTypes.string.isRequired,
+  currentActiveKey: PropTypes.string.isRequired,
+  selectedViewBy: PropTypes.string.isRequired,
+};
+
+export default CVVersionCompareTable;

data/webpack/scenes/ContentViews/Details/Versions/Compare/__tests__/AnsibleCollectionsCompareAllContentData.fixtures.json

@@ -0,0 +1,63 @@
+{
+  "total": 3,
+  "subtotal": 3,
+  "selectable": 3,
+  "page": "1",
+  "per_page": "20",
+  "error": null,
+  "search": null,
+  "sort": {
+    "by": "name",
+    "order": "asc"
+  },
+  "results": [
+    {
+      "id": 3,
+      "name": "ansodium",
+      "namespace": "marmorag",
+      "version": "1.0.0",
+      "checksum": "e0bff51d314dd76b26a41268282be2663e3eb971004932ad99b600b262603e95",
+      "description": "simple wrapper module around libsodium using pynacl",
+      "tags": [
+        "sodium",
+        "development",
+        "system"
+      ],
+      "comparison": [
+        17
+      ]
+    },
+    {
+      "id": 2,
+      "name": "ansodium",
+      "namespace": "marmorag",
+      "version": "1.0.2",
+      "checksum": "1a4420fa969bbfc843d252407dee2537cbc2626072adef7bc8fce631d3490d0e",
+      "description": "simple wrapper module around libsodium using pynacl",
+      "tags": [
+        "sodium",
+        "development",
+        "system"
+      ],
+      "comparison": [
+        17
+      ]
+    },
+    {
+      "id": 1,
+      "name": "ansodium",
+      "namespace": "marmorag",
+      "version": "1.0.1",
+      "checksum": "68e92a8d7f5019252655592785477ae3d76151b902b7b246f2585ec143b430ed",
+      "description": "simple wrapper module around libsodium using pynacl",
+      "tags": [
+        "sodium",
+        "development",
+        "system"
+      ],
+      "comparison": [
+        17
+      ]
+    }
+  ]
+}