Licensiering

Funktioner, licenstier och licenstjänsten

Den här sidan är referensen vid körning för hur en licens påverkar Doconut's beteende: vad varje licenstillstånd tillåter, hur funktioner beviljas och hur man inspekterar allt detta från kod. (För laddning av en licens, se Licensinställning.)

Licenstillstånd och vad de gör

TillståndÖppnar dokument?VattenstämpelFunktioner
Full (betald) licens (denna build släpptes innan dess prenumerationsdatum)JaIngenDe som köpts (Has* flaggor)
Tillfällig licens (Developer/NFR — utvärderingslicensen, före dess utgångsdatum)JaIngen i basvisaren; pluginutdata är vattenstämpladAlla — generell beviljning (utvärderingsflödet)
Utgången tillfällig licens (förbi dess LicenseExpiry datum)JaUtvärderingsvattenstämpelIngen beviljad
Ingen licensfil allsJaUtvärderingsvattenstämpelIngen beviljad
Hittad men avvisad (ogiltig signatur, manipulerad, svartlistad, eller en build släppt efter licensens prenumerationsdatum)Nej — LicenseException vid varje öppning——

En betald licens vars prenumerationsdatum har passerat fortsätter att fungera — ren, med sina funktioner — på varje build som släppts före det datumet. Endast en build som släpps efter den avvisas.

Två konsekvenser som är värda att internalisera:

  • En saknad licens är inte en tillfällig licens. Utan licensfil renderas sidor med vattenstämpel och ingen funktion (sökning, annotering, plugins) är aktiv. Den fullständiga, ovattenstämplade upplevelsen kräver en faktisk Tillfällig licens (skaffa en).
  • Endast en avvisad licens blockerar öppning. En utgången Tillfällig licens låter appen fortsätta köra med utvärderingsvattenstämpel, och en betald licens efter dess prenumerationsdatum fortsätter rendera rent på de builds den täcker; men att distribuera en build som släpps efter licensens prenumerationsdatum avvisas och misslyckas snabbt med en LicenseException, så du fångar det vid distribution — inte genom att tyst leverera vattenstämplat resultat. Det undantaget (från OpenDocumentAsync) innehåller orsaken från License.RejectionMessage.

Funktioner

Doconut styr valfri funktionalitet med funktion. Det omfattar de inbyggda Sök- och Annotering-funktionerna samt de valfria Converter, Dicom och Signer-plugins, var och en beviljad av din licens. Basvisaren är inte en funktion — den är förutsättningen, presenterad som IsViewerLicensed:

csharp
var lic = Doconut.DoconutHost.Services.GetRequiredService<IDoconutLicenseService>();
bool viewerLicensed = lic.IsViewerLicensed; // non-TRIAL licens finns OCH som täcker denna byggs version

Den enda grind som hela pipeline använder är IsCapabilityGranted:

csharp
var lic = Doconut.DoconutHost.Services.GetRequiredService<IDoconutLicenseService>();
bool searchGranted = lic.IsCapabilityGranted(LicenseCapability.Search);

Dess logik, ordagrant från implementationen: en aktiv (icke-utgången) Tillfällig licens beviljar alla funktioner — inklusive funktioner som ännu inte har en dedikerad köpflagga; en verklig köpt licens beviljar exakt sina Has* flaggor och är default-deny för allt som inte är mappat. (En äldre TRIAL-typ fil är inte en rättighet — den behandlas som olicensierad: vattenstämplad, inget beviljat.)

Tillfälliga licenser

Tillfälliga (Developer/NFR) licenser markeras med en ExpiryNote-tagg och har ett fast utgångsdatum:

MedlemBetydelse
IsTemporaryEn ExpiryNote-tagg är närvarande (detektering sker via taggens närvaro — matcha aldrig notens text, den är dynamisk)
ExpiryNoteInformativ text inbäddad i licensen
LicenseExpiryDet fasta utgångsdatumet (DateTime?)

Utgångssemantiken skiljer sig åt efter nivå: en tillfällig licens går ut på sitt LicenseExpiry endast datum (dess prenumerationsfönster ignoreras; en tillfällig licens utan datum behandlas som utgången, felsäker). Alla andra licenser går ut på sitt prenumerations-/uppdateringsfönster datum; för en betald licens rapporterar IsExpired endast att detta datum har passerat — builds som släpps före det förblir rena och behåller sina funktioner.

