@red-hat-developer-hub/backstage-plugin-bulk-import/dist/components/PreviewFile/PreviewFileSidebar.esm.js

import { jsx } from 'react/jsx-runtime';
import { useState, useCallback, useEffect } from 'react';
import { useApi, identityApiRef, configApiRef } from '@backstage/core-plugin-api';
import Drawer from '@mui/material/Drawer';
import { makeStyles } from '@mui/styles';
import { useFormikContext } from 'formik';
import { bulkImportApiRef } from '../../api/BulkImportBackendClient.esm.js';
import { RepositoryStatus } from '../../types/types.esm.js';
import { evaluatePRTemplate, getPRTemplate } from '../../utils/repository-utils.esm.js';
import { PreviewFileSidebarDrawerContent } from './PreviewFileSidebarDrawerContent.esm.js';

const useDrawerStyles = makeStyles({
  paper: {
    width: "40%",
    gap: "3%"
  }
});
const PreviewFileSidebar = ({
  open,
  onClose,
  repositoryType,
  data,
  handleSave,
  isSubmitting
}) => {
  const { setStatus, status, setFieldValue, values } = useFormikContext();
  const classes = useDrawerStyles();
  const bulkImportApi = useApi(bulkImportApiRef);
  const identityApi = useApi(identityApiRef);
  const configApi = useApi(configApiRef);
  const [pullRequest, setPullRequest] = useState({});
  const [isInitialized, setIsInitialized] = useState(false);
  const fetchPullRequestData = async (id, repoName, orgName, url, branch, repoPrTemplate) => {
    if (values?.repositories?.[id]?.catalogInfoYaml?.isInitialized) {
      return values.repositories[id].catalogInfoYaml?.prTemplate;
    }
    const result = await bulkImportApi.getImportAction(
      url || "",
      branch || "main"
    );
    if (result?.statusText) {
      setStatus({
        ...status,
        errors: {
          ...status?.errors || {},
          [id]: {
            error: {
              title: result?.statusText,
              message: [
                `Failed to fetch the pull request. A new YAML has been generated below.`
              ]
            }
          }
        }
      });
      return repoPrTemplate;
    } else if (result?.status === RepositoryStatus.WAIT_PR_APPROVAL) {
      const importJobResult = result;
      const evaluatedPRTemplate = evaluatePRTemplate(importJobResult);
      let pullReqPreview = { ...evaluatedPRTemplate.pullReqPreview };
      if (evaluatedPRTemplate.isInvalidEntity) {
        const identityRef = await identityApi.getBackstageIdentity();
        const baseUrl = configApi.getString("app.baseUrl");
        const prTemp = getPRTemplate(
          repoName,
          orgName,
          identityRef.userEntityRef || "user:default/guest",
          baseUrl,
          url,
          branch
        );
        delete prTemp.prDescription;
        delete prTemp.prTitle;
        setStatus({
          ...status,
          infos: {
            ...status?.infos || {},
            [id]: {
              error: {
                message: [
                  "The entity YAML in your pull request is invalid (empty file or missing apiVersion, kind, or metadata.name). A new YAML has been generated below."
                ]
              }
            }
          }
        });
        pullReqPreview = {
          ...prTemp,
          pullRequestUrl: pullReqPreview.pullRequestUrl || "",
          prDescription: pullReqPreview.prDescription || "",
          prTitle: pullReqPreview.prTitle || ""
        };
      }
      return pullReqPreview;
    }
    return repoPrTemplate;
  };
  const initializePullRequest = useCallback(async () => {
    const newPullRequestData = {};
    if (Object.keys(data?.selectedRepositories || [])?.length > 0) {
      for (const repo of Object.values(data?.selectedRepositories || [])) {
        newPullRequestData[repo.id] = await fetchPullRequestData(
          repo.id,
          repo.repoName || "",
          repo.orgName || "",
          repo.repoUrl || "",
          repo.defaultBranch || "main",
          repo.catalogInfoYaml?.prTemplate
        );
        setFieldValue(
          `repositories.${repo.id}.catalogInfoYaml.isInitialized`,
          true
        );
      }
    } else {
      newPullRequestData[data.id] = await fetchPullRequestData(
        data.id,
        data.repoName || "",
        data.orgName || "",
        data.repoUrl || "",
        data.defaultBranch || "main",
        data.catalogInfoYaml?.prTemplate
      );
      setFieldValue(
        `repositories.${data.id}.catalogInfoYaml.isInitialized`,
        true
      );
    }
    setPullRequest(newPullRequestData);
    setIsInitialized(true);
  }, [data, bulkImportApi, setStatus, status]);
  useEffect(() => {
    if (!isInitialized && data?.id) {
      initializePullRequest();
    }
  }, [isInitialized, data?.id, initializePullRequest]);
  const handleCancel = () => {
    initializePullRequest();
    onClose();
  };
  return /* @__PURE__ */ jsx(
    Drawer,
    {
      anchor: "right",
      open,
      onClose,
      "data-testid": !isInitialized ? "preview-pullrequest-sidebar-loading" : "preview-pullrequest-sidebar",
      classes: {
        paper: classes.paper
      },
      children: /* @__PURE__ */ jsx(
        PreviewFileSidebarDrawerContent,
        {
          repositoryType,
          onCancel: handleCancel,
          isLoading: !isInitialized,
          isSubmitting,
          data,
          pullRequest,
          onSave: handleSave,
          setPullRequest
        }
      )
    }
  );
};

export { PreviewFileSidebar };
//# sourceMappingURL=PreviewFileSidebar.esm.js.map