Doc write

frontend/src/components/smart-editor/context.tsx

@@ -1,4 +1,4 @@
-import { useCanManageDocument } from '@app/components/smart-editor/hooks/use-can-edit-document';
+import { useCanEditDocument, useCanManageDocument } from '@app/components/smart-editor/hooks/use-can-edit-document';
 import {
   useSmartEditorAnnotationsAtOrigin,
   useSmartEditorGodeFormuleringerOpen,
@@ -25,6 +25,8 @@ interface ISmartEditorContext extends Pick<ISmartDocument, 'templateId' | 'dokum
   setShowAnnotationsAtOrigin: (show: boolean) => void;
   sheetRef: MutableRefObject<HTMLDivElement | null>;
   canManage: boolean;
+  canEdit: boolean;
+  creator: string;
 }
 
 export const SmartEditorContext = createContext<ISmartEditorContext>({
@@ -43,6 +45,8 @@ export const SmartEditorContext = createContext<ISmartEditorContext>({
   setShowAnnotationsAtOrigin: noop,
   sheetRef: { current: null },
   canManage: false,
+  canEdit: false,
+  creator: '',
 });
 
 interface Props {
@@ -51,7 +55,7 @@ interface Props {
 }
 
 export const SmartEditorContextComponent = ({ children, smartDocument }: Props) => {
-  const { dokumentTypeId, templateId, id } = smartDocument;
+  const { dokumentTypeId, templateId, id, creator } = smartDocument;
   const { value: showGodeFormuleringer = false, setValue: setShowGodeFormuleringer } =
     useSmartEditorGodeFormuleringerOpen();
   const { value: showHistory = false, setValue: setShowHistory } = useSmartEditorHistoryOpen();
@@ -61,7 +65,8 @@ export const SmartEditorContextComponent = ({ children, smartDocument }: Props)
     useSmartEditorAnnotationsAtOrigin();
   // const [sheetRef, setSheetRef] = useState<HTMLDivElement | null>(null);
   const sheetRef = useRef<HTMLDivElement | null>(null);
-  const canManage = useCanManageDocument(templateId);
+  const canManage = useCanManageDocument(templateId, creator.employee.navIdent);
+  const canEdit = useCanEditDocument(templateId, creator.employee.navIdent);
 
   return (
     <SmartEditorContext.Provider
@@ -81,6 +86,8 @@ export const SmartEditorContextComponent = ({ children, smartDocument }: Props)
         setShowAnnotationsAtOrigin,
         sheetRef,
         canManage,
+        canEdit,
+        creator: creator.employee.navIdent,
       }}
     >
       {children}

frontend/src/components/smart-editor/history/history-editor.tsx

@@ -34,7 +34,7 @@ export const HistoryEditor = memo(
   ({ smartDocument, version, versionId }: Props) => {
     const mainEditor = useMyPlateEditorRef(smartDocument.id);
     const { templateId } = useContext(SmartEditorContext);
-    const canManage = useCanManageDocument(templateId);
+    const canManage = useCanManageDocument(templateId, smartDocument.creator.employee.navIdent);
 
     const id = `${smartDocument.id}-${versionId}`;
 

frontend/src/components/smart-editor/hooks/use-can-edit-document.ts

@@ -7,17 +7,22 @@ import type { IOppgavebehandling } from '@app/types/oppgavebehandling/oppgavebeh
 import { TemplateIdEnum } from '@app/types/smart-editor/template-enums';
 import { useContext, useMemo } from 'react';
 
-export const useCanManageDocument = (templateId: TemplateIdEnum): boolean => {
+export const useCanManageDocument = (templateId: TemplateIdEnum, creator: string): boolean => {
   const { data: oppgave, isSuccess } = useOppgave();
   const { user } = useContext(StaticDataContext);
 
   return useMemo<boolean>(
-    () => isSuccess && canManageDocument(templateId, oppgave, user),
-    [oppgave, isSuccess, templateId, user],
+    () => isSuccess && canManageDocument(templateId, oppgave, user, creator),
+    [oppgave, isSuccess, templateId, user, creator],
   );
 };
 
-const canManageDocument = (templateId: TemplateIdEnum, oppgave: IOppgavebehandling, user: IUserData): boolean => {
+const canManageDocument = (
+  templateId: TemplateIdEnum,
+  oppgave: IOppgavebehandling,
+  user: IUserData,
+  creator: string,
+): boolean => {
   if (
     (oppgave.typeId === SaksTypeEnum.KLAGE || oppgave.typeId === SaksTypeEnum.ANKE) &&
     oppgave.rol?.flowState === FlowState.SENT &&
@@ -32,16 +37,23 @@ const canManageDocument = (templateId: TemplateIdEnum, oppgave: IOppgavebehandli
   }
 
   if (isMu(oppgave, user)) {
-    return false;
+    return oppgave.avsluttetAvSaksbehandlerDate !== null && saksbehandlerCanEdit(templateId, oppgave, user, creator);
   }
 
-  return saksbehandlerCanEdit(templateId, oppgave, user);
+  return saksbehandlerCanEdit(templateId, oppgave, user, creator);
 };
 
-const saksbehandlerCanEdit = (templateId: TemplateIdEnum, oppgave: IOppgavebehandling, user: IUserData): boolean => {
-  if (oppgave.saksbehandler?.navIdent !== user.navIdent) {
-    return false;
-  }
+const saksbehandlerCanEdit = (
+  templateId: TemplateIdEnum,
+  oppgave: IOppgavebehandling,
+  user: IUserData,
+  creator: string,
+): boolean => {
+  const isCreator = creator === user.navIdent;
+  const isFinished = oppgave.avsluttetAvSaksbehandlerDate !== null;
+  const isAssigned = oppgave.saksbehandler?.navIdent === user.navIdent;
+
+  const canWrite = (!isFinished && isAssigned) || (isFinished && isCreator);
 
   if (templateId === TemplateIdEnum.ROL_ANSWERS) {
     return false;
@@ -50,12 +62,13 @@ const saksbehandlerCanEdit = (templateId: TemplateIdEnum, oppgave: IOppgavebehan
   // When behandling is sent to ROL, saksbehandler can edit everything except questions.
   if (templateId === TemplateIdEnum.ROL_QUESTIONS) {
     return (
+      canWrite &&
       (oppgave.typeId === SaksTypeEnum.KLAGE || oppgave.typeId === SaksTypeEnum.ANKE) &&
       oppgave.rol?.flowState !== FlowState.SENT
     );
   }
 
-  return oppgave.medunderskriver?.flowState !== FlowState.SENT;
+  return canWrite && oppgave.medunderskriver?.flowState !== FlowState.SENT;
 };
 
 const isMu = (oppgave: IOppgavebehandling, user: IUserData): boolean =>
@@ -71,18 +84,23 @@ const rolCanEdit = (templateId: TemplateIdEnum, oppgave: IOppgavebehandling): bo
   oppgave.rol.flowState === FlowState.SENT &&
   templateId === TemplateIdEnum.ROL_ANSWERS;
 
-export const useCanEditDocument = (templateId: TemplateIdEnum): boolean => {
+export const useCanEditDocument = (templateId: TemplateIdEnum, creator: string): boolean => {
   const { data: oppgave, isSuccess } = useOppgave();
   const { user } = useContext(StaticDataContext);
 
   return useMemo<boolean>(
-    () => isSuccess && canEditDocument(templateId, oppgave, user),
-    [oppgave, isSuccess, templateId, user],
+    () => isSuccess && canEditDocument(templateId, oppgave, user, creator),
+    [oppgave, isSuccess, templateId, user, creator],
   );
 };
 
 const muCanEdit = (templateId: TemplateIdEnum, oppgave: IOppgavebehandling): boolean =>
   oppgave.medunderskriver.flowState === FlowState.SENT && templateId !== TemplateIdEnum.ROL_ANSWERS;
 
-export const canEditDocument = (templateId: TemplateIdEnum, oppgave: IOppgavebehandling, user: IUserData): boolean =>
-  canManageDocument(templateId, oppgave, user) || (isMu(oppgave, user) && muCanEdit(templateId, oppgave));
+export const canEditDocument = (
+  templateId: TemplateIdEnum,
+  oppgave: IOppgavebehandling,
+  user: IUserData,
+  creator: string,
+): boolean =>
+  canManageDocument(templateId, oppgave, user, creator) || (isMu(oppgave, user) && muCanEdit(templateId, oppgave));

frontend/src/components/smart-editor/tabbed-editors/editor.tsx

@@ -68,10 +68,10 @@ interface LoadedEditorProps extends EditorProps {
 }
 
 const LoadedEditor = ({ oppgave, smartDocument, scalingGroup }: LoadedEditorProps) => {
-  const { id, templateId } = smartDocument;
+  const { id, templateId, creator } = smartDocument;
   const { newCommentSelection } = useContext(SmartEditorContext);
   const { user } = useContext(StaticDataContext);
-  const canEdit = useCanEditDocument(templateId);
+  const canEdit = useCanEditDocument(templateId, creator.employee.navIdent);
   const plugins = collaborationSaksbehandlerPlugins(oppgave.id, id, smartDocument, user);
 
   const editor = usePlateEditor<KabalValue, (typeof plugins)[0]>({
@@ -295,8 +295,7 @@ interface EditorWithNewCommentAndFloatingToolbarProps {
 }
 
 const EditorWithNewCommentAndFloatingToolbar = ({ id, isConnected }: EditorWithNewCommentAndFloatingToolbarProps) => {
-  const { templateId, sheetRef } = useContext(SmartEditorContext);
-  const canEdit = useCanEditDocument(templateId);
+  const { sheetRef, canEdit } = useContext(SmartEditorContext);
   const [containerElement, setContainerElement] = useState<HTMLDivElement | null>(null);
   const lang = useSmartEditorSpellCheckLanguage();
 

frontend/src/components/smart-editor/tabbed-editors/tab-panel.tsx

@@ -16,7 +16,7 @@ export const TabPanel = ({ smartDocument }: TabPanelProps) => {
   const { id } = smartDocument;
   const smartDocumentRef = useRef<ISmartDocument>(smartDocument);
 
-  const canEditDocument = useCanEditDocument(smartDocument.templateId);
+  const canEditDocument = useCanEditDocument(smartDocument.templateId, smartDocument.creator.employee.navIdent);
   const canEditDocumentRef = useRef(canEditDocument);
 
   // Ensure that smartDocumentRef and canEditDocumentRef are always up to date in order to avoid the unmount debounce triggering on archive/delete/fradeling

frontend/src/plate/components/signature/hooks.ts

@@ -1,8 +1,14 @@
+import { SmartEditorContext } from '@app/components/smart-editor/context';
 import { useOppgave } from '@app/hooks/oppgavebehandling/use-oppgave';
+import { getName, getTitle } from '@app/plate/components/signature/functions';
+import { MISSING_TITLE } from '@app/plate/components/signature/title';
+import type { ISignature, SignatureElement } from '@app/plate/types';
 import { useGetSignatureQuery } from '@app/redux-api/bruker';
+import type { ISignatureResponse } from '@app/types/bruker';
 import { SaksTypeEnum } from '@app/types/kodeverk';
 import { TemplateIdEnum } from '@app/types/smart-editor/template-enums';
 import { skipToken } from '@reduxjs/toolkit/query';
+import { useContext } from 'react';
 
 export const useMedunderskriverSignature = () => {
   const { data: oppgave } = useOppgave();
@@ -19,31 +25,47 @@ export const useMedunderskriverSignature = () => {
   return medunderskriverSignature;
 };
 
-export const useMainSignature = (template: TemplateIdEnum) => {
+export const useMainSignature = (element: SignatureElement): ISignature | undefined => {
   const { data: oppgave } = useOppgave();
+  const { templateId, creator } = useContext(SmartEditorContext);
 
-  const isRolAnswers = template === TemplateIdEnum.ROL_ANSWERS;
+  const isRolAnswers = templateId === TemplateIdEnum.ROL_ANSWERS;
   const isRolSakstype = oppgave?.typeId === SaksTypeEnum.KLAGE || oppgave?.typeId === SaksTypeEnum.ANKE;
 
-  const { data: saksbehandlerSignature } = useGetSignatureQuery(
-    !isRolAnswers && typeof oppgave?.saksbehandler?.navIdent === 'string' ? oppgave.saksbehandler.navIdent : skipToken,
-  );
-
+  const { data: creatorSignature } = useGetSignatureQuery(isRolAnswers ? skipToken : creator);
+  const { data: overrideSignature } = useGetSignatureQuery(element.overriddenSaksbehandler ?? skipToken);
   const { data: rolSignature } = useGetSignatureQuery(
     isRolAnswers && isRolSakstype ? (oppgave.rol.employee?.navIdent ?? skipToken) : skipToken,
   );
 
+  if (element.anonymous) {
+    return { name: 'Nav klageinstans' };
+  }
+
+  const suffix = templateId !== TemplateIdEnum.ROL_ANSWERS && element.useSuffix ? 'saksbehandler' : undefined;
+
   if (isRolAnswers) {
-    if (oppgave === undefined || !isRolSakstype || oppgave.rol.employee === null || rolSignature === undefined) {
-      return null;
-    }
+    return toSignature(rolSignature, element.useShortName, suffix);
+  }
 
-    return rolSignature;
+  if (element.overriddenSaksbehandler !== undefined) {
+    return toSignature(overrideSignature, element.useShortName, suffix);
   }
 
-  if (oppgave === undefined || oppgave.saksbehandler === null || saksbehandlerSignature === undefined) {
-    return null;
+  return toSignature(creatorSignature, element.useShortName, suffix);
+};
+
+const toSignature = (
+  signature: ISignatureResponse | undefined,
+  useShortName: boolean,
+  suffix: string | undefined,
+): ISignature | undefined => {
+  if (signature === undefined) {
+    return undefined;
   }
 
-  return saksbehandlerSignature;
+  return {
+    name: getName(signature, useShortName),
+    title: getTitle(signature.customJobTitle, suffix) ?? MISSING_TITLE,
+  };
 };

frontend/src/plate/components/signature/individual-signature.tsx

@@ -1,7 +1,7 @@
 import { SmartEditorContext } from '@app/components/smart-editor/context';
-import { getName, getTitle } from '@app/plate/components/signature/functions';
+import { getName } from '@app/plate/components/signature/functions';
 import { useMainSignature, useMedunderskriverSignature } from '@app/plate/components/signature/hooks';
-import { type ISignature, type SignatureElement, useMyPlateEditorRef } from '@app/plate/types';
+import { type SignatureElement, useMyPlateEditorRef } from '@app/plate/types';
 import { TemplateIdEnum } from '@app/types/smart-editor/template-enums';
 import { setNodes } from '@udecode/plate-common';
 import { useContext, useEffect, useMemo } from 'react';
@@ -14,41 +14,17 @@ interface Props {
 
 export const SaksbehandlerSignature = ({ element }: Props) => {
   const editor = useMyPlateEditorRef();
-  const { templateId } = useContext(SmartEditorContext);
-  const saksbehandlerSignature = useMainSignature(templateId);
-
-  const signature: ISignature | undefined = useMemo(() => {
-    if (saksbehandlerSignature === null) {
-      return undefined;
-    }
-
-    const suffix = templateId !== TemplateIdEnum.ROL_ANSWERS && element.useSuffix ? 'saksbehandler' : undefined;
-
-    if (saksbehandlerSignature.anonymous) {
-      return { name: 'Nav klageinstans' };
-    }
-
-    return {
-      name: getName(saksbehandlerSignature, element.useShortName),
-      title: getTitle(saksbehandlerSignature.customJobTitle, suffix) ?? MISSING_TITLE,
-    };
-  }, [saksbehandlerSignature, templateId, element.useSuffix, element.useShortName]);
+  const signature = useMainSignature(element);
 
   useEffect(() => {
-    if (element.saksbehandler?.name === signature?.name && element.saksbehandler?.title === signature?.title) {
+    if (
+      signature === element.saksbehandler ||
+      (signature?.name === element.saksbehandler?.name && signature?.title === element.saksbehandler?.title)
+    ) {
       return;
     }
 
-    const data: Partial<SignatureElement> = {
-      useShortName: element.useShortName,
-      medunderskriver: element.medunderskriver,
-      saksbehandler: signature,
-    };
-
-    setNodes(editor, data, {
-      at: [],
-      match: (n) => n === element,
-    });
+    setNodes(editor, { saksbehandler: signature }, { at: [], match: (n) => n === element });
   }, [editor, element, signature]);
 
   if (signature === undefined) {

frontend/src/plate/components/signature/signature.tsx

@@ -1,3 +1,4 @@
+import { StaticDataContext } from '@app/components/app/static-data-context';
 import { SmartEditorContext } from '@app/components/smart-editor/context';
 import { useOppgave } from '@app/hooks/oppgavebehandling/use-oppgave';
 import { AddNewParagraphs } from '@app/plate/components/common/add-new-paragraph-buttons';
@@ -6,7 +7,7 @@ import { MedunderskriverSignature, SaksbehandlerSignature } from '@app/plate/com
 import type { SignatureElement } from '@app/plate/types';
 import { useGetMySignatureQuery } from '@app/redux-api/bruker';
 import { TemplateIdEnum } from '@app/types/smart-editor/template-enums';
-import { setNodes } from '@udecode/plate-common';
+import { type SetNodesOptions, setNodes } from '@udecode/plate-common';
 import { PlateElement, type PlateElementProps, useEditorReadOnly } from '@udecode/plate-common/react';
 import { type InputHTMLAttributes, useContext } from 'react';
 import { styled } from 'styled-components';
@@ -17,7 +18,8 @@ export const Signature = (props: PlateElementProps<SignatureElement>) => {
   const isReadOnly = useEditorReadOnly();
   const { data: signature } = useGetMySignatureQuery();
   const { data: oppgave } = useOppgave();
-  const { canManage, templateId } = useContext(SmartEditorContext);
+  const { canManage, templateId, creator } = useContext(SmartEditorContext);
+  const { user } = useContext(StaticDataContext);
 
   if (oppgave === undefined || signature === undefined) {
     return null;
@@ -33,9 +35,19 @@ export const Signature = (props: PlateElementProps<SignatureElement>) => {
   const hideAll = !(showForkortedeNavnCheckbox || showSuffixCheckbox || hasMedunderskriver);
 
   const { children, element, editor } = props;
+  const overriddenWithSelf = element.overriddenSaksbehandler === user.navIdent;
+
+  const options: SetNodesOptions = { at: [], voids: true, mode: 'lowest', match: (n) => n === element };
 
   const setSignatureProp = (prop: Partial<SignatureElement>) =>
-    setNodes(editor, { ...element, ...prop }, { at: [], voids: true, mode: 'lowest', match: (n) => n === element });
+    setNodes(
+      editor,
+      { ...prop, overriddenSaksbehandler: overriddenWithSelf ? element.overriddenSaksbehandler : undefined },
+      options,
+    );
+
+  const setOverriddenSaksbehandler = (overriddenSaksbehandler: string | undefined) =>
+    setNodes(editor, { overriddenSaksbehandler }, options);
 
   return (
     <PlateElement<SignatureElement> {...props} asChild contentEditable={false}>
@@ -79,6 +91,19 @@ export const Signature = (props: PlateElementProps<SignatureElement>) => {
                 Bruk «/saksbehandler»-tittel
               </Checkbox>
             ) : null}
+
+            <Checkbox
+              disabled={
+                isReadOnly ||
+                (user.navIdent === creator && (overriddenWithSelf || element.overriddenSaksbehandler === undefined))
+              }
+              checked={
+                overriddenWithSelf || (user.navIdent === creator && element.overriddenSaksbehandler === undefined)
+              }
+              onChange={({ target }) => setOverriddenSaksbehandler(target.checked ? user.navIdent : undefined)}
+            >
+              Signer med mitt navn
+            </Checkbox>
           </Checkboxes>
         )}