Hvordan lage ekstern behandling for en typisk konfigurasjon. Legge til ekstern behandling i databasen Opprett ekstern behandling for 1s 8.3

Konfigurasjonsseksjon: Applikasjonsobjekter

La meg ta en reservasjon med en gang: dette materialet er mer egnet for konfigurasjoner utviklet på kontrollerte former. Likevel generelle prinsipper er de samme for alle former.

For å opprette en ekstern behandling eller rapport, trenger du bare å velge Fil/Ny-menyen og velge type behandling eller rapport. Etter å ha opprettet behandlingen, kan du i prinsippet allerede bruke den. Men for å koble den til en standardkonfigurasjon som tilleggsbehandling eller rapportering, er ikke dette nok.

For å gjøre dette må du registrere flere prosedyrer i behandlingsmodulen. Deres generelle betydning koker ned til det faktum at du lar konfigurasjonen vite hva slags behandling det er (behandling, rapport, trykt skjema, utfylling av en tabelldel, etc.), og du angir også i hvilket undersystem den skal ligge.

Denne koden er gitt nedenfor. For behandlingen må du endre flere parametere.

Vel, først og fremst er dette versjonen og navnet på behandlingen, samt navnet på kommandoen. Som jeg allerede skrev, må du angi delsystemet der det vil være plassert eller et spesifikt objekt (katalog, dokument).
Også type behandling og bruksmåte. Sikker modus tillater ikke endringer i databasen.

Funksjon InformationOnExternalProcessing() Export
// La oss deklarere en variabel der vi vil lagre og returnere de nødvendige dataene "utenfor"
Registreringsparametere = Ny struktur;

// La oss erklære en annen variabel som vi trenger nedenfor
ArrayDestinations = New Array;

// Den første parameteren vi må spesifisere er hvilken type prosessering systemet skal registrere.
// Gyldige typer: AdditionalProcessing, AdditionalReport, FillingObject, Report, PrintForm, CreatingLinkedObjects
Registreringsparametere.Insert("View", "AdditionalProcessing");

// Nå må vi sende i form av en rekke navn hva vår VPF vil være koblet til
// Husk at du kan angi navnet i følgende skjema: Dokument.* - i dette tilfellet vil behandlingen kobles til alle dokumenter i systemet,
// som støtter VPF-mekanismen
Array of Assignments.Add("Subsystems.RegulatedAccounting");
Registration Parameters.Insert("Destination", Array of Destination);

// La oss nå angi navnet som VPF vil bli registrert under i den eksterne behandlingskatalogen
Registration Parameters.Insert("Navn", "Analyse av negative saldoer etter registre");

// Angi behandlingsrettigheten som skal brukes sikker modus. Flere detaljer finner du i plattformhjelpen (SetSafeMode-metoden)
Registreringsparametere.Insert("SafeMode", True);

// De neste to parameterne spiller mer informasjonsrolle, dvs. dette er hva brukeren vil se i informasjonen for behandling
Registreringsparametere.Insert("Versjon", "1.0");
Registration Parameters.Insert("Informasjon", "Analyse av negative saldoer etter registre");

// Lag en tabell med kommandoer (se detaljer nedenfor)
CommandTable = GetCommandTable();

// Legg til en kommando i tabellen
Legg til kommando(Tabell med kommandoer, "Analyse av negative saldoer etter registre", "Analyse av negative saldoer etter registre", "Åpningsskjema");

// Lagre kommandotabellen til beh
Registreringsparametere.Insert("Kommandoer", CommandTable);

// La oss nå returnere parameterne våre til systemet
ReturnRegistration Parameters;
EndFunction

Funksjon GetTableCommand()

// Lag en tom kommandotabell og kolonner i den
Kommandoer = Ny verditabell;

// Hvordan beskrivelsen av det trykte skjemaet vil se ut for brukeren
Commands.Columns.Add("View", NewTypeDescription("Row"));

// Navnet på layouten vår, slik at vi kan skille den kalte kommandoen i utskriftsbehandling
Commands.Columns.Add("Identifier", New TypeDescription("String"));

// Dette angir hvordan prosesseringskommandoen skal kalles
// Mulige alternativer:
// - OpeningForm - i dette tilfellet skal identifikatorkolonnen angi navnet på skjemaet som systemet vil åpne
// - CallClientMethod - kall opp klienteksportprosedyren fra behandlingsskjemamodulen
// - Call ServerMethod - kall opp en servereksportprosedyre fra prosesseringsobjektmodulen
Commands.Columns.Add("Bruk", New TypeDescription("Row"));

