Inflow.aiDocs

Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.

Preserved from source baseline d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.

First-Party Identity and Access Plugins

Practical guide and worked examples

Start with the business effect and its acting identity

These are trusted first-party declarations bound to native host handlers, not arbitrary Java plugins granted implicit identity authority. Manage Application Access reconciles a published persona profile inside its governed application scope. Administer Tenant Security performs its declared tenant operation as the step's admitted run-as identity. People expression reads and actions use those same native visibility/effect boundaries.

Before adding an identity step, identify the exact target profile/person/group, who the step runs as, which operation is read-only or mutating, and how the publisher's reviewed scope is retained at execution. A successful Verify cannot authorize a different resolved target later. A service identity does not inherit the current browser administrator's authority, and a workflow initiator must not acquire an administrator role through a convenient implicit conversion.

Design choice Use Avoid
Persona grant reconciliation Published profile and current admitted references Copying a group label into a raw grant payload.
Persona membership Eligible selected person and group ownership rules Treating an adopted group's membership as application-owned.
Tenant directory change Declared operation and actual run-as permission Assuming a plugin runner or manifest is a sandbox/permission bypass.
People read expression Visible directory value/reference Logging hidden profile or sign-in security fields.
People action expression Supported effect position and native idempotent command Executing a membership change while rendering a label, preview or condition.

Use the detailed operation/settings/input/output tables retained below as the reference after the worked path. A receiptKey in these plugin results belongs to this actual dispatcher contract; it must not be copied into an unrelated human-task completion API.

The examples below use synthetic teaching data. They are grounded in the cited source contracts; this documentation change did not execute these operations against a running Inflow deployment. Use normal authenticated sessions and the actual returned identifiers, revisions and versions from an authorized environment.

Example ROOT-PLUGID-01 — Reconcile a published persona profile to its application

Scenario and inputs. Nadia has an admitted application and a published Leave managers access profile. The profile identifies the actual persona group and its desired application/function/object grants. The author is adding a Manage Application Access step that sets persona access, not trying to grant all platform permissions or create a new group on every case execution.

Procedure. In the step settings select Set persona access (setPersonaAccess) and pick the actual published profile. Review the profile's desired grants and bind its supported published version input where the current node contract requires it. Keep irrelevant operation settings out of this step. Choose the admitted run-as identity, Verify, inspect the publication impact and publish through the current native process boundary. Inspect the resulting status, changed, changes, governed references and dispatcher receipt/audit references in an authorized run's safe output.

Expected result. The handler reconciles only the profile's governed desired scope. The changes describe added, retained, upgraded, downgraded and removed grants. A second execution with no difference answers UNCHANGED; missing platform permissions are not secretly granted. The native handler and current run-as authorization remain active at execution/replay, not only during design.

Failure and recovery. A retired/unpublished profile, changed target or missing native authority must be corrected through the profile/publication owner. Do not replace a refused profile with raw workspace Admin grants or assume the current browser session authorizes a background service account. Retain original receipt/evidence and inspect actual changes before attempting another business effect.

Sources. ApplicationAccessCapabilityHandler.java:60, ApplicationAccessCapability.java:1, ApplicationAccessCapabilityTest.java:1.

Example ROOT-PLUGID-02 — Remove persona grants while preserving membership ownership

Scenario and inputs. A published contractor persona must no longer contribute its application grants, but its managed group may still contain people. Nadia has the exact published profile and the scope needed to author the removal. Removing persona access is a grant reconciliation operation; it is not synonymous with deleting users, clearing group memberships or revoking unrelated group contributions.

Procedure. Inspect the current profile and contribution first. Configure Remove persona access (removePersonaAccess) for that same selected profile and supported version. Review the current targets and run-as identity, Verify and publish the specific change. In an admitted execution inspect the returned changes and warnings. Independently inspect membership through its authorized identity surface, and check the affected person's effective access to distinguish the removed source from other surviving sources.

Expected result. The operation reconciles the profile's desired grants to an empty state while retaining the group's membership. It can report PERSONA_GROUP_STILL_HAS_MEMBERS, which is an operational warning rather than proof that removal failed. Existing independent grants can still explain allowed access. Stored coordinates let removal account for grants whose target item disappeared after the profile was published.

Failure and recovery. Do not respond to the warning by deleting the directory group or deactivating every member. Those are separate tenant decisions. If the removal is refused, inspect profile ownership/version, native operation settings and current run-as authority. Preserve the original accepted or uncertain outcome rather than adding an unreviewed second removal path.

Sources. ApplicationAccessCapabilityHandler.java:61, ApplicationAccessCapability.java:1, first-party-identity-plugins.md:1. PersonaAccessReconciler.java:42.

Example ROOT-PLUGID-03 — Author a tenant group edit with an explicit run-as boundary

Scenario and inputs. The People Operations administrator needs to update the description of an ordinary editable group. Nadia is authoring an Administer Tenant Security step and has selected the exact group through the native picker. This is tenant-wide identity administration, so a workspace Editor role by itself does not authorize the operation or a service account acting across that tenant.