IDoconutLicenseService referens

Lös IDoconutLicenseService (namnrymd Doconut.Core.Interfaces) från DoconutHost.Services. Det är en singleton — licensen analyseras en gång, i DoconutHost.Initialize:

MedlemBetydelse
LicenseFull DoconutLicenseInfo ögonblicksbild (nedan)
IsTrialEn äldre TRIAL-typ fil (behandlad som olicensierad — inte en rättighet)
IsTemporary / ExpiryNote / LicenseExpiryTillfälliga licensmarkörer
IsExpiredUtgången enligt tier-reglerna ovan
IsVersionValidDenna build faller inom licensens supportfönster
IsViewerLicensedIcke-TRIAL fil hittad och version täckt — grundförutsättning
IsCapabilityGranted(cap)Den enda kapacitetsgrinden
HasSearch HasAnnotation HasEditor HasConverter HasDicom HasDocumentTools HasSigner HasRedactor HasComparer HasForms HasProtector HasCompressorEn flagga per kapabilitet: köpt av en licens som täcker denna build, eller beviljad av en aktiv tillfällig licens. IsCapabilityGranted svarar på samma fråga per kapabilitet
IsValidForDomain(host)Värdtäckning; V4-licenser använder wildcard *.*
LicenseRejectionReasonEj tom ⇒ öppning blockeras med detta meddelande

DoconutLicenseInfo exponerar den displayvänliga ögonblicksbilden för adminpaneler: Owner, LicenseType, Domain, IsLicenseFileFound, IsVersionValid, IsTrial, IsExpired, Has*-flaggorna, de tillfälliga licensfälten, och RejectionMessage.

csharp
// GET /Features - feature-flagga ditt UI från samma sanningskälla som SDK:n använder
public ActionResult Index()
{
    var lic = Doconut.DoconutHost.Services.GetRequiredService<IDoconutLicenseService>();

    return Json(new
    {
        viewer     = lic.IsViewerLicensed || lic.IsTemporary,
        search     = lic.IsCapabilityGranted(LicenseCapability.Search),
        annotation = lic.IsCapabilityGranted(LicenseCapability.Annotation),
        conversion = lic.HasConverter,
        dicom      = lic.HasDicom,
    }, JsonRequestBehavior.AllowGet);
}

Hälsokontroll

Doconut registrerar en "doconut" hälsokontroll som rapporterar licenstillståndet. Classic ASP.NET har ingen egen hälsoslutpunkt, så exponera den från en controller:

csharp
// GET /Health - Doconut registrerar en "doconut" hälsokontroll som rapporterar licensstatusen:
// Frisk (giltig), Nedsatt (prövning eller ingen licensfil), Ohälsosam (avvisad eller utgången).
public async Task<ActionResult> Index()
{
    var health = Doconut.DoconutHost.Services.GetRequiredService<HealthCheckService>();
    HealthReport report = await health.CheckHealthAsync();

    Response.StatusCode = report.Status == HealthStatus.Unhealthy ? 503 : 200;
    return Content(report.Status.ToString(), "text/plain");
}

Koppla in den i din övervakning så blir en utgående prenumeration ett larm istället för ett supportärende. Kontrollrapporten visar Unhealthy när licensen avvisas eller IsExpired är sann; för en betald licens betyder det att prenumerationsdatumet har passerat och ett paket som släpps efter det kommer att avvisas — den aktuella builden renderas fortfarande korrekt. Se DoconutHost för statusvärdena.

Versionsuppgraderingar

En licens täcker ett versionsfönster. Att uppdatera NuGet-paketet till en build nyare än det fönstret gör licensen ogiltig för denna build: IsVersionValid blir false och öppning blockeras med en LicenseException (orsaken finns i License.RejectionMessage) — avsiktligt fail-fast, så att en föråldrad eller olicensierad build fångas vid distribution snarare än att tyst vattenmärka produktionsutdata. Förnya prenumerationen, ersätt .lic i wwwroot, och återvinn applikationspoolen så att DoconutHost.Initialize laddar den nya licensen.

Var den här sidan hjälpsam?