Handledning: Säker inbäddning av Doconut Viewer med React – Från början till slut
Att inbädda en dokumentvisare på ett säkert sätt kräver mer än att bara kopiera ett middleware‑snutt i en ASP.NET Core‑applikation. Integrationen måste definiera tydliga gränser för autentisering, dokumentåtkomst, sessionshantering, rendering, annoteringar, sökning, utskrift och revisionsloggning.
Företag som bygger dokument‑centrerade portaler – exempelvis DMS, CRM, juridisk granskning eller ingenjörs‑ritningsapplikationer – måste också hålla originalfilerna bakom applikationsgränsen. Doconut stödjer en server‑sidig visningsmodell för PDF, Office, CAD och bilddokument, medan ett React‑gränssnitt kan tillhandahålla användarupplevelsen.
Denna handledning fokuserar på en pålitlig arkitektur och undviker medvetet paketnamn, alternativ‑egenskaper, metodsignaturer och endpoint‑vägar som kan variera mellan SDK‑versioner. Använd den officiella dokumentationen som matchar din licensierade version för exakt registrering och API‑detaljer.
1️⃣ Steg 1 – Förbered ASP.NET Core‑ och React‑projekten
Innan du skriver någon kod, se till att din utvecklingsmiljö uppfyller grundkraven:
| Krav | Rekommenderad version |
|---|---|
| .NET runtime | .NET 6 eller senare |
| ASP.NET Core | 6.0+ |
| IDE | En stödjande .NET‑utvecklingsmiljö |
| Front‑end (valfritt) | En React‑applikation som är kompatibel med ditt projekt |
- Skapa ett nytt ASP.NET Core Web API‑projekt
dotnet new webapi -n DocPortal
cd DocPortal
-
Lägg till de licensierade Doconut‑beroendena – Hämta de exakta paketnamnen, versionerna, inhemska beroenden och licensladdningsinstruktioner från den officiella dokumentationen för din Doconut‑utgåva. Anta inte att ett paket eller omslag som visas i en orelaterad handledning gäller för din version.
-
Förbered React‑applikationen – Om visaren ska presenteras via React, använd den front‑end‑konfiguration som redan godkänts av ditt team. Låt React‑applikationen vara beroende av ditt eget autentiserade API snarare än odokumenterade tredjeparts‑omslag.
-
Checka in det initiala tillståndet – De flesta företags‑team upprätthåller en Git‑policy som kräver en signerad commit för alla ändringar som berör licensiering eller säkerhetsinställningar.
Nu har du en ren lösning som är redo för den dokumenterade Doconut‑serverintegrationen.
2️⃣ Steg 2 – Konfigurera serverintegrationen säkert
Registrera visaren enligt instruktionerna som levereras för den exakta Doconut‑versionen i ditt projekt. Middleware‑ordning, tjänsteregistreringar, licensinitialisering och konfigurations‑egenskapsnamn är versionsspecifika detaljer och bör inte kopieras från otestade exempel.
Oavsett SDK‑version bör den omgivande ASP.NET Core‑applikationen upprätthålla följande kontroller:
- Autentisera innan ett dokument öppnas – En visarsession får aldrig kringgå applikationens identitetslager.
- Lös upp dokumentidentifierare på servern – Acceptera ett applikations‑nivå‑dokument‑ID, inte en godtycklig fysisk filsökväg som levereras av webbläsaren.
- Auktorisera varje operation – Visning, annotering, sökning, nedladdning och utskrift kan kräva olika behörigheter.
- Håll hemligheter utanför versionskontrollen – Lagra licenser, anslutningssträngar och krypteringsmaterial i den godkända hemlighets‑hanteringsmekanismen.
- Tillämpa begäransgränser – Ställ in lämpliga gränser för uppladdning, dokumentstorlek, tidsgräns och hastighet kring visarens arbetsflöde.
- Registrera säkerhetshändelser – Logga åtkomstbeslut och dokumentåtgärder utan att skriva dokumentinnehåll eller känsliga token till loggar.
Behandla alla SDK‑inställningar som versionsstyrd konfiguration. Bekräfta deras innebörd i den officiella referensen innan du aktiverar dem i produktion.
3️⃣ Steg 3 – Isolera dokumentsessioner bakom en applikationstjänst
Håll Doconut‑specifika interaktioner inom en dedikerad applikationstjänst. Referenser till en Viewer‑klass är användbara på arkitekturell nivå, men konstruktor‑signaturer, dokument‑öppningsmetoder, cache‑krav och licensupptäckningsbeteende måste hämtas från dokumentationen för din installerade version.
En säker tjänsteboundary bör:
- Ta emot en autentiserad användare och ett applikations‑nivå‑dokument‑identifierare.
- Kontrollera användarens behörighet för den begärda åtgärden.
- Hämta dokumentet från godkänt server‑sidigt lagringsutrymme.
- Begära att den dokumenterade visar‑API:n upprättar en dokumentsession.
- Returnera endast den minsta opaka sessionsinformationen som krävs av klienten.
- Frigöra eller låta sessioner gå ut enligt dina lagrings‑ och cache‑policyer.
Webbläsaren bör aldrig få en fysisk lagringsväg, licensdata, intern cache‑nyckel eller obegränsad referens till det ursprungliga dokumentet.
4️⃣ Steg 4 – Aktivera annoteringar, sökning och kontrollerad utskrift
Annoteringar, sökning, OCR och kontrollerad utskrift bör endast aktiveras när de ingår i din licensierade Doconut‑konfiguration och stöds av den installerade versionen. Undvik att anta metodnamn, persistensformat eller alternativklasser.
- Annoteringar – Bestäm vilka roller som får skapa, redigera, visa eller radera markeringar. Lagra annoteringsstatus enligt persistensriktlinjerna för din SDK‑version och dina egna revisionskrav.
- Sökning och OCR – Fastställ vilka dokumenttyper som kräver OCR, var extraherad text lagras och hur länge index är tillgängliga. Behandla sökresultat som dokumentdata och auktorisera dem därefter.
- Kontrollerad utskrift – Definiera sidgränser, vattenstämpelpolicy, godkännanderegler och revisionshändelser på applikationsnivå, och mappa sedan dessa krav till de dokumenterade utskriftsfunktionerna.
Håll dessa operationer bakom samma applikationstjänst som används för dokumentsessioner så att kontrollerna förblir tunna och affärsreglerna förblir testbara.
5️⃣ Steg 5 – Anslut React‑frontend
React‑applikationen bör anropa ditt autentiserade ASP.NET Core‑API snarare än att acceptera lagringsvägar eller ansluta direkt till interna dokumenttjänster. Definiera ditt eget resurs‑orienterade API‑kontrakt kring affärshandlingar och undvik att publicera SDK‑specifika endpoint‑namn som en del av det offentliga klientkontraktet.
En typisk interaktionssekvens är:
- Användaren väljer ett dokument som redan är synligt i applikationen.
- React begär en visningssession med dokumentets applikations‑ID.
- ASP.NET Core autentiserar begäran, auktoriserar dokumentet och koordinerar visarsessionen.
- React får endast den information som krävs för att visa visaren.
- Begäran om annotering, sökning och utskrift returneras via det autentiserade applikations‑API:t.
- Servern registrerar revisionshändelser och låter sessionen gå ut när det är lämpligt.
I React‑UI:n, håll sessionsstatus kortlivad, hantera auktoriseringsfel explicit, undvik att placera känsliga värden i beständig webbläsarlagring, och tillhandahåll laddnings‑ och felstatusar som inte avslöjar interna sökvägar eller undantagsdetaljer.
Denna separation håller rendering och dokumentkontroller på servern medan React förblir ansvarig för presentation och interaktion.
Slutsats
Genom att placera Doconut‑integrationen bakom en säker ASP.NET Core‑applikationstjänst kan du bygga en dokumentportal för PDF‑, Office‑, CAD‑ och bildarbetsflöden utan att koppla React‑gränssnittet till odokumenterade SDK‑detaljer. Autentisering, auktorisation, sessionslivscykel, sökning, annotering, utskrift och revisionspolicy förblir explicita delar av din applikationsdesign.
Redo att utvärdera Doconut för ditt .NET‑projekt? Använd det officiella paketet, licensieringen och API‑dokumentationen för din valda version, och tillämpa sedan arkitekturen och säkerhetslistan ovan i din implementation.