Procedure. Select Edit Group in the operation-specific settings, pick the intended group and supply only that operation's allowed profile/detail inputs. Choose the legitimate run-as identity and review its native tenant-administration permission and any stricter protected-group rules. Inspect Verify errors, publication impact and the pinned capability declaration before publishing. In an admitted run, compare the actual old/new group properties, safe audit reference and changed/unchanged outcome; do not post a private group roster as evidence.

Expected result. The trusted declaration maps to the host tenant-security handler. The handler goes through the native secured identity services with the acting identity's rights and retains their validation, audit and notification behavior. A group edit does not authorize changing arbitrary person roles or another operation's settings; the manifest is an operation contract, not a blanket administrative grant.

Failure and recovery. A protected or application-owned group and a missing run-as permission are meaningful refusals. Correct the intended target/authority with its legitimate owner, not by importing another plugin version or borrowing an administrator session. If the actual goal is self-service joining, use the separately declared open-membership operation and its own constraints.

Sources. TenantSecurityCapability.java:55, TenantSecurityCapabilityHandler.java:1, TenantSecurityCapabilityTest.java:1.

Example ROOT-PLUGID-04 — Keep people reads separate from membership-changing expressions

Scenario and inputs. The leave form should display the current employee's manager, and a separately admitted process step may change an eligible group's membership. These are different expression effects. A rendered text value, visibility rule or validation expression must not change directory state while the UI is calculating a display value.

Procedure. For a displayed manager use the actual people read functions, for example the expression fragment managerOf(currentUser()), and handle an unavailable/empty manager through the control's current value contract. Resolve a user reference through native pickers/bindings rather than casting an employee-number Text field into authority. If a legitimate workflow operation needs an action such as addToGroup, place it only in the supported Set variables or published screen action context, under the explicitly admitted acting identity and target group.

Expected result. Read functions use native profile visibility and return the supported visible value. People actions delegate to the tenant-security capability and retain its rights, audit and effect-position restrictions. A mutation is not valid merely because its expression parses; its position, publication and current actor/run-as must all be admitted.

Failure and recovery. Putting an action in a display/condition/rule context is refused with the relevant people/action-position code, such as PEOPLE_ACTION_NOT_ALLOWED_HERE or its native publication counterpart. Move the intended effect to the supported action surface and review it; never weaken the visibility policy, render a hidden profile field or turn a template calculation into a silent provisioning operation.

Sources. PeopleFunctions.java:40, PeopleFunctions.java:82, PeopleFunctionsEndToEndJdbcTest.java:1.

Inflow ships identity and access automation as Inflow-owned process-node plugins that run host-side: the packaged artifact only declares the node and its platform capability, and the Inflow application performs every operation itself through its secured domain services, under the trusted run context of the step.

This manual covers the Manage Application Access plugin and the Administer Tenant Security plugin.

Installation, trust and settings

Both plugins are system plugins. They ship inside the Inflow application and load automatically at every start, exactly like Inflow's bundled expression function packs: there is nothing to upload, approve or enable, and they never appear in the list of plugins administrators manage. A new Inflow version brings their new build with it.

Why they are trusted. A step runs only when the plugin came with the Inflow application itself, from Inflow.ai, and offers exactly the operations this Inflow version expects. The same plugin arriving any other way (an upload, a file copied onto the server) is refused, and a step whose plugin is refused does not run. A refused plugin never stops the server; platform administrators see it on the plugin administration page and in the health signal.

Settings. The capabilities are always on. A platform administrator can stop every identity and access step, or only one of the two plugins, and must allow tenant-wide identity steps (Administer Tenant Security) application by application before they run. Consultants never see these settings: Studio says a platform administrator must allow tenant-wide identity steps for the application.

The installation settings, the checks that the plugins loaded, and the plugin runner they need are described in the operations guide.

Manage Application Access (inflow.security.application-access)

Plugin id inflow-application-access
Node key inflow.security.application-access, palette category "Identity & Access", icon security-shield
Capability identity.application-access@1
Required permission APPLICATION_ACCESS_MANAGE (every operation; platform administrators, application creators and application administrators hold it by default)
Run as the person who started the case, the person who completes the task before it, or a service account (it acts on behalf of the person who started the case); every operation
Scope the application (workspace) the process belongs to; never another one

An application is a workspace. A persona is described by a published Application Access Profile: the group that represents it (managed by the application, or adopted), its role on the application, its business-function roles, its item roles, and the platform permissions it is expected to hold. The plugin never appends grants: it reconciles the persona group's live grants to the profile's latest published version, and removes any grant the profile does not describe.

This workspace-level profile reconciliation is distinct from Spec118's scoped App Shell Use application / Application user journey. Do not treat selecting this plugin's persona profile as proof of an App Shell runtime contribution or landing/Studio policy. See Application users, landing pages and Studio access for the scoped journey and its current rollout/acceptance status.

Trust and availability

A bundled system plugin: see Installation, trust and settings. Publishing a process with one of its steps needs the step's own permission (APPLICATION_ACCESS_MANAGE), not PROCESS_NODE_PLUGIN_USE: see Publishing and impact.