// Neste parameter angir om et varsel skal vises når en behandlingsjobb starter og avsluttes. Det gir ikke mening når du åpner skjemaet
Commands.Columns.Add("ShowAlert", NewTypeDescription("Boolean"));

// For et trykt skjema må det inneholde strengen PrintMXL
Commands.Columns.Add("Modifier", New TypeDescription("Row"));
Return Team;
EndFunction

Prosedyre AddCommand(CommandTable, View, Identifier, Usage, ShowAlert = False, Modifier = "")
// Legg til en kommando i kommandotabellen i henhold til den beståtte beskrivelsen.
// Parametre og deres verdier kan sees i GetCommandTable-funksjonen
NewCommand = CommandTable.Add();
NewCommand.View = Vis;
NewCommand.Identifier = Identifikator;
NewCommand.Use = Bruk;
NewCommand.ShowAlert = ShowAlert;
NewCommand.Modifier = Modifikator;

I 1C er det mange konfigurasjonsobjekter som på en eller annen måte er knyttet til regnskap - det vil si at de lar det vedlikeholdes - kataloger, dokumenter, registre og så videre. Men hva skal du gjøre når du trenger å lage et program på 1C-språket som ikke har noe med regnskap å gjøre, men som kreves for programmererens offisielle behov eller for å gjøre brukerens arbeid enklere?

Et godt eksempel er batchbehandling av dokumenter. Dette er et verktøy som lar deg holde/endre/skrive ut ikke bare ett dokument, men mange samtidig, i henhold til en valgt liste. Enig - veldig praktisk.

For å implementere verktøy i 1C for å lette arbeidet til en bruker eller administrator av en 1C-database, er det et spesielt konfigurasjonsobjekt - 1C-behandling. 1C-behandling kan være en del av konfigurasjonen eller distribueres som separate filer (da kalles behandlingen ekstern 1C-behandling).

1C-behandling lar deg utvikle dine egne verktøy både for 1C-programmering og for å sette opp eller administrere 1C. Takket være dette er det hundrevis av standardbehandlinger på Internett (utviklet av 1C) og tusenvis av amatørbehandlinger på Internett.

Det er på tide å prøve å gjøre 1C-behandling selv. Detaljer nedenfor.

Hva er 1C-behandling og hvordan brukes de?

En liten introduksjon. De som allerede er kjent med 1C-behandling kan hoppe over dette punktet.

Så prosessering er et verktøy skrevet av en programmerer. Hun kan ikke gjøre noe på egen hånd og lagrer ikke data til 1C-databasen, i motsetning til for eksempel et dokument - som er lagret i databasen og kan registreres og behandles uavhengig, uten tilleggsprogrammering. 1C-behandlingsfunksjoner avhenger helt av programmereren som skrev den.

Basert på funksjonalitet kan 1C-behandling deles inn i tre typer:

Hjelpebehandling av 1C-konfigurasjon
I hver typisk konfigurasjon det er mange behandlinger. De brukes som ekstra grensesnittskjemaer (brukerskrivebord, konfigurasjonsoversikt), som en del av konfigurasjonsfunksjonaliteten (legge inn startsaldo, innledende fylling av databasen, avslutte måneden).
Objekter (klasser)
Alle som kan andre programmeringsspråk er allerede kjent med begrepet objekt. Dette er en viss klasse som har til disposisjon et sett med "variabler" og "funksjoner". Dens skjønnhet ligger i dens selvforsyning - det vil si at alt som er nødvendig for å utføre funksjonene er samlet i en klasse.
I 1C kan klasser opprettes ved hjelp av 1C-behandling: "variabler" - 1C-behandlingsdetaljer, "funksjoner" - funksjoner i 1C-behandlingsobjektmodulen (Eksportmerke for offentlige funksjoner). Bekvemmeligheten ligger i både å lage en forekomst av en slik klasse og flytte den mellom konfigurasjoner.

Et godt eksempel er behandling av 1C-utskrift (ekstra trykte skjemaer), som du finner i standardkonfigurasjoner i katalogen Ytterligere trykte skjemaer. De har alltid en offentlig Print()-funksjon og standardisert bruk.

