Lifecyclestatussen beheren in Vault met C#

Lifecyclestatussen bepalen in welke fase een bestand zit: van concept tot goedgekeurd tot vrijgegeven. Ze zijn de basis van gecontroleerde documentbeheersprocessen (DMS/PLM). Via C# kun je statussen uitlezen, overgangen uitvoeren en zelfs batchgewijs bestanden door een workflow sturen.

Hoe lifecycle-management werkt in Vault

Elk bestand heeft een Lifecycle Definition (bv. "Engineering Change") met daarin States (bv. "Work in Progress", "Released", "Obsolete") en Transitions tussen die staten. Welke overgang jij kunt uitvoeren, hangt af van je Vault-rol en de opgegeven overgangsrechten.

Lifecycledefinities ophalen

using Autodesk.Connectivity.WebServices;

public void ToonLifecycleDefs(WebServiceManager wsm)
{
    var lcDefs = wsm.LifeCycleService.GetAllLifeCycleDefinitions();

    foreach (var def in lcDefs)
    {
        Console.WriteLine($"Definitie: {def.DispName} (ID={def.Id})");
        foreach (var state in def.StateArray)
            Console.WriteLine($"  Status: {state.DispName} (ID={state.Id})");
    }
}

Huidige status van bestanden ophalen

public void ToonBestandsStatussen(WebServiceManager wsm, long[] bestandIds)
{
    // GetFilesByIds geeft File-objecten terug met lifecycle-info
    var bestanden = wsm.DocumentService.GetFilesByIds(bestandIds);

    foreach (var b in bestanden)
    {
        var statusNaam = b.FileLfCyc?.LfCycStateName ?? "Geen lifecycle";
        var defNaam    = b.FileLfCyc?.LfCycDefName   ?? "n.v.t.";
        Console.WriteLine($"{b.Name,-40} Status: {statusNaam,-20} Definitie: {defNaam}");
    }
}

Toegestane overgangen ophalen voor een bestand

public void ToonToegestaneOvergangen(WebServiceManager wsm, File bestand)
{
    if (bestand.FileLfCyc == null)
    {
        Console.WriteLine("Geen lifecycle gekoppeld.");
        return;
    }

    // Haal de lifecycle-definitie op
    var def = wsm.LifeCycleService.GetAllLifeCycleDefinitions()
        .FirstOrDefault(d => d.Id == bestand.FileLfCyc.LfCycDefId);

    if (def == null) return;

    // Huidige status vinden
    var huidigeStatus = def.StateArray
        .FirstOrDefault(s => s.Id == bestand.FileLfCyc.LfCycStateId);

    Console.WriteLine($"Huidige status: {huidigeStatus?.DispName}");
    Console.WriteLine("Mogelijke overgangen:");

    foreach (var trans in def.TransArray)
    {
        if (trans.FromId == huidigeStatus?.Id)
        {
            var naarStatus = def.StateArray.First(s => s.Id == trans.ToId);
            Console.WriteLine($"  → {naarStatus.DispName} (transitie-ID: {trans.Id})");
        }
    }
}

Status wijzigen (overgang uitvoeren)

public void WijzigStatus(
    WebServiceManager wsm,
    File[] bestanden,
    long nieuweStatusId,
    string commentaar)
{
    // UpdateFileLifeCycleStates accepteert arrays van master-ID's en status-ID's
    var masterIds  = bestanden.Select(b => b.MasterId).ToArray();
    var statusIds  = bestanden.Select(_ => nieuweStatusId).ToArray();
    var commentaren = bestanden.Select(_ => commentaar).ToArray();

    wsm.LifeCycleService.UpdateFileLifeCycleStates(
        masterIds, statusIds, commentaar);

    Console.WriteLine($"{bestanden.Length} bestand(en) naar nieuwe status verplaatst.");
}

Volledig voorbeeld: zoek en promoveer alle "Work in Progress" bestanden

public void PromoveerNaarReview(
    VDF.Vault.Currency.Connections.Connection conn,
    string lcDefNaam,
    string vanStatusNaam,
    string naarStatusNaam,
    string commentaar)
{
    var wsm = conn.WebServiceManager;

    // 1. Lifecycle-definitie opzoeken
    var lcDef = wsm.LifeCycleService.GetAllLifeCycleDefinitions()
        .FirstOrDefault(d => d.DispName == lcDefNaam)
        ?? throw new Exception($"Lifecycle '{lcDefNaam}' niet gevonden.");

    var vanStatus  = lcDef.StateArray.First(s => s.DispName == vanStatusNaam);
    var naarStatus = lcDef.StateArray.First(s => s.DispName == naarStatusNaam);

    // 2. Zoek bestanden met de huidige status
    long lcStatPropId = wsm.PropertyService
        .GetPropertyDefinitionsByDomainAndEntityClassId("FILE", "FILE")
        .First(p => p.DispName == "State").Id;

    var cond = new SrchCond
    {
        PropDefId = lcStatPropId,
        PropTyp   = PropertySearchType.SingleProperty,
        SrchOper  = 1,
        SrchTxt   = vanStatusNaam,
        SrchRule  = SearchRuleType.Must
    };

    string bm = string.Empty; SrchStatus st;
    var gevonden = wsm.DocumentService
        .FindFilesBySearchConditions(new[] { cond }, null, null, true, true, ref bm, out st);

    if (gevonden == null || gevonden.Length == 0)
    {
        Console.WriteLine("Geen bestanden gevonden.");
        return;
    }

    Console.WriteLine($"{gevonden.Length} bestand(en) gevonden. Overgang uitvoeren...");

    // 3. Overgang uitvoeren
    var masterIds = gevonden.Select(f => f.MasterId).ToArray();
    var statusIds = gevonden.Select(_ => naarStatus.Id).ToArray();
    wsm.LifeCycleService.UpdateFileLifeCycleStates(masterIds, statusIds, commentaar);

    Console.WriteLine("Klaar.");
}

