diff --git a/content/altinn-studio/concepts/signing/_index.en.md b/content/altinn-studio/concepts/signing/_index.en.md index b1da2d2134b..abeaa0b1bc8 100644 --- a/content/altinn-studio/concepts/signing/_index.en.md +++ b/content/altinn-studio/concepts/signing/_index.en.md @@ -1,11 +1,11 @@ --- -title: Signing -description: What is signing in an Altinn 3 service? -weight: 10 - +title: Signing +description: What is signing in an Altinn 3 service? +weight: 10 --- ## Authenticated Electronic Signature + An electronic signature is linked to traceability. Traceability means being able to demonstrate that an action was performed at a specific time and tied to a specific identity. The requirements for traceability describe the extent to which it should be possible to verify afterward that an actor was responsible for a piece of information or performed an action at a specific time. An authenticated electronic signature allows service owners to ensure traceability by verifying that an identified person performed a signing action at a specific time, e.g., when the end user confirms the accuracy of information by signing. The signing solution in Altinn 3 is an authenticated signature with the option of security level 3 or 4. The authentication level is configurable for each service. It is also possible to choose lower authentication levels than 3 and 4. If advanced signatures are desired, third-party products such as [eSignering | Samarbeidsportalen (digdir.no)](https://samarbeid.digdir.no/esignering/esignering/22) must be used. @@ -13,32 +13,40 @@ An authenticated electronic signature allows service owners to ensure traceabili Service owners must make their own assessment of which electronic signature they want and need for their services, based on the requirements for signature and traceability in the regulations for which each service owner is responsible. ## Functionality + ### What is being signed? + The service owner controls the selection of data elements that are to be signed and selects which authentication level (identification level) the end user must log in with before signing (level 1-4). One or more signing steps in sequence are possible. ### Signature + The signing action is logged, and a signature object is created. The signature object represents a signature performed by a person and contains information about which data elements are signed and which are not. The signature object contains a so-called hash code of the data associated with the data elements that are signed. Hashing is a one-way mathematical algorithm that calculates a unique code based on the data. If even one character in the data is changed, the hash code will no longer match. This ensures that the data no longer aligns with what was signed, making any changes to the data detectable. ### Logging + An event log is kept, recording actions performed in the application. Signing is a type of action that is explicitly logged. The ID of the person who performed the signing action is logged, along with the security level of the login, the time of the action, which step in the process the action was performed on, and that it was a signing action. Log data related to electronic signatures in Altinn 3 is stored separately from services in a central event log database. ## Processing of personal data + To ensure traceability, personal data is processed for logging purposes. The ID of the person who performed the signing action is logged, which can be linked to a national ID number, the security level of the login, the step in the process at which the action was performed, the time of the action, and that it was a signing action. Digdir is the data controller for the processing of this personal data for this purpose. The service owner is the data controller for the processing of personal data in their services and forms, including the relevant signature object and associated data. This includes the ID of the person who performed the signing action and the national ID number. According to the collaboration agreement, Digdir is the data processor for the service owner. ## Storage time + After the process in Altinn 3 is completed, the service owner can download all data, including the signature object. The end user receives a receipt (PDF). +You may configure the persistence lifetime of the instance and its data by configuring [Persistence](../../reference/data/persistence/). If not configured, the following applies: + The service owner acknowledges that the signature object and associated data have been downloaded. The end user can choose to keep or delete their receipt for the signing from their inbox. If the end user chooses to delete their receipt after the service owner has downloaded the signature object, this means that Digdir deletes the signature object from our systems. Therefore, if you wish to archive the signature, the signature object and associated data must be stored in the service owner's systems. Digdir logs that the signing action was performed. This means that even if the signature object is deleted, Digdir still retains the log showing that a signing action was completed. Regular application logs (typically used for troubleshooting) are stored by Digdir for 90 days, while event logs are stored for 13 months. ## Verification of signature + The service owner stores the signature object in their archival system. The signature object contains a hash code of the data associated with the data element. If the signature object is later altered, this can be verified by the fact that the hash code in the signature object no longer matches. This contributes to the traceability of the signature object. This assumes that the signature, i.e., the hash code, also exists on the end user's receipt so that both parties have their own copy. [Here you can read the technical description of how signature verification is done.](https://docs.altinn.studio/nb/altinn-studio/reference/process/tasks/signing/#verifisering-av-sha256-hash) --- -Let me know if you need further adjustments! \ No newline at end of file diff --git a/content/altinn-studio/concepts/signing/_index.nb.md b/content/altinn-studio/concepts/signing/_index.nb.md index e627c40ad11..f6424d984a3 100644 --- a/content/altinn-studio/concepts/signing/_index.nb.md +++ b/content/altinn-studio/concepts/signing/_index.nb.md @@ -3,36 +3,47 @@ title: Signering description: Hva er signering i en Altinn 3 tjeneste? weight: 10 --- + ## Autentisert elektronisk signatur -Elektronisk signatur er knyttet til sporbarhet. Sporbarhet innebærer å kunne sannsynliggjøre at en handling ble gjennomført på et bestemt tidspunkt og knyttet til en bestemt identitet. Krav til sporbarhet beskriver i hvilken grad det i ettertid skal være mulig å sannsynliggjøre at en aktør står bak et informasjonselement eller har utført en handling på et bestemt tidspunkt. + +Elektronisk signatur er knyttet til sporbarhet. Sporbarhet innebærer å kunne sannsynliggjøre at en handling ble gjennomført på et bestemt tidspunkt og knyttet til en bestemt identitet. Krav til sporbarhet beskriver i hvilken grad det i ettertid skal være mulig å sannsynliggjøre at en aktør står bak et informasjonselement eller har utført en handling på et bestemt tidspunkt. Autentisert elektronisk signatur gjør det mulig for tjenesteeiere å sikre sporbarhet for å sannsynliggjøre at en identifisert person foretok en signeringshandling på et bestemt tidspunkt, f.eks. ved at sluttbruker bekrefter at opplysninger er riktig ved å signere. Signeringsløsningen i Altinn 3 er en autentisert signatur med mulighet for sikkerhetsnivå 3 eller 4. Autentiseringsnivå er konfigurerbart i den enkelte tjeneste. Man kan også velge lavere autentiseringsnivå enn 3 og 4. Ønsker man avansert signatur må man ta i bruk tredjeparts produkter som [eSignering | Samarbeidsportalen (digdir.no)](https://samarbeid.digdir.no/esignering/esignering/22). Tjenesteeierne må foreta en egen vurdering av hvilken elektronisk signatur de ønsker og har behov for i sine tjenester. Dette blant annet ut ifra hvilke krav som stilles til signatur og sporbarhet i det regelverket som den enkelte tjenesteeier har ansvar for. ## Funksjonalitet + ### Hva signeres det på? -Tjenesteeier styrer utvalg av dataelementer som skal signeres og tjenesteeier velger hvilket autentiseringsnivå (identifikasjonsnivå) som sluttbruker må logge inn med før signering (nivå 1-4). Det er mulig med ett eller flere signeringssteg i sekvens. + +Tjenesteeier styrer utvalg av dataelementer som skal signeres og tjenesteeier velger hvilket autentiseringsnivå (identifikasjonsnivå) som sluttbruker må logge inn med før signering (nivå 1-4). Det er mulig med ett eller flere signeringssteg i sekvens. ### Signatur -Signaturhandling logges og det opprettes et signaturobjekt. Signaturobjektet representerer en signatur utført av en person, inneholder informasjon om hvilke dataelementer som er signert og eventuelt ikke signert. Signaturobjektet inneholder en såkalt hash kode av dataene som tilhører dataelementene som det signeres på. Hashing er en enveis matematisk algoritme som beregner en unik kode med utgangspunkt i dataene. Dersom bare ett tegn i dataene endres vil ikke lenger hash koden bli lik. Dataene stemmer dermed ikke lenger med det som ble signert, og det blir dermed synlig hvis data endres. + +Signaturhandling logges og det opprettes et signaturobjekt. Signaturobjektet representerer en signatur utført av en person, inneholder informasjon om hvilke dataelementer som er signert og eventuelt ikke signert. Signaturobjektet inneholder en såkalt hash kode av dataene som tilhører dataelementene som det signeres på. Hashing er en enveis matematisk algoritme som beregner en unik kode med utgangspunkt i dataene. Dersom bare ett tegn i dataene endres vil ikke lenger hash koden bli lik. Dataene stemmer dermed ikke lenger med det som ble signert, og det blir dermed synlig hvis data endres. ### Logging -Det føres en hendelseslogg som inneholder hendelser utført i applikasjonen. Signering er en type handling som logges eksplisitt. Det logges id til den som utførte signeringshandlingen, sikkerhetsnivå for innloggingen, tidspunktet for handlingen, hvilket steg i prosessen handlingen ble utført på og at det var en signeringshandling. Loggdata knyttet til elektronisk signatur i Altinn 3 lagres adskilt fra tjenestene i en sentral hendelseslogg database. + +Det føres en hendelseslogg som inneholder hendelser utført i applikasjonen. Signering er en type handling som logges eksplisitt. Det logges id til den som utførte signeringshandlingen, sikkerhetsnivå for innloggingen, tidspunktet for handlingen, hvilket steg i prosessen handlingen ble utført på og at det var en signeringshandling. Loggdata knyttet til elektronisk signatur i Altinn 3 lagres adskilt fra tjenestene i en sentral hendelseslogg database. ## Behandling av personopplysninger + For å sikre sporbarhet behandles det personopplysninger til loggformål. Det logges id til den som utførte signeringshandlingen som kan kobles til fødselsnummer, sikkerhetsnivå for innloggingen, hvilket steg i prosessen handlingen ble utført på, tidspunktet for handlingen og at det er en signeringshandling. Behandling av disse personopplysningene til dette formål er Digdir behandlingsansvarlig for. Tjenesteeier er behandlingsansvarlig for behandling av personopplysninger i sine tjenester og skjema, og her for det aktuelle signeringsobjekt og tilhørende data. Dette inkluderer id til den som utførte signeringshandlingen og fødselsnummer. I henhold til samarbeidsavtalen er da Digdir databehandler for tjenesteeier. ## Lagringstid -Etter at prosessen i Altinn 3 er gjennomført, kan tjenesteeier laste ned alle data inkludert signeringsobjektet. Sluttbruker mottar en kvittering (PDF). + +Etter at prosessen i Altinn 3 er gjennomført, kan tjenesteeier laste ned alle data inkludert signeringsobjektet. Sluttbruker mottar en kvittering (PDF). + +Du kan konfigurere levetiden for persistens av instansen og dataene ved å konfigurere [Persistens](../../reference/data/persistence/). Hvis dette ikke er konfigurert, gjelder følgende: Tjenesteeier kvitterer ut at signeringsobjekt og at tilhørende data er lastet ned. Sluttbruker kan velge å beholde eller å slette sin kvittering på signeringen i sin innboks. Dersom sluttbruker velger å slette sin kvittering etter at tjenesteeier har lastet ned signeringsobjektet, så innebærer det at Digdir sletter signeringsobjektet i våre systemer. Signeringsobjektet og tilhørende data må dermed lagres i tjenesteeiers systemer om man ønsker å arkivere signaturen. -Digdir logger at signeringshandlingen er utført. Det betyr at selv om signeringsobjektet er slettet, så lagrer Digdir fortsatt loggen som viser at det er utført en signaturhandling. Vanlige applikasjonslogger (benyttes som regel til feilsøking) lagrer Digdir i 90 dager, mens hendelseslogger lagrer vi i 13 måneder. +Digdir logger at signeringshandlingen er utført. Det betyr at selv om signeringsobjektet er slettet, så lagrer Digdir fortsatt loggen som viser at det er utført en signaturhandling. Vanlige applikasjonslogger (benyttes som regel til feilsøking) lagrer Digdir i 90 dager, mens hendelseslogger lagrer vi i 13 måneder. ## Verifisering av signatur + Tjenesteeier lagrer signaturobjektet i sitt arkivsystem. Signaturobjektet inneholder en hash kode av dataene som tilhører dataelementet. Dersom signaturobjektet senere endres vil dette kunne verifiseres ved at hash koden i signaturobjektet ikke lenger stemmer, dette bidrar til sporbarhet for signaturobjektet. Dette forutsetter at signaturen, dvs. hash koden, også finnes på sluttbruker sin kvittering slik at begge parter har hver sin kopi. -[Her kan du kan lese den teknisk beskrivelse for hvordan verifisering av signaturen gjøres.](https://docs.altinn.studio/nb/altinn-studio/reference/process/tasks/signing/#verifisering-av-sha256-hash) +[Her kan du kan lese en teknisk beskrivelse for hvordan verifisering av signaturen gjøres.](https://docs.altinn.studio/nb/altinn-studio/reference/process/tasks/signing/#verifisering-av-sha256-hash) diff --git a/content/altinn-studio/guides/development/signing/_index.en.md b/content/altinn-studio/guides/development/signing/_index.en.md new file mode 100644 index 00000000000..1ef24105afe --- /dev/null +++ b/content/altinn-studio/guides/development/signing/_index.en.md @@ -0,0 +1,29 @@ +--- +title: How to configure signing in your Altinn app +linktitle: Signing +description: Below you will find guides for common configurations of signing. +tags: [signing] +weight: 50 +aliases: + - /altinn-studio/guides/signing/ +--- + +The different scenarios below can to some extent be combined with each other, but many services will only need one of them. + +## Role/access package based signing + +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/intro.en.md" %}} + +[How to configure](/altinn-studio/guides/development/signing/role-based-signing) + +## Runetime delegated singing + +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.en.md" %}} + +[How to configure](/altinn-studio/guides/development/signing/runtime-delegated-signing) + +## Sign and submit + +{{% insert "content/altinn-studio/guides/development/signing/sign-and-submit/intro.en.md" %}} + +[How to configure](/altinn-studio/guides/development/signing/sign-and-submit) diff --git a/content/altinn-studio/guides/development/signing/_index.nb.md b/content/altinn-studio/guides/development/signing/_index.nb.md new file mode 100644 index 00000000000..fb2b3070e52 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/_index.nb.md @@ -0,0 +1,26 @@ +--- +title: Hvordan konfigurere signering i din Altinn-app +linktitle: Signering +description: Nedenfor finner du veiledninger for vanlige oppsett av signering. +tags: [signering] +weight: 50 +aliases: +- /nb/altinn-studio/guides/signing/ +--- + +De ulike scenarioene nedenfor kan i noen grad kombineres med hverandre, men ofte trenger en tjeneste bare en av variantene. + +## Rolle-/tilgangspakkebasert +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/intro.nb.md" %}} + +[Slik gjør du det](/nb/altinn-studio/guides/development/signing/role-based-signing) + +## Brukerstyrt +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.nb.md" %}} + +[Slik gjør du det](/nb/altinn-studio/guides/development/signing/runtime-delegated-signing) + +## Signer og send inn +{{% insert "content/altinn-studio/guides/development/signing/sign-and-submit/intro.nb.md" %}} + +[Slik gjør du det](/nb/altinn-studio/guides/development/signing/sign-and-submit) \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/_index.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/_index.en.md new file mode 100644 index 00000000000..43902699243 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/_index.en.md @@ -0,0 +1,47 @@ +--- +title: Role and access package based signing +linktitle: Role and access package +description: Follow these steps to implement role based signing in your service. +tags: [role based, signing] +weight: 50 +aliases: + - /altinn-studio/guides/signing/role-based-signing +--- + +## What does role/access package-based signing mean? + +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/intro.en.md" %}} + +## Prerequisites + +If the service should send a signature receipt to the inbox of the signee, the Altinn message service (Correspondence) must be enabled. + +See [how](/correspondence/getting-started/) to get started. + +## 1. Add a signing task to the app process, with related configuration + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.en.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.en.md" %}} +{{}} + +{{}} + +## 2. Add layout-set for signing + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.nb.md" %}} +{{}} + +{{}} diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/_index.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/_index.nb.md new file mode 100644 index 00000000000..749406f3e23 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/_index.nb.md @@ -0,0 +1,45 @@ +--- +title: Rolle- og tilgangspakkebasert signering +linktitle: Rolle/tilgangspakke +description: Følg disse stegene for å implementere rolle- og tilgangspakkebasert signering i din tjeneste. +tags: [rollebasert, signering] +weight: 50 +aliases: +- /nb/altinn-studio/guides/signing/role-based-signing +--- + +## Hva betyr rolle- og tilgangspakkebasert signering? +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/intro.nb.md" %}} + +## Avhengigheter +Dersom appen skal kunne sende signeringskvittering til innboksen til den som signerer så må oppsett for bruk av meldingstjenesten i Altinn være satt opp. + +Se [hvordan](/nb/correspondence/getting-started/) du kommer i gang med det. + +## 1. Legg til en signeringsoppgave i appens prosess, med tilhørende konfigurasjon + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.nb.md" %}} +{{}} + +{{}} + +## 2. Legg til layout-set for signering + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.nb.md" %}} +{{}} + +{{}} \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.en.md new file mode 100644 index 00000000000..aa16360ae0f --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.en.md @@ -0,0 +1,60 @@ +--- +hidden: true +--- + +### Extend the app process with signing task: + +A singing task must be added to `App/config/process/process.bpmn`. + +We recommend doing this using the Altinn Studio process editor, so that the BPMN diagram is generated, to show the apps process. + +Signing normally uses two user actions. If the Altinn user interface is used by the app, these will be called by button pressen in the signing step. If only the API is used, these must be called manually via the `/actions` endpoint or via process next. +- `sign`: The actual act of singing the data. Performed by the signees. +- `reject`: If the end user sees something wrong with the singing step, they can abort the signing step. All signatures and the signee state is deleted, and runtime delegated access rights are revoked. Which process step the user is taken to after this is specified in a gateway, as exemplified below. + +```xml + + + + signing + + sign + reject + + + + ref-data-as-pdf + + signatures + + + + SequenceFlow_1oot28q + SequenceFlow_1if1sh9 + +``` + + +### Add data types for storing signing related data + +The value of the node `signatures` must match the ID of the data type you configured in the previous step. + +These data types should be added in the `dataTypes` array in `App/config/applicationmetadata.json`. + +This data type is used to store the actual signatures that are generated when a user performs the sign action. + +```json +{ + "id": "signatures", + "allowedContentTypes": [ + "application/json" + ] +} +``` + +The IDs can be set to something else, but they must match the IDs entered in `signatureDataType` in the process step, as shown in the process task step. + + +### Tilgangsstyring + +Give `read`, `write` and alternatively `sign` to the instance owner. Others who should sign also need `read` and `write`. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.nb.md new file mode 100644 index 00000000000..38be955acca --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/add-process-task.nb.md @@ -0,0 +1,58 @@ +--- +hidden: true +--- + +### Utvid app prossesen med signing task: + +Det må legges til et prosessteg og en gateway i `App/config/process/process.bpmn`, som i eksemplet nedenfor. + +Det anbefales å dra inn prosessteget via prosessdesigneren i Altinn Studio. Da får man generert BPMN-diagram som viser flyten i appen. Forløpig vil prosessdesigneren bare delvis konfigurere steget riktig, så det må suppleres med noe manuell konfigurasjon. + +Signering består av to brukerhandlinger (user actions). Dersom Altinn-brukergrensesnittet brukes av appen, så vil disse bli kalt automatisk når man står i signeringssteget. Om kun API-et benyttes, så må disse kalles manuelt via `/actions`-endepunktet eller process next. +- `sign`: Selve signeringshandlingen. +- `reject`: Dersom det skal være mulig å avbryte signeringssteget, så må det også legges til en gateway for å styre hvor prosessen skal gå videre da. + +```xml + + + + signing + + sign + reject + + + + ref-data-as-pdf + + signatures + + + + SequenceFlow_1oot28q + SequenceFlow_1if1sh9 + +``` + + +### Legg til datatyper for å lagre signeringsdata + +Denne datatypen legges til i `dataTypes` i `App/config/applicationmetadata.json`. + +Den benyttes av signeringssteget til å lagre de faktiske signaturene som genereres når brukeren utfører signeringshandlingen. + +```json +{ + "id": "signatures", + "allowedContentTypes": [ + "application/json" + ] +} +``` + +ID-en kan settes til noe annet, men det må matche ID-en som legges inn i `signatureDataType` i prossessteget. + + +### Tilgangsstyring + +Gi ```read```, ```write``` og eventuelt ```sign``` til den som fyller ut skjemaet. Andre som skal signere må også få `read` og `write`. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.en.md new file mode 100644 index 00000000000..83ccb05bb0c --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.en.md @@ -0,0 +1,91 @@ +--- +hidden: true +--- + +Add a folder under `App/ui` for your singing task called `signing` or some other logical name. +Update `App/ui/layout-sets.json` with a new page group, using the same `id` as the folder you just created. + +Your updated `layout-sets.json` can look something like this: + +```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout-sets.schema.v1.json", + "sets": [ + { + "id": "form", + "dataType": "model", + "tasks": [ + "Task_1" + ] + }, + { + "id": "signing", + "dataType": "model", + "tasks": [ + "SigningTask" + ] + } + ] + } +``` + +In the folder you created, add a new file called `signing.json`. + +There are standard components that can be used to build a layout set for a signing step. You are not required to use these components, but it is recommended. + +- SigningDocumentList: + - Lists the data being signed. For example attachments, XML data or a PDF summary from an earlier step. +- SigneeList: + - Lists the signees expected to sign and their signing status. + - As of now this list doesn't support showing roles that should sign, only people and organisations that have been delegated access rights at runtime. But as soon as a person clicks "sign", they will show up, so you can use it as a "Signatures" list, to show who has signed. +- SigningStatusPanel: + - Determines the current status of the singing task and present relevant information and buttons to the end user, for instance the "Sign"-button. + +If you choose not to use the `SingingStatusPanel` to display the "Sign"-button, you must as a minimum add an action button with action `sign`, to allow the end user to sign. + +Example of usage of the standard components: + +```json +{ + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout.schema.v1.json", + "data": { + "layout": [ + { + "id": "headerSigningFounders", + "type": "Header", + "size": "L", + "textResourceBindings": { + "title": "Her kan man ha en overskrift" + } + }, + { + "id": "signing-documents", + "type": "SigningDocumentList", + "textResourceBindings": { + "title": "Dokumenter som skal signeres", + "description": "Dokumenter som skal signeres beskrivelse" + } + }, + { + "id": "signee-list", + "type": "SigneeList", + "textResourceBindings": { + "title": "Signaturer" + } + }, + { + "id": "signing-state", + "type": "SigningStatusPanel" + } + ] + } + } +``` + +You can override the text that is shown when the list is empty, before anyone signed, by adding a text resource override for the key `signee_list.no_signees` in the text resource files. +```json +{ + "id": "signee_list.no_signees", + "value": "No signatures yet." +} +``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.nb.md new file mode 100644 index 00000000000..74ade60e08e --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/backend-manual/configure-layouts.nb.md @@ -0,0 +1,92 @@ +--- +hidden: true +--- + +Legg til en ny mappe under `App/ui` for signeringsoppgaven din. Kall den f.eks. `signing`. + +Oppdater filen `App/ui/layout-sets.json` med ny sidegruppe, som har samme `id` som mappen du nettopp opprettet. + +Din oppdaterte `layout-sets.json` kan se slik ut: + + ```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout-sets.schema.v1.json", + "sets": [ + { + "id": "form", + "dataType": "model", + "tasks": [ + "Task_1" + ] + }, + { + "id": "signing", + "dataType": "model", + "tasks": [ + "Task_2" + ] + } + ] + } + ``` + +I mappen du opprettet, legg til en ny fil kalt `signing.json`. + +Det finnes et sett med ferdige komponenter for å bygge opp layout for et signeringssteg. Vi anbefaler å bruke disse, men de er ikke obligatoriske. + +- SigningDocumentList: + - Lister ut dataene som blir signert på. Feks. vedlegg, xml-data eller PDF-oppsummering fra tidligere steg. +- SigneeList: + - Lister ut signatarer og tilhørende signeringsstatus. + - Per nå støtter ikke denne listen å vise roller som skal signere, kun personer som har fått brukerstyrt delegert tilgang. Men i det øyeblikket en person utfører en signering vil de dukke opp, så vi kan bruke den som en "Signaturer"-liste. +- SigningStatusPanel: + - Utleder status for signeringssteget og viser relevante knapper til sluttbruker, feks. "Signer"-knappen. + +Dersom du ikke benytter `SigningStatusPanel` for å vise "Signer"-knappen, så må du legge til en egen action button med action "sign", for å la sluttbruker signere. + +Eksempel på bruk av komponentene: + +```json +{ + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout.schema.v1.json", + "data": { + "layout": [ + { + "id": "headerSigningFounders", + "type": "Header", + "size": "L", + "textResourceBindings": { + "title": "Her kan man ha en overskrift" + } + }, + { + "id": "signing-documents", + "type": "SigningDocumentList", + "textResourceBindings": { + "title": "Dokumenter som skal signeres", + "description": "Dokumenter som skal signeres beskrivelse" + } + }, + { + "id": "signee-list", + "type": "SigneeList", + "textResourceBindings": { + "title": "Signaturer" + } + }, + { + "id": "signing-state", + "type": "SigningStatusPanel" + } + ] + } +} +``` + +Du kan overstyre teksten som vises når listen er tom, før noen har signert, ved å legge til en tekst for text resource nøkkel `signee_list.no_signees` i text resource filene deres. +```json +{ + "id": "signee_list.no_signees", + "value": "Ingen signaturer enda" +} +``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/intro.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/intro.en.md new file mode 100644 index 00000000000..cd4a255e2e2 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/intro.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +By role and access package based signing, we mean a service where individuals who need to sign have the right to read and sign due to a role or access package they hold. +For example a CEO, accountant or auditor. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/intro.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/intro.nb.md new file mode 100644 index 00000000000..66c6dd94b3a --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/intro.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +Med rolle- og tilgangspakkebasert signering mener vi en tjeneste hvor de som skal signere har rettigheter til å lese og signere fordi de tilfredstiller rolle- eller tilgangspakkekrav i henhold til policy for tjenesten. +Dette kan for eksempel være daglig leder, regnskapsfører eller revisor. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.nb.md new file mode 100644 index 00000000000..7158b821c4d --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/studio/add-process-task.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> Dette steget må gjøres manuelt. Støtte for konfigurasjon i Altinn Studio kommer senere. +> Se "Manuelt oppsett"-fanen for denne seksjonen for veiledning. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.en.md b/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.nb.md b/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.nb.md new file mode 100644 index 00000000000..33d32691f37 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/role-based-signing/studio/configure-layouts.nb.md @@ -0,0 +1,88 @@ +--- +hidden: true +--- + +Legg til en ny mappe under `App/ui` for signeringsoppgaven din. Kall den f.eks. `signing`. + +Oppdater filen `App/ui/layout-sets.json` med ny sidegruppe, som har samme `id` som mappen du nettopp opprettet. + +Din oppdaterte `layout-sets.json` kan se slik ut: + + ```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout-sets.schema.v1.json", + "sets": [ + { + "id": "form", + "dataType": "model", + "tasks": [ + "Task_1" + ] + }, + { + "id": "signing", + "dataType": "model", + "tasks": [ + "Task_2" + ] + } + ] + } + ``` + +I mappen du opprettet, legg til en ny fil kalt `signing.json`. + +Det finnes et sett med ferdige komponenter for å bygge opp layout for et signeringssteg. Vi anbefaler å bruke disse, men de er ikke obligatoriske. + +- SigneeList: + - Lister ut signatarer og tilhørende signeringsstatus. +- SigningDocumentList: + - Lister ut dataene som blir signert på. Feks. vedlegg, xml-data eller PDF-oppsummering fra tidligere steg. +- SigningStatusPanel: + - Utleder status for signeringssteget og viser relevante knapper til sluttbruker, feks. "Signer"-knappen. + +Dersom du ikke benytter `SigningStatusPanel` for å vise "Signer"-knappen, så må du legge til en egen action button med action "sign", for å la sluttbruker signere. + +Eksempel på bruk av komponentene: + + ```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout.schema.v1.json", + "data": { + "layout": [ + { + "id": "headerSigningFounders", + "type": "Header", + "size": "L", + "textResourceBindings": { + "title": "Her kan man ha en overskrift" + } + }, + { + "id": "signee-list", + "type": "SigneeList", + "textResourceBindings": { + "title": "Personer som skal signere", + "description": "Personer som skal signere beskrivelse", + "help": "Dette er personer som skal signere" + } + }, + { + "id": "signing-documents", + "type": "SigningDocumentList", + "textResourceBindings": { + "title": "Dokumenter som skal signeres", + "description": "Dokumenter som skal signeres beskrivelse" + } + }, + { + "id": "signing-state", + "type": "SigningStatusPanel" + } + ] + } + } + ``` + + + \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.en.md new file mode 100644 index 00000000000..de47755657b --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.en.md @@ -0,0 +1,98 @@ +--- +title: Runtime delegated signing +linktitle: Runtime delegated +description: Follow these steps to implement runtime delegated signing in your service +tags: [signing] +weight: 50 +aliases: + - /altinn-studio/guides/signing/runtime-delegated-signing +--- + +## What does runtime delegated singing mean? + +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.en.md" %}} + +## Prerequisites + +Runtime deleaged singing depends on then message service (Correspondence) in Altinn, which requires separate configuration. + +The message service is used to tell the signee that they have been asked to sign a form in Altinn, and to send them a receipt of what they signed when the signature has been submitted. + +See how to get started in [this guide](/nb/correspondence/getting-started/). + +## Example Application + +In the following [repository](https://altinn.studio/repos/ttd/signering-brukerstyrt), you can find an example of an application with user-driven signing. + +The main flow is: + +1. The form filler enters the personal identification number and last name of the individuals who need to sign, or alternatively, the organization number if it is a company. +2. Once the form is completed, the filler clicks a "Go to signing" button, which moves the process to the signing step. +3. During the signing step, the application calls an implementation of the interface `ISigneeProvider`, which you must implement, to determine who should be delegated access to sign. +4. The signers are delegated rights and receive a notification that they have a signing task. +5. The signers find the form in their inbox, open it, review the data, and click "Sign." +6. The submitter also signs if the app is configured this way and then submits the form. Automatic submission is currently not supported. + +Below are the key configuration steps for setting up such an application. + +## 1. Add and configure a singing task in the app process + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.en.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.en.md" %}} +{{}} + +{{}} + +## 2. Add a singing layout set + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.en.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.en.md" %}} +{{}} + +{{}} + +## 3. Setup text resources + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.en.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.en.md" %}} +{{}} + +{{}} + +## 4. Tell the app who the signees are + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.en.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.en.md" %}} +{{}} + +{{}} + +## 5. Testing + +> **Note:** Fow now, delegation mocking is not implemented in local testing, so testing must be performed in the TT02 environment. + +Authorization caching may cause delays in users seeing delegated forms in their Altinn inbox if they were logged in when delegation occurred. To avoid this, delegate access to a user not used in testing for the last hour. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.nb.md new file mode 100644 index 00000000000..07b6a4363e2 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/_index.nb.md @@ -0,0 +1,105 @@ +--- +title: Brukerstyrt signering +linktitle: Brukerstyrt +description: Følg disse stegene for å implementere brukerstyrt signering i din tjeneste. +tags: [signering] +weight: 50 +aliases: + - /nb/altinn-studio/guides/signing/runtime-delegated-signing +--- + +## Hva betyr brukerstyrt signering? + +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.nb.md" %}} + +## Avhengigheter + +Brukerstyrt signering avhenger av Meldingstjenesten (Correspondence) i Altinn, som krever eget oppsett. + +Melding brukes for å gi beskjed til signatar om at de har blitt bedt om å signere et skjema i Altinn, og for å sende signeringskvittering til innboksen ders når signeringen er utført. + +Se hvordan du kommer i gang med det i [denne guiden](/nb/correspondence/getting-started/). + +## Eksempel på konfigurasjon + +I følgende [repo](https://altinn.studio/repos/ttd/signering-brukerstyrt) ligger det eksempel på en applikasjon med brukerstyrt signering. + +Hovedflyten i applikasjonen er: + +1. Utfyller av skjema oppgir fødselsnummer og etternavn for personer eller organisasjonsnummer for organisasjoner som skal signere. +2. Når skjema er ferdig utfylt trykker utfyller "Til signering", som beveger prosessen til neste steg i prosessen, som er signeringssteget. +3. I det signeringssteget initialiseres kaller appen en implementasjon av interfacet `ISigneeProvider`, som dere må implementere, for å finne ut hvem som må få delegert tilgang til å signere. +4. Signatarene får delegert rettigheter og mottar notifikasjon om at de har en signeringsoppgave. +5. Signatarene finner skjemaet i sin innboks, åpner det, ser over data og trykker signer. +6. Innsender signerer også, dersom appen satt opp slik, og sender deretter inn skjemaet. Automatisk innsending er p.t. ikke søttet. + +Nedenfor følger de viktiste konfigurasjonsstegene for å få satt opp en slik applikasjon. + +## 1. Legg til en signeringsoppgave i appens prosess, med tilhørende konfigurasjon + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.nb.md" %}} +{{}} + +{{}} + +## 2. Legg til layout-set for signering + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.nb.md" %}} +{{}} + +{{}} + +## 3. Legg til tekstressurser + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.nb.md" %}} +{{}} + +{{}} + +## 4. Oppgi hvem som skal signere + +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.nb.md" %}} +{{}} + +{{}} +{{% insert "content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.nb.md" %}} +{{}} + +{{}} + +## 5. Testing + +> **Obs!** Foreløpig er det ikke laget mocking av delegasjon i localtest, så testing må i praksis utføres i TT02-miljøet. + +Det er caching i autorisasjonslaget som gjør at det kan ta tid før en bruker som har fått delegert tilgang til et skjema via brukerstyrt signering ser skjemaet i sin Altinn innboks. + +Men dette vil altså bare inntreffe for: + +- De brukerne som er aktivt pålogget Altinn når instansdelegeringen skjer +- Ikke allerede har annen tilgang for InstanceOwner + +For å unngå å oppleve dette under testing kan man delegere til en person man ikke har brukt i testing den siste timen. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.en.md new file mode 100644 index 00000000000..f3a32fd521e --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.en.md @@ -0,0 +1,188 @@ +--- +hidden: true +--- + +### Extend the Application Process with a Signing Task + +A signing task must be added to `App/config/process/process.bpmn`, as shown in the example below. + +We recommend doing this using the Altinn Studio process editor, so that the BPMN diagram is generated, to show the apps process. +However, as of now, the process editor will only partially configure this task correctly, so some manual adjustments are required. + +Signing uses two user actions. +- `sign`: The actual signing action. +- `reject`: If the signing step should be cancellable, a gateway must also be added to control where the process should continue. See the example below. + +If the Altinn user interface is used by the application, these actions will be triggered by button clicks in the signing stage. If only the API is used, they must be triggered manually via the `/actions` endpoint or the process next endpoint. + +```xml + + + + signing + + sign + reject + + + + + ref-data-as-pdf + + + + signatures + + + signeesState + + + signees + + + signing-step-pdf + + + app-correspondence-resource + + + + + SequenceFlow_1oot28q + SequenceFlow_1if1sh9 + +``` + + +### Add data types for storing signing related data + +These data types should be added to `dataTypes` in `App/config/applicationmetadata.json`. + +The first data type is used by the signing stage to store the actual signatures generated when a user completes the signing action. + +```json +{ + "id": "signatures", + "allowedContentTypes": [ + "application/json" + ], + "allowedContributers": [ + "app:owned" + ] +} +``` + +This data type is used to store information about the signers who should be delegated signing rights and their status. + +```json +{ + "id": "signeeState", + "allowedContentTypes": [ + "application/pdf" + ], + "allowedContributers": [ + "app:owned" + ], + "maxCount": 1, + "minCount": 0 +} +``` + +It is important to set `allowedContributers` to `"app:owned"`. This ensures that these data items cannot be edited via the app’s API but only by the app itself. + +The IDs of the data types can be changed, but they must match the IDs set in `signatureDataType` and `signeeStatesDataTypeId` in the process step, as shown in the next section. + + +### Access control + + Give `read`m `write` and optionally `sign` to the role that should fill out the form. + + In order for the service to be able to delegate access rights to the signees, the app needs to have the right to delegate the `read` and `sign` actions. + Below is an example which you can use in your policy.xml file. + + - Replace `ttd` with the correct org. + - Replace `app_ttd_signering-brukerstyrt` with your own org and app name inserted into this template: `app_{org}_{app-name}`. + - Replace `signering-brukerstyrt` with your app name + - Modify the RuleId attribute to fit nicely into your policy.xml. + + ```xml + + + A rule defining all instance delegation rights the App itself is allowed to perform for instances of the app ttd/signering-brukerstyrt. In this example the app can delegate the Read and Sign actions for task SingingTask. + + + + + + + app_ttd_signering-brukerstyrt + + + + + + + + + ttd + + + + signering-brukerstyrt + + + + SingingTask + + + + + + + read + + + + + + sign + + + + + + + ``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.nb.md new file mode 100644 index 00000000000..195ffec22b0 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/add-process-task.nb.md @@ -0,0 +1,193 @@ + +--- +hidden: true +--- + +### Utvid app prossesen med signing task: + +Det må legges til et signeringssteg i appens prosess, som er definert i `App/config/process/process.bpmn`. + +Det anbefales å dra inn prosessteget via prosessdesigneren i Altinn Studio. Da får man generert BPMN-diagram som viser flyten i appen. +Forløpig vil prosessdesigneren bare delvis konfigurere steget riktig, så det må suppleres med manuell konfigurasjon. + +Signering benytter to burkerhandlinger (user actions): +- `sign`: Selve signeringshandlingen. +- `reject`: Dersom det skal være mulig å avbryte signeringssteget, så må det også legges til en gateway for å styre hvor prosessen skal gå videre når det skjer. + +Dersom Altinn-brukergrensesnittet benyttes av appen, så vil handlingene ovenfor bli kalt ved knappetrykk i signeringssteget. +Om kun API-et benyttes, så må disse kalles manuelt via `/actions`-endepunktet eller process next. + +Et signeringssteg kan se omtrent slik ut: +```xml + + + + signing + + sign + reject + + + + + + ref-data-as-pdf + + + + signatures + + + signeeState + + + signees + + + app-correspondence-resource + + + signing-step-pdf + + + + + SequenceFlow_1oot28q + SequenceFlow_1if1sh9 + +``` + +### Legg til datatyper for å lagre signeringsdata + +Disse datatypene legger til i `dataTypes` i `App/config/applicationmetadata.json`. + +Den første datatypen benyttes av signeringssteget til å lagre de faktiske signaturene som genereres når brukeren utfører signeringshandlingen. + +```json +{ + "id": "signatures", + "taskId": "SigningTask", + "allowedContentTypes": [ + "application/json" + ], + "allowedContributers": [ + "app:owned" + ] +} +``` + +Denne datatypen benyttes for å lagre informasjon om signatarene som skal få deligert rettigheter til å signere og statusen deres. + +```json +{ + "id": "signeeState", + "taskId": "SigningTask", + "allowedContentTypes": [ + "application/pdf" + ], + "allowedContributers": [ + "app:owned" + ], + "maxCount": 1, + "minCount": 0, +} +``` + +Det er viktig å sette `allowedContributers` til ```"app:owned"```. Det gjør at disse dataene ikke kan redigeres via appens API, men kun av appen selv. + +Datatypenes ID-er kan settes til noe annet, men det må matche ID-ene som legges inn i `signatureDataType` og `signeeStatesDataTypeId` i prossessteget, som vist i punktet under. + + +### Tilgangsstyring + + Gi ```read```, ```write``` og eventuelt ```sign``` til den som fyller ut skjemaet. + + For at appen skal kunne delegere rettigheter til de som skal signere så må appen få rettigheter til å delegere ```read``` og ```sign```. + Se eksempel nedenfor. + + - Bytt ut ```ttd``` med riktig org. + - Bytt ut ```app_ttd_signering-brukerstyrt``` med tilsvarende ```app_{org}_{appnavn}```. + - Bytt ut ```signering-brukerstyrt``` med appnavn. + + ```xml + + + + A rule defining all instance delegation rights the App itself is allowed to perform for instances of the app ttd/signering-brukerstyrt. In this example the app can delegate the Read and Sign actions for task SingingTask. + + + + + + + app_ttd_signering-brukerstyrt + + + + + + + + + ttd + + + + signering-brukerstyrt + + + + SingingTask + + + + + + + read + + + + + + sign + + + + + + + ``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.en.md new file mode 100644 index 00000000000..87b6753734c --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.en.md @@ -0,0 +1,82 @@ +--- +hidden: true +--- + +Add a folder under `App/ui` for your singing task called `signing` or some other logical name. +Update `App/ui/layout-sets.json` with a new page group, using the same `id` as the folder you just created. + +```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout-sets.schema.v1.json", + "sets": [ + { + "id": "form", + "dataType": "model", + "tasks": [ + "Task_1" + ] + }, + { + "id": "signing", + "dataType": "model", + "tasks": [ + "SigningTask" + ] + } + ] + } +``` + +In the folder you created, add a new file called `signing.json`. + +There are standard components that can be used to build a layout set for a signing step. You are not required to use these components, but it's recommended. + +- SigneeList: + - Lists the signees and their signing status. +- SigningDocumentList: + - Lists the data being signed. For example attachments, xml-data or a PDF summary from an earlier step. +- SigningStatusPanel: + - Determines the current status of the singing task and present relevant information and buttons to the end user, for instance the "Sign"-button. + +If you choose not to use the `SingingStatusPanel` to display the "Sign"-button, you must as a minimum add an action button with action `sign`, to allow the end user to sign. + +Example of usage of the standard components: + +```json +{ + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout.schema.v1.json", + "data": { + "layout": [ + { + "id": "headerSigningFounders", + "type": "Header", + "size": "L", + "textResourceBindings": { + "title": "Her kan man ha en overskrift" + } + }, + { + "id": "signee-list", + "type": "SigneeList", + "textResourceBindings": { + "title": "Personer som skal signere", + "description": "Personer som skal signere beskrivelse", + "help": "Dette er personer som skal signere" + } + }, + { + "id": "signing-documents", + "type": "SigningDocumentList", + "textResourceBindings": { + "title": "Dokumenter som skal signeres", + "description": "Dokumenter som skal signeres beskrivelse" + } + }, + { + "id": "signing-state", + "type": "SigningStatusPanel" + } + ] + } + } +``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.nb.md new file mode 100644 index 00000000000..d41daf8f676 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/configure-layouts.nb.md @@ -0,0 +1,85 @@ +--- +hidden: true +--- + +Legg til en ny mappe under `App/ui` for signeringsoppgaven din. Kall den f.eks. `signing`. + +Oppdater filen `App/ui/layout-sets.json` med ny sidegruppe, som har samme `id` som mappen du nettopp opprettet. + +Din oppdaterte `layout-sets.json` kan se slik ut: + + ```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout-sets.schema.v1.json", + "sets": [ + { + "id": "form", + "dataType": "model", + "tasks": [ + "Task_1" + ] + }, + { + "id": "signing", + "dataType": "model", + "tasks": [ + "SigningTask" + ] + } + ] + } + ``` + +I mappen du opprettet, legg til en ny fil kalt `signing.json`. + +Det finnes et sett med ferdige komponenter for å bygge opp layout for et signeringssteg. Vi anbefaler å bruke disse, men de er ikke obligatoriske. + +- SigneeList: + - Lister ut signatarer og tilhørende signeringsstatus. +- SigningDocumentList: + - Lister ut dataene som blir signert på. Feks. vedlegg, xml-data eller PDF-oppsummering fra tidligere steg. +- SigningStatusPanel: + - Utleder status for signeringssteget og viser relevante knapper til sluttbruker, feks. "Signer"-knappen. + +Dersom du ikke benytter `SigningStatusPanel` for å vise "Signer"-knappen, så må du legge til en egen action button med action "sign", for å la sluttbruker signere. + +Eksempel på bruk av komponentene: + + ```json + { + "$schema": "https://altinncdn.no/toolkits/altinn-app-frontend/4/schemas/json/layout/layout.schema.v1.json", + "data": { + "layout": [ + { + "id": "headerSigningFounders", + "type": "Header", + "size": "L", + "textResourceBindings": { + "title": "Her kan man ha en overskrift" + } + }, + { + "id": "signee-list", + "type": "SigneeList", + "textResourceBindings": { + "title": "Personer som skal signere", + "description": "Personer som skal signere beskrivelse", + "help": "Dette er personer som skal signere" + } + }, + { + "id": "signing-documents", + "type": "SigningDocumentList", + "textResourceBindings": { + "title": "Dokumenter som skal signeres", + "description": "Dokumenter som skal signeres beskrivelse" + } + }, + { + "id": "signing-state", + "type": "SigningStatusPanel" + } + ] + } + } + ``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.en.md new file mode 100644 index 00000000000..7769e84518d --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.en.md @@ -0,0 +1,57 @@ +--- +hidden: true +--- + +Add a [text resource file](/altinn-studio/reference/ux/texts/) under 'App/config/texts' for each language you want to support. + +Here you define text resources to be used in communication with the user. + +Text resource IDs for the signing flow are set up to **override** the content in messages sent to the Altinn inbox. + +`signing.correspondence_cta_title` - title of notification message to signer
+`signing.correspondence_cta_summary` - subtitle of notification message to signer
+`signing.correspondence_cta_body` - content of notification message to signer + +`signing.correspondence_receipt_title` - title of receipt message +`signing.correspondence_receipt_summary` - subtitle of receipt message +`signing.correspondence_receipt_body` - content of receipt message + +You can also set up text resources to **override** the content in SMS and email sent to notify the signer of a signing task. +You can name these whatever you want and connect them to the notification implementation in the next step (step 4). + +Example of text resources for notifications with custom texts for email, as well as receipt: + +``` +{ + "id": "signing.correspondence_receipt_title", + "value": "Receipt: Signing of founding documents" +}, +{ + "id": "signing.correspondence_receipt_summary", + "value": "You have signed the founding documents" +}, +{ + "id": "signing.correspondence_receipt_body", + "value": "The documents you have signed are attached. These can be downloaded if desired.

If you have any questions, contact the Brønnøysund Register Centre at phone 75 00 75 00." +}, +{ + "id": "signing.correspondence_cta_title", + "value": "Task - Sign founding documents" +}, +{ + "id": "signing.correspondence_cta_summary", + "value": "You have been added as a signer." +}, +{ + "id": "signing.correspondence_cta_body", + "value": "You have been added as a signer for founding documents.
$InstanceUrl

" +}, +{ + "id": "signing.notification_content", + "value": "Hello {0},\n\nYou have received founding documents for signing in Altinn. Log in to Altinn to sign the documents.\n\nBest regards,\nBrønnøysund Register Centre" +}, +{ + "id": "signing.email_subject", + "value": "Founding documents received for signing in Altinn. Go to Altinn inbox to sign." +}, +``` diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.nb.md new file mode 100644 index 00000000000..13b78106a70 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/setup-text-resources.nb.md @@ -0,0 +1,58 @@ +--- +hidden: true +--- + +Legg til en [teksressurs-fil](/nb/altinn-studio/reference/ux/texts/) under ´App/config/texts´ for hvert språk du vil støtte. + +Her definerer du tekstressurser som skal brukes i kommunikasjonen med brukerene. + +Tekstressurs-ID-er for signeringsflyten settes opp for å **overstyre** innholdet i meldinger som blir sendt til Altinn-innboksen. + +`signing.correspondence_cta_title` - tittel på varselmelding til signatar
+`signing.correspondence_cta_summary` - undertittel på varselmelding signatar
+`signing.correspondence_cta_body` - innhold i varselmelding signatar + +`signing.correspondence_receipt_title` - tittel på kvitteringsmelding +`signing.correspondence_receipt_summary` - undertittel på kvitteringsmelding +`signing.correspondence_receipt_body` - innhold i kvitteringsmelding + +Du kan også sette opp tekstressurser for å **overstyre** innholdet i sms og e-post som sendes for å varsle signatar og signeringsoppgave. +Disse kan du kalle hva du vil, og koble dem opp til notification implementasjonen i neste punkt (punkt 4.). + +Eksempel på tekstressurser for varsling med egne tekster for e-post, samt kvittering: + +``` + + { + "id": "signing.correspondence_receipt_title", + "value": "Kvittering: Signering av stiftelsesdokumenter" + }, + { + "id": "signing.correspondence_receipt_summary", + "value": "Du har signert stiftelsesdokumentene" + }, + { + "id": "signing.correspondence_receipt_body", + "value": "Dokumentene du har signert er vedlagt. Disse kan lastes ned om ønskelig.

Hvis du lurer på noe, ta kontakt med Brønnøysundregistrene på telefon 75 00 75 00." + }, + { + "id": "signing.correspondence_cta_title", + "value": "Oppgave - Signer stiftelsesdokumenter" + }, + { + "id": "signing.correspondence_cta_summary", + "value": "Du har blitt lagt til som signatar." + }, + { + "id": "signing.correspondence_cta_body", + "value": "Du har blitt lagt til som signatar for stiftelsesdokumenter.
$InstanceUrl

" + }, + { + "id": "signing.notification_content", + "value": "Hei {0},\n\nDu har mottatt stiftelsesdokumenter for signering i Altinn. Logg inn på Altinn for å signere dokumentene.\n\nMed vennlig hilsen\nBrønnøysundregistrene" + }, + { + "id": "signing.email_subject", + "value": "Stiftelsesdokumenter mottatt for signering i Altinn. Gå til Altinn-innboks for å signere." + }, +``` diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.en.md new file mode 100644 index 00000000000..99c09d63a89 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.en.md @@ -0,0 +1,132 @@ +--- +hidden: true +--- + +To allow the app to determine who should receive access to read and sign, the C# interface `ISigneeProvider` must be implemented. + +The implementation must return a set of individuals and/or organizations that should receive rights to sign. This can be based on the data model, as shown in the example below. + +The `Id` property in this implementation must match the ID specified in . + +```csharp +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using Altinn.App.Core.Features.Signing.Interfaces; +using Altinn.App.Core.Features.Signing.Models; +using Altinn.App.Core.Internal.Data; +using Altinn.App.Core.Models; +using Altinn.App.Models.Skjemadata; +using Altinn.Platform.Storage.Interface.Models; + +namespace Altinn.App.logic; + +public class FounderSigneesProvider : ISigneeProvider +{ + private readonly IDataClient _dataClient; + + public FounderSigneesProvider(IDataClient dataClient) + { + _dataClient = dataClient; + } + + public string Id { get; init; } = "founders"; + + public async Task GetSigneesAsync(Instance instance) + { + Skjemadata formData = await GetFormData(instance); + + List providedSignees = []; + foreach (StifterPerson stifterPerson in formData.StifterPerson) + { + var personSignee = new PersonSignee + { + FullName = string.Join( + " ", + [stifterPerson.Fornavn, stifterPerson.Mellomnavn, stifterPerson.Etternavn] + ), + SocialSecurityNumber = stifterPerson.Foedselsnummer?.ToString() ?? string.Empty, + Notifications = new Notifications + { + OnSignatureAccessRightsDelegated = new Notification + { + Email = new Email + { + EmailAddress = stifterPerson.Epost, + SubjectTextResourceKey = "signing.email_subject", + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterPerson.Fornavn + ), + }, + Sms = new Sms + { + MobileNumber = stifterPerson.Mobiltelefon, + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterPerson.Fornavn + ), + } + } + } + }; + + providedSignees.Add(personSignee); + } + + foreach (StifterVirksomhet stifterVirksomhet in formData.StifterVirksomhet) + { + var organisationSignee = new OrganisationSignee + { + Name = stifterVirksomhet.Navn, + OrganisationNumber = + stifterVirksomhet.Organisasjonsnummer?.ToString() ?? string.Empty, + Notifications = new Notifications + { + OnSignatureAccessRightsDelegated = new Notification + { + Email = new Email + { + EmailAddress = stifterVirksomhet.Epost, + SubjectTextResourceKey = "signing.email_subject", + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterVirksomhet.Navn + ), + }, + Sms = new Sms + { + MobileNumber = stifterVirksomhet.Mobiltelefon, + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterVirksomhet.Navn + ), + } + } + } + }; + + providedSignees.Add(organisationSignee); + } + + return new SigneesResult { Signees = providedSignees }; + } + + private async Task GetFormData(Instance instance) + { + DataElement modelData = instance.Data.Single(x => x.DataType == "Skjemadata"); + InstanceIdentifier instanceIdentifier = new(instance); + + return (Skjemadata) + await _dataClient.GetFormData( + instanceIdentifier.InstanceGuid, + typeof(Skjemadata), + instance.Org, + instance.AppId, + instanceIdentifier.InstanceOwnerPartyId, + new Guid(modelData.Id) + ); + } +} +``` diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.nb.md new file mode 100644 index 00000000000..7e0acc0cef8 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/backend-manual/signee-provider.nb.md @@ -0,0 +1,133 @@ +--- +hidden: true +--- + +For at appen skal vite hvem som skal få tilganger for å lese og signere må C# interface-et `ISigneeProvider` implementeres. + +Den må returnere et sett med personer og/eller virksomheter som skal få rettighetene. Det kan for eksempel være basert på datamodellen, som vist nedenfor. +`Id`-attributtet i denne implementasjonen må matche ID som ble angitt i ``. + +```csharp +#nullable enable +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using Altinn.App.Core.Features.Signing.Interfaces; +using Altinn.App.Core.Features.Signing.Models; +using Altinn.App.Core.Internal.Data; +using Altinn.App.Core.Models; +using Altinn.App.Models.Skjemadata; +using Altinn.Platform.Storage.Interface.Models; + +namespace Altinn.App.logic; + +public class FounderSigneesProvider : ISigneeProvider +{ + private readonly IDataClient _dataClient; + + public FounderSigneesProvider(IDataClient dataClient) + { + _dataClient = dataClient; + } + + public string Id { get; init; } = "founders"; + + public async Task GetSigneesAsync(Instance instance) + { + Skjemadata formData = await GetFormData(instance); + + List providedSignees = []; + foreach (StifterPerson stifterPerson in formData.StifterPerson) + { + var personSignee = new PersonSignee + { + FullName = string.Join( + " ", + [stifterPerson.Fornavn, stifterPerson.Mellomnavn, stifterPerson.Etternavn] + ), + SocialSecurityNumber = stifterPerson.Foedselsnummer?.ToString() ?? string.Empty, + Notifications = new Notifications + { + OnSignatureAccessRightsDelegated = new Notification + { + Email = new Email + { + EmailAddress = stifterPerson.Epost, + SubjectTextResourceKey = "signing.email_subject", + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterPerson.Fornavn + ), + }, + Sms = new Sms + { + MobileNumber = stifterPerson.Mobiltelefon, + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterPerson.Fornavn + ), + } + } + } + }; + + providedSignees.Add(personSignee); + } + + foreach (StifterVirksomhet stifterVirksomhet in formData.StifterVirksomhet) + { + var organisationSignee = new OrganisationSignee + { + Name = stifterVirksomhet.Navn, + OrganisationNumber = + stifterVirksomhet.Organisasjonsnummer?.ToString() ?? string.Empty, + Notifications = new Notifications + { + OnSignatureAccessRightsDelegated = new Notification + { + Email = new Email + { + EmailAddress = stifterVirksomhet.Epost, + SubjectTextResourceKey = "signing.email_subject", + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterVirksomhet.Navn + ), + }, + Sms = new Sms + { + MobileNumber = stifterVirksomhet.Mobiltelefon, + BodyTextResourceKey = "signing.notification_content".Replace( + "{0}", + stifterVirksomhet.Navn + ), + } + } + } + }; + + providedSignees.Add(organisationSignee); + } + + return new SigneesResult { Signees = providedSignees }; + } + + private async Task GetFormData(Instance instance) + { + DataElement modelData = instance.Data.Single(x => x.DataType == "Skjemadata"); + InstanceIdentifier instanceIdentifier = new(instance); + + return (Skjemadata) + await _dataClient.GetFormData( + instanceIdentifier.InstanceGuid, + typeof(Skjemadata), + instance.Org, + instance.AppId, + instanceIdentifier.InstanceOwnerPartyId, + new Guid(modelData.Id) + ); + } +} + +``` diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.en.md new file mode 100644 index 00000000000..f30f7217bb7 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.en.md @@ -0,0 +1,11 @@ +--- +hidden: true +--- + +By runtime delegated signing, we mean an app where those who need to sign are granted rights during the form-filling process. + +Typically, the app will ask the form owner to provide the social security number and last name of the individuals who need to sign, or alternatively, the organization number if someone with signing authority within a company needs to sign. + +Once the form is fully completed, the user presses "Submit for singing". +The app will then delegate rights and send a message to the inbox in Altinn. +The recipient may also be notified via email and SMS, depending on the configuration. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.nb.md new file mode 100644 index 00000000000..dfd27bed3d2 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/intro.nb.md @@ -0,0 +1,11 @@ +--- +hidden: true +--- + +Med brukerstyrt signering mener vi en app hvor de som skal signere tildeles rettigheter underveis i utfyllingen av skjemaet. + +Typisk vil appen be skjemaeier om å oppgi fødselsnummer og etternavn for de de personene som skal signere, eventuel organisasjosnummer dersom noen med rett til å signere i en bedrift som skal signere. + +Når skjemaet er ferdig fylt ut, trykker man på "Send til signering". +Da vil appen delegere rettigheter og sende en melding til innboksen i Altinn. +Vedkommende vil også kunne varsles via e-post og sms, avhengig av konfigurasjon. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.nb.md new file mode 100644 index 00000000000..7158b821c4d --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/add-process-task.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> Dette steget må gjøres manuelt. Støtte for konfigurasjon i Altinn Studio kommer senere. +> Se "Manuelt oppsett"-fanen for denne seksjonen for veiledning. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.nb.md new file mode 100644 index 00000000000..7158b821c4d --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/configure-layouts.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> Dette steget må gjøres manuelt. Støtte for konfigurasjon i Altinn Studio kommer senere. +> Se "Manuelt oppsett"-fanen for denne seksjonen for veiledning. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.nb.md new file mode 100644 index 00000000000..86731e375a9 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/setup-text-resources.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> Dette steget må gjøres manuelt. Støtte for konfigurasjon i Altinn Studio kommer senere. +> Se "Manuelt oppsett"-fanen for denne seksjonen for veiledning. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.en.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.en.md new file mode 100644 index 00000000000..f8af3c797d4 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.en.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> This step needs to be done manually. Support for configuration in Altinn Studio Designer will come later. +> Take a look at the "Manual setup"-tab for this section for guidance. diff --git a/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.nb.md b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.nb.md new file mode 100644 index 00000000000..7158b821c4d --- /dev/null +++ b/content/altinn-studio/guides/development/signing/runtime-delegated-signing/studio/signee-provider.nb.md @@ -0,0 +1,6 @@ +--- +hidden: true +--- + +> Dette steget må gjøres manuelt. Støtte for konfigurasjon i Altinn Studio kommer senere. +> Se "Manuelt oppsett"-fanen for denne seksjonen for veiledning. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/sign-and-submit/_index.en.md b/content/altinn-studio/guides/development/signing/sign-and-submit/_index.en.md new file mode 100644 index 00000000000..c2435a000c5 --- /dev/null +++ b/content/altinn-studio/guides/development/signing/sign-and-submit/_index.en.md @@ -0,0 +1,91 @@ +--- +title: Sign and submit +linktitle: Sign and submit +description: Follow these steps to implement sign and submit in one step in you app +tags: [signing] +weight: 50 +aliases: +- /altinn-studio/guides/signing/sign-and-submit +--- + +## What does sign and submit mean? + +{{% insert "content/altinn-studio/guides/development/signing/sign-and-submit/intro.en.md" %}} + +## Prerequisites +If the service should send a signature receipt to the inbox of the signee, the Altinn message service (Correspondence) must be enabled. + +## Convert data task step to a singing task + +Below is an example of a data task that has been converted to a signing task. + +The task will still work like a normal data task, except that the instance owner can sign the data at the same time as submitting the instance. + +1. Change the `taskType` to be `signing`. +2. Add `sign` to possible actions. +3. Configure what data types should be signed, for instance the raw data model, in ``. +4. Configure in which data type the actual signature should be stored. The data type is examplified below. + +Finished converted example in `process.xml`: + +```xml + + + + signing + + sign + + + + model + + signatureInformation-2mjK + + + + Flow_0esyro2 + Flow_1438z6c + +``` + +The data type in `applicationmetadata.json`: + +```json +{ + "id": "signatureInformation-2mjK", + "allowedContentTypes": [ + "application/json" + ], + "allowedContributors": ["app:owned"] +} +``` + +## Access rights + +Make sure that the instance owner has rights to do the `sign` action. + +For this scenario you can likely add `sign` right next to where they get access to `read` and `write`. + +```xml + + + + read + + + + + + write + + + + + + sign + + + + +``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/sign-and-submit/_index.nb.md b/content/altinn-studio/guides/development/signing/sign-and-submit/_index.nb.md new file mode 100644 index 00000000000..dea95923f2a --- /dev/null +++ b/content/altinn-studio/guides/development/signing/sign-and-submit/_index.nb.md @@ -0,0 +1,91 @@ +--- +title: Signer og send inn +linktitle: Signer og send inn +description: Følg disse stegene for å implementere signering og send inn i ett steg i din app +tags: [signering] +weight: 50 +aliases: +- /nb/altinn-studio/guides/signing/sign-and-submit +--- + +## Hva betyr signer og send inn? + +{{% insert "content/altinn-studio/guides/development/signing/sign-and-submit/intro.nb.md" %}} + +## Avhengigheter +Dersom appen skal kunne sende signeringskvittering til innboksen til den som signerer så må oppsett for bruk av meldingstjenesten i Altinn være satt opp. + +## Konverter data-prosesssteget til et signeringssteg + +Se eksempel på et datasteg som har blitt konvertert til et signeringssteg nedenfor. + +Steget vil fremdeles fungere som et vanlig datasteg, bare at man i tillegg kan signere samtidig som man sender inn skjemaet. + +1. Endre `taskType` på datasteget til `signing`. +2. Legg til `sign` action som en mulig handling. +3. Anngi hvilke data som skal signeres på i ``, feks. skjemadataene i datamodellen. +5. Oppgi en datatype i ``. Hvordan den bør se ut finner du nedenfor. + +Ferdig konvertert eksempel i `process.xml`: + +```xml + + + + signing + + sign + + + + model + + signatureInformation-2mjK + + + + Flow_0esyro2 + Flow_1438z6c + +``` + +Datatypen i `applicationmetadata.json`: + +```json +{ + "id": "signatureInformation-2mjK", + "allowedContentTypes": [ + "application/json" + ], + "allowedContributors": ["app:owned"] +} +``` + +## Tilgangsrettigheter + +Sørg for at den som fyller ut skjema har rettighet til å utføre action `sign`. + +Man kan feks. legge til dette rett ved der vedkommede får read og write. + +```xml + + + + read + + + + + + write + + + + + + sign + + + + +``` \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/sign-and-submit/intro.en.md b/content/altinn-studio/guides/development/signing/sign-and-submit/intro.en.md new file mode 100644 index 00000000000..76fa2519e4a --- /dev/null +++ b/content/altinn-studio/guides/development/signing/sign-and-submit/intro.en.md @@ -0,0 +1,5 @@ +--- +hidden: true +--- + +This is a scenario where the form instance owner is supposed to sign the data at the same time as submitting the form. Singing and submitting is the same button press. \ No newline at end of file diff --git a/content/altinn-studio/guides/development/signing/sign-and-submit/intro.nb.md b/content/altinn-studio/guides/development/signing/sign-and-submit/intro.nb.md new file mode 100644 index 00000000000..c46077dbe0b --- /dev/null +++ b/content/altinn-studio/guides/development/signing/sign-and-submit/intro.nb.md @@ -0,0 +1,5 @@ +--- +hidden: true +--- + +Dette er et scenario hvor utfyller av skjemaet skal signere for dataene samtidig som skjemaet sendes inn. Signering og innsending er samme knappetrykk. \ No newline at end of file diff --git a/content/altinn-studio/reference/data/persistence/_index.en.md b/content/altinn-studio/reference/data/persistence/_index.en.md new file mode 100644 index 00000000000..b0aa93bfa00 --- /dev/null +++ b/content/altinn-studio/reference/data/persistence/_index.en.md @@ -0,0 +1,21 @@ +--- +title: Persistence +linktitle: Persistence +description: +weight: 10 +--- + +## Configure minimum persistence lifetime + +You may configure the persistence lifetime for instances of an application by configuring the `preventInstanceDeletionForDays` property in the `App/config/applicationmetadata.json`-file. +This prevents the instances from being deleted by users and the service owner for the time period set. + +### Example - prevent deletion of instances for 30 days + +``` +{ + ... + "preventInstanceDeletionForDays": 30, + ... +} +``` diff --git a/content/altinn-studio/reference/data/persistence/_index.nb.md b/content/altinn-studio/reference/data/persistence/_index.nb.md new file mode 100644 index 00000000000..aec68efdb58 --- /dev/null +++ b/content/altinn-studio/reference/data/persistence/_index.nb.md @@ -0,0 +1,21 @@ +--- +title: Lagring +linktitle: Lagring +description: +weight: 10 +--- + +## Konfigurer minimum levetid for persistens + +Du kan konfigurere persistensens levetid for instanser av en applikasjon ved å konfigurere egenskapen `preventInstanceDeletionForDays` i filen `App/config/applicationmetadata.json`. +Dette hindrer at instansene blir slettet av brukere og tjenesteeieren i den angitte tidsperioden. + +### Eksempel - hindre sletting av instanser i 30 dager + +``` +{ + ... + "preventInstanceDeletionForDays": 30, + ... +} +```