Vær oppmerksom på at slike "klasser" selvfølgelig ikke er direkte assosiert med data - de må bestås eller leses i "konstruktøren".
Ytterligere bruker- og administrasjonsverktøy
Det er mange generiske verktøy tilgjengelig for bruk av en typisk DBA som ikke er knyttet til en bestemt konfigurasjon. Slike verktøy er ofte ikke inkludert i standard konfigurasjonspakken og distribueres separat (vanligvis på ITS-disker). I tillegg til standard, legger programmerere ut mange av sine egne verktøy på Internett.
Eksempler inkluderer: 1C-behandling av arbeid med kommersielt utstyr, 1C-oppgavekonsoll (viser en liste over oppgaver som kjører på en tidsplan), 1C-spørringskonsoll (lar deg utføre alle spørringer uten programmering), etc.

Hvor er 1C-behandling plassert?

Så det er 1C-behandling innebygd i konfigurasjonen og ekstern 1C-behandling.

Innebygd 1C-behandling brukes situasjonsbestemt av programmereren som utvikler konfigurasjonen - det vil si at de enten kan vises i brukermenyen (del av Service-menyen), eller åpnes programmatisk fra andre 1C-objekter (for eksempel fra et katalogskjema ).

På en eller annen måte, under administratorrettigheter, kan du åpne en liste over prosessorer innebygd i konfigurasjoner og hvilken som helst av dem, hvis den kan åpnes (det vil si hvis den har et skjermskjema og programmereren ikke har satt en lås ved åpning) . For å gjøre dette, bruk Operations/Processing-menyen i den tykke klienten, bruk menyen Alle funksjoner/Processing i tynnklienten. Hvis du ikke vet hvordan du finner disse menyene - .

I konfiguratoren er 1C-behandling innebygd i konfigurasjonen plassert i Processing-grenen.

Ekstern 1C-behandling åpnes både i konfiguratoren og i Enterprise ved hjelp av Fil/Åpne-menyen.

Sikkerhet. Vær oppmerksom på. 1C-behandlingsobjektmodulen kjøres automatisk når du åpner 1C-behandling i Enterprise-modus. Derfor, hvis du åpner en behandling skrevet av en angriper, kan den utføres automatisk uten spørsmål.

Hvordan gjøre 1C-behandling selv

Så la oss komme til den morsomme delen - algoritmen for å lage 1C-behandling selv fra bunnen av.

Eksterne behandlinger er veldig hendig verktøy for selskaper som bruker standardkonfigurasjoner på 1C:Enterprise 8.3. De lar deg ikke kaste bort krefter og penger på 1C-oppdateringer, noe som gjør det mulig å oppdatere databaser med én knapp i enkel brukermodus. Ved å bruke standard delsystembibliotekmekanisme kan du legge til forskjellige knapper i dokumenter og oppslagsverk uten å endre standardkonfigurasjonen. La oss vurdere et eksempel på å lage og koble til ekstern prosessering i en av 1C-konfigurasjonene.

Vi lager ekstern prosessering i 1C 8.3

For å lage en ny ekstern prosessering bruker vi konfiguratoren. Gjennom "Fil"-menyen velger du opprettelseskommandoen "Ny..." og bestemmer at vi vil opprette ekstern behandling. Angi navnet i vinduet som åpnes, og når du trykker "Enter", fylles det ut automatisk. Systemet vil også tilby deg dette navnet som filnavn når du lagrer.

La oss legge til et behandlingsskjema ved å klikke på knappen med et forstørrelsesglass i det tilsvarende vinduet. La oss som et eksempel lage en behandling som viser hvilke kundeordrer som bruker en bestemt vare. For å gjøre dette, må vi plassere på skjemaet:

Attributter – felt for innstilling av nomenklaturen;
En knapp som vil ringe koden.

Legg til «Nomenclature»-attributtet med datatypen «DirectoryLink.Nomenclature» i den tilsvarende delen og «Vis»-knappen i «Kommandoer» -> «Skjemakommandoer»-menyen.