Lifecycle koppelen aan een bestand dat er nog geen heeft

public void KoppelLifecycle(WebServiceManager wsm, File bestand,
    long lcDefId, long initStatusId)
{
    wsm.LifeCycleService.UpdateFileLifeCycleDefinitions(
        new[] { bestand.MasterId },
        new[] { lcDefId },
        new[] { initStatusId });

    Console.WriteLine($"Lifecycle gekoppeld aan {bestand.Name}.");
}

Statusoverzicht exporteren naar CSV

public void ExporteerStatusOverzicht(WebServiceManager wsm, long[] ids, string csvPad)
{
    var bestanden = wsm.DocumentService.GetFilesByIds(ids);
    var regels    = new List { "Naam,Status,Lifecycle Definitie" };

    foreach (var b in bestanden)
    {
        string status = b.FileLfCyc?.LfCycStateName ?? "";
        string def    = b.FileLfCyc?.LfCycDefName   ?? "";
        regels.Add($""{b.Name}","{status}","{def}"");
    }

    File.WriteAllLines(csvPad, regels, System.Text.Encoding.UTF8);
    Console.WriteLine($"Statusoverzicht opgeslagen: {csvPad}");
}

Veelgemaakte fouten

Overgang niet toegestaan voor jouw rol — Vault valideert rollen bij elke overgang. Zorg dat de serviceaccount die de automatisering uitvoert, de juiste lifecycle-rechten heeft.

Fout op één bestand stopt de batch niet — UpdateFileLifeCycleStates probeert alle bestanden te verwerken. Bekijk de teruggestuurde status per item voor foutrapportage.

Transitie-ID vs Status-ID — sommige API-versies werken met transitie-ID's, anderen met status-ID's. Gebruik def.StateArray voor status-ID's en def.TransArray voor transitie-ID's. Controleer de versie van je Vault SDK.

LfCyc is null — niet elk bestand heeft een lifecycle gekoppeld. Controleer altijd op null voor je de lifecycle-properties gebruikt.

Samenvatting

Lifecycle-automatisering in Vault stelt je in staat om documentworkflows volledig te beheren vanuit C#: zoek bestanden op status, haal toegestane overgangen op, voer ze in bulk uit en rapporteer het resultaat. De sleuteldienst is LifeCycleService, gecombineerd met DocumentService voor het opzoeken van bestanden.

Lifecycle states determine which phase a file is in: from draft to approved to released. They are the foundation of controlled document management processes (DMS/PLM). Via C# you can read states, execute transitions and even drive files through a workflow in batch.

How Lifecycle Management Works in Vault

Each file has a Lifecycle Definition (e.g. "Engineering Change") containing States (e.g. "Work in Progress", "Released", "Obsolete") and Transitions between those states. Which transition you can execute depends on your Vault role and the configured transition permissions.

Fetching Lifecycle Definitions

var lcDefs = wsm.LifeCycleService.GetAllLifeCycleDefinitions();
foreach (var def in lcDefs)
{
    Console.WriteLine($"Definition: {def.DispName}");
    foreach (var state in def.StateArray)
        Console.WriteLine($"  State: {state.DispName} (ID={state.Id})");
}

Getting the Current State of Files

var files = wsm.DocumentService.GetFilesByIds(fileIds);
foreach (var f in files)
    Console.WriteLine($"{f.Name,-40} State: {f.FileLfCyc?.LfCycStateName ?? "No lifecycle"}");

Executing a State Transition

var masterIds = files.Select(f => f.MasterId).ToArray();
var stateIds  = files.Select(_ => targetStateId).ToArray();
wsm.LifeCycleService.UpdateFileLifeCycleStates(masterIds, stateIds, "Automated promotion");

Full Example: Find and Promote All "Work in Progress" Files

// 1. Find lifecycle definition
var lcDef     = wsm.LifeCycleService.GetAllLifeCycleDefinitions().First(d => d.DispName == lcDefName);
var fromState = lcDef.StateArray.First(s => s.DispName == "Work in Progress");
var toState   = lcDef.StateArray.First(s => s.DispName == "Released");

// 2. Search for files in that state
var cond = new SrchCond { PropDefId = statePropId, PropTyp = PropertySearchType.SingleProperty,
    SrchOper = 1, SrchTxt = "Work in Progress", SrchRule = SearchRuleType.Must };
string bm = string.Empty; SrchStatus st;
var found = wsm.DocumentService.FindFilesBySearchConditions(new[] { cond }, null, null, true, true, ref bm, out st);

// 3. Execute transition
if (found?.Length > 0)
    wsm.LifeCycleService.UpdateFileLifeCycleStates(
        found.Select(f => f.MasterId).ToArray(),
        found.Select(_ => toState.Id).ToArray(),
        "Batch promotion");

Common Pitfalls

Transition not allowed for your role — Vault validates roles on every transition. Ensure the service account running the automation has the correct lifecycle permissions.

LfCyc is null — not every file has a lifecycle attached. Always null-check before accessing lifecycle properties.

Transition ID vs State ID — some API versions use transition IDs, others use state IDs. Use def.StateArray for state IDs and def.TransArray for transition IDs.

Summary

Lifecycle automation in Vault lets you fully manage document workflows from C#: search files by state, retrieve allowed transitions, execute them in bulk and report the result. The key service is LifeCycleService, combined with DocumentService for file lookups.