Operations

Every operation is chosen in the step's settings; the settings of the other operations are refused at publish. References are always picked, never typed: the Access Profile picker stores the profile's key, the person picker the user's id, the business-function picker the function's key. Each picked reference is checked at publish and again before the step runs (a retired or never-published profile, a deactivated person or a missing function refuses the step).

Operation Effect Settings Inputs Outputs
Configure persona-group binding (bindPersonaMember) mutating profile (required), person, membership: a member / not a member (required) user, profileVersion status, changed, governedReferences, receiptKey, auditReference, warnings
Set persona access (setPersonaAccess) mutating profile (required) profileVersion status, changed, governedReferences, changes, receiptKey, auditReference, warnings
Remove persona access (removePersonaAccess) mutating profile (required) profileVersion as above
Check effective access (checkEffectiveAccess) read person, business function user, itemType, item status, effectiveAccess, auditReference, warnings
Verify complete persona permissions (verifyPersonaPermissions) read profile (required), person user, profileVersion status, complete, governedReferences, missingPermissions, missingGrants, changes, auditReference, warnings
List eligible users and groups (listEligiblePrincipals) read profile, list: people / groups / people and groups (required), search cursor, pageSize, searchText ("Search text"; either this or the search setting, never both) status, items, nextCursor, auditReference, warnings