For at de tilførte dataene skal reflekteres på skjemaet, må du dra det inn i skjemaelementene som ligger øverst til venstre. Det er mulig å bytte elementer ved hjelp av de blå pilene. For at knappen vi opprettet skal gjøre det den har til hensikt, må den tildeles en prosedyre. Gjennom kontekstmenyen velger du "Kommandohandling", og når vi blir spurt om hvor behandleren er nødvendig, svarer vi: "Opprett på klienten og en prosedyre på serveren."

Fragment 1

&OnClient-prosedyre Vis(kommando) ShowOnServer(); Slutt på prosedyre &OnServer Prosedyre ShowOnServer() //Sett inn innholdet i behandleren. Slutt på prosedyre

Vi valgte å lage en prosedyre på serveren fordi vi ønsker å motta en prøve fra databasen som et resultat. Vi har ikke dette alternativet på klienten, så vi må koble til serveren, som utveksler data med databasen. Nå må vi skrive kode som implementerer det vi har planlagt. Forespørselen og utgangen av alle dokumenter gjennom "Report()"-funksjonen vil bli brukt.

Fragment 2

&OnClient-prosedyre Vis(Kommando) ShowOnServer(Nomenklatur); EndProcedure &OnServer Prosedyre ShowOnServer(Nomenclature) Request = Ny forespørsel;

Request.SetParameter("Nomenklatur", Nomenklatur);

Funksjon InformationOnExternalProcessing() Export DataForReg = New Structure();

DataForReg.Insert("Navn","Ny ekstern behandling");

DataForReg.Insert("SafeMode", True);

DataForReg.Insert("Versjon", "ver.: 1.001"); DataForReg.Insert("View", "Additional Processing"); CommandTable = NewValueTable;

TabZnCommands.Columns.Add("Identifier");

TabZnCommands.Columns.Add("Bruk");
TabZnCommands.Columns.Add("Vis"); NewRow = TabZnCommands.Add(); NewString.Identifier = "NewExternalProcessing";
NewRow.Use = "OpenForm"; NewRow.View = "Ny ekstern behandling"; DataForReg.Insert("Kommandoer", TabZnCommands);
Returner DataForReg; EndFunction

Hvis vi ønsker å gjøre endringer i behandlingen vår, må vi først laste den ut av databasen. For å gjøre dette, finn den nødvendige linjen i katalogen "Ytterligere behandling og rapporter" og bruk kommandoen "Last opp til fil...". Gjør endringer, lagre behandlingen og bruk "Last fra fil..."-knappen for å finne den endrede epf-filen uten å endre parametrene. Etter opptak vil alle brukere se endringene som er gjort.

Hvis du bruker en ikke-standard eller utgått 1C-database, så dra nytte av muligheten til å laste ned behandling gjennom konfiguratoren. I objekttreet, i delen "Behandlinger", oppretter du en ny behandling og velger "Erstatt med ekstern behandling, rapporter..." gjennom kontekstmenyen. Alt som gjenstår er å konfigurere lanseringen av ekstern behandling fra ønsket seksjon, som aktiverer den ekstra behandlingen i det ønskede undersystemet.

Å jobbe med ekstern prosessering er veldig praktisk og lar deg unngå mange konflikter. Deres eneste betydelige ulempe er at de ikke oppdateres automatisk sammen med konfigurasjonen. Det vil si at hvis utviklerne endret navnet på dokumentet eller referanseboken i hovedkonfigurasjonen, må vi konfigurere behandlingen manuelt.

Oppmerksomhet! Dette er en introduksjonsversjon av leksjonen, hvis materiell kan være ufullstendig.

Logg inn på siden som student

Logg på som student for å få tilgang til skolemateriell

Opprette 1C-konfigurasjoner: legge til behandling

Vi fortsetter å studere det grunnleggende om å lage konfigurasjoner på 1C.

I denne leksjonen vil vi lage en ny prosessering sammen, og deretter skrive kommandoer for den som viser hvordan du arbeider med "Ansatte"-katalogen.

Vi går tilbake til konfiguratoren og åpner konfigurasjonstreet.

Legger til en ny behandling

Høyreklikk på delen "Behandler" og velg "Legg til":

Vinduet for å opprette en ny behandling åpnes. La oss gå til "Main"-fanen og spesifisere "Directory Processing" som behandlingsnavn:

Opprette et skjema for behandling

La oss gå til "Skjemaer"-fanen, klikk på det grønne plusstegnet for å legge til ny uniform(visuell representasjon av vår behandling):

