1218 lines
40 KiB
JavaScript
1218 lines
40 KiB
JavaScript
import {
|
|
DocumentActionButton,
|
|
DocumentActionsMenu,
|
|
useDocumentActions,
|
|
useDocumentRBAC
|
|
} from "./chunk-GXKJFURG.js";
|
|
import {
|
|
DocumentStatus
|
|
} from "./chunk-7FUKGPNR.js";
|
|
import {
|
|
buildValidParams,
|
|
createYupSchema,
|
|
isBaseQueryError,
|
|
useContentTypeSchema,
|
|
useDoc,
|
|
useDocLayout,
|
|
useGetAllDocumentsQuery,
|
|
useGetManyDraftRelationCountQuery,
|
|
usePublishManyDocumentsMutation
|
|
} from "./chunk-UATNJIHQ.js";
|
|
import {
|
|
contentManagerApi
|
|
} from "./chunk-P4VL3IHZ.js";
|
|
import {
|
|
getTranslation
|
|
} from "./chunk-HIZVCZYI.js";
|
|
import {
|
|
DescriptionComponentRenderer
|
|
} from "./chunk-QF6GPHA4.js";
|
|
import {
|
|
ValidationError
|
|
} from "./chunk-XLSIZGJF.js";
|
|
import {
|
|
Table,
|
|
useTable
|
|
} from "./chunk-ZM6TT53G.js";
|
|
import {
|
|
getYupValidationErrors
|
|
} from "./chunk-BFLP6DBI.js";
|
|
import {
|
|
useAPIErrorHandler
|
|
} from "./chunk-5CAWUBTQ.js";
|
|
import {
|
|
useQueryParams,
|
|
useStrapiApp
|
|
} from "./chunk-W2TBR6J3.js";
|
|
import {
|
|
require_lib
|
|
} from "./chunk-LCL5TIBZ.js";
|
|
import {
|
|
useNotification
|
|
} from "./chunk-N55RVBRV.js";
|
|
import {
|
|
Box,
|
|
Button,
|
|
Dialog,
|
|
Flex,
|
|
IconButton,
|
|
LinkButton,
|
|
Loader,
|
|
Modal,
|
|
RawTable,
|
|
Tbody,
|
|
Td,
|
|
TooltipImpl,
|
|
Tr,
|
|
Typography,
|
|
useIntl
|
|
} from "./chunk-7XB6XSWQ.js";
|
|
import {
|
|
Link,
|
|
NavLink,
|
|
useLocation,
|
|
useNavigate
|
|
} from "./chunk-TUXTO2Z5.js";
|
|
import {
|
|
ForwardRef$1v,
|
|
ForwardRef$3,
|
|
ForwardRef$3R,
|
|
ForwardRef$43,
|
|
ForwardRef$4D,
|
|
ForwardRef$4F,
|
|
ForwardRef$4v,
|
|
ForwardRef$59
|
|
} from "./chunk-WRD5KPDH.js";
|
|
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-NIAJZ5MX.js";
|
|
import {
|
|
dt
|
|
} from "./chunk-ACIMPXWY.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-MADUDGYZ.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/BulkActions/Actions.mjs
|
|
var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
|
|
var React3 = __toESM(require_react(), 1);
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/BulkActions/PublishAction.mjs
|
|
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
|
|
var React2 = __toESM(require_react(), 1);
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/BulkActions/ConfirmBulkActionDialog.mjs
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
var React = __toESM(require_react(), 1);
|
|
var ConfirmBulkActionDialog = ({ onToggleDialog, isOpen = false, dialogBody, endAction }) => {
|
|
const { formatMessage } = useIntl();
|
|
return (0, import_jsx_runtime.jsx)(Dialog.Root, {
|
|
open: isOpen,
|
|
children: (0, import_jsx_runtime.jsxs)(Dialog.Content, {
|
|
children: [
|
|
(0, import_jsx_runtime.jsx)(Dialog.Header, {
|
|
children: formatMessage({
|
|
id: "app.components.ConfirmDialog.title",
|
|
defaultMessage: "Confirmation"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime.jsx)(Dialog.Body, {
|
|
children: (0, import_jsx_runtime.jsxs)(Flex, {
|
|
direction: "column",
|
|
alignItems: "stretch",
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime.jsx)(Flex, {
|
|
justifyContent: "center",
|
|
children: (0, import_jsx_runtime.jsx)(ForwardRef$3, {
|
|
width: "24px",
|
|
height: "24px",
|
|
fill: "danger600"
|
|
})
|
|
}),
|
|
dialogBody
|
|
]
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime.jsxs)(Dialog.Footer, {
|
|
children: [
|
|
(0, import_jsx_runtime.jsx)(Dialog.Cancel, {
|
|
children: (0, import_jsx_runtime.jsx)(Button, {
|
|
fullWidth: true,
|
|
onClick: onToggleDialog,
|
|
variant: "tertiary",
|
|
children: formatMessage({
|
|
id: "app.components.Button.cancel",
|
|
defaultMessage: "Cancel"
|
|
})
|
|
})
|
|
}),
|
|
endAction
|
|
]
|
|
})
|
|
]
|
|
})
|
|
});
|
|
};
|
|
var BoldChunk = (chunks) => (0, import_jsx_runtime.jsx)(Typography, {
|
|
fontWeight: "bold",
|
|
children: chunks
|
|
});
|
|
var ConfirmDialogPublishAll = ({ isOpen, onToggleDialog, isConfirmButtonLoading = false, onConfirm }) => {
|
|
var _a, _b;
|
|
const { formatMessage } = useIntl();
|
|
const selectedEntries = useTable("ConfirmDialogPublishAll", (state) => state.selectedRows);
|
|
const { toggleNotification } = useNotification();
|
|
const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler(getTranslation);
|
|
const { model, schema } = useDoc();
|
|
const [{ query }] = useQueryParams();
|
|
const enableDraftRelationsCount = false;
|
|
const { data: countDraftRelations = 0, isLoading, error } = useGetManyDraftRelationCountQuery({
|
|
model,
|
|
documentIds: selectedEntries.map((entry) => entry.documentId),
|
|
locale: (_b = (_a = query == null ? void 0 : query.plugins) == null ? void 0 : _a.i18n) == null ? void 0 : _b.locale
|
|
}, {
|
|
skip: !enableDraftRelationsCount
|
|
});
|
|
React.useEffect(() => {
|
|
if (error) {
|
|
toggleNotification({
|
|
type: "danger",
|
|
message: formatAPIError(error)
|
|
});
|
|
}
|
|
}, [
|
|
error,
|
|
formatAPIError,
|
|
toggleNotification
|
|
]);
|
|
if (error) {
|
|
return null;
|
|
}
|
|
return (0, import_jsx_runtime.jsx)(ConfirmBulkActionDialog, {
|
|
isOpen: isOpen && !isLoading,
|
|
onToggleDialog,
|
|
dialogBody: (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
|
|
children: [
|
|
(0, import_jsx_runtime.jsxs)(Typography, {
|
|
id: "confirm-description",
|
|
textAlign: "center",
|
|
children: [
|
|
countDraftRelations > 0 && formatMessage({
|
|
id: getTranslation(`popUpwarning.warning.bulk-has-draft-relations.message`),
|
|
defaultMessage: "<b>{count} {count, plural, one { relation } other { relations } } out of {entities} { entities, plural, one { entry } other { entries } } {count, plural, one { is } other { are } }</b> not published yet and might lead to unexpected behavior. "
|
|
}, {
|
|
b: BoldChunk,
|
|
count: countDraftRelations,
|
|
entities: selectedEntries.length
|
|
}),
|
|
formatMessage({
|
|
id: getTranslation("popUpWarning.bodyMessage.contentType.publish.all"),
|
|
defaultMessage: "Are you sure you want to publish these entries?"
|
|
})
|
|
]
|
|
}),
|
|
(schema == null ? void 0 : schema.pluginOptions) && "i18n" in schema.pluginOptions && (schema == null ? void 0 : schema.pluginOptions.i18n) && (0, import_jsx_runtime.jsx)(Typography, {
|
|
textColor: "danger500",
|
|
textAlign: "center",
|
|
children: formatMessage({
|
|
id: getTranslation("Settings.list.actions.publishAdditionalInfos"),
|
|
defaultMessage: "This will publish the active locale versions <em>(from Internationalization)</em>"
|
|
}, {
|
|
em: Emphasis
|
|
})
|
|
})
|
|
]
|
|
}),
|
|
endAction: (0, import_jsx_runtime.jsx)(Button, {
|
|
onClick: onConfirm,
|
|
variant: "secondary",
|
|
startIcon: (0, import_jsx_runtime.jsx)(ForwardRef$4F, {}),
|
|
loading: isConfirmButtonLoading,
|
|
children: formatMessage({
|
|
id: "app.utils.publish",
|
|
defaultMessage: "Publish"
|
|
})
|
|
})
|
|
});
|
|
};
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/BulkActions/PublishAction.mjs
|
|
var TypographyMaxWidth = dt(Typography)`
|
|
max-width: 300px;
|
|
`;
|
|
var TableComponent = dt(RawTable)`
|
|
width: 100%;
|
|
table-layout: fixed;
|
|
td:first-child {
|
|
border-right: 1px solid ${({ theme }) => theme.colors.neutral150};
|
|
}
|
|
td:first-of-type {
|
|
padding: ${({ theme }) => theme.spaces[4]};
|
|
}
|
|
`;
|
|
var formatErrorMessages = (errors, parentKey, formatMessage) => {
|
|
const messages = [];
|
|
Object.entries(errors).forEach(([key, value]) => {
|
|
const currentKey = parentKey ? `${parentKey}.${key}` : key;
|
|
if (typeof value === "object" && value !== null && !Array.isArray(value)) {
|
|
if ("id" in value && "defaultMessage" in value) {
|
|
messages.push(formatMessage({
|
|
id: `${value.id}.withField`,
|
|
defaultMessage: value.defaultMessage
|
|
}, {
|
|
field: currentKey
|
|
}));
|
|
} else {
|
|
messages.push(...formatErrorMessages(
|
|
// @ts-expect-error TODO: check why value is not compatible with FormErrors
|
|
value,
|
|
currentKey,
|
|
formatMessage
|
|
));
|
|
}
|
|
} else {
|
|
messages.push(formatMessage({
|
|
id: `${value}.withField`,
|
|
defaultMessage: value
|
|
}, {
|
|
field: currentKey
|
|
}));
|
|
}
|
|
});
|
|
return messages;
|
|
};
|
|
var EntryValidationText = ({ validationErrors, status }) => {
|
|
const { formatMessage } = useIntl();
|
|
if (validationErrors) {
|
|
const validationErrorsMessages = formatErrorMessages(validationErrors, "", formatMessage).join(" ");
|
|
return (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(ForwardRef$43, {
|
|
fill: "danger600"
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(TooltipImpl, {
|
|
description: validationErrorsMessages,
|
|
children: (0, import_jsx_runtime2.jsx)(TypographyMaxWidth, {
|
|
textColor: "danger600",
|
|
variant: "omega",
|
|
fontWeight: "semiBold",
|
|
ellipsis: true,
|
|
children: validationErrorsMessages
|
|
})
|
|
})
|
|
]
|
|
});
|
|
}
|
|
if (status === "published") {
|
|
return (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(ForwardRef$4D, {
|
|
fill: "success600"
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
textColor: "success600",
|
|
fontWeight: "bold",
|
|
children: formatMessage({
|
|
id: "content-manager.bulk-publish.already-published",
|
|
defaultMessage: "Already Published"
|
|
})
|
|
})
|
|
]
|
|
});
|
|
}
|
|
if (status === "modified") {
|
|
return (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(ForwardRef$59, {
|
|
fill: "alternative600"
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: formatMessage({
|
|
id: "content-manager.bulk-publish.modified",
|
|
defaultMessage: "Ready to publish changes"
|
|
})
|
|
})
|
|
]
|
|
});
|
|
}
|
|
return (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(ForwardRef$4D, {
|
|
fill: "success600"
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: formatMessage({
|
|
id: "app.utils.ready-to-publish",
|
|
defaultMessage: "Ready to publish"
|
|
})
|
|
})
|
|
]
|
|
});
|
|
};
|
|
var TABLE_HEADERS = [
|
|
{
|
|
name: "id",
|
|
label: "id"
|
|
},
|
|
{
|
|
name: "name",
|
|
label: "name"
|
|
},
|
|
{
|
|
name: "status",
|
|
label: "status"
|
|
},
|
|
{
|
|
name: "publicationStatus",
|
|
label: "Publication status"
|
|
}
|
|
];
|
|
var SelectedEntriesTableContent = ({ isPublishing, rowsToDisplay = [], entriesToPublish = [], validationErrors = {} }) => {
|
|
const { pathname } = useLocation();
|
|
const { formatMessage } = useIntl();
|
|
const { list: { settings: { mainField } } } = useDocLayout();
|
|
const shouldDisplayMainField = mainField != null && mainField !== "id";
|
|
return (0, import_jsx_runtime2.jsxs)(Table.Content, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsxs)(Table.Head, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Table.HeaderCheckboxCell, {}),
|
|
TABLE_HEADERS.filter((head) => head.name !== "name" || shouldDisplayMainField).map((head) => (0, import_jsx_runtime2.jsx)(Table.HeaderCell, {
|
|
...head
|
|
}, head.name))
|
|
]
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Loading, {}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Body, {
|
|
children: rowsToDisplay.map((row) => (0, import_jsx_runtime2.jsxs)(Table.Row, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Table.CheckboxCell, {
|
|
id: row.id
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Cell, {
|
|
children: (0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: row.id
|
|
})
|
|
}),
|
|
shouldDisplayMainField && (0, import_jsx_runtime2.jsx)(Table.Cell, {
|
|
children: (0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: row[mainField]
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Cell, {
|
|
children: (0, import_jsx_runtime2.jsx)(DocumentStatus, {
|
|
status: row.status,
|
|
maxWidth: "min-content"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Cell, {
|
|
children: isPublishing && entriesToPublish.includes(row.documentId) ? (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: formatMessage({
|
|
id: "content-manager.success.record.publishing",
|
|
defaultMessage: "Publishing..."
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Loader, {
|
|
small: true
|
|
})
|
|
]
|
|
}) : (0, import_jsx_runtime2.jsx)(EntryValidationText, {
|
|
validationErrors: validationErrors[row.documentId],
|
|
status: row.status
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Table.Cell, {
|
|
children: (0, import_jsx_runtime2.jsx)(Flex, {
|
|
children: (0, import_jsx_runtime2.jsx)(IconButton, {
|
|
tag: Link,
|
|
to: {
|
|
pathname: `${pathname}/${row.documentId}`,
|
|
search: row.locale && `?plugins[i18n][locale]=${row.locale}`
|
|
},
|
|
state: {
|
|
from: pathname
|
|
},
|
|
label: formatMessage({
|
|
id: "content-manager.bulk-publish.edit",
|
|
defaultMessage: "Edit"
|
|
}),
|
|
target: "_blank",
|
|
marginLeft: "auto",
|
|
variant: "ghost",
|
|
children: (0, import_jsx_runtime2.jsx)(ForwardRef$1v, {
|
|
width: "1.6rem",
|
|
height: "1.6rem"
|
|
})
|
|
})
|
|
})
|
|
})
|
|
]
|
|
}, row.id))
|
|
})
|
|
]
|
|
});
|
|
};
|
|
var PublicationStatusSummary = ({ count, icon, message }) => {
|
|
return (0, import_jsx_runtime2.jsxs)(Flex, {
|
|
justifyContent: "space-between",
|
|
flex: 1,
|
|
gap: 3,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
icon,
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
children: message
|
|
})
|
|
]
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Typography, {
|
|
fontWeight: "bold",
|
|
children: count
|
|
})
|
|
]
|
|
});
|
|
};
|
|
var PublicationStatusGrid = ({ entriesReadyToPublishCount, entriesPublishedCount, entriesModifiedCount, entriesWithErrorsCount }) => {
|
|
const { formatMessage } = useIntl();
|
|
return (0, import_jsx_runtime2.jsx)(Box, {
|
|
hasRadius: true,
|
|
borderColor: "neutral150",
|
|
children: (0, import_jsx_runtime2.jsx)(TableComponent, {
|
|
colCount: 2,
|
|
rowCount: 2,
|
|
children: (0, import_jsx_runtime2.jsxs)(Tbody, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsxs)(Tr, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Td, {
|
|
children: (0, import_jsx_runtime2.jsx)(PublicationStatusSummary, {
|
|
count: entriesReadyToPublishCount,
|
|
icon: (0, import_jsx_runtime2.jsx)(ForwardRef$4D, {
|
|
fill: "success600"
|
|
}),
|
|
message: formatMessage({
|
|
id: "app.utils.ready-to-publish",
|
|
defaultMessage: "Ready to publish"
|
|
})
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Td, {
|
|
children: (0, import_jsx_runtime2.jsx)(PublicationStatusSummary, {
|
|
count: entriesPublishedCount,
|
|
icon: (0, import_jsx_runtime2.jsx)(ForwardRef$4D, {
|
|
fill: "success600"
|
|
}),
|
|
message: formatMessage({
|
|
id: "app.utils.already-published",
|
|
defaultMessage: "Already published"
|
|
})
|
|
})
|
|
})
|
|
]
|
|
}),
|
|
(0, import_jsx_runtime2.jsxs)(Tr, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Td, {
|
|
children: (0, import_jsx_runtime2.jsx)(PublicationStatusSummary, {
|
|
count: entriesModifiedCount,
|
|
icon: (0, import_jsx_runtime2.jsx)(ForwardRef$59, {
|
|
fill: "alternative600"
|
|
}),
|
|
message: formatMessage({
|
|
id: "content-manager.bulk-publish.modified",
|
|
defaultMessage: "Ready to publish changes"
|
|
})
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Td, {
|
|
children: (0, import_jsx_runtime2.jsx)(PublicationStatusSummary, {
|
|
count: entriesWithErrorsCount,
|
|
icon: (0, import_jsx_runtime2.jsx)(ForwardRef$43, {
|
|
fill: "danger600"
|
|
}),
|
|
message: formatMessage({
|
|
id: "content-manager.bulk-publish.waiting-for-action",
|
|
defaultMessage: "Waiting for action"
|
|
})
|
|
})
|
|
})
|
|
]
|
|
})
|
|
]
|
|
})
|
|
})
|
|
});
|
|
};
|
|
var SelectedEntriesModalContent = ({ listViewSelectedEntries, toggleModal, setListViewSelectedDocuments, model }) => {
|
|
var _a, _b;
|
|
const { formatMessage } = useIntl();
|
|
const { schema, components } = useContentTypeSchema(model);
|
|
const documentIds = listViewSelectedEntries.map(({ documentId }) => documentId);
|
|
const [{ query }] = useQueryParams();
|
|
const params = React2.useMemo(() => buildValidParams(query), [
|
|
query
|
|
]);
|
|
const { data, isLoading, isFetching, refetch } = useGetAllDocumentsQuery({
|
|
model,
|
|
params: {
|
|
page: "1",
|
|
pageSize: documentIds.length.toString(),
|
|
sort: query.sort,
|
|
filters: {
|
|
documentId: {
|
|
$in: documentIds
|
|
}
|
|
},
|
|
locale: (_b = (_a = query.plugins) == null ? void 0 : _a.i18n) == null ? void 0 : _b.locale
|
|
}
|
|
}, {
|
|
selectFromResult: ({ data: data2, ...restRes }) => ({
|
|
data: (data2 == null ? void 0 : data2.results) ?? [],
|
|
...restRes
|
|
})
|
|
});
|
|
const { rows, validationErrors } = React2.useMemo(() => {
|
|
if (data.length > 0 && schema) {
|
|
const validate = createYupSchema(
|
|
schema.attributes,
|
|
components,
|
|
// Since this is the "Publish" action, the validation
|
|
// schema must enforce the rules for published entities
|
|
{
|
|
status: "published"
|
|
}
|
|
);
|
|
const validationErrors2 = {};
|
|
const rows2 = data.map((entry) => {
|
|
try {
|
|
validate.validateSync(entry, {
|
|
abortEarly: false
|
|
});
|
|
return entry;
|
|
} catch (e) {
|
|
if (e instanceof ValidationError) {
|
|
validationErrors2[entry.documentId] = getYupValidationErrors(e);
|
|
}
|
|
return entry;
|
|
}
|
|
});
|
|
return {
|
|
rows: rows2,
|
|
validationErrors: validationErrors2
|
|
};
|
|
}
|
|
return {
|
|
rows: [],
|
|
validationErrors: {}
|
|
};
|
|
}, [
|
|
components,
|
|
data,
|
|
schema
|
|
]);
|
|
const [isDialogOpen, setIsDialogOpen] = React2.useState(false);
|
|
const { publishMany: bulkPublishAction, isLoading: isPublishing } = useDocumentActions();
|
|
const [, { isLoading: isSubmittingForm }] = usePublishManyDocumentsMutation();
|
|
const selectedRows = useTable("publishAction", (state) => state.selectedRows);
|
|
const selectedEntries = rows.filter((entry) => selectedRows.some((selectedEntry) => selectedEntry.documentId === entry.documentId));
|
|
const entriesToPublish = selectedEntries.filter((entry) => !validationErrors[entry.documentId]).map((entry) => entry.documentId);
|
|
const selectedEntriesWithErrorsCount = selectedEntries.filter(({ documentId }) => validationErrors[documentId]).length;
|
|
const selectedEntriesPublishedCount = selectedEntries.filter(({ status }) => status === "published").length;
|
|
const selectedEntriesModifiedCount = selectedEntries.filter(({ status, documentId }) => status === "modified" && !validationErrors[documentId]).length;
|
|
const selectedEntriesWithNoErrorsCount = selectedEntries.length - selectedEntriesWithErrorsCount - selectedEntriesPublishedCount;
|
|
const toggleDialog = () => setIsDialogOpen((prev) => !prev);
|
|
const handleConfirmBulkPublish = async () => {
|
|
toggleDialog();
|
|
const res = await bulkPublishAction({
|
|
model,
|
|
documentIds: entriesToPublish,
|
|
params
|
|
});
|
|
if (!("error" in res)) {
|
|
const unpublishedEntries = rows.filter((row) => {
|
|
return !entriesToPublish.includes(row.documentId);
|
|
});
|
|
setListViewSelectedDocuments(unpublishedEntries);
|
|
}
|
|
};
|
|
return (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsxs)(Modal.Body, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(PublicationStatusGrid, {
|
|
entriesReadyToPublishCount: selectedEntriesWithNoErrorsCount - selectedEntriesModifiedCount,
|
|
entriesPublishedCount: selectedEntriesPublishedCount,
|
|
entriesModifiedCount: selectedEntriesModifiedCount,
|
|
entriesWithErrorsCount: selectedEntriesWithErrorsCount
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Box, {
|
|
marginTop: 7,
|
|
children: (0, import_jsx_runtime2.jsx)(SelectedEntriesTableContent, {
|
|
isPublishing: isSubmittingForm,
|
|
rowsToDisplay: rows,
|
|
entriesToPublish,
|
|
validationErrors
|
|
})
|
|
})
|
|
]
|
|
}),
|
|
(0, import_jsx_runtime2.jsxs)(Modal.Footer, {
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Button, {
|
|
onClick: toggleModal,
|
|
variant: "tertiary",
|
|
children: formatMessage({
|
|
id: "app.components.Button.cancel",
|
|
defaultMessage: "Cancel"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsxs)(Flex, {
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime2.jsx)(Button, {
|
|
onClick: refetch,
|
|
variant: "tertiary",
|
|
loading: isFetching,
|
|
children: formatMessage({
|
|
id: "app.utils.refresh",
|
|
defaultMessage: "Refresh"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(Button, {
|
|
onClick: toggleDialog,
|
|
disabled: selectedEntries.length === 0 || selectedEntries.length === selectedEntriesWithErrorsCount || selectedEntriesPublishedCount === selectedEntries.length || isLoading,
|
|
loading: isPublishing || isSubmittingForm,
|
|
children: formatMessage({
|
|
id: "app.utils.publish",
|
|
defaultMessage: "Publish"
|
|
})
|
|
})
|
|
]
|
|
})
|
|
]
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)(ConfirmDialogPublishAll, {
|
|
isOpen: isDialogOpen,
|
|
onToggleDialog: toggleDialog,
|
|
isConfirmButtonLoading: isPublishing || isSubmittingForm,
|
|
onConfirm: handleConfirmBulkPublish
|
|
})
|
|
]
|
|
});
|
|
};
|
|
var PublishAction = ({ documents, model }) => {
|
|
const { formatMessage } = useIntl();
|
|
const hasPublishPermission = useDocumentRBAC("unpublishAction", (state) => state.canPublish);
|
|
const showPublishButton = hasPublishPermission && documents.some(({ status }) => status !== "published");
|
|
const setListViewSelectedDocuments = useTable("publishAction", (state) => state.selectRow);
|
|
const refetchList = () => {
|
|
contentManagerApi.util.invalidateTags([
|
|
{
|
|
type: "Document",
|
|
id: `${model}_LIST`
|
|
}
|
|
]);
|
|
};
|
|
if (!showPublishButton) return null;
|
|
return {
|
|
actionType: "publish",
|
|
variant: "tertiary",
|
|
label: formatMessage({
|
|
id: "app.utils.publish",
|
|
defaultMessage: "Publish"
|
|
}),
|
|
dialog: {
|
|
type: "modal",
|
|
title: formatMessage({
|
|
id: getTranslation("containers.ListPage.selectedEntriesModal.title"),
|
|
defaultMessage: "Publish entries"
|
|
}),
|
|
content: ({ onClose }) => {
|
|
return (0, import_jsx_runtime2.jsx)(Table.Root, {
|
|
rows: documents,
|
|
defaultSelectedRows: documents,
|
|
headers: TABLE_HEADERS,
|
|
children: (0, import_jsx_runtime2.jsx)(SelectedEntriesModalContent, {
|
|
listViewSelectedEntries: documents,
|
|
toggleModal: () => {
|
|
onClose();
|
|
refetchList();
|
|
},
|
|
setListViewSelectedDocuments,
|
|
model
|
|
})
|
|
});
|
|
},
|
|
onClose: () => {
|
|
refetchList();
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/BulkActions/Actions.mjs
|
|
var BulkActionsRenderer = () => {
|
|
const plugins = useStrapiApp("BulkActionsRenderer", (state) => state.plugins);
|
|
const { model, collectionType } = useDoc();
|
|
const { selectedRows } = useTable("BulkActionsRenderer", (state) => state);
|
|
return (0, import_jsx_runtime3.jsx)(Flex, {
|
|
gap: 2,
|
|
children: (0, import_jsx_runtime3.jsx)(DescriptionComponentRenderer, {
|
|
props: {
|
|
model,
|
|
collectionType,
|
|
documents: selectedRows
|
|
},
|
|
descriptions: plugins["content-manager"].apis.getBulkActions(),
|
|
children: (actions) => actions.map((action) => (0, import_jsx_runtime3.jsx)(DocumentActionButton, {
|
|
...action
|
|
}, action.id))
|
|
})
|
|
});
|
|
};
|
|
var DeleteAction = ({ documents, model }) => {
|
|
var _a;
|
|
const { formatMessage } = useIntl();
|
|
const { schema: contentType } = useDoc();
|
|
const selectRow = useTable("DeleteAction", (state) => state.selectRow);
|
|
const hasI18nEnabled = Boolean((_a = contentType == null ? void 0 : contentType.pluginOptions) == null ? void 0 : _a.i18n);
|
|
const [{ query }] = useQueryParams();
|
|
const params = React3.useMemo(() => buildValidParams(query), [
|
|
query
|
|
]);
|
|
const hasDeletePermission = useDocumentRBAC("deleteAction", (state) => state.canDelete);
|
|
const { deleteMany: bulkDeleteAction, isLoading } = useDocumentActions();
|
|
const documentIds = documents.map(({ documentId }) => documentId);
|
|
const handleConfirmBulkDelete = async () => {
|
|
const res = await bulkDeleteAction({
|
|
documentIds,
|
|
model,
|
|
params
|
|
});
|
|
if (!("error" in res)) {
|
|
selectRow([]);
|
|
}
|
|
};
|
|
if (!hasDeletePermission) return null;
|
|
return {
|
|
variant: "danger-light",
|
|
label: formatMessage({
|
|
id: "global.delete",
|
|
defaultMessage: "Delete"
|
|
}),
|
|
dialog: {
|
|
type: "dialog",
|
|
title: formatMessage({
|
|
id: "app.components.ConfirmDialog.title",
|
|
defaultMessage: "Confirmation"
|
|
}),
|
|
loading: isLoading,
|
|
content: (0, import_jsx_runtime3.jsxs)(Flex, {
|
|
direction: "column",
|
|
alignItems: "stretch",
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime3.jsx)(Flex, {
|
|
justifyContent: "center",
|
|
children: (0, import_jsx_runtime3.jsx)(ForwardRef$3, {
|
|
width: "24px",
|
|
height: "24px",
|
|
fill: "danger600"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime3.jsx)(Typography, {
|
|
id: "confirm-description",
|
|
textAlign: "center",
|
|
children: formatMessage({
|
|
id: "popUpWarning.bodyMessage.contentType.delete.all",
|
|
defaultMessage: "Are you sure you want to delete these entries?"
|
|
})
|
|
}),
|
|
hasI18nEnabled && (0, import_jsx_runtime3.jsx)(Box, {
|
|
textAlign: "center",
|
|
padding: 3,
|
|
children: (0, import_jsx_runtime3.jsx)(Typography, {
|
|
textColor: "danger500",
|
|
children: formatMessage({
|
|
id: getTranslation("Settings.list.actions.deleteAdditionalInfos"),
|
|
defaultMessage: "This will delete the active locale versions <em>(from Internationalization)</em>"
|
|
}, {
|
|
em: Emphasis
|
|
})
|
|
})
|
|
})
|
|
]
|
|
}),
|
|
onConfirm: handleConfirmBulkDelete
|
|
}
|
|
};
|
|
};
|
|
DeleteAction.type = "delete";
|
|
var UnpublishAction = ({ documents, model }) => {
|
|
var _a, _b;
|
|
const { formatMessage } = useIntl();
|
|
const { schema } = useDoc();
|
|
const selectRow = useTable("UnpublishAction", (state) => state.selectRow);
|
|
const hasPublishPermission = useDocumentRBAC("unpublishAction", (state) => state.canPublish);
|
|
const hasI18nEnabled = Boolean((_a = schema == null ? void 0 : schema.pluginOptions) == null ? void 0 : _a.i18n);
|
|
const hasDraftAndPublishEnabled = Boolean((_b = schema == null ? void 0 : schema.options) == null ? void 0 : _b.draftAndPublish);
|
|
const { unpublishMany: bulkUnpublishAction, isLoading } = useDocumentActions();
|
|
const documentIds = documents.map(({ documentId }) => documentId);
|
|
const [{ query }] = useQueryParams();
|
|
const params = React3.useMemo(() => buildValidParams(query), [
|
|
query
|
|
]);
|
|
const handleConfirmBulkUnpublish = async () => {
|
|
const data = await bulkUnpublishAction({
|
|
documentIds,
|
|
model,
|
|
params
|
|
});
|
|
if (!("error" in data)) {
|
|
selectRow([]);
|
|
}
|
|
};
|
|
const showUnpublishButton = hasDraftAndPublishEnabled && hasPublishPermission && documents.some((entry) => entry.status === "published" || entry.status === "modified");
|
|
if (!showUnpublishButton) return null;
|
|
return {
|
|
variant: "tertiary",
|
|
label: formatMessage({
|
|
id: "app.utils.unpublish",
|
|
defaultMessage: "Unpublish"
|
|
}),
|
|
dialog: {
|
|
type: "dialog",
|
|
title: formatMessage({
|
|
id: "app.components.ConfirmDialog.title",
|
|
defaultMessage: "Confirmation"
|
|
}),
|
|
loading: isLoading,
|
|
content: (0, import_jsx_runtime3.jsxs)(Flex, {
|
|
direction: "column",
|
|
alignItems: "stretch",
|
|
gap: 2,
|
|
children: [
|
|
(0, import_jsx_runtime3.jsx)(Flex, {
|
|
justifyContent: "center",
|
|
children: (0, import_jsx_runtime3.jsx)(ForwardRef$3, {
|
|
width: "24px",
|
|
height: "24px",
|
|
fill: "danger600"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime3.jsx)(Typography, {
|
|
id: "confirm-description",
|
|
textAlign: "center",
|
|
children: formatMessage({
|
|
id: "popUpWarning.bodyMessage.contentType.unpublish.all",
|
|
defaultMessage: "Are you sure you want to unpublish these entries?"
|
|
})
|
|
}),
|
|
hasI18nEnabled && (0, import_jsx_runtime3.jsx)(Box, {
|
|
textAlign: "center",
|
|
padding: 3,
|
|
children: (0, import_jsx_runtime3.jsx)(Typography, {
|
|
textColor: "danger500",
|
|
children: formatMessage({
|
|
id: getTranslation("Settings.list.actions.unpublishAdditionalInfos"),
|
|
defaultMessage: "This will unpublish the active locale versions <em>(from Internationalization)</em>"
|
|
}, {
|
|
em: Emphasis
|
|
})
|
|
})
|
|
})
|
|
]
|
|
}),
|
|
confirmButton: formatMessage({
|
|
id: "app.utils.unpublish",
|
|
defaultMessage: "Unpublish"
|
|
}),
|
|
onConfirm: handleConfirmBulkUnpublish
|
|
}
|
|
};
|
|
};
|
|
UnpublishAction.type = "unpublish";
|
|
var Emphasis = (chunks) => (0, import_jsx_runtime3.jsx)(Typography, {
|
|
fontWeight: "semiBold",
|
|
textColor: "danger500",
|
|
children: chunks
|
|
});
|
|
var DEFAULT_BULK_ACTIONS = [
|
|
PublishAction,
|
|
UnpublishAction,
|
|
DeleteAction
|
|
];
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/TableActions.mjs
|
|
var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
|
|
var React4 = __toESM(require_react(), 1);
|
|
var import_qs = __toESM(require_lib(), 1);
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/AutoCloneFailureModal.mjs
|
|
var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
|
|
var AutoCloneFailureModalBody = ({ prohibitedFields }) => {
|
|
const { formatMessage } = useIntl();
|
|
const getDefaultErrorMessage = (reason) => {
|
|
switch (reason) {
|
|
case "relation":
|
|
return "Duplicating the relation could remove it from the original entry.";
|
|
case "unique":
|
|
return "Identical values in a unique field are not allowed";
|
|
default:
|
|
return reason;
|
|
}
|
|
};
|
|
return (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, {
|
|
children: [
|
|
(0, import_jsx_runtime4.jsx)(Typography, {
|
|
variant: "beta",
|
|
children: formatMessage({
|
|
id: getTranslation("containers.list.autoCloneModal.title"),
|
|
defaultMessage: "This entry can't be duplicated directly."
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime4.jsx)(Box, {
|
|
marginTop: 2,
|
|
children: (0, import_jsx_runtime4.jsx)(Typography, {
|
|
textColor: "neutral600",
|
|
children: formatMessage({
|
|
id: getTranslation("containers.list.autoCloneModal.description"),
|
|
defaultMessage: "A new entry will be created with the same content, but you'll have to change the following fields to save it."
|
|
})
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime4.jsx)(Flex, {
|
|
marginTop: 6,
|
|
gap: 2,
|
|
direction: "column",
|
|
alignItems: "stretch",
|
|
children: prohibitedFields.map(([fieldPath, reason]) => (0, import_jsx_runtime4.jsxs)(Flex, {
|
|
direction: "column",
|
|
gap: 2,
|
|
alignItems: "flex-start",
|
|
borderColor: "neutral200",
|
|
hasRadius: true,
|
|
padding: 6,
|
|
children: [
|
|
(0, import_jsx_runtime4.jsx)(Flex, {
|
|
direction: "row",
|
|
tag: "ol",
|
|
children: fieldPath.map((pathSegment, index) => (0, import_jsx_runtime4.jsxs)(Typography, {
|
|
fontWeight: "semiBold",
|
|
tag: "li",
|
|
children: [
|
|
pathSegment,
|
|
index !== fieldPath.length - 1 && (0, import_jsx_runtime4.jsx)(ForwardRef$4v, {
|
|
fill: "neutral500",
|
|
height: "0.8rem",
|
|
width: "0.8rem",
|
|
style: {
|
|
margin: "0 0.8rem"
|
|
}
|
|
})
|
|
]
|
|
}, index))
|
|
}),
|
|
(0, import_jsx_runtime4.jsx)(Typography, {
|
|
tag: "p",
|
|
textColor: "neutral600",
|
|
children: formatMessage({
|
|
id: getTranslation(`containers.list.autoCloneModal.error.${reason}`),
|
|
defaultMessage: getDefaultErrorMessage(reason)
|
|
})
|
|
})
|
|
]
|
|
}, fieldPath.join()))
|
|
})
|
|
]
|
|
});
|
|
};
|
|
|
|
// node_modules/@strapi/content-manager/dist/admin/pages/ListView/components/TableActions.mjs
|
|
var TableActions = ({ document }) => {
|
|
const { formatMessage } = useIntl();
|
|
const { model, collectionType } = useDoc();
|
|
const plugins = useStrapiApp("TableActions", (state) => state.plugins);
|
|
const props = {
|
|
activeTab: null,
|
|
model,
|
|
documentId: document.documentId,
|
|
collectionType,
|
|
document
|
|
};
|
|
return (0, import_jsx_runtime5.jsx)(DescriptionComponentRenderer, {
|
|
props,
|
|
descriptions: plugins["content-manager"].apis.getDocumentActions("table-row").filter((action) => action.name !== "PublishAction"),
|
|
children: (actions) => {
|
|
const tableRowActions = actions.filter((action) => {
|
|
const positions = Array.isArray(action.position) ? action.position : [
|
|
action.position
|
|
];
|
|
return positions.includes("table-row");
|
|
});
|
|
return (0, import_jsx_runtime5.jsx)(DocumentActionsMenu, {
|
|
actions: tableRowActions,
|
|
label: formatMessage({
|
|
id: "content-manager.containers.list.table.row-actions",
|
|
defaultMessage: "Row actions"
|
|
}),
|
|
variant: "ghost"
|
|
});
|
|
}
|
|
});
|
|
};
|
|
var EditAction = ({ documentId }) => {
|
|
const navigate = useNavigate();
|
|
const { formatMessage } = useIntl();
|
|
const { canRead } = useDocumentRBAC("EditAction", ({ canRead: canRead2 }) => ({
|
|
canRead: canRead2
|
|
}));
|
|
const { toggleNotification } = useNotification();
|
|
const [{ query }] = useQueryParams();
|
|
return {
|
|
disabled: !canRead,
|
|
icon: (0, import_jsx_runtime5.jsx)(StyledPencil, {}),
|
|
label: formatMessage({
|
|
id: "content-manager.actions.edit.label",
|
|
defaultMessage: "Edit"
|
|
}),
|
|
position: "table-row",
|
|
onClick: async () => {
|
|
if (!documentId) {
|
|
console.error("You're trying to edit a document without an id, this is likely a bug with Strapi. Please open an issue.");
|
|
toggleNotification({
|
|
message: formatMessage({
|
|
id: "content-manager.actions.edit.error",
|
|
defaultMessage: "An error occurred while trying to edit the document."
|
|
}),
|
|
type: "danger"
|
|
});
|
|
return;
|
|
}
|
|
navigate({
|
|
pathname: documentId,
|
|
search: (0, import_qs.stringify)({
|
|
plugins: query.plugins
|
|
})
|
|
});
|
|
}
|
|
};
|
|
};
|
|
EditAction.type = "edit";
|
|
EditAction.position = "table-row";
|
|
var StyledPencil = dt(ForwardRef$1v)`
|
|
path {
|
|
fill: currentColor;
|
|
}
|
|
`;
|
|
var CloneAction = ({ model, documentId }) => {
|
|
const navigate = useNavigate();
|
|
const { formatMessage } = useIntl();
|
|
const { canCreate } = useDocumentRBAC("CloneAction", ({ canCreate: canCreate2 }) => ({
|
|
canCreate: canCreate2
|
|
}));
|
|
const { toggleNotification } = useNotification();
|
|
const { autoClone } = useDocumentActions();
|
|
const [prohibitedFields, setProhibitedFields] = React4.useState([]);
|
|
return {
|
|
disabled: !canCreate,
|
|
icon: (0, import_jsx_runtime5.jsx)(StyledDuplicate, {}),
|
|
label: formatMessage({
|
|
id: "content-manager.actions.clone.label",
|
|
defaultMessage: "Duplicate"
|
|
}),
|
|
position: "table-row",
|
|
onClick: async () => {
|
|
if (!documentId) {
|
|
console.error("You're trying to clone a document in the table without an id, this is likely a bug with Strapi. Please open an issue.");
|
|
toggleNotification({
|
|
message: formatMessage({
|
|
id: "content-manager.actions.clone.error",
|
|
defaultMessage: "An error occurred while trying to clone the document."
|
|
}),
|
|
type: "danger"
|
|
});
|
|
return;
|
|
}
|
|
const res = await autoClone({
|
|
model,
|
|
sourceId: documentId
|
|
});
|
|
if ("data" in res) {
|
|
navigate(res.data.documentId);
|
|
return true;
|
|
}
|
|
if (isBaseQueryError(res.error) && res.error.details && typeof res.error.details === "object" && "prohibitedFields" in res.error.details && Array.isArray(res.error.details.prohibitedFields)) {
|
|
const prohibitedFields2 = res.error.details.prohibitedFields;
|
|
setProhibitedFields(prohibitedFields2);
|
|
}
|
|
},
|
|
dialog: {
|
|
type: "modal",
|
|
title: formatMessage({
|
|
id: "content-manager.containers.list.autoCloneModal.header",
|
|
defaultMessage: "Duplicate"
|
|
}),
|
|
content: (0, import_jsx_runtime5.jsx)(AutoCloneFailureModalBody, {
|
|
prohibitedFields
|
|
}),
|
|
footer: ({ onClose }) => {
|
|
return (0, import_jsx_runtime5.jsxs)(Modal.Footer, {
|
|
children: [
|
|
(0, import_jsx_runtime5.jsx)(Button, {
|
|
onClick: onClose,
|
|
variant: "tertiary",
|
|
children: formatMessage({
|
|
id: "cancel",
|
|
defaultMessage: "Cancel"
|
|
})
|
|
}),
|
|
(0, import_jsx_runtime5.jsx)(LinkButton, {
|
|
tag: NavLink,
|
|
to: {
|
|
pathname: `clone/${documentId}`
|
|
},
|
|
children: formatMessage({
|
|
id: "content-manager.containers.list.autoCloneModal.create",
|
|
defaultMessage: "Create"
|
|
})
|
|
})
|
|
]
|
|
});
|
|
}
|
|
}
|
|
};
|
|
};
|
|
CloneAction.type = "clone";
|
|
CloneAction.position = "table-row";
|
|
var StyledDuplicate = dt(ForwardRef$3R)`
|
|
path {
|
|
fill: currentColor;
|
|
}
|
|
`;
|
|
var DEFAULT_TABLE_ROW_ACTIONS = [
|
|
EditAction,
|
|
CloneAction
|
|
];
|
|
|
|
export {
|
|
BulkActionsRenderer,
|
|
DEFAULT_BULK_ACTIONS,
|
|
TableActions,
|
|
DEFAULT_TABLE_ROW_ACTIONS
|
|
};
|
|
//# sourceMappingURL=chunk-MLTBQQQV.js.map
|