The person of a step is either picked in its settings or bound from the case through the "Person from the case" input (user, a user value: the person's id), never both. In the same way, List eligible users and groups takes its search text either from the Search setting or from "Search text" bound from the case, never both; Verify and publish refuse a step that sets both. A person picked for Configure persona-group binding must be able to hold persona membership: a locked account is refused at Verify and publish, as the step would refuse it. The reads accept any active person and report what they find.

Configure persona-group binding sets the desired membership of the person in the group the application manages for the persona. It refuses an adopted group (its membership belongs to the identity administrators), a person who is deactivated, locked or a service account, and the person the step runs as. Applying the same membership twice changes nothing and records nothing. A change is audited as IDENTITY_GROUP_MEMBER_ADDED / _REMOVED with via=application-access-profile, the profile key and version. When the step runs as a service account and the person bound is the one who started the case, the binding is allowed but named with the warning INITIATOR_BOUND, so an operator can see that the person who started the case gained or lost a persona through an identity that is not theirs.

Set persona access compares the profile's published version with what the persona group holds in this application and writes only the difference: grants are raised first (the application role, then business functions, then items), then lowered (items, then functions), then removed, and the application role is touched last. changes lists added, retained, upgraded, downgraded and removed grants (scope, objectType, scopeId, fromRole, toRole). A "no access" override (NONE) on a business function is a stored grant, not an absence. Running the step again with nothing to change answers UNCHANGED.

Remove persona access is the same reconciliation to an empty desired state. It leaves the group's membership as it is and warns (PERSONA_GROUP_STILL_HAS_MEMBERS) when people remain. A grant on an item that has been deleted since is removed by its stored coordinates, so a vanished screen or form never blocks the persona.

Check effective access answers the grant service's Check-access debugger for one person: the effective role and where it comes from (effectiveAccess: role, scope, scope id, principal, granted by, granted at); status is ACCESS or NO_ACCESS. Bind itemType with item.

Verify complete persona permissions reads whether the persona holds every grant the profile describes (missingGrants) and every platform permission it requires (missingPermissions; required permissions are verified, never granted), and, with a person, whether that person is an eligible member holding the persona's application role (warnings PERSON_INELIGIBLE, PERSON_NOT_A_MEMBER, PERSON_LACKS_WORKSPACE_ROLE). complete is true only when nothing is missing.

List eligible users and groups pages, by id, the active unlocked people (never service accounts; narrowed to the persona group's members when a profile is given) and the active, non-built-in, non-privileged groups not managed by another application, each with its ownership towards this application (MANAGED, ADOPTED, AVAILABLE) and ownedBy profile key. pageSize is 1–100 (default 50); bind nextCursor back into cursor for the next page. The listing and the member check of Remove read the tenant directory in memory (as the process-authoring directory does); a very large tenant directory is a recorded follow-up before the listing is offered to interactive callers.

Designing the step in Studio

The tile sits once under Identity & Access in the Flow palette and in the lifecycle toolbox. On the canvas, the step's inspector is guided throughout:

  • What this step does. Choose one of the six actions from the list; the arrow keys move and Enter chooses. Only that action's settings are shown. A switch that would drop settings lists them and asks first.

  • Settings. Pick the access profile, person or business function with a searchable picker. Only their stable references are stored, never shown. The profile picker lists retired and never-published profiles but will not let you choose them. The person picker lists only the people the step can act on.

  • What this step changes. The inspector explains each action's desired-state effect: Set replaces the persona's whole access, Remove leaves membership alone, and Bind is refused for an adopted group. It also says which profile version applies. Once a profile is chosen, it names the persona, its group and whether the application manages the group or adopted it; these are read-only, fixed by the profile.

  • See what it would change now shows what the step would do if it ran now, and the step works it out again when it runs. It needs the same rights as reading the application's profiles (application editor), and an item you cannot view yourself is shown as "An item you can't view".

    • Set and Remove list, by name, the access the step would add, raise, lower, remove and leave in place.
    • Verify changes nothing (See what it would find now). It lists the access the persona is missing, holds below or above the profile, or holds outside it, and the platform permissions it lacks.
    • Configure persona-group binding changes membership only. It says whether the chosen person would join or leave the persona's group, or the refusal the step would hit, such as an adopted group.

    When the version comes from the case, the preview uses the latest published version.

  • Runs as. Only the modes the action accepts are offered:

    • The person who started the case (the default);
    • The person who completes the task before it;
    • A service account (it acts on behalf of the person who started the case).

    Service accounts are picked, never typed. Also required to enter this step adds an extra platform permission, chosen by its description. Only accounts the platform can run as are listed, and only to authors allowed to bind service accounts. An account without the action's permission is shown but cannot be chosen. The server's findings about who the step runs as, such as "no person starts this process", appear here.

  • Data. Every port shows its name for people. The profile version is a choice:

    • the latest when the step runs;
    • only the current version, which refuses the step if the profile is published again (a stale pin is flagged, with a one-click repin);
    • a version from the case.

    For Check effective access, the item is picked from the application's items (application administrators) or filled from the case.

  • Saving and publishing. A draft can always be saved. A reference that is no longer valid (a retired profile, a person who can no longer be acted on) is flagged on the step, and Verify and Publish refuse it until it is chosen again.

Outputs that every operation shares

  • status ("Result"): one of APPLIED, UNCHANGED, ACCESS, NO_ACCESS, COMPLETE, INCOMPLETE or LISTED. The mutations answer APPLIED or UNCHANGED; Check effective access answers ACCESS or NO_ACCESS; Verify complete persona permissions answers COMPLETE or INCOMPLETE; List eligible users and groups answers LISTED.
  • governedReferences: profileKey, profileVersion, contentDigest, personaKey, personaLabel, groupId, groupOwnership.
  • warnings: [{code, message}], for example GROUP_PERMISSIONS_CHANGED_SINCE_PUBLICATION (the persona group's platform permissions drifted since the profile was published; it is still a permitted persona group) or OUT_OF_PROFILE_GRANTS_REMOVED.
  • receiptKey (mutations): the durable receipt of this activation, written by the platform; a redelivery of the same activation replays the same receipt without repeating the change.
  • auditReference: process-node-capability/identity.application-access@1/<instance>/<node>/<token>, the key to search the audit trail (PLATFORM_CAPABILITY_REQUESTED / _COMPLETED / _DENIED / _FAILED, with targets and before/after digests).

Outputs never carry a secret, an e-mail address or a person's permission list. Every declared output of the chosen operation is present (JSON null when it has nothing to say), so a mapped output always lands.

Version pinning

Without profileVersion, a step applies the profile's latest published version at run time. Bind profileVersion to pin one: a pin that is not the latest published version, behind it or ahead of it, refuses the step (ACCESS_PROFILE_STALE), so a process authored against one version never silently applies another. The pin is a run-time input, so it is checked when the step runs, not at publish.

Refusals

Every refusal has a stable code and leaves no change; refusals of a mutation roll the step back and the refusal itself is audited (ACCESS_PROFILE_REFUSED) in its own transaction.

Code Meaning
PROCESS_NODE_CAPABILITY_ACCESS_DENIED the principal lacks APPLICATION_ACCESS_MANAGE, or is not an administrator (mutations) / editor (reads) of this application
ACCESS_PROFILE_NOT_FOUND, _NOT_PUBLISHED, _RETIRED, _STALE the profile does not exist here, was never published, is retired, or the pinned version is not the latest (behind or ahead)
ACCESS_PROFILE_GROUP_PRIVILEGED after the writes the persona's group became privileged while the step was applying; the step rolled back
ACCESS_PROFILE_GROUP_UNKNOWN, _GROUP_INACTIVE, _GROUP_PRIVILEGED, _GROUP_NESTED, _GROUP_SHARED, _GROUP_NOT_MANAGED, _GROUP_OWNED_ELSEWHERE, _CROSS_WORKSPACE the persona's group binding no longer holds (re-checked live before every step)
APPLICATION_ACCESS_LAST_ADMIN the persona holds the application's last administrator access; give another person or group administration first
APPLICATION_ACCESS_CONFLICT the persona's access changed while the step was applying it; run it again
APPLICATION_ACCESS_USER_REQUIRED, _USER_CONFLICT, _USER_INVALID, _USER_INELIGIBLE, _SELF_BINDING no person, two people, a value that is not a person, a person who cannot be a member, or the step's own principal
APPLICATION_ACCESS_PROFILE_VERSION_INVALID, _PAGE_SIZE_INVALID, _ITEM_TYPE_REQUIRED, _CHOICE_REQUIRED an input that does not fit the operation

Administer Tenant Security (inflow.security.tenant-administration)

Plugin id inflow-tenant-administration
Node key inflow.security.tenant-administration, palette category "Identity & Access", tile "Administer Tenant Security"
Capability identity.tenant-administration@1 (fifteen operations)
Required permission TENANT_SECURITY_ADMINISTER for every operation that administers someone else; PROCESS_INSTANCE_START for Join Group and Leave Group
Run as the person who started the case, the person who completes the task before it, or a service account (it acts on behalf of the person who started the case); Join Group and Leave Group only the first two
Scope the whole tenant: people and groups, from inside one application's process

No approvals. A step runs with the rights of the person or account it runs as. If the process was designed to create an administrator and it runs as someone who holds unrestricted administration, it does so at once. The publish checks still apply: the publisher must hold the operation's permission, and a case started with a limited key, or with no recorded start, never runs the step.

The step acts across the tenant, so a platform administrator must allow tenant-wide identity steps for the application before any of its operations run. Until then every operation is refused (PROCESS_NODE_CAPABILITY_TENANT_SCOPE_DISABLED). How to allow them is in the operations guide.

Trust and availability

A bundled system plugin, like Manage Application Access: see Installation, trust and settings.

Who may do what

The step's run-as identity must hold the rights the platform's own administration screens require:

  • changing a person needs identity administration; changing a group needs group administration;
  • creating an administrator, making someone an administrator or a basic user again, changing an administrator's account or security, and granting or revoking any permission held directly need unrestricted administration;
  • a step never changes the account it runs as, and a step that runs as a service account never gives the person who started the case more than end-user work;
  • platform groups, groups that hold unrestricted or administrative permissions, an application's persona groups and anything a provisioning provider owns through SCIM are never changed by these operations; they are changed on the platform's own security screens.

Operations

Operation What it does Settings Inputs from the case
Create User Creates a person as a Basic user or an Administrator. An existing username is refused; no password is set. User type (Basic user / Administrator), Initial groups, E-mail to the person username (required), email, displayName, firstName, lastName, locale, timezone
Update User Profile Changes the profile values you bind; anything not bound stays as it is (a blank value changes nothing). Person, E-mail to the person "Person from the case" (user), or the Person setting; displayName, firstName, middleName, lastName, preferredName, email, phoneNumber, mobileNumber, jobTitle, jobGrade, employeeNumber, costCenter, organizationUnit, locale, timezone
Rename User Changes the username; one another person has is refused. Person, E-mail to the person user, username (the new one)
Deactivate User Stops the person signing in. The last active administrator is never deactivated. Person, E-mail to the person user
Reactivate User Lets a deactivated person sign in again. Person, E-mail to the person user
Change User Type Makes the person a Basic user or an Administrator. The last active administrator stays one. Person, User type, E-mail to the person user
Modify User Security One change per step: lock, unlock, require a new password at next sign-in, reset multi-factor sign-in, set who sees the profile (Everyone / Administrators only), or grant or revoke permissions held directly (chosen with the permission picker). Person, Change, Profile visible to (only for that change), Permissions (only for grant and revoke), E-mail to the person user
Create Group Creates an ordinary group. Its key comes from groupKey, or from its name. Name and Description are each set in the step or bound from the case, never both. Name, Description, Parent group, People may join or leave this group themselves groupKey, groupName ("Group name"), groupDescription ("Group description")
Edit Group Changes name, description, whether it is active and whether people may join or leave it themselves. Name and Description are each set in the step or bound from the case, never both. "Active" and "People may join or leave" each offer Leave as it is / Yes / No; an empty setting stays as it is. A group a published Access Profile uses is not deactivated. Group, Name, Description, Active, People may join or leave this group themselves groupName ("Group name"), groupDescription ("Group description")
Delete Group Deletes an ordinary group with no members and no groups under it. A group a published Access Profile uses is not deleted. Group —
Set Group Attributes Sets named values on an ordinary group; an empty value removes the attribute; the group's other values stay. Platform groups' attributes cannot be changed. See Group attribute rules. Group, Attributes (name and value rows) attributeValues ("Attribute values": a record of names to values from the case; it adds to the typed rows, and a value from the case overrides the matching row)
Add Group Members Adds people and groups; a group added is placed under this one. Group, People, Groups, E-mail to the person user (one more person)
Remove Group Members Removes people and groups. Group, People, Groups, E-mail to the person user
Join Group The person the step runs as joins a group that lets people join or leave it themselves. Group, E-mail to the person —
Leave Group The person the step runs as leaves such a group. A group that is not open is refused; a privileged group always is. Group, E-mail to the person —

The input user is labelled "Person from the case" in the step, as in Manage Application Access.

Group attribute rules

The same rules apply in a Set Group Attributes step and on the admin Groups screen:

  • a name starts with a letter, followed by letters, digits, _, . or -, and is at most 80 characters;
  • a name Inflow keeps for itself (such as role, tenant or createdBy) is never allowed;
  • a group holds at most 50 attributes;
  • a value is text only, at most 2,000 characters;
  • platform groups' attributes cannot be changed.

"Attribute values" bound from the case adds to the rows typed in the step; for a name in both, the value from the case wins; an empty value removes the attribute.

Open groups. "People may join or leave this group themselves" is off for every group until an administrator turns it on (Create Group or Edit Group, or the group's Edit form under Access control > Groups, where its attributes are edited too). Platform groups and groups holding unrestricted administration are never opened.

Profile visibility. "Administrators only" leaves the person out of people lists and pickers for anyone who does not administer identities (the people directory of the process designer, the rule principals picker, the workspace sharing picker and the workspace members list). Identity administrators still see everyone, and a person always sees themselves. The people functions show such a person to others by name only (and whether they are active); a membership read (membersOf, usersIn, inGroup) still returns them as a reference (id and name), never another profile value. Nothing else about the person changes. Administrators also set it when creating or editing a user (Access step) and from the user's menu.

Permissions held directly. Granted permissions are held by the person themselves, outside any group. Unrestricted administration is never granted this way: use Change User Type.

What Verify asks for, and who may publish which operation

  • A person given once. An operation that acts on one person takes it either picked in "Person" or bound from the case ("Person from the case"), never both: the step's Data section warns, and Verify and publish refuse the step.
  • A group name and description given once. Create Group and Edit Group take Name either set in the step or bound from the case ("Group name"), and Description either set in the step or bound from the case ("Group description"), never both. Verify and publish refuse a step that gives both.
  • Required values. Create User and Rename User need "Username" bound from the case; Update User Profile needs at least one profile value bound; Create Group needs "Name" set or "Group name" bound; Set Group Attributes needs rows or "Attribute values" bound. Verify and publish name what is missing by its label.
  • Attribute rows that follow the rules. Verify and publish refuse a Set Group Attributes row that breaks the group attribute rules.
  • Making someone an administrator. A Create User or Change User Type step whose User type is Administrator can only be published by a full administrator. Anyone else is refused with "Making someone an administrator needs a process or screen published by a full administrator. Ask one to publish it."
  • Only the operations you may publish. The step lists only the operations whose permission you hold (Join and Leave need only permission to take part in processes; the others need tenant security administration). A step already set to an operation you may not publish says so, and publishing it is refused. The tile appears only when at least one operation is yours to publish.
  • Resetting sign-in factors of a person who has none changes nothing (UNCHANGED), spends no recovery code, and is still recorded in the audit trail.

The e-mail to the person

Every operation that changes a person e-mails that person; Create Group, Edit Group, Delete Group and Set Group Attributes send nothing, and members of a group that is added or removed as a whole are not e-mailed.

  • Standard e-mail. Each operation has one: a greeting, what changed, when and by whom, and who to contact. Create User says that sign-in details follow separately. No e-mail ever carries a password, a sign-in link or any other secret.
  • Editing it. In the step's properties, "E-mail to the person" shows "Uses the standard e-mail" or "Custom e-mail". "Edit or preview e-mail" opens the e-mail editor with the subject and message. "Insert field" adds one of the listed fields (person's name, username, what changed, when, who, and the group name where it applies). "Insert expression" opens the expression builder, as in the Send e-mail step, to add a value from the case: a case variable, a calculation, or a people function that reads. The expression can use the listed fields by name, person (the person the step changes) and, for a group operation, group (the group it acts on); for example "Dear " + coalesce(userInfo(person, "firstName"), personName). A value can be missing (many accounts have no first name): give it a fallback with coalesce(...), or the e-mail is not sent for that person. People reads run with the rights of the identity the step runs as, and the usual profile-visibility rule applies. The preview fills fields with sample values and shows each expression as a placeholder naming it. "Restore the standard e-mail" removes your edit.
  • Checked before publishing. Verify and publish refuse an e-mail without a subject or message, and an expression that is not valid, calls a function Inflow does not know, or changes something (a people function that creates, changes or adds is never allowed in an e-mail); the message names the expression. The people reads are allowed, as everywhere (they read the directory at the moment the e-mail is written); other functions whose result changes between evaluations, such as the current time, are not, as in the Send e-mail step.
  • Expressions when the step runs. They are worked out from the case at the moment the step runs, before its change is saved, with the same rules as the Send e-mail step; every value is escaped, so it shows as text. Case values the process marks sensitive are never available to them. When an expression cannot be worked out for this case (a value the case does not have), the person is not e-mailed, the change still stands, and the step's "E-mail status" and warning (EMAIL_EXPRESSION_FAILED) say why and where (for example "message block 1, part 2", and "use coalesce() to give it a fallback" for a missing value); the warning is recorded in the step's audit. A function that is no longer available when the step runs has the same effect: only the e-mail is skipped. Expressions can read the process context too, such as process.initiator.displayName.
  • Where it is sent. To the person's address when the step runs; a notice that the address itself changed goes to the address the person had before.
  • Signing in. Create User's e-mail never contains a password, a link that sets one, or any other secret. When the installation uses Inflow's own sign-in, the person receives the product's separate set-password invitation after the account is saved (as when an administrator creates an account on the security screens); otherwise their administrator sends sign-in details.
  • When it is sent. After the change is saved. Nothing is sent for a change that was undone, and a step that is delivered again never sends twice. When the installation has no e-mail service switched on, or the person has no e-mail address, nothing is sent: the step still succeeds, emailStatus is NOT_SENT and a warning says why. A change of e-mail address is announced to the address the person had before.

Outputs that every operation shares

status (CREATED, UPDATED, APPLIED, DELETED or UNCHANGED), changed, user or group, governedReferences, changes (before and after, in names), receiptKey, auditReference, warnings, and, for the operations that e-mail, emailStatus (QUEUED, PARTLY_QUEUED, NOT_SENT, or empty when nothing changed). QUEUED means the message was handed to the notification service with the change, not that it was delivered: delivery happens after the case moves on, is retried by the notification service, and its outcome (sent, or failed and why) is recorded in the notification history and audit trail, not in the case.

Refusals

Code What to do
PROCESS_NODE_CAPABILITY_ACCESS_DENIED The person or account the step runs as lacks the right (for example unrestricted administration to create an administrator).
TENANT_SECURITY_USER_EXISTS, _USERNAME_TAKEN, _EMAIL_TAKEN Use another username or address.
TENANT_SECURITY_USERNAME_REQUIRED, _PROFILE_VALUES_REQUIRED, _MEMBERS_REQUIRED, _ATTRIBUTES_REQUIRED, _GROUP_NAME_REQUIRED Bind or set the missing value.
TENANT_SECURITY_SELF_TARGET Run the step as someone other than the person it changes.
TENANT_SECURITY_LAST_ADMINISTRATOR, _STILL_ADMINISTRATOR Make another person an administrator first; remove the person from the other administrative group on the security screens.
TENANT_SECURITY_PRIVILEGED_GROUP, _PREDEFINED_GROUP, _GROUP_MANAGED_BY_APPLICATION, _EXTERNALLY_OWNED The group or person is administered elsewhere (security screens, the application, or its SCIM provider).
TENANT_SECURITY_GROUP_CLOSED The group does not let people join or leave it themselves.
TENANT_SECURITY_GROUP_NOT_EMPTY Remove the group's members and sub-groups first.
TENANT_SECURITY_PERMISSION_UNRESTRICTED Use Change User Type to make someone an administrator.
TENANT_SECURITY_MFA_UNAVAILABLE This installation has no multi-factor sign-in.

A case whose first step is one of these and that is started directly answers the refusal to the caller (403, 409 or 422), never a server error.

People functions (inflow-functions-people)

Expression functions over people and groups, shipped inside Inflow (a bundled plugin that only declares the functions; Inflow performs them). They appear in the function catalogue under People.

Reading people and groups (usable in every expression)

Function Answers
currentUser() The person the expression runs as: the signed-in person, or the person a Set variables step runs as.
userInfo(user, field) One profile value: username, displayName, firstName, middleName, lastName, preferredName, email, phoneNumber, mobileNumber, jobTitle, jobGrade, employeeNumber, costCenter, organizationUnit, locale or timezone.
userKind(user) "Administrator" or "Basic user".
userIsActive(user) Whether the person may sign in.
managerOf(user) The person's manager.
userGroups(user, includeInherited) The person's groups; inherited groups too unless includeInherited is false.
groupInfo(group, field) name, key, description, parent, active or openMembership.
groupAttributeValue(group, name) One named value of the group (Set Group Attributes).
membersOf(group, includeSubgroups) The people in the group (and its sub-groups when true).
inGroup(user, groups, requireAll) Whether the person is in any (or all) of the groups, directly or through a parent group.
usersIn(usersAndGroups) One argument: a person, a group, or a list of people and groups. Answers the people, without repeats; a group contributes its members, including the members of its sub-groups. For example usersIn([currentUser(), "sales"]).

A person or group can be passed as a value (from currentUser(), a picker, membersOf, process.initiator), or as text: a person's id or username, a group's id or key. When a person's profile is visible to "Administrators only", someone who does not administer identities sees only the person's name and whether they are active; every other answer about them is empty. A person always sees their own profile. Group membership can be read by anyone signed in. Sign-in security (locks, last sign-in, sign-in factors, passwords) is never available.

Changing people and groups (actions)

Function Tenant Security operation
createUser(username, profile, kind) Create User (kind "Basic user" or "Administrator"; profile names and values in turn, such as ["email", "sam@example.com", "displayName", "Sam Lee"], or a record); answers the new person.
updateUser(user, profile) Update User Profile.
renameUser(user, newUsername) Rename User.
deactivateUser(user), reactivateUser(user) Deactivate User, Reactivate User.
setUserKind(user, kind) Change User Type.
createGroup(name, details) Create Group (details, names and values in turn such as ["openMembership", true]: description, openMembership, parent, key); answers the new group.
updateGroup(group, details) Edit Group (name, description, openMembership, active).
deleteGroup(group) Delete Group.
setGroupAttribute(group, name, value) Set Group Attributes.
addToGroup(group, members), removeFromGroup(group, members) Add / Remove Group Members (people and groups).

Each action answers true when it changed something (false when there was nothing to change), and does exactly what the Tenant Security operation does: the same rights, rules, refusals, audit and e-mail to the person changed. Actions run in two places only:

  • A Set variables step, as the identity the step runs as. Assign the result to a variable, for example joined = addToGroup("sales", process.initiator).
  • A screen button or submit action of a published screen, as the person pressing it, for example a "When pressed" step whose value is =addToGroup("book-club", currentUser()). Pressing twice quickly changes once; a retried request never changes twice. If an action is refused, nothing the press did is kept and no e-mail is sent. When the person pressing may not perform the action, the screen says "You are not allowed to do this." (Screens with the current expression syntax only.)

Anywhere else (a displayed value, a visibility or validation rule, a gateway, a binding, a rule, a preview) an action is refused with PEOPLE_ACTION_NOT_ALLOWED_HERE, and Verify and publish name it: PROCESS_BINDING_ACTION_NOT_ALLOWED, RULE_ACTION_NOT_ALLOWED or SCREEN_ACTION_FUNCTION_NOT_ALLOWED. Within one step or press, each call happens once: a step that is delivered again repeats nothing.

Publishing and impact

These rules apply to both plugins.

Who may publish an identity and access step

The publisher must hold the permission the step's operation needs when it runs: APPLICATION_ACCESS_MANAGE for Manage Application Access and TENANT_SECURITY_ADMINISTER for Administer Tenant Security. It is checked against the same resource the step is checked against when it runs, so a publisher can never author a step they could not run themselves. A publish with a scoped API key is limited by that key, as every permission check is. PROCESS_NODE_PLUGIN_USE, the ceiling for third-party plugin nodes, does not apply to these steps (and third-party plugins still need it). A step that runs as a service account also needs PROCESS_RUNAS_SERVICE_ACCOUNT_BIND for that account, as before.

When the publisher does not hold that permission, publishing is refused with a message that names the step and its operation and says that the publisher does not hold the permission the operation needs. A Create User or Change User Type step that makes someone an Administrator needs more: only a full administrator can publish it (see What Verify asks for).

What publishing checks, and what you see first

Before you publish, Studio's publish dialog (section "Governed identity steps"; a lifecycle's verify view lists the same verdicts as findings, and MCP's assess_lifecycle names blocked steps) shows every identity and access step that needs your attention, with the operation it performs, who it runs as, what it changes, and one of three verdicts:

  • Ready: nothing to do.
  • Warning: publishing goes ahead, but read the note. A tenant-wide operation runs only where a platform administrator has allowed tenant-wide identity steps for this application (Studio asks you to request exactly that; platform administrators: see the operations guide); a step set to run as the person who completes the task before it needs a user task before it on every path; a profile version taken from the case is checked only when the step runs; cases started by a record change have no person for a step that runs as the person who started the case.
  • Blocked: publishing is refused until you fix it. A step that runs as the person who started the case or as a service account in a process only record changes start (PROCESS_CAPABILITY_STEP_NEEDS_PERSON_START), or a pinned Access Profile version that is not the latest published one (PROCESS_CAPABILITY_PROFILE_PIN_STALE: pin the latest version, or remove the pin so the step always applies the latest).

Nothing is changed for you: the dialog explains, and you decide.

Every run is held to what was published

Publishing records, for each identity and access step, exactly what it was approved against: the plugin and its build, the capability version, the operation with its permission, what it changes and where, who it runs as, and the references you picked. Every time the step runs it must still match that record (PROCESS_NODE_CAPABILITY_BINDING_UNVERIFIED otherwise; publish the process again), the person or account it runs as must still hold the operation's permission, and the case must have been started by a person without a limited API key or MCP token (TRUSTED_CONTEXT_SCOPED_START; cases that existed before this check are TRUSTED_CONTEXT_START_UNRECORDED: start a new case).

When a new build of a plugin arrives

Before a new build or a re-approval of either plugin is registered, Inflow checks it against every process already published with one of its steps. A build that still offers each published step's operation unchanged (a rebuild, or a later version that adds operations) is registered and the published processes keep running. A build that would change or drop an operation a published process uses is refused: the version registered before keeps serving, nothing is republished for you, and platform administrators can read which processes (application, process version, step), why, and how many running cases are affected, in Studio's plugin administration page ("Impact on published processes"); the refusal is also recorded in the audit trail (the same report for operators is described in the operations guide). Every published version counts, including older versions with nothing running now: a lifecycle, a call activity, a "start process" step or an API start that names a version can still start it. Such a version is marked "older version, nothing running now", but it still holds the build back. Retiring a process does not help, because retired versions can still be started by those pinned starts. To let the build in, do one of these:

  • publish the affected processes again against it, and update whatever pins their older versions;
  • delete the processes that are no longer needed (deleting removes their published steps);
  • or keep the previous build.

The page names the application, the process, the operation and the plugin as you know them; it never shows internal keys. If a plugin has not been assessed yet (for example right after the server started), the page says so and offers "Refresh", which reloads the report the server holds; the assessment itself runs when a build is registered or approved. A build whose assessment cannot be recorded in the audit trail is refused too (PROCESS_NODE_CAPABILITY_IMPACT_UNAUDITED); the previous version keeps serving.

Try “document generation”, “integrations” or “first form”.