En konstruktør for skjemaoppretting har dukket opp. La oss la alt være standard og klikk "Fullfør":

Et nytt skjema har åpnet:

Opprett en ny kommando for skjemaet

La oss gå til fanen "Kommandoer" -> "Skjemakommandoer":

La oss legge til en ny kommando (grønt plusstegn):

Og i eiendommer nytt lag spesifiser navnet "Output of All Employees":

I egenskapene klikker du på forstørrelsesglasset ved siden av "Handling"-feltet for å angi kommandobehandleren. Velg alternativet for å opprette en behandler "På klient" og klikk "OK":

Vi ble overført til skjemamodulen i behandlerprosedyren for kommandoen "Output All Employees":

Skrive kommandobehandlerkoden

Nå er oppgaven vår å skrive kode på det interne 1C-språket som vil iterere gjennom alle elementene i "Ansatte"-katalogen.

Jeg vil si med en gang at denne koden ikke kan skrives direkte i "Output All Employees"-prosedyren, siden den utføres på klienten (vær oppmerksom på den spesielle linjen før "&OnClient"-prosedyren). Å prøve å lese data fra databasen i en klientprosedyre vil alltid resultere i en feil (bare husk dette for nå).

La oss derfor legge til en prosedyre som denne på slutten av modulen:

Vær oppmerksom på at før det indikerte jeg "&OnServer"-attributtet. Dette betyr at det vil bli utført på serveren, noe som betyr at vi kan lese katalogdata fra den.

La oss nå organisere en oppfordring til denne prosedyren fra klienten "OutputAllEmployees":

Her er logikken slik:

Brukeren kaller kommandoen "Output All Employees" (for eksempel ved å klikke på en knapp, som vi egentlig ikke har ennå)
Kommandoen starter behandlerprosedyren med samme navn "Output All Employees" på klienten (tross alt er knappen, og derfor kommandoen, på klienten)
Klientprosedyren "OutputAllEmployees" kaller serverprosedyren "OutputAllEmployeesOnServer"
Serverprosedyren "Output All Employees on Server" leser katalogdata fra databasen og viser dem i meldingsvinduet

Alt vi har igjen er å skrive koden for "Output All Employees on Server"-prosedyren, som går gjennom elementene i "Employees"-katalogen og viser dem i meldingsvinduet.

Det er faktisk ikke vanskelig. Å krysse alle kataloger i 1C er det samme. Dette betyr at etter å ha lært å gjøre dette nå med "Ansatte"-katalogen, kan du gjøre det samme med alle andre kataloger.

For å få tilgang til katalogdata brukes en leder, som du får tilgang til på følgende måte:

Manager = Kataloger. Ansatte;

I denne setningen er nøkkeldelen til høyre for likhetstegnet. Til venstre er bare en variabel som vi lagrer administratoren i slik at vi kan jobbe videre med den. Navnet på denne variabelen kan ikke bare være "Manager", men også en hvilken som helst annen - til og med "Trommeslager".

Hva er en katalogbehandler? En leder er ikke selve katalogdataene. En leder er et programobjekt (du kan tenke på det som en svart boks) som vi kan gjøre noe med katalogen gjennom.

Katalogbehandleren er som et lag mellom koden vår og katalogdataene. Og det viser seg at hvis vi trenger å lese alle elementene i katalogen, kan vi ikke gjøre dette direkte. Vi kan bare spørre laget vårt mellom oss og katalogen, det vil si sjefen, om dette.

For å gjøre dette, må du kalle "Velg" -metoden innebygd i manageren. Den kalles med en prikk etter navnet på variabelen som lederen er lagret i, og returnerer en samling katalogelementer:

Manager = Kataloger. Ansatte; Eksempel = Manager. Velg() ;

Hva er en prøve? Et utvalg (igjen, dette er bare navnet på variabelen som vi lagrer resultatet av "Select"-metoden i, og det kan være noe annet) er en samling, men ikke det samme som for eksempel en matrise eller en liste av verdier.

Utvalget er et objekt - igjen tenk på det som en boks - men ennå ikke selve dataene. Det særegne ved dette objektet er at det kan iterere gjennom elementene i katalogen vi trenger. Dessuten sorterer det dem ut dynamisk. Dette betyr at bruk av sampling ikke leser alle katalogelementene samtidig, men velger dem i deler fra databasen.

Denne tilnærmingen lar deg raskt gå gjennom store lister med kataloger ved å bruke utvalg, uten å laste dem alle inn i datamaskinens minne på en gang.

For å få den neste databiten fra en prøve, må du kalle «Neste»-metoden innebygd i prøven. Mottak av databiter (en del tilsvarer ett katalogelement) skjer vanligvis i en løkke:

Når dataene (katalogelementene) i utvalget går tom, vil "Neste"-metoden returnere False og syklusen vil stoppe.

Etter hvert kall til "Neste"-metoden (forutsatt at den returnerte "True"), vil utvalget inneholde alle feltene med data for bare lesekatalogelementet, som kan nås med navn adskilt med en prikk:

Det viser seg i ett øyeblikk - vi jobber med dataene til bare ett av elementene i katalogen. Og her kan vi enten umiddelbart vise dem til brukeren (ved å bruke «Varsle»-metoden) eller for eksempel sette dem i en annen samling (array) slik at vi kan gjøre noe med dem på en gang. Alt avhenger av problemet vi løser.

Utvendig 1C-behandling og rapporter er behandling og rapporter som ikke er en del av applikasjonsløsningen og er lagret i separate filer. Deres største fordel er at slik behandling og rapportering kan brukes i ulike applikasjonsløsninger uten å endre strukturen på selve løsningene. En viktig fordel eksterne rapporter og prosessering er muligheten til å designe og feilsøke dem under driften av 1C Enterprise, uten å lagre konfigurasjonen av applikasjonsløsningen hver gang.

I 1C Enterprise-modus utvendig 1C-behandling kan startes for kjøring ved å åpne den som enhver annen fil som er lagret på disken. Slik behandling vil fungere akkurat som om de var en del av en applikasjonsløsning.

Enhver prosessering som eksisterer i konfigurasjonen kan konverteres til ekstern behandling, og omvendt. Utenom dette ekstern behandling 1C kan legges til strukturen til applikasjonsløsningen som nye objekter.

Å bruke ekstern behandling 1C når du arbeider med 1C Enterprise-systemet, må du åpne det på samme måte som i konfiguratoren. Men det bør huskes at i 1C Enterprise-systemet åpnes ekstern behandling kun for bruk, det vil si at brukeren ikke kan redigere den.

Kompilering av den eksterne behandlingsmodulen utføres når du åpner ekstern behandling, derfor, etter å ha redigert den eksterne behandlingen i konfiguratoren og lagret den, må du åpne denne behandlingen på nytt i 1C Enterprise-systemet.

Redigering ekstern behandling 1C utføres i konfiguratoren. For å åpne en eksisterende ekstern behandling, velg Fil - Åpne. I standarddialogen som vises på skjermen, velg filtypen - Ekstern behandling - og angi navnet på den eksterne behandlingsfilen som skal åpnes. Når du åpner ekstern behandling i konfiguratoren, åpnes objektredigeringsdialogen automatisk. I motsetning til andre konfigurasjonsobjekter, feilsøking ekstern behandling 1C utføres uten å starte 1C Enterprise på nytt.

Fordeler ekstern behandling 1C: lagre ekstern prosessering og åpne den i bedriften på samme konfigurasjon og datamaskin tar alltid et par sekunder; noe programfunksjonalitet kan overføres til ekstern behandling, og når disse delene endres, vil det ikke være behov for å sende hele konfigurasjonen, det vil være nok å endre behandlingen og sende den til brukeren; for å rette en feil i en database hvor det er mange brukere, kan du lagre rapporten som en ekstern behandling og gjøre de nødvendige endringene i den og gi den til brukerne, og deretter sakte, på et passende tidspunkt, sette inn en ekstern behandling til erstatte den feilaktige rapporten; mange programmerere distribuerer sine nye løsninger, implementert for noen standardkonfigurasjoner, uten å kopiere hele databasen.

Ulemper med ekstern behandling 1C: kan ikke opprettes ved hjelp av ekstern prosessering nytt dokument eller oppslagsbok; alt som ikke angår strukturen til databasen kan håndteres ved behandling.

For å opprette ekstern behandling må du gå til konfiguratoren og finne driftsrapporten etter dato i konfigurasjonstreet. Så inn kontekstmenyen velg alternativet for å lagre som ekstern behandling og angi stedet der du vil lagre det.

Operasjon