Skip to content

About

No description, website, or topics provided.

Resources

Stars

2 stars

Watchers

0 watching

Forks

Latest commit

 

History

3,902 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

ExchangeAdminWeb

ASP.NET Core 10 Blazor Server application for Exchange Online administration, mailbox/calendar permissions, group management, MFA operations, conference room setup, named locations, and Active Directory tasks through a self-service web interface. Provides 22 modules (21 operational + 1 config-only) covering EXO, Graph API, and on-prem AD operations.

Features

Mailbox Permissions

  • Full Access - Grant/revoke full mailbox access with optional AutoMapping, on a cloud or an on-premises mailbox
  • Send As - Grant/revoke Send As. On a directory-synced mailbox, wherever it lives, the right is written and read back on both sides - Exchange Online and the mailbox's on-premises account - and counts as applied only when both are confirmed (see "Send As on a synced mailbox" below)
  • Single operations and bulk CSV upload support; every CSV row follows the same rules as a single change, on the side its mailbox lives on (see "CSV rows for on-premises mailboxes" below)
  • When user notifications are on, the grantee and the mailbox owner are emailed for each right that was applied; a bulk upload sends each person one email for the whole file, and none for a row Exchange reports as no change
  • Every write names a grantee bound before it, never the name as typed; an entry whose holder cannot be found is removed by its SID (see "The grantee a permission write names" below)
  • On-premises mailbox support for authorized power users (see below)

Calendar Permissions

  • Set calendar sharing permissions (Owner, Editor, Reviewer, Limited Details, etc.)
  • Remove calendar permissions
  • Automatic calendar folder detection (supports international/localized folder names)
  • A grant sets the user's existing entry, and adds one only when Exchange answers that the user holds none (read from the error's type, identifier or wording, not one sentence). Any other refusal is reported as the Set's, in Exchange's words, with nothing added; an Add that Exchange refuses is reported as the Add's
  • Single operations and bulk CSV upload support; every CSV row follows the same rules as a single change, on the side its mailbox lives on (see "CSV rows for on-premises mailboxes" below)
  • Every write names a grantee bound before it, never the name as typed; an entry whose holder cannot be found is removed by its SID (see "The grantee a permission write names" below)
  • On-premises mailbox support for authorized power users (see below)

Exchange Migration (/migration)

Check migration eligibility and create move batches between Exchange Online and on-premises Exchange.

  • Validates current mailbox location before eligibility decisions
  • Excluded AD Groups (Migration module config): a move to Exchange Online is refused for a direct member of a configured group. The user is found at the forest's global catalog by the typed address - as their UPN, mail or an smtp proxy address, one read - and read in their own domain for memberOf; each group is resolved in every domain. A name held by groups in several domains excludes a member of any of them, naming the group and the domains (a member of none passes, with a warning); enter the group's SID or objectGUID to name one. A check that cannot be completed is Undetermined, never Eligible; in a bulk file a failed read is read once and repeated for each row, which says so. The check runs in a warm directory session and logs its time (sweep-c item 14)
  • Verify on the module's Module Configuration pane (docs/history/DirectoryObjectVerify-Plan.md A5, slice V4) checks each comma entry of Excluded AD Groups exactly as the eligibility check resolves it - Get-ADGroup -Identity in each domain of the forest, the lookup both share: verified (one group), missing (no domain holds it - the check could not be completed for anyone while it is set), several objects (groups in several domains; the check excludes the members of each), or could not verify. Remove now takes that one comma entry out and keeps the others
  • Checks on-prem mailbox and archive size before cloud migrations. The CloudQuotaGB limit applies to the primary mailbox and the archive separately; their combined size is not a criterion
  • A move does not carry Send As, so the check warns who holds it. For a mailbox the check finds eligible it reads the Send As entries on the side the mailbox lives on today: on-premises for a move to Exchange Online (Get-Mailbox | Get-ADPermission, in the one on-premises session the mailbox's sizes are read in, under the module's on-premises credential - one session and one of the server's two slots per mailbox. The sizes are applied to the verdict inside that session, and the Send As read is made there only for a mailbox they leave eligible: one over the limit, or whose size could not be read, shows no Send As warning and does not wait on that read. A Send As read that fails does not lose the sizes), Exchange Online for a move back (Get-RecipientPermission -AccessRights SendAs). The holders are shown as a warning beside the verdict, single and bulk; the single check also records them (sendAsWarning) and mails them (a Send As row). That field and that row are there only for a holder by name, or a read that could not say whether there is one, so their presence signals a real holder; sendAsHeldByName on the record says it in a word (yes, no, not known). yes needs a holder by name listed without a doubt: when every one of them is listed as one a Deny may override (below), nobody is known to hold it and the word is not known. The warning never changes the verdict: a read that fails or cannot be made says the holders could not be read, why, and to check Send As by hand. Nothing is granted again by the move or by this module: use Mailbox Permissions afterwards
    • Who is listed. Everyone an allowing entry lets send as the mailbox today: the trustee of each entry written on the mailbox itself, and of each entry the mailbox inherits from a container above it - a group or service account granted Send As on the container that holds the mailboxes - marked (inherited) (the entry's own IsInherited; the rows do not say which container). A trustee with both kinds of Send As entry is listed once, unmarked. "No one holds Send As" is said only when no allowing entry applies
    • Send As without an entry that names it (on-premises). Full control of the mailbox's account, or every extended right on it, carries Send As. An entry that names no extended right and whose AccessRights hold the directory's extended-right access (ExtendedRight, which GenericAll includes) lists its trustee apart, in a second sentence: "Send As also comes with full control of its account, held by: ...", with (all extended rights) where it is not full control. A trustee who holds it both ways is listed in both sentences, each listing marked by its own entries: an inherited Send As entry stays (inherited) whatever its trustee holds through the account. When these are the only holders the check says "No one is granted Send As by name" and names them, without the word Warning, and records and mails them under names of their own (sendAsThroughTheAccount, a Send As through the account row): on most directories they are the administrators' and the system's own entries, which every account carries. Whether they are listed at all is one switch in the code (MigrationService.ListsHoldersThroughTheAccount). On, the page note says the check names, apart from the holders by name, "who holds full control or all extended rights of its account". Off, the note leaves that out and the check answers of holders by name only, and says so whatever it found: "Send As on this mailbox is granted by name ... to: ... Only holders granted it by name are listed.", or "No one is granted Send As by name on this mailbox ..." - never "No one holds Send As", which nobody looked for. Unverified against a live server: if on-premises Exchange reports such an entry in another shape, it is not recognised and its trustee is not listed. Exchange Online has no such route
    • The read never changes a verdict or stops a check. Every failure of it is "could not be read" for that mailbox, a cancellation-type error Exchange or remoting raises of its own (a request that timed out) included: no operator's cancel reaches this read, so such an error is the read's failure. A bulk file keeps every row
    • A list read in part is not the list. Exchange Online is asked for every entry (-ResultSize Unlimited): past its default the cmdlet cuts the list short with a warning and no error. If either side's read writes a warning all the same, what it read is listed and the check adds "The list may not be complete: ..." with the warning's own words, and never says "No one holds Send As" or "No one is granted Send As by name": of such a list it says no holder was read, and that the list may not be complete. Any warning counts: its words are the server's, and the check does not try to recognise them
    • A holder may be a group. Neither side's entries say what a trustee is, so a group is not marked as one: wherever a name is listed the warning says it may be a group, whose members hold Send As through it
    • A Deny, in the order Windows weighs entries. A Deny written on the mailbox, then an allow written on it, then an inherited Deny, then an inherited allow. So a trustee a Deny written on the mailbox itself names is not a holder, whatever allows they have: they cannot send and lose nothing at the move, and are not listed apart for that reason. An inherited Deny does not remove a trustee with an allow written on the mailbox - "deny on the container, allow the exception on the mailbox" - who is listed like any other holder. Against a trustee whose allows are all inherited too, which of the two wins depends on which container is nearer the mailbox, and the rows do not say: the trustee is listed, marked (inherited; an inherited Deny may override it), never dropped. An entry whose row carries no IsInherited value is taken for neither kind, so that no holder is dropped and no doubt is hidden: such a Deny removes nobody and its trustee is listed marked (a Deny whose inheritance was not reported may override it); such an allow does not clear the doubt an inherited Deny leaves and is listed marked (inheritance not reported; an inherited Deny may override it). Unverified against a live server whether either side ever leaves the value out. A Deny on a group is not applied to its members, whose membership the check does not read: a member with an allow of their own stays listed
    • The mailbox's own entry is never a holder, and no name written in the code decides it. It is told by its SID when the row carries one - TrusteeSidString in Exchange Online, the SecurityIdentifier of the row's User on-premises when the value arrives with its properties, or a trustee that is itself a SID - against the SID Windows reserves for an object's own account. A row that gives only a name is compared with the name this server's Windows gives that SID, translated once at run time. Where on-premises Exchange words it in another language than this server does, the entry is listed as a holder, never dropped. Every other trustee is a holder, Windows' own groups (Administrators, Authenticated Users, Everyone) included: a grant to one of them is a grant
  • A create that stops part-way is not a plain failure. A create sends New-MigrationBatch, then Start-MigrationBatch and Set-MigrationBatch -CompleteAfter when auto-start and auto-complete are ticked. When Exchange refuses a later write the batch already exists, so the result is Partial: it names the batch, says it exists and what it has not done (not started; auto-complete not set), and what to do - start it from Migration Status with Resume, complete it there once it has synced, or delete it; never create it again. The write after the one that failed is not sent. When a write was sent and its failure does not show that Exchange refused it, whether Exchange accepted it is not known. The result says which write that is and which of two things happened, with the error's own words: "Exchange's answer to the command was not received" (a timeout, a request that failed in transit) or "the command failed with an error that does not show whether it took effect" (any other error that names no refusal; see "What makes a result Undetermined"). For the create itself it says to look for the batch in Migration Status first, that the auto-start and auto-complete that were ticked were never sent, and - if the batch found is this one - to do only what was ticked: it never says to start a batch nobody asked to have started. It never says a batch found under the name is the one that was asked for, because the name does not make it so. It says how to tell: the batch is this one only if it was created at the time of this attempt, which the message gives to the minute in UTC, and holds the mailboxes of this attempt; one that was already there is not this one and must not be started or deleted on the message's say-so. The page shows both as a warning. The MigrationBatch record of a partial create is filed Failed with outcome Partial, an error beginning Partial: and stepsDone; an unknown one is filed Undetermined with stepsUnconfirmed. The administrators' mail action ends _PARTIAL or _UNCONFIRMED. The plain failure is a create that was sent and that Exchange answered with a refusal: the result is Exchange's own words, and it says what Exchange answered, not that no batch exists - the module can send a request again by itself, so a refusal such as "already exists" can follow a create its own first try made. A create stopped before anything was sent - a name a batch already goes by, a name read that found the session dead - is not that failure: it is recorded as a refusal before any write (the name check, below). The hover tips on the two options say the same in one line each
    • The batch's name is read before anything is sent. A create first asks Exchange, on its own connection, whether a batch already goes by the name (Get-MigrationBatch -Identity). The single create's name defaults to the address and the bulk create's to the date and direction, so a name already in use is an everyday case. A batch that is found refuses the create with nothing sent, saying what is known and not whose the batch is: "A migration batch named '...' was already there before this attempt (status ...), and nothing was sent to Exchange. If an earlier attempt of yours under this name could not be confirmed, that batch may be the one it made: check it in Migration Status by its creation time and its mailboxes. Otherwise choose another batch name." The refusal never rests on recognising Exchange's own, because the create is never sent. It is recorded, mailed and shown as the module does every refusal before a write: the MigrationBatch record is filed Failed with mutationAttempted false and refusedAt BatchNameCheck, the mail has an Options requested row and Applied: Nothing: nothing was sent to Exchange, single and bulk, and the banner is the refusal in red - never the record and mail of a create that Exchange was sent and refused. Taken is a returned batch that carries the name asked (its Identity or Name, ignoring case); batches returned of which none carries it - a wildcard, an identity Exchange resolved to something else - leave the name not checked. Exchange's "no such batch" lets the create go on, but only when it is about the name asked: the error names that name, or names nothing. A not-found that names something else says nothing of the name, which is then not checked. A create that went on after a "no such batch" and whose own outcome is then unknown says no batch of that name existed when it was checked. A read whose failure shows that its session failed or that its answer never came back - a timeout, a request dropped in transit, the module's own word that the session is not connected, an error the shared reading marks as the session's - stops the create too, because a create is not sent on such a session: "Exchange could not be reached to check the batch name, so nothing was sent: ... Try again.", recorded, mailed and shown as the taken name is (refusedAt BatchNameCheck). Only a read that came back with an error that is neither of these nor Exchange's "no such batch" lets the create go on: whatever that create comes to, a success included, says "Whether a batch named '...' already existed could not be checked before the create was sent: ...". The hover tip on Batch Name says a create is refused when Exchange shows that a batch already goes by the name
    • A create that throws before anything is sent - the pool cannot sign in, the protection check or the target-database lookup throws - is recorded and mailed too, as a batch or mailbox action's throw is: a MigrationBatch record filed Failed with "Nothing was written: the create failed before anything was sent to Exchange: ..." and mutationAttempted false, and a mail saying nothing was applied. The page shows the cause in its own words, as it did. A throw once a write may have been sent is not a failure anybody can vouch for: the page shows it as a warning, and the record and the mail are an undetermined create's - but it keeps what the create recorded before the throw. The writes Exchange had accepted stay done and only the rest is unconfirmed: with none accepted, "Whether migration batch ... was created, and how far the create got, could not be confirmed", with the same minute, mailbox count and name-check sentence as any other unknown create and what was asked for to check it against; with the batch accepted, "Migration batch ... was created with N mailbox(es), but how far the create got after that could not be confirmed ... The batch exists", batchCreated created and stepsDone Created. The mailboxes the protection check left out are recorded and mailed as on any create, and the count is of the mailboxes that were sent. When every write had been accepted the result is the success it was, saying that the call then failed
    • What was ticked and what became of it. The record's autoStart and autoComplete are what the operator ticked. On a partial or undetermined create all three say, beside them, what became of the batch and of each option - not requested; requested and applied; requested, NOT applied (refused, or never sent because a write before it failed); requested, NOT confirmed (its answer never came back). The result's Detail has Batch:, Auto-Start: and Auto-Complete: lines in those words; the record has batchCreated, autoStartOutcome and autoCompleteOutcome; the mail has an Options requested row and an Applied row in place of Options, and the bulk mail's count says what the mailboxes are in, and only what is known of it: a batch that exists and is not as requested (a later write was refused); a batch that exists, whether it is as requested not confirmed (a later write's answer was lost - it may be exactly as requested); or a batch whose creation is not confirmed. The failed write's further error lines are kept at the end of the Detail
  • Move-back batches pass all configured databases from OnPremTargetDatabases in the Migration module config to Exchange for distribution
  • Built-in move-back database defaults match the approved 2019 database list; no DAG lookup or space balancing is performed
  • Migration Status supports multi-select, with three bulk actions that have three different targets. One ticket covers the run and each batch is audited individually. A selection that mixes statuses is never refused: the eligible batches are acted on and every skipped batch is named with the status that disqualified it
    • Delete removes every selected batch whatever its status. Exchange decides what it will accept; a refusal comes back as that batch's own reported failure. The confirmation states the count and a per-status breakdown before the ticket is accepted, because this is the only action that takes in-flight batches
    • Remove Completed removes only the selected batches whose status is exactly Completed. CompletedWithErrors is deliberately excluded -- a batch that finished with errors is not a batch that finished, and sweeping it would destroy the evidence
    • Resume/Retry restarts the selected batches that are idle but restartable. Defined by exclusion rather than an allowlist: everything except the actively-working statuses and Completed, so a batch status this app has not seen before still gets a button and Exchange refuses it if invalid
  • Batch actions report what was QUEUED, not what is finished. Remove-MigrationBatch and Start-MigrationBatch return when Exchange accepts the request; the batch then sits at Removing or Starting until Exchange completes it, so the row stays visible for a while. Batches Exchange accepted are unticked automatically; ones it refused stay ticked so they can be retried
  • The ticket field for a single-batch or single-user action appears directly beneath that row, not at the top of the table
  • The per-user Report button is available on every user row, not only rows that already look broken
  • Approve on a mailbox in a batch of its own completes that batch, so it runs only when the batch is exactly Synced. A batch at SyncedWithErrors or CompletedWithErrors is refused saying the batch holds errors and to fix or remove them first (owner ruling 2026-09-25); nothing is changed
  • Migration Status results can be downloaded as CSV (BatchName,Status,Direction,Created,Started,Completed,Total,Synced,Finalized,Failed,TargetEndpoint)
  • Section access keys: MigrationCheck, MigrationCreate, MigrationManage

Message Analysis (/message-analysis)

Analyze message headers and search mail flow across Exchange Online and on-premises transport logs.

  • Two permissions. The module's own permission (MessageTrace, headed Header Analysis on the module's Access tab) opens the page and analyses headers, which reads nothing from Exchange. Trace Search (MessageTraceSearch), held as well, is what searches traces, reads a message's delivery detail, takes either export, queues a detail-export job and opens Downloadable Reports; held without the module's own permission it opens nothing. An operator without Trace Search is not shown the Trace Search tab or the Fill Trace Form and Run Trace Now buttons. Each of those operations asks for the permission again as it starts, so an operator whose Trace Search was removed while the page was open is refused before anything is read, as is every operator while section access cannot be read: the page says "Authorization denied. Message trace search, delivery detail and exports require the Trace Search permission." (Downloadable Reports: "Authorization denied. The trace exports require the Trace Search permission.", and its list is cleared) and the refusal is audited as a failed row with refusedAt Authorization. No grant is copied from one permission to the other: a group searches traces only once it is added to Trace Search

  • Trace queries both Exchange Online message trace and on-premises message tracking logs. On-premises, every transport server's log is searched. If the list of transport servers cannot be read or names none, the search still runs against the connected server alone, the result carries the warning "On-prem message tracking searched one server only", and the application log has the reason. Like any warning on a trace, it files that search's audit row as Failed with the warning as its detail

  • Any range up to 90 days is searched in the app and rendered on the page. Exchange Online accepts a maximum span of 10 days per call, so a wider range is split into contiguous windows and queried in sequence; on-premises is queried once for the whole range. The operator never sees the limit. 90 days is the hard ceiling because that is Exchange Online's retention

  • If one window fails, the whole Exchange Online result is reported as failed rather than returned with an invisible hole in the middle of the range

  • Optional ticket number is recorded in audit logs only; it does not call ServiceNow

  • Header Analysis is the primary workflow and supports pasted headers plus .eml and .msg uploads

  • Extracts Message-ID, sender, recipient, subject, routing hops, authentication details, spam/filtering clues, delivery-failure evidence, and all parsed header values

  • Header analysis can populate or immediately run a trace using the parsed Message-ID and date window, for an operator who holds Trace Search

  • The results table renders the first 50 rows and states the true total. This is a fixed boundary, not a setting: Blazor Server renders rows server-side and holds them in circuit memory, so a large table degrades other operators' sessions too

  • Two different exports, and they are not interchangeable:

    Control Covers Contents Delivery
    Export CSV every result, however many one summary line per message - the table columns downloads immediately
    Download details (up to 10) the selected messages the full per-hop delivery trail downloads immediately
    Export details as a job the selected messages, max 50 the full per-hop delivery trail background job, listed on Downloadable Reports

    Delivery detail costs one Exchange lookup per message, so the 50 is a ceiling rather than a page: there is no way to obtain detail for every result in one export, and narrowing the search is how to cover more. Live download is capped lower still, at 10

  • Subject and Message ID filters work on every range, including a 90-day one

  • Per-message delivery-detail exports above the live threshold run as background jobs. The notification email carries a link to the Downloadable Reports page (/message-analysis/reports), never the export itself, so the data stays behind the login gate

  • A queued detail export is checked again before every message and once more as it ends (see Background Jobs under Session Revalidation), against Trace Search as well as the module's own permission: it runs only while a group that gave its operator Trace Search when it was queued is still allowed for Trace Search. If it is refused at either point, no export is produced and no email is sent, and Downloadable Reports lists it as Denied, which is never downloadable. That includes a job cancelled before it started or interrupted by a restart: if still allowed, it produces its export with every message marked not processed, as before. A detail export queued before Trace Search was enforced carries no record of it and is refused the same way

  • The notification recipient box is pre-filled with the operator's own address and is freely editable: any address may be added, and clearing it entirely is valid and means no email is sent. The export is still produced and still listed on the Downloadable Reports page. Administrators are never added to the recipient set

  • Downloadable Reports lists those exports with who requested what, to operators who hold Trace Search; a download also requires a ticket number, which is recorded with the download for audit

  • Exports are kept for 30 days. The app deletes expired ones itself at startup, in the same pass that prunes old job records — there is nothing to install and no scheduled task. A row whose export could not be saved shows as Failed, distinct from an expired one, and a refused job's row as Denied

  • Leaving the page during a search, a delivery detail or a detail download cancels it at its next step: while it waits for a free Exchange Online connection or for the on-premises server, between a wide search's windows, as its on-premises session opens, between connect attempts, or between its on-premises reads. It is filed Cancelled, "Cancelled by the operator". A read already sent to Exchange finishes first.

  • Section access keys: MessageTrace, MessageTraceSearch

Recipient Lookup (/recipient-lookup)

Look up any recipient - by its address, another of its addresses, its alias or its name - and see what it is, where its mailbox is, and that mailbox's size, quotas, archive and settings. Read-only; every lookup is written to the audit log. The exact field list per recipient kind, with each value's source, is in docs/history/RecipientLookupAccuracy-Plan.md, "Displayed fields per recipient kind".

  • What it is. Recipient Type names the recipient in plain words - "Mailbox", "Shared mailbox", "Room mailbox", "Equipment mailbox", "Distribution list", "Mail-enabled security group", "Dynamic distribution list", "Room list", "Microsoft 365 group", "Contact", "Guest", "Mail user", "Mail-enabled public folder" - with Exchange's own type words in small print beneath. A type is named only when Exchange reports it from the side that holds the object: an on-premises mailbox, which Exchange Online sees as a mail user, is named from on-premises Exchange's own answer.
  • Where its mailbox is. Mailbox Location reads "Cloud", "On-Premises", "Not applicable" (it has no mailbox: lists, mail-enabled security groups, room lists, contacts, guests and mail users; a note beneath says so) or "Could not be determined". A Microsoft 365 group reads "Cloud": Exchange Online holds its mailbox, which this module does not read.
  • "Could not be determined" means Exchange Online and on-premises Exchange disagree about the recipient, or a side that had to be asked could not be: on-premises Exchange is not set up for this module, its credentials could not be retrieved, its session or read failed, or the account comes from a directory that server does not serve. The warning box at the top says which, and the small print gives each side's words. The page never guesses a type.
  • Primary Email is the recipient's real primary address; when you typed anything else it adds "(looked up as ...)". Every figure on the page is about that recipient.
  • On-premises Exchange is asked only when it has to be: for a mail user Exchange Online does not report as cloud-only, and for a type the app does not name when Exchange Online holds no mailbox for it. Cloud mailboxes, lists, groups, contacts, guests and cloud-only objects open no on-premises session.

The page, top to bottom. The error box (the lookup failed) or the warning box first. Then two tables, the same rows for every kind:

  • Left: Display Name, Primary Email, Recipient Type, Mailbox Location, Created, Last Logon, Last User Activity, Synced from On-Premises, Entra Object ID, Alias, Hidden from Address Book, External Address, Last Changed.
  • Right: Mailbox Size, Warning Quota, Prohibit Send Quota, Prohibit Send/Receive Quota, Send Quota Used, Deleted Item Size, Total Size, Item Count, Deleted Items, Archive, Archive Status; when an archive was found, Archive Size, Archive Quota, Archive Warning Quota, Archive Deleted, Archive Items; then Forwarding, Send on Behalf, Account Disabled.

Then the Show all details switch and Email Addresses (the first 20; every one with the switch on).

What each kind shows ("shown": the value Exchange returned):

Row Cloud mailbox On-premises mailbox No mailbox: mail user, list, security group, dynamic list, room list, contact, guest, public folder Microsoft 365 group Could not be determined
Mailbox Location Cloud On-Premises Not applicable, with a note Cloud Could not be determined
Display Name, Primary Email, Created, Synced from On-Premises, Entra Object ID, Alias, Hidden from Address Book, Last Changed, Email Addresses shown shown shown shown shown
External Address Not applicable shown: where Exchange Online sends its mail shown for a mail user, contact or guest; Not applicable otherwise Not applicable shown when Exchange Online holds it as a mail user; otherwise Not applicable
Last Logon, Last User Activity shown Not read for on-premises mailboxes Not applicable Not read for this recipient type Not read
Mailbox Size shown shown (read on-premises) Not applicable Not read for this recipient type Not read
Quotas, Send Quota Used shown Not read for on-premises mailboxes Not applicable Not read for this recipient type Not read
Deleted Item Size, Total Size, Item Count, Deleted Items shown Not read for on-premises mailboxes Not applicable Not read for this recipient type Not read
Archive Enabled / Disabled Enabled / Disabled (read on-premises) Not applicable Not read for this recipient type Not read
Archive Status shown Not read for on-premises mailboxes Not applicable Not read for this recipient type Not read
Archive Size (archive found) shown shown (read on-premises) hidden hidden hidden
Archive Quota, Archive Warning Quota, Archive Deleted, Archive Items (archive found) shown Not read for on-premises mailboxes hidden hidden hidden
Forwarding, Send on Behalf, Account Disabled shown Not read for on-premises mailboxes Not applicable Not read for this recipient type Not read

Site, public folder and system mailboxes read as a Microsoft 365 group does. A type the app does not name reads "Not a type this app names: ..." and is placed by what Exchange's own mailbox reads say.

The words. "Not applicable": it has no mailbox, so the row can have no value. "Not read for on-premises mailboxes" and "Not read for this recipient type": the value exists, and this module does not ask for it. "Not read": what the recipient is could not be settled, so its mailbox was not asked about. "Could not be read": the read was made and failed; the warning box says why. "Not reported by Exchange": Exchange's answer did not include it. "N/A": Exchange's answer carried no value for it. "None": Exchange said there is none. Created and Last Changed add "(Exchange Online's copy)" for a recipient synced from on-premises: the date is that of Exchange Online's copy, not of the account.

Show all details (off by default) lists every property each read returned and every email address. Legal and retention holds are left out.

  • Audit: each lookup writes a Lookup row: target is what was typed, and resolvedAddress the primary address it found. A cancelled lookup is filed Cancelled, in the words "Cancelled by the operator".
  • Leaving the page during a lookup cancels it at its next step: while it waits for a free Exchange Online connection, or between its Exchange Online reads; on-premises, while it waits for the server, as its session opens, between connect attempts, or between its reads. A read already sent to Exchange is never interrupted; it finishes first.
  • Requires: the Exchange Online connection; for on-premises mailboxes, OnPremExchange:ServerUri and the module's own on-premises Exchange credential (DelineaSecretId). Without them an on-premises mailbox reads "Could not be determined", saying why.
  • Section access key: RecipientLookup

Out of Office (/out-of-office)

Check a mailbox's automatic reply, or set, schedule or disable it, whether the mailbox lives in Exchange Online or on the on-premises Exchange servers. The operator does nothing different for either: the page reads where the mailbox lives first, and reads or writes on that side.

  • Where the mailbox lives is read before its settings are read or written, by the read Mailbox Permissions and Calendar Permissions route by: Exchange Online is asked first, and on-premises Exchange only about a mailbox Exchange Online does not hold. On Set / Clear it is asked by the GUID of the mailbox the protection check validated, never by the address typed. A location that cannot be read - either side failing to answer - refuses, with nothing read or written; it is never taken for a cloud mailbox. A mailbox neither side holds is refused the same way.
  • A cloud mailbox is read and written in Exchange Online, and opens no on-premises session. Its write is not read back.
  • A mailbox that lives on-premises is read with Get-MailboxAutoReplyConfiguration and written with Set-MailboxAutoReplyConfiguration on on-premises Exchange, bound to that same GUID, in a session of the module's own credential. The write is read back in the same session and is a success only when the read-back shows everything that was sent: the state, each message sent and, for a schedule, both times to the minute.
  • In place with a difference. A write Exchange accepted whose read-back shows something else is neither a success nor a change that was not made. The result begins "Partial:" and says what is in place: the state, each setting that is not as asked (both values for a time) and each that is. A time read back with no time zone, with nothing else differing, leaves the outcome unknown instead.
  • A write that did not succeed says what is known of it, on either side: refused before the command was sent (no connection, no session, no credential) - "... was not changed: ... Nothing was written."; refused by Exchange - a failed change; or sent with its answer lost, or accepted and not readable back - "Whether the auto-reply ... was changed could not be confirmed", and the operator is told to check the mailbox before trying again.
  • Messages are HTML, as Exchange takes them: plain text is fine and tags format it. What is required, compared and shown on Check Status is the text a recipient reads - the stored document's body with its markup out and its entities then decoded. A < that opens no tag ("Back <3pm") is text; anything in <...> that starts with a letter is markup and is not seen by a recipient, an address in angle brackets included. A message with no visible text (only markup, entities or white space) is refused before anything is read or written. Formatting is not compared.
  • The external reply. The External box is optional: left blank, no external message is sent and the one the mailbox holds stays as it is. Who gets an external message is the mailbox's external audience (None, Known, All), which the page reads and never changes. The result of a change that turns the auto-reply on says which of these applies - plainly when the audience is None and the external message will reach nobody - and Check Status shows the audience.
  • Until the module is set up for on-premises, a mailbox Exchange Online does not hold is refused in words that say what is missing: OnPremExchange:ServerUri not set, no DelineaSecretId in the Out of Office Module Config, the module's configuration unreadable, or the vault returning no credential for the ID - each in its own words. Nothing is written, and no other module's credential is used.
  • Permission: the one OutOfOffice permission covers both sides; there is no separate on-premises permission. The ticket check, the protected-principal check and the authorization re-check run where they did, before the location is read; and authorization is checked a second time immediately before the write, after the location and the state before have been read. A denial there, or a check that could not be made, refuses with nothing written.
  • Audit: a change to an on-premises mailbox is recorded as OnPrem_OutOfOffice_Set or OnPrem_OutOfOffice_Disable (a cloud one as OutOfOffice_Set or OutOfOffice_Disable), with previousState, newState and writtenIdentity, the GUID written. An unknown outcome is filed Undetermined. A change that was never sent carries mutationAttempted false and no writtenIdentity. A change in place with a difference is filed Failed with outcome Partial, an error beginning Partial:, stateInPlace, stepsDone (the settings in place as asked) and stepsDiffering. Refusals are OutOfOffice_Denied rows with mutationAttempted false and refusedAt: MailboxLocation for a location that could not be read, MailboxIdentity when the check validated no mailbox to write to (no mail is sent for it), Authorization for the check before the write.
  • Mail: the administrators are mailed for every change that reaches the write; the action starts OnPrem_ for an on-premises mailbox and ends _UNCONFIRMED for an unknown outcome or _PARTIAL for a change in place with a difference. The mailbox owner is mailed for a change that succeeded and, for a change in place with a difference, when the auto-reply is in the state asked for - then with what is in place, a schedule with the window in place. The owner's notice goes to the primary address of the mailbox that was checked and written, never to the address typed; with no address for it, no notice is sent.
  • Check Status reads the same way, by the address typed, and marks a mailbox read on-premises "On-premises". A state Exchange did not report is shown as not known, never as Disabled.
  • Requires: the Exchange Online connection; for on-premises mailboxes, OnPremExchange:ServerUri and the module's own on-premises Exchange credential (DelineaSecretId: an account that may read and set auto-replies there).
  • Section access key: OutOfOffice

On-Premises Permission Operations

When a target mailbox is detected as on-premises:

  • Regular users see an escalation message directing them to contact the Exchange team.
  • Power users (members of the MailboxPermissionsOnPrem or CalendarPermissionsOnPrem section-access groups) are prompted with a confirmation dialog and can proceed. Every on-premises write - a mailbox right or a calendar permission, a grant or a removal - is made for the grantee's own on-premises account, found from the name typed, or refused (see "The grantee a permission write names" below); on a directory-synced mailbox Send As is written on each side where the grantee exists - on-premises, and in Exchange Online when Exchange Online holds the grantee (see "Send As on a synced mailbox" below).
  • Execution uses an on-prem PowerShell remoting session (New-PSSession) authenticated with credentials retrieved from Delinea Secret Server at runtime.
  • Concurrency is throttled to 2 simultaneous on-prem operations.
  • The on-premises Exchange endpoint runs one command per call (no-language mode), so each step is its own command. A Calendar Permissions change reads the mailbox's own calendar folder first (a localized name such as "Kalender" is written as such; a failed read writes nothing), then sets the permission, and adds it only when Exchange answers that the user holds no entry on the folder. Any other refusal is reported as that failure.

CSV rows for on-premises mailboxes

A CSV run of Mailbox Permissions or Calendar Permissions checks and writes each row as the same single change would be, on the side the row's mailbox lives on. It differs from a single change in four ways:

  • No confirmation prompt for a row whose mailbox is on-premises: uploading the file is the confirmation.
  • No cancel: once started, a run goes through every row. A single change can be cancelled up to its first write.
  • One email per person, after the run, not one per row, and none for a row that changed nothing (see User Notifications).
  • One administrator email for the whole run, naming the rows that failed (below).

What a run does, row by row:

  • Invalid rows are refused before anything is asked of Exchange for them: no target, no user, no right asked for (Mailbox Permissions), or - Calendar Permissions - an AccessRight that is not one of the level names (None, Owner, PublishingEditor, Editor, PublishingAuthor, Author, NonEditingAuthor, Reviewer, Contributor, AvailabilityOnly, LimitedDetails, in any letter case). A number or a list is not a level: the row is refused (BulkSetCalendar_InvalidAccessRight) and nothing is written. The row's record, its entry and the emails name the level that was written.
  • Location, per row: after the row's protection and self-grant checks, the mailbox's location is read by the read a single change uses. A cloud mailbox is written in Exchange Online as before, and no on-premises session is opened for it. A location that cannot be read, or a mailbox neither side holds, refuses that row with nothing written; a row is never taken for a cloud mailbox because the read failed.
  • On-premises rows: the operator must hold MailboxPermissionsOnPrem (or CalendarPermissionsOnPrem), asked for each such row immediately before it is written. Without it the row is refused with the single change's escalation message; if the permission cannot be read the row is refused. There is no per-row confirmation prompt: uploading the file is the confirmation. The row then runs the single on-premises write itself, for the grantee's bound on-premises account - for Mailbox Permissions including auto-mapping and, on a directory-synced mailbox, Send As on both sides with read-back.
  • Missing credential or server: with the module's on-premises secret or OnPremExchange:ServerUri unset, every on-premises row is refused with that reason and nothing written; cloud rows are unaffected.
  • Results: a refused or failed row never stops the run, and a run with one is never reported clean. The summary counts it, the row's entry and the downloaded report carry its reason, and a Send As row confirmed on one side only is a failed row naming the side written and the side missing, with the same follow-up emails as a single change. A row whose audit record could not be written stays the row it was - a success stays a success, a refusal a refusal - and its entry ends "The audit row could not be written."; the run goes on. A row that fails with an error before its change was sent is a failed row with nothing written. One that fails with an error while its change is being written - sent, and not yet answered - is not a plain failure: its outcome is unknown, so its entry says "Whether the change was made could not be confirmed ...", its record (Bulk..._Error) is filed Undetermined, and the administrator email marks it UNCONFIRMED. Once the write has answered, the row keeps that answer whatever fails after it: a row that was written stays a success ("The change was written, but failed: ..."), a row that was refused or failed stays that in its own words, with "A later step also failed, : ..." added and nothing said to have been written, and neither is UNCONFIRMED unless the write itself left it so. The entry names the step and, when the failure left any out, ends "Not sent: ..." with them - the row's place in the run's mails to the grantee and to the mailbox owner, the follow-up for a Send As written on one side only. The later step has its own record (Bulk..._Error), filed Failed, or Undetermined when the write left the outcome unknown. Two records can be missing, and each is named: "The audit row could not be written." is the row's own record, "The record of the step that failed could not be written." the later step's.
  • A single change is shown and recorded the same way when a step after its write fails: the banner is the write's own result - a success for a change that was written - in the same words, and "Not sent: ..." can also name the notification to the administrators. Its own row stands as written; the later step's row is the change's action with _Error. An unconfirmed change whose administrators had not yet been told is reported to them as unconfirmed.
  • Administrator email: one per run. A file refused for its size (more than 200 rows) is reported as failed, and the email says it was refused for its size and that nothing was written. With no failed row it reports success; a row that succeeded and whose audit row could not be written is still named there, apart from failed rows ("NOT RECORDED"), because the audit log does not show it. Otherwise it reports the run as failed and lists each failed row: its data row number, target, user, right and reason, and for a Send As on a synced mailbox what became of each side (for example "Exchange Online: granted and confirmed; on-premises: FAILED"). A row whose outcome is unknown - its change was sent and the write's answer never came back - is listed first and marked UNCONFIRMED, and the email's action then ends _UNCONFIRMED, as a single change's does. To keep it one email for a file of any size, at most 25 failed rows are listed and a reason is cut at 600 characters; the rest are counted, and the email points to the page's Download Full Report and the audit log, which have every row. "data row N" is the row's place among the rows of data - the header line is not counted, and a blank line is skipped and not counted - which is also its place in the downloaded report. It is not the line number in the file; the email says so.
  • Records: a refused row is the row's own action (BulkAdd_<rights>, BulkSetCalendar, ...), Failed, with refusedAt (MailboxLocation or OnPremPermission; MailboxIdentity for a row whose check validated no mailbox to write to) and mutationAttempted: false. An on-premises Mailbox Permissions row has one row per right, BulkAdd_OnPrem_FullAccess / BulkAdd_OnPrem_SendAs (BulkRemove_... for a removal), and on a synced mailbox the Exchange Online side's own BulkAdd_SendAs / BulkRemove_SendAs row. An on-premises Calendar Permissions row is BulkSetCalendar_OnPrem / BulkRemoveCalendar_OnPrem.
  • Sessions: each on-premises row opens one on-premises session for its location read and one for its write, two at a time at most, as a single change does.

The grantee a permission write names

Mailbox Permissions and Calendar Permissions never hand Exchange the name typed in the User box (or a CSV row's User cell) to resolve by its own rules: the object the checks examined and the object a write landed on could then differ. Every grant and every removal, a single change or a CSV row, names an identity bound before the write, or is refused with nothing written.

  • A mailbox in Exchange Online (Full Access, Send As on a mailbox that is not synced, a calendar permission): the write names the one recipient Exchange Online answers the name with, by that recipient's GUID. It is asked on the write's own connection, immediately before the write, with the question the checks ask (Get-Recipient -Identity). No recipient, more than one, or one with no GUID refuses the change ("Refused: Exchange Online holds no recipient for '...'. Nothing was written."), and so does a read that fails ("Refused: Exchange Online could not be asked who '...' is: ...").
  • A mailbox that lives on-premises (Full Access, Send As on a mailbox that is not synced, a calendar permission): the write names the grantee's on-premises account by its objectGUID. The account is bound before anything is sent, from the directory alone: the name typed must match exactly one object in the forest that a right can name - a user or a group, in any domain - read at the forest's global catalog with the Directory Read Credential, in the forms listed under "Grantee Exchange Online does not hold" below. Exchange Online and Microsoft Graph are not asked, because nothing of such a change is written there. No such object, or more than one, refuses the change ("... lives on-premises, where Full Access can be written only for a grantee's on-premises account, and ...", naming the right asked for); a lookup that could not be made - the Directory Read Credential not set or not retrievable, the catalog not answering - refuses it as "could not be read". Nothing is written, and the refusal is recorded as the change's Failed row. A removal is bound the same way, so it needs that credential too, whatever Prevent Self-Grant is set to.
  • Send As on a synced mailbox binds the grantee on both sides ("Send As on a synced mailbox" below).
  • A grantee outside this forest - an account of a trusted forest - cannot be granted to: the checks can examine only an account or group of this forest, so the grant is refused and says so ("... no account or group of this forest is named '...'"; typed as DOMAIN\name, "... is not an account of this forest: the forest holds no domain named ...").
  • Removing an entry whose holder cannot be found - a deleted account, an account of another forest: type the entry's SID in the User box, as the mailbox shows it (S-1-5-21-...). A removal typed that way names that entry exactly: no lookup is made, and it is written on the side the mailbox lives on alone - a Send As removal on a synced mailbox does not go to the other side. Only a removal reads a SID, and only a SID a domain issues to its accounts. A removal refused for a grantee that was not found says this.
  • A calendar's built-in entries: exactly the names Default and Anonymous (in any letter case) name no account, so nothing is bound or looked up for them - on a mailbox that lives on-premises the write names the entry as it is, except that a grant to one is refused while Prevent Self-Grant is on (it grants to everyone, the operator included), and in Exchange Online the module does not change them and says so.
  • Records: a row keeps the grantee as typed and, once a command was sent, names who it was sent for: writtenGrantee (the recipient's GUID) on a row written in Exchange Online, writtenGranteeDirectoryObject (the account's objectGUID, or the SID a removal was typed as) on a row written on-premises - Full Access, Send As and calendar rows alike. A change refused before anything was sent names nobody as written.
  • Not proven by tests: that on-premises Exchange takes an account's objectGUID as -User on Add-MailboxPermission / Remove-MailboxPermission, Add-ADPermission / Remove-ADPermission and the MailboxFolderPermission commands; that Exchange Online takes a recipient's GUID as -User on its mailbox and folder permission commands and as -Trustee on Add-RecipientPermission / Remove-RecipientPermission; and that either side takes a SID for the entry to remove (a calendar folder may show such an entry in another form). What Exchange refuses is reported as failed in Exchange's words; nothing is written under another name.

Send As on a synced mailbox

Directory sync does not carry Send As. A right granted on one side alone leaves a sender on the other side refused, so Mailbox Permissions writes Send As on both sides whenever the mailbox is directory-synced: the side the mailbox lives on first, then the other. No setting turns this on: Exchange Online's own answer for the mailbox (directory-synced or not) decides it per mailbox, at the time of the change. The bullets below describe a cloud mailbox; "A mailbox that lives on-premises" after them gives the same rules with the sides swapped.

  • Cloud-only mailbox: written in Exchange Online only, and no on-premises session is opened.
  • Synced cloud mailbox: written in Exchange Online, then on the mailbox's on-premises account, which is found by the Active Directory objectGUID the protection check bound - never by the address typed. Where that check binds no account (no protected-principal configuration), the account is bound for the change: the one object holding the on-premises SID Microsoft Graph reports for the mailbox. The grantee - a person or a group - is bound the same way. Exchange Online is told the grantee by the GUID of that same recipient, read back by it immediately before the write and refused if it no longer answers as that recipient - never by the name typed, so both sides are always for one grantee. Binding a group reads GET /groups/{id} with the Graph Directory Read Credential, whose app registration needs Group.Read.All for it.
  • Read-back: each side is read back after its write (Get-RecipientPermission in Exchange Online, the account's Send As entries on-premises). The grantee's entries are weighed in the order Windows weighs an object's - a Deny written on the object, an allow written on it, an inherited Deny, an inherited allow - by the one weighing Mailbox Migrations' listing of a mailbox's Send As holders reads too. So a Deny written on the mailbox or account itself overrides a grant: a grant with one is not confirmed, the message names it, and it is not read again. A grant whose own entry stands beside an inherited Deny is confirmed - "deny on the container, allow the exception on the mailbox". Where every allowing entry shown is inherited beside an inherited Deny, or a Deny's row does not say whether it is inherited, the grant is not confirmed and the message says the doubt ("an inherited Deny may override it", "a Deny whose inheritance was not reported may override it"). A read that does not yet show the write is repeated, up to three reads about two seconds apart; the write is never repeated. A grant that still does not show, or a removal that still shows, is not confirmed. On-premises, a grant reads the account's entries before it writes, as a removal does: an entry of the grantee's own that is already in place is "nothing changed" for that side and is not written again. If that read fails, the grant is written and read back as usual - unless it failed because the on-premises session itself is gone: then the grant is not sent, and that side is "NOT attempted", nothing written, rather than a write whose outcome is unknown. On-premises, both reads count only entries that apply to the account itself: one that applies only to the objects below it (InheritanceType Descendents or Children) lets nobody send as the mailbox, so it is neither "already in place" nor a confirmation.
  • Result: Send As is applied only when every side it needs is written and confirmed. Otherwise that right has FAILED, and the message names the side that was written and the side that was not, for example "Send As was granted in Exchange Online but NOT on-premises: ... On-premises senders will be refused until this is fixed." The Exchange Online half is left in place; nothing is rolled back. If the Exchange Online half fails, the on-premises half is not attempted. Each side is said as it came out: a side that was already in place (or already absent, for a removal) is said as that, in the message and in the administrators' follow-up email, never as granted, removed or confirmed by this change.
  • Removal: mirrors the grant. An entry that was not there on a side is "nothing changed" for that side, not a failure, so a mailbox that was put right by hand can be cleaned up. An inherited entry is not the removal's to take away: when one still grants Send As on a side after the removal, the message says so for that side, and the removal is not failed for it.
  • Grantee with no on-premises account: an on-premises entry cannot name them and they do not need one to send from the cloud, so only Exchange Online is written and the right is not failed for it. The on-premises side is "not needed" whatever becomes of Exchange Online: if that write fails or cannot be confirmed, the message, the record and the administrator email say so of Exchange Online and say that nothing was needed on-premises, not that an on-premises half was left unattempted.
  • Refused before anything is written, on either side: everything the on-premises half needs that can be known beforehand. A mailbox whose sync state could not be read; a synced mailbox or a synced grantee that cannot be bound to exactly one on-premises object of its kind (Graph or the directory not answering, no SID, no object or several); a grantee Exchange Online could not be asked about; OnPremExchange:ServerUri not set; the module's on-premises secret not set or not readable. Only what happens from the on-premises session on - it cannot be reached, it refuses the write, the read-back does not confirm - can leave the Exchange Online half in place.
  • Permission and credential: the on-premises half runs under the operator's ordinary Mailbox Permissions permission, re-checked immediately before each side is written; the MailboxPermissionsOnPrem group and its confirmation still gate mailboxes that live on-premises. It uses the module's own on-premises Exchange secret and OnPremExchange:ServerUri; with either unset the change is refused with that reason before anything is written.
  • Records: the change's audit row carries the Exchange Online side (sendAsSide, sendAsSideState), and the on-premises side has its own row (OnPrem_AddSendAs / OnPrem_RemoveSendAs; BulkAdd_OnPrem_SendAs / BulkRemove_OnPrem_SendAs for a CSV row) with its own result and mutationAttempted: false when nothing was sent. The rows also record who was written, beside the name typed: writtenGrantee (Exchange's GUID for the grantee) on the change's row and writtenGranteeDirectoryObject (the grantee's on-premises account) on the on-premises row. The administrator email states both sides. The grantee and the owner get the ordinary email only for a right that is applied, and only for what the run changed: a run that completes the missing side after a half-applied change names that side (for example "SendAs (completed on-premises; already in place in Exchange Online)"), and a run that changes nothing on either side emails them nothing.
  • Exchange Online done, on-premises not: the change is still reported and recorded as failed. The administrators also get a separate follow-up email naming the mailbox, the grantee and the reason, and the grantee and the mailbox owner are emailed that the right works from cloud mailboxes now and that sending from an on-premises mailbox will not work until IT completes it (for a removal: that an on-premises entry may still allow it until IT completes the removal). A CSV run sends these per row, after its digest. When the on-premises outcome is unknown, or the Exchange Online half was already in place (already absent, for a removal), only the administrators' follow-up goes, and it says which of those it was. Nothing is sent when the Exchange Online half is not confirmed.

A mailbox that lives on-premises (by an operator in the MailboxPermissionsOnPrem group: a single change after the confirmation, or a CSV row):

  • Not synced: written on-premises only, for the grantee's bound on-premises account ("The grantee a permission write names" above), and Exchange Online is not called.
  • Synced: Send As is written on-premises first - on the mailbox's on-premises account, by its objectGUID, for the grantee's on-premises account - and read back there; then in Exchange Online, on the recipient that stands for the mailbox there (a mail user), with Add-RecipientPermission / Remove-RecipientPermission, and read back with Get-RecipientPermission. That recipient is named by Exchange Online's own GUID for it, taken from the recipient the typed address resolves to while it still carries the validated mailbox's GUID - never by the address typed and never through Get-Mailbox, which holds no mail user. On-premises goes first because that is where the mailbox and its Full Access are, and where the change was written before this; a failure there leaves Exchange Online untouched.
  • Full Access on its own, on a synced mailbox (a grant or a removal, single or a CSV row): written on-premises only, for the grantee's on-premises account bound from the directory alone ("The grantee a permission write names" above). A mailbox whose sync state could not be read is held to the same binding.
  • Refused before anything is written, on either side: a sync state that could not be read; a mailbox whose on-premises account or Exchange Online recipient could not be bound; a grantee whose Exchange Online state could not be read, or who answers there as several or as a different object. Both recipients are also read back in Exchange Online by their GUIDs before the first on-premises command: one that is gone, answers as several or as another refuses the change, and an Exchange Online connection that cannot be had ends it with nothing written.
  • Result: applied only when both sides are confirmed. On-premises not settled: failed (or not confirmed), and Exchange Online is not attempted. On-premises confirmed and Exchange Online not: failed, "Send As was granted on-premises but NOT in Exchange Online: ... Senders whose mailbox is in Exchange Online will be refused until this is fixed."; the on-premises half is left in place. An outcome that could not be read is unknown, never success. Removal mirrors it; an entry that was not there on a side is "nothing changed" for that side.
  • Grantee with no on-premises account: no on-premises entry can name them, so only Exchange Online is written. With Send As alone no on-premises session is opened, the result carries no "(on-premises)" tag, and a cancel is honoured up to that Exchange Online write. If the write fails, the message says so and that nothing was written on-premises; it does not say the right was granted there. Full Access in the same change is refused, with nothing written on either side: it lives in the on-premises mailbox, where only an on-premises account can hold it, and the name typed is never handed to on-premises Exchange to resolve in place of a bound account. Change Send As on its own for such a grantee.
  • Grantee Exchange Online does not hold (an on-premises account or group kept out of directory sync): no Exchange Online entry can name them and they can only send from on-premises, so only on-premises is written and read back, the Exchange Online side is "not needed" (its row: Success, mutationAttempted: false), and Exchange Online is not written. This is never concluded from a failed read, an error about something else, or names alone. The name typed must match exactly one object in the forest that a right can name - a user or a group, in any domain - read at the forest's global catalog, which is found from the server's own forest. The name may be a user principal name, a mail or other SMTP address of the object, its alias, its sAMAccountName, its name (common name), its distinguished name, or DOMAIN\name, where the domain half (NetBIOS or DNS name) is looked up among the forest's own domains and only an account of that domain is taken. Not accepted: a display name, an object GUID, a canonical name (domain/OU/name) or a legacy Exchange DN - type one of the forms above instead. More than one such object refuses the change as ambiguous; a read that fails refuses it as "could not be read". Exchange Online is then asked for that object's user principal name, mail address and sAMAccountName, and - because it may hold the object under other names - for the object itself: Microsoft Graph is asked which directory object is synced from the object's own SID (GET /users for a user account, GET /groups for a group - which needs Group.Read.All, as binding a group does - filtered on onPremisesSecurityIdentifier, with the Graph Directory Read Credential), and Exchange Online for the recipient of that directory object, by its object id. The Exchange Online side is "not needed" only when Graph answers in full that it holds no such object, or Exchange Online answers that the object has no recipient. If either cannot be asked, or Graph holds more than one such object, the change is refused as "could not be determined", with nothing written. A recipient found by a name or by the object is used as the grantee only when it is synced from that same object (by the on-premises SID Microsoft Graph reports); otherwise the change is refused.
  • Permission: the MailboxPermissionsOnPrem gate and the protection check run where they did; both permissions are re-checked before the Exchange Online side. No separate permission is needed for it.
  • Records and mail: one row per side - OnPrem_AddSendAs / OnPrem_RemoveSendAs for the on-premises side and AddSendAs / RemoveSendAs for the Exchange Online side, each with sendAsSide, sendAsSideState and its own result; the Exchange Online row's writtenIdentity and writtenRecipient are the recipient its write named (the mail user that stands for the mailbox), not the mailbox's own GUID, which is on the on-premises row; it also carries writtenGrantee. A side that sent nothing carries mutationAttempted: false and names no object written; an Exchange Online write that Exchange answered as changing nothing was sent, so its row names what it was sent to and carries no mutationAttempted: false. The administrator email states both sides. With on-premises confirmed and Exchange Online not, the administrators get the separate follow-up and the grantee and the owner are emailed that the right works from on-premises mailboxes now and not yet from cloud ones; the same exceptions apply as above.
  • Not proven by tests: that Exchange Online accepts Add-RecipientPermission on the mail user of an on-premises mailbox, and that a sender in the cloud is then let through. If Exchange Online refuses, the change is reported as failed with Exchange's own words. Nor that Microsoft Graph accepts the filter on onPremisesSecurityIdentifier for users and groups without an advanced query, or that Exchange Online's Get-Recipient -Filter accepts ExternalDirectoryObjectId: if either refuses, a grantee no name finds in Exchange Online is refused as "could not be determined", and nothing is written. What else is not proven about the identities a write names is listed under "The grantee a permission write names" above.

Full Access lives in the mailbox and is written only on the side the mailbox lives on, for a bound grantee on either side ("The grantee a permission write names" above). The AutoMapping box is passed to the grant on either side: on-premises Add-MailboxPermission takes the same -AutoMapping parameter.

Admin Settings Page (/admin-settings)

Module enablement controls, gated by Security:AdminGroups.

Per-Module Config Pages (/module-config/{ModuleId})

Each module has its own config page (linked in the sidebar) with:

  • Module Status — enable/disable the module (global admin only)
  • Section Access — which AD groups can use the module (global admin only)
  • Configuration — module-specific settings (config fields)
  • Module Admins — AD groups that can configure this module without global admin. A grant is stored as the group's SID and matched against the SIDs in the user's token. A grant stored by name, from before grants were stored as SIDs, grants nothing; it is listed on the pane marked not converted - run db convert-identifiers, with a Remove beside it. The app's db convert-identifiers command (run by hand before the deploy - see Troubleshooting) looks each such name up once (DOMAIN\name in that domain, a bare name across the forest, matched on sAMAccountName, common name, name or display name, groups only) and replaces it with the SID of the one group it names, which grants from then on; it refuses, writing nothing, while any name matches no group or several (docs/history/ProtectedPrincipalIdentifiers-Plan.md K).

Verify (docs/history/DirectoryObjectVerify-Plan.md, slice V3). The Section Access tab (the module's access groups and its Protected principal servicing groups) and the Module Admins tab each have a Verify button, for global admins only. The page asks the directory nothing when it opens; pressing Verify asks Active Directory about every group stored on that tab - by SID at the global catalog, read with the Directory Read Credential - and marks each: verified; missing (the directory answered and holds no object with that SID); name changed (the display name shown is not the group's current sAMAccountName - cosmetic, the grant is by SID; module admins borrow the section-access display names); not converted (stored by name, so it grants nothing, with what that store's own lookup finds: one group, none, several, or no answer); several objects; wrong type (not a group, or not a usable group SID such as a well-known SID); could not verify (the directory could not be asked - never read as missing); or ignored. A grant stored by name is looked up by the rule its store has always used: on Section Access as the startup SID migration does (DOMAIN\Name in that domain, a bare name in this server's own domain), on Module Admins as db convert-identifiers does (DOMAIN\name in that domain, a bare name across the forest). The summary line reads "Verified N entries at : M findings, K ignored, J could not be verified", and the last press of each tab is shown to the next admin. Beside each finding are its actions, each checked against the groups as Verify read them (a change since refuses: "run Verify again"), re-authorized at the click as a global admin - a module admin who is not one is refused, and the refusal is audited - and audited under Verify:SectionAccess or Verify:ModuleAdmins: Rename (store the group's current name as the display name of that SID, written at once), Convert (one grant, as the startup migration or db convert-identifiers would, written at once), Replace... (takes the grant out of the list; pick the replacement in the search below it and Save, which checks it as any added group is), Remove now (the grant and any ignore of it, written at once), and Ignore (keep the grant and stop the finding being reported until what Verify sees changes; never offered for a grant stored by name, one that is not a usable SID, or one that could not be verified). An ignore on these tabs changes only what Verify reports, never who is granted anything: section access, servicing and module-admin grants are matched against the SIDs in the user's token, and nothing that decides access reads the ignore list. Verify is not offered while the tab has unsaved changes, and the ordinary Remove and Save also deletes a removed grant's ignores.

The Configuration pane of Migration, Emergency Disable, AD Attribute Editor, BitLocker Recovery and Conference Rooms has its own Verify (slice V4) for the settings that hold a directory object as text - each entry of a list on its own, each checked by the rule its module applies when it uses it (see each module's section). It is offered to global admins and to that module's module admins - the page's own gate, re-checked at every click - and audited under Verify:Config. Its actions: Edit... (opens the field, with the OU browser for a DN; change it and Save), Remove now (that one entry, by the module's own parsing, keeping the others), and Ignore (changes only what Verify reports). Fields of the new types SearchBase (any container) and RecipientGroup (an Exchange group) and the list AdGroup field are text boxes; OU and SearchBase fields offer the OU browser. The ordinary Save drops the ignores of entries it removed.

Changes are stored in the config database - the module_enablement, section_access, module_config and module_admins tables (docs/ConfigDbOperations.md) - and take effect immediately. The legacy config/*.json files are imported once and archived; a tab whose store cannot be read says which table, or which legacy file was not imported, and does not offer Save. Global admins see all module config links; module admins see only their delegated modules.

Admin Event Log Page (/admin-event-log)

A read-only JSONL audit log viewer, also gated by Security:AdminGroups.

  • Browse audit events by date (one file per rotation period).
  • Filter by category, user, IP address, and result (Success/Failed).
  • Displays full event detail in an expandable JSON view.
  • Download CSV includes a Ticket column carrying the stored audit/trace ticket field.
  • A line in a log file that cannot be parsed is not shown, and the page says how many such lines each log had. One example is the cut line a writer that stopped mid-write leaves.

Usage telemetry. An "Events | Usage" toggle above the filters switches the page to an anonymous usage view: per module, how many times it was opened, how many audited actions ran, how many failed and how many visits touched it (every module is listed, so a module nobody opens shows zeros); per theme, how many visits ended on it; and a one-line visit summary. The rows behind it come from config/exchangeadmin-usage.db, a separate database that is never promoted between instances and is not part of the config backup. What is recorded: a throwaway per-visit id, a timestamp, the route or module opened, the audit category and action name of a completed action with its success flag, and the selected theme id. What is NOT recorded: the user, the IP address, the target of the action, the ticket number, or any operator-typed text. Rows older than 90 days are deleted at startup. Turn it off with the "Record anonymous usage" setting on the Event Log module in Admin Settings; the Home page notice announcing collection appears only while it is on, and the Usage view keeps showing rows already recorded.

Cloud Password Reset (/cloud-password-reset)

Reset the password of an Entra ID cloud-only account - one with no on-premises AD object, and therefore unreachable from the AD tooling L2 already has. Almost every target is an admin or tactical account; resetting a Global Administrator is the module's normal operating mode.

  • The operator does not choose where the password goes. The module reads the employeeId off the target account, finds the one directory user carrying it, and emails the new password to that person's mailbox. There is no address field on the page.
  • The operator normally never sees the password. It is generated by the app, written to Entra and mailed. A separate CloudPasswordResetReveal permission shows it on screen instead, for an account whose owner cannot be determined - the only route by which an operator can learn one.
  • A missing employee ID can be filled in (module 1.2.0, off until "Fill in a missing employee ID" is switched on in the module's settings). The owner is looked up from the account's name: the part before the @, less the longest configured ending it ends with (ignoring case), as a logon name across the server's forest. Only when exactly one person answers to it, their employee ID leads back to them alone and they have a mailbox, the preflight shows that person, the confirm saves their employee ID on the account, and the password is reset and mailed to them; the next reset of that account takes the ordinary route. Anyone who can reset passwords here can trigger the save - there is no new permission. When the lookup finds nobody suitable, a person who can open the module but cannot see passwords gets the same refusal as before, word for word, and a person who can see passwords sees it once, as before; nothing is saved. A save Entra refuses, or does not answer, never stops the reset, and the administrators are told the number was not saved. The endings are the deployment's to type in; the module ships with none. Detail: docs/history/CloudPasswordResetEmployeeId-Plan.md.
  • Refuses, with its reason audited, when the account is synced or a guest, when the employee ID is missing (and not filled in) or matches nobody, when it matches more than one person, when the owner has no mailbox, or when the directory could not be searched. None falls back to another destination.
  • Generated passwords are 18-32 character passphrases with a measured 60-bit entropy floor; after 100 attempts that fail the floor the generator refuses rather than issuing something weaker.
  • Force password change at next sign-in is checked by default - the password travels by email, so forcing a change makes it a one-time handover. Clearable per reset for an account whose sign-in path cannot service a change prompt.
  • A send failure after the write discards the password rather than showing it, logs at Critical and audits CloudPasswordReset_DeliveryFailed. Running the reset again issues a new one.
  • A saved employee ID is audited as CloudPasswordReset_EmployeeIdSet with its own administrator alert, sent once the password write that follows the save has completed (after the reset's own alert), and every event of the module carries employeeIdFill, employeeIdFillValue and employeeIdFillSource.
  • The Graph client built from the module's Delinea record is kept for five minutes from the read, so a preflight and its confirm - the account re-read, the employee-ID save and the password write - make one Secret Server read and use one Graph token (sweep-d item 29). A rotated secret is picked up within five minutes.
  • Requires: its own Graph app registration with User.Read.All, User-PasswordProfile.ReadWrite.All and RoleManagement.Read.Directory, and its own Delinea record. Ships disabled. Filling in an employee ID also needs the registration to be allowed to write user details - assumed to be User.ReadWrite.All (application), not yet confirmed: the first live save settles it. Without it, resets still go out and every save is reported not saved.
  • Section access keys: CloudPasswordReset, CloudPasswordResetReveal
  • Full detail: docs/CloudPasswordReset.md

MFA Reset (/mfa-reset)

Reset user MFA authentication methods via Microsoft Graph API.

  • Lists all registered authentication methods for a user (phone, FIDO2, authenticator app, etc.)
  • Confirmation step before deletion
  • One reset deletes the user's non-password authentication methods one at a time, each with its own request to Graph. It is not all-or-nothing: a reset can end with some methods removed and others not, and says which
  • Before the reset, the user is read from Graph and the protected-principal check is of that object (see "Entra users" under Security & Compliance)
  • The module permission is checked when the reset starts, again after the protected-principal check, and then as the last step before each method's delete is sent: the reset signs in to Graph once, before its first delete, so nothing is fetched between a check and its delete. An operator who lost it before the first delete is refused, nothing is removed and the refusal is recorded. If it goes between deletes the reset stops part-way
  • A reset that does not remove every method - stopped part-way, or with a delete Graph refused - is reported as a failed reset. A delete that fails with no answer from Graph, or a Graph sign-in that cannot be renewed between deletes, stops the reset part-way the same way, with the cause. The page, the audit record and the administrators' mail say what became of every method, each group apart: removed, outcome unknown (no answer came back to its delete, so it may or may not be gone), never attempted, refused by Graph (with Graph's status), already gone (Graph answered 404), and not deletable here. The audit record carries one field per group (removedMethods, outcomeUnknownMethods, notAttemptedMethods, refusedByGraphMethods, alreadyGoneMethods, undeletableMethods). Each method is named by its type, for a phone the kind of phone as Graph gives it (mobile, alternate mobile, office), and its Graph method id; the phone number, mail address or device name the page lists is never written to the audit record or the mail
  • Requires: Separate Graph app registration with UserAuthenticationMethod.ReadWrite.All application permission (per-module registration pattern)
  • Section access key: MfaReset

Group Management (/group-management)

Search and manage distribution lists, mail-enabled security groups, and Microsoft 365 groups.

  • Three backends depending on group type:
    • EXO — Cloud-only distribution and mail-enabled security groups
    • On-prem AD — Synced groups modified via Delinea-authenticated AD operations
    • Graph API — Microsoft 365 (Unified) groups
  • Add/remove members, view group details
  • On-prem AD members can be users or nested groups: the member list shows each member's kind, adds are guarded against self-nesting and membership cycles in the service, writes are confirmed by a post-write read-back, and a protected group member is refused (the ProtectedServicer:GroupManagement override applies)
  • Bulk actions (on-prem AD): tick members (select-all covers only removable rows) and remove them in one confirmed batch under one ticket; paste a list of usernames, emails, UPNs or group names, Resolve checks every line against the forest in one pass, and "Add resolved" adds the lines that resolved to exactly one object. Every member still runs the single-member path (per-row authorization, protection, read-back, audit), a per-row outcome table shows Done / Not done with the reason, and each batch writes one summary audit event (success only when every row succeeded) and one summary admin email
  • Requires: GroupManagementOnPrem section access for on-premises group modifications
  • Section access key: GroupManagement

Self-Service Groups (/self-service-groups)

On-prem AD group membership management for group OWNERS (managedBy / co-managers holding member-write rights on the group DACL), without admin access. (Section added 2026-08-27; the module previously had no README entry.)

  • Lists the groups the signed-in user owns; write eligibility is checked at list time against the group's DACL and re-checked at every write
  • Add or remove USER members by username, email, or UPN; every change is confirmed by a post-write read-back, audited, and notifies the affected member for security groups
  • Nested groups: adding a group is never possible here (the page says so up front and a typed group gets a refusal directing to the IT Support Desk); a nested group CAN be removed, behind an inline warning that re-adding it will require a ticket
  • Protected principals - including protected groups and groups nested under one - are refused; the ProtectedServicer:SelfServiceGroups override applies
  • Bulk actions: tick members (select-all covers only removable rows) and remove them in one confirmed batch - a nested group in the batch carries its one-way warning inside the confirmation; paste a list of usernames, emails or UPNs, Resolve checks every line in one pass (users only - a line naming a group is reported, not added), and "Add resolved" adds the lines that resolved to exactly one user. Every member still runs the single-member path (per-row authorization, eligibility, protection, read-back, audit, affected-member notification), a per-row outcome table shows Done / Not done with the reason, and each batch writes one summary audit event (success only when every row succeeded) and one summary admin email
  • Section access key: SelfServiceGroups

M365 Group Management (/m365-group-management)

Create, modify, and delete Microsoft 365 groups via Graph API.

  • Full lifecycle management for M365 (Unified) groups
  • A ticket number is required before any create, update, delete or member/owner change runs: a blank one, or one ServiceNow rejects where that integration is enabled, is refused with an audited denial and nothing is sent to Graph
  • A member or owner is added by user principal name, object id, or address. An address that is not a UPN - a guest's own address, or a member's alias - is looked up by mail and proxyAddresses and must match exactly one user: none reads "not found" naming the address, several refuse with the count (sweep-d item 30)
  • Each user added or removed as a member or owner is checked for protection by the object id the write names - an add resolves it first (see "Entra users" under Security & Compliance); an object Graph holds no user for, such as a service principal owner, has no user to protect; a blank entry is refused
  • Requires: Graph app registration with Group.ReadWrite.All permission, and User.Read.All to resolve a typed name or address to its object id
  • Section access key: M365GroupManagement

Comms-10k (/comms-10k)

Dedicated bulk member replacement for broadcast distribution lists.

  • CSV upload of new member list
  • Resolves all entries before applying changes
  • Confirmation step stating the number of members the list will be set to. Not an add/remove diff: the write never reads the prior membership, so no removal count exists to show
  • Clear, then fill, then read back. The directory refuses a single-operation swap at this module's size, so the write empties the member attribute, adds the resolved list in batches of 2,000, and reports from a read-back of what the group actually holds -- never from which batches were believed to have run. This gives up atomicity: the list is briefly empty and then partial during the sequence (about eight seconds at ten thousand members), and a failure in that window leaves it empty or partial until a re-run. The module reports that state explicitly rather than as a generic failure (a failed add names the batch and the error), and re-running the same CSV repairs it. The order was briefly add-first and is back to clear-then-fill by owner ruling 2026-11-06: add-first was measured seven times slower on a full swap. Access is checked once, immediately before the clear, and the run then goes to completion; a permission removed mid-run applies to the next run (sweep-d item 20). Replaces are not serialised (owner ruling 2026-09-30): two run at the same time on the same group can interleave and leave the list holding neither uploaded file. Each run's read-back compares against its own list, so an interleaved run reports as incomplete rather than claiming success, and re-running one file on its own repairs it
  • Runs no protected-principal check of either kind -- see the Protected Principals section of docs/ProjectConstitution.md, which carries it as a named scoped exception
  • Uses Delinea credentials for Active Directory operations
  • Replacements run as durable background jobs. A separate Submitted notice confirms enqueue; Your jobs on this page shows all your active replacements and paged retained history, including job messages, ticket/times and recorded Resolve/Replace stage outcomes. A Completed job may contain failures or no recorded stages. Missing AD credentials do not hide history; current Comms-10k permission and enablement still gate access.
  • Request cancellation of your queued/running jobs or delete your finished job records. Cancellation cannot undo or abort an in-flight clear/refill. Deleting a record retains its audit history; job controls are scoped to your full signed-in identity and are audited.
  • Section access key: Comms10k

AD Attribute Editor (/ad-attribute-editor)

View and edit allowlisted Active Directory attributes for on-premises user accounts.

  • Tiered access control with three granular permission levels (Level1, Level2, Level3)
  • Configurable attribute allowlist, edited in the Editable Attributes table on the module's Module Configuration page and stored in the config database (editable_attribute; repairs per docs/ConfigDbOperations.md, with both application pools stopped). A legacy config/ad-editable-attributes.json is imported once and archived; one the import refuses is left in place and named, with its reason, on the Module Configuration page
  • Optional search base boundary restrictions (DefaultSearchBase, semicolon-separated; empty means no boundary). On the Module Configuration pane the field offers the OU browser, and Verify (docs/history/DirectoryObjectVerify-Plan.md A7, slice V4) reads each entry at its DN in its own domain: an OU, a container or a domain root is verified, nothing there is missing. Remove now takes that one semicolon entry out and keeps the others; removing the last one asks for a confirmation, because no search-base boundary will remain: the editor may then search the whole directory
  • Uses Delinea credentials for Active Directory operations
  • Choice attributes take extra choices and their descriptions from the legend in the config database (attribute_legend). A legend that cannot be read is logged as an error and the editor says, above the attribute table, that choices are missing; an attribute's own configured choices are still offered
  • A save is done when it reads back as written. The re-read before the write, the write and the read-back all go to one writable domain controller of the object's domain, located at the time of the save and confirmed by its RootDSE (logged) - never a read-only one, whose writes would all be refused. Each value is compared in the syntax the schema gives the attribute: a Boolean or an integer by its value, whatever form the directory returns it in; a DN by DN, whatever its case and spacing; text as text. A value that differs is still a failed save, with no Undo and a failure notice. If no writable DC can be confirmed, or the RootDSE or the schema cannot be read, the save goes to the domain name and judges by the values' own types, as before (a warning is logged)
  • Everything a save was allowed on is checked when it starts and again once the account has been re-read and verified, as the last thing before the write, against the operator as they are at that moment: the module permission, the level of the attributes actually being changed, and - for a protected account - the servicer grant. An operator who lost any of them meanwhile is refused: nothing is written, the refusal is recorded and nobody is mailed. An undo from the Event Log is checked the same way, on everything it was allowed on: the Event Log's own two permissions, the module still being enabled, the operator's level for the attributes being restored, and the servicer grant of a protected account
  • Section access keys: ADAttributeEditor, ADAttributeEditorLevel1, ADAttributeEditorLevel2, ADAttributeEditorLevel3

Licensing Updates (/licensing-updates)

Bulk update Exchange licensing SKU assignments (extensionAttribute11) via CSV upload.

  • CSV upload with validation against allowed license types
  • Configurable allowed license values (default: E5, EOP2+SOP2, F3, F3+EOP1)
  • Uses Delinea credentials for Active Directory operations
  • Section access key: LicensingUpdates

Conference Rooms (/conference-rooms)

Room mailbox metadata configuration and booking policy management.

  • Set room properties: city, building, capacity, floor label, timezone
  • Apply booking policy templates (the RoomType enum in Models/ConferenceRoomModels.cs):
    • Standard — Open auto-booking (AllBookInPolicy), 180-day window
    • Video — Like Standard plus a video-room additional response
    • Restricted — Delegate/group-gated booking (BookInPolicy), 180-day window, site-aware
    • Exception — Restricted to an exception group, 1080-day window
    • CEO — CEO-group only; always clears existing calendar permissions, 1080-day window
    • Executive — Exec VP/admin groups, 1080-day window
  • Where the room type tag is written. Applying a type writes the booking policy, calendar permissions and time zone in Exchange Online, then the tag RoomType:<type> (Exchange's CustomAttribute9). Where the tag goes is decided per room from what Exchange reported when the room was bound:
    • A room that is not synchronized from on-premises: the tag goes to Exchange Online with Set-Mailbox, together with the type's mail tip when the type has one. A type with no mail tip sends the tag alone; a mail tip the room holds that a room type set is then cleared by a Set-Mailbox of its own, so a clearing Exchange Online refuses fails that step only ("The room's mail tip was not cleared: ...") and the tag stays written. No clearing is sent for a room that holds no mail tip, or one no room type set. Nothing is asked on-premises and no AD credential is needed.
    • The mail tip a room already holds. One rule on both sides, decided from the tip read where it is written - Exchange Online for a room that is not synced, on-premises Exchange for a synced one. A type that has a mail tip sets it over whatever is there, and a different text it replaces is named: "The room's mail tip '' was replaced with ''." A type with no mail tip (Standard, Exception, CEO - and one whose mail tip setting is stored empty) clears the room's only when it is a room type's. Its text - without Exchange's html wrapper, white space collapsed - is recognised as one when it is a tip the settings produce now for some type at some site, one of the module's built-in texts ("This is a video conference room.", "Only exec admins may book this room."), or one of its built-in templates with any contact address in it ("This is a restricted room. Email for assistance with booking this room.", and the ADGT one, "... if you need assistance with booking this room."): a tip set under an earlier contact address is still recognised. "The room's mail tip '', one a room type sets, was cleared." Any other stays - one written by hand, or a text that was wholly a setting's (Restricted Room MailTip, Executive Room MailTip) and was changed since the room was given it, which cannot be recognised: "The room's mail tip '' was left in place: it does not match a mail tip the current room-type settings produce." A room whose mail tip Exchange did not report has none cleared, and the apply is Partial and says so. The module writes and clears the mail tip itself (-MailTip), which Exchange keeps as the default entry of the recipient's MailTipTranslations; translations for other languages are not ones a room type sets, so they are neither read nor cleared and can outlive a clear (Exchange's documented behaviour for the two properties, not verified against a live server). The text the room held is the audit row's old value (old_mailTip, beside new_mailTip and mailTipChange; see Audit below): on the apply's own row for a room that is not synced, on the on-premises mail tip row for a synced one. The Type CSV preview's MailTip column says for each row what will happen - Set, Replaced, Cleared, Left in place or None - from the tip Exchange Online shows; a synced room's is decided at apply from the one on-premises, and the column says that. A room whose sync state Exchange Online did not report has nothing planned: the column says so and the row carries a warning that the apply will refuse it.
    • A room synchronized from on-premises: Exchange Online cannot write the tag, so it is written on the room's Active Directory account - extensionAttribute9, with Set-ADUser under the module's AD credential, on the object the room was bound to by objectGUID, never on the address as typed. The object is found in whichever domain of the forest it lives in: the module's default domain is asked first and, when it answers that it holds no such object - and only then - the forest's global catalog (discovered from the forest itself) is asked for the same objectGUID. Any other failure of that first read (a controller that does not answer, a credential refused) refuses the apply, with nothing written. One writable domain controller of the object's own domain is located when the apply starts (by the DC locator, never named or configured) and confirmed writable by its own RootDSE, which must not report a read-only domain controller; the check before the write, the write and the read-back all go to that one controller, and the result names it. A located controller that does not answer for the object, or is not confirmed writable, is replaced once - while nothing has been written - by a freshly discovered different one, which must pass the same checks. If none can be located, or the replacement fails too or is the same controller, the apply is refused with "Nothing was written.", naming each. Once the write has been sent the controller is never swapped: if it stops answering after the write, the outcome is reported as not known - the domain's name is never asked in its place. Room Finder's City/State/Country write goes the same way: a row whose read-back could not be made reads "Whether City/State/Country were written on-premises is not known", is filed Undetermined and, in a job, is labelled UNKNOWN. A Room Finder row that stops at City/State/Country, or at the time zone, names what it did not go on to: "Not attempted after it: the time zone and working hours, adding the room to room list ''." The tag shows in Exchange Online after the next directory sync.
    • The mail tip of a synced room is written on-premises as well, through Exchange - Exchange Online refuses it for a synced mailbox, so nothing is sent there for it. It is set, or cleared, with Set-RemoteMailbox -MailTip in an on-premises Exchange session (OnPremExchange:ServerUri) opened with the module's one credential: the account behind AD Delinea Secret ID writes the room's AD attributes and, through on-premises Exchange, its mail tip, so it needs recipient rights there. The recipient is found by the objectGUID of the room's validated AD account, never by the address as typed, and on-premises Exchange is asked through the domain controller located for the domain that account lives in (-DomainController, the controller the tag is written through) - for the read that binds the recipient, the write and its read-back. An account in another domain of the forest is so asked for in its own domain, not in whichever one the session's recipient scope covers. When no recipient is found the result says where it was asked and names no remedy: whether the account is no Exchange recipient on-premises, or on-premises Exchange does not search its domain, is not known to the app. A room whose mailbox is in Exchange Online is a remote mailbox on-premises; where on-premises Exchange holds the room as a mailbox of its own, Set-Mailbox -MailTip is used instead - decided from what on-premises Exchange answers. The tip is written after the Exchange Online steps and before the tag, whether or not one of those steps failed: it is a notice to senders about the booking policy, which is in place by then. A type with no mail tip clears the tip the room holds on-premises when it is one a room type sets (the rule above); otherwise nothing is sent. It counts as written only when reading it back on-premises shows the text this apply sent (no tip, for a clear): "The mail tip was written on-premises (Set-RemoteMailbox), read back, and will show in Exchange Online after the next directory sync." An error on the write with a matching read-back is "read back as set". A read-back that does not show it, or could not be made, after a write on-premises Exchange accepted or one whose failure is not its answer, is "Whether the mail tip was written on-premises is not known: ... Check the room's mail tip on-premises before re-running.", filed Undetermined: a write that may have been made is never told as not written. Only a write on-premises Exchange refused, with the read-back showing what the room held before it, is "The mail tip was NOT written on-premises: ...". A refusal for missing rights says so, naming the cmdlet: "The module's account may not run Set-RemoteMailbox on on-premises Exchange: ...". A role that has the cmdlet without its DomainController parameter is told as that, for the read (Get-RemoteMailbox) and the write alike, with what to do: "The role the module's account holds on on-premises Exchange does not allow naming a domain controller on (its DomainController parameter): ... Give the account a management role in which has the DomainController parameter, then re-apply." The app does not ask again without the controller: a read that names none can be answered by a controller the write has not reached.
    • What refuses the whole apply, and what does not (synced room). The apply is refused, with its reason and "Nothing was written.", when the room's sync state was not read, the AD credential is not set or cannot be read, the room has no validated AD object, or that object does not answer by its objectGUID through a writable controller of its domain: the tag is the label of the configuration the Exchange Online steps write, so where it will be written is proven before any of them is sent. The mail tip refuses nothing. It needs on-premises Exchange - OnPremExchange:ServerUri set to an http or https address, a session that opens with the module's credential, and exactly one recipient (a remote mailbox or a mailbox) under the room's validated AD object. When any of that is wanting, the room's mail tip there could not be read, so the mail tip is not checked: nothing of it is read or written, and whether one was to be set, replaced or cleared is not known. The Exchange Online steps and the tag are written as for any synced room, and the result is Partial - never a success and never "nothing to clear", whatever Exchange Online shows - with a failed step "Mail tip on-premises": "The mail tip was not checked - it could not be read on-premises: Exchange Online currently shows ''; it can be behind. Re-apply once on-premises Exchange answers for the room." The sentence is the same whatever the cause, and names it: the server not configured, the session not opened, the recipient not found, ambiguous or not readable. The copy of the mail tip Exchange Online shows ("shows none" when it holds none, "did not report the room's mail tip either" when it did not say) is quoted as information only: it is a synced copy, can be behind what the room holds on-premises, and decides nothing. When the apply stops at an Exchange Online step instead, the result says "The mail tip was not attempted, because the Exchange Online changes did not complete, and was not read on-premises: ".
    • What the result says. Success only when the read-back shows the tag. A write the read-back does not show: "Configured as in Exchange Online. The room type was NOT written on-premises: ". A write whose read-back could not be made: "Whether the room type was written on-premises is not known", filed Undetermined. If the Exchange Online steps do not complete, the on-premises write is not started and the message says so. An apply that stops after Exchange Online took earlier writes is Partial, not Failed: "Partial: the Exchange Online changes stopped at : Written before that: ... Not written: ...". One that stops before anything was taken is Failed.
    • An Exchange Online write that was sent and whose failure is not Exchange Online's answer - the request timed out, failed in transit or was cancelled, or the failure shows neither an answer nor a failed transport, read by the app's one rule for it (see "What makes a result Undetermined") - is listed apart, "Outcome not known: ...", never under "Not written". The apply stops there and sends nothing more; the result is filed Undetermined, not Failed, and ends "Check the room in Exchange Online before re-running." Only a failure the rule reads as a refusal - an error from Exchange Online that names one, which the one refusal recorded from production does not - and the pre-flight error that proves no cmdlet ran stay "Not written"; a refusal the rule cannot recognise is listed "Outcome not known" too.
    • A calendar permission is sent as Set-MailboxFolderPermission first, as Calendar Permissions sends it. An entry that exists - Default and Anonymous always do - is set, and that rests on no refusal. A first grant does rest on one: Add-MailboxFolderPermission is sent only when Exchange Online answers the Set that the user holds no entry on the folder, and that answer is recognised narrowly, by the piece Calendar Permissions recognises it by - Exchange's own sentence ("There is no existing permission entry found for user: ...") or its error type (UserNotFoundInPermissionEntryException), and never beside a failure that says its session failed. The step then says "Granted by Add-MailboxFolderPermission: ...". If Exchange Online ever words that answer differently, no Add is sent and nothing more is written: the step says "Whether the permission was set is not known: ..." with what reading the permission back showed, the apply stops there and is filed Undetermined, and the grant has to be made in Exchange itself. One case is known to read so today: a grantee whose display name holds a full stop and a space followed by a word a dead session is told by ("Dr. Session Host"). Exchange Online's exact error for a Set on a user with no entry has not been recorded from production: it is a check to make on dev. Any other refusal of the Set is the permission's answer ("Set-MailboxFolderPermission was refused: ...") and no Add follows it; an Add that is refused keeps both commands' words. A Set or an Add that was sent and whose outcome is not known is read back (Get-MailboxFolderPermission -User). Its step says which of the two it was, in the app's two sentences for an unknown outcome, with the failure's words in brackets: "Exchange's answer to the command was not received (...)" when no answer came back, "the command failed with an error that does not show whether it took effect (...)" when an error did - never "not received" for an error that came back. In place at the rights asked for, the step adds that the read shows the permission, and the apply carries on to its end; otherwise the permission is not known, the step says what the read showed - the rights the user holds, or that the user holds no entry - and the apply stops there. The step of a room type tag, or of a mail tip's clearing, whose outcome is not known says the cause the same way. When that read fails for the user in words the app does not recognise, the folder itself is listed - a read that does not fail for an entry that is not there - and the step says that the folder was read, what Exchange Online answered for the user and whose entries the folder holds; only when the folder cannot be listed either, or the read for the user was not answered at all, does it say that reading the permission back failed.
    • One rule for the status. Failed only when nothing was written; Partial when something was written and something was not, on either side: "Partially configured as . N step(s) failed: ... Written in Exchange Online: ...". The on-premises tag is written last, and only when every Exchange Online step succeeded, so it never names a configuration that is not in place; otherwise the result says the tag was not written and why, and the apply is re-run. A mail tip that could not be written on-premises does not hold the tag back, and the mail tip is not held back by a failed Exchange Online step.
    • In a bulk job. A job keeps three counts - succeeded, partial, failed. A row with an outcome that is not known, on either side, is counted with the partial rows, is labelled UNKNOWN, and its message opens "Outcome unknown (counted as partial)."; the job's summary and its completion notice say how many of the partial rows are such rows, both counted from the job's recorded rows - so the notice of a job interrupted by a restart says it too. A row whose mail tip was not checked is a partial row like any other, and is not labelled UNKNOWN: nothing was sent for it.
    • Audit. Each on-premises write of a synced room has a row of its own under the same action (side = OnPremises, sideWrite = MailTip or RoomType, sideState), with writtenDirectoryObject only when the read-back showed the write, attemptedDirectoryObject when it was sent and not confirmed, and mutationAttempted false when nothing was sent. An apply with no mail tip to write or clear on-premises has no mail tip row; one whose mail tip on-premises Exchange did not report has a row saying none was cleared, with mutationAttempted false. An apply that could not read the room's mail tip on-premises has a mail tip row with sideState = NotRead, mutationAttempted false, mailTipChange = NotKnown and its reason in error, and no mail tip values: none was read there, and the copy Exchange Online shows is never recorded as the room's old value. The apply's own row carries the result's message, which says the same. The mail tip values (old_mailTip, new_mailTip) are the change as the apply planned it - a tip set on a room that held none records new_mailTip too - on whichever row the mail tip is written on, whatever became of it; mailTipChange beside them says what did: Made, NotMade (refused, withheld or never sent) or NotKnown (sent with its outcome not known, or not read on-premises). On the apply's own row writtenDirectoryObject is the tag's alone, so it is absent beside a tag withheld, not written or only confirmed in place; the account a synced room's mail tip was written on is named there as mailTipWrittenDirectoryObject.
  • CSV bulk upload for multi-room setup
  • Room list management (add/remove rooms from room lists). A room list Exchange reports as synchronized from on-premises takes a room's membership on its on-premises group (Set-ADGroup, proven before anything is written): the add is not sent to Exchange Online, which refuses a membership write on a synced group, so a Room Finder row never rests on that refusal being sent or on how it reads. A list not reported as synchronized is added to in Exchange Online; if Exchange Online refuses that add as on-prem-mastered all the same, the row says so and adds nothing on-prem.
  • Group settings (the arbiter, coordinator, admin, VP, CEO, exception and ADGT groups) are Exchange group addresses. Verify on the Module Configuration pane (docs/history/DirectoryObjectVerify-Plan.md A8, slice V4) looks each up through this module's Exchange session (Get-Recipient): one recipient that is a group is verified, Exchange's not-found is missing, any other kind of recipient is wrong type (a check Verify adds: the module passes the address on as it is), any other failure could not verify. Verify only reads, and adds no protected-principal check
  • Leaving the page during a single-room setup cancels it at its next step before Set-Place - the room read, the room list's resolution, a preflight's Active Directory step, or the wait for a free Exchange Online connection: nothing is written, and it is filed Cancelled, "Cancelled by the operator. Nothing was written.". Once Set-Place is sent the setup runs to its end, so the room is never left half-configured.
  • Cancelling a Room Finder job on the Bulk Jobs page stops the row in hand at the same steps: nothing is written for it, its audit entry is Cancelled, "Cancelled by the operator. Nothing was written.", under the submitter's name and ticket, and it is not listed among the job's row outcomes. A row already past Set-Place finishes and is recorded. A row stopped by the service shutting down is filed Failed, "The service stopped before this row was written. Nothing was written.".
  • No protected-principal check (owner ruling 2026-11-03): protected principals do not apply to this module, so a room the protection rules name is written like any other and no servicing option is offered. Every write is still bound to the room mailbox Exchange names - a RoomMailbox or RemoteRoomMailbox only - and, for a synced room, to the one Active Directory account holding its on-premises SID; a room that cannot be bound is refused and nothing is written.
  • Section access key: ConferenceRooms

Emergency Disable (/emergency-disable)

Rapidly disable a compromised user account across on-prem AD and Entra ID with session revocation.

  • Disables the AD account, resets its password and revokes Entra ID sessions in a single workflow; a cloud-only account is also disabled in Entra ID in the same run
  • Synced accounts: the cloud lags. For an account synced from on-premises, Entra ID takes the disabled state from AD at the next directory sync and refuses a direct write. Until that sync the cloud account stays enabled and sign-in remains possible (how long depends on the environment's sync; the app does not know it), and a session obtained in that window is not covered by the revoke made at the disable. Such a run is not shown as complete: the steps carry a SecondSignOut row marked OWED, the page shows a warning in place of the green banner, the audit log gets an EmergencyDisable_SecondSignOutOwed row beside the disable's own, and the security team and the administrators get a follow-up mail naming the account and what to do. A cloud-only account, and a synced account the cloud already showed disabled, owe nothing
  • Sign out again (on the result of such a disable, or after looking the account up later; needs a ticket): reads the cloud account's state and revokes its sessions again only when the cloud shows it disabled. While the cloud still shows it enabled, or the state cannot be read, nothing is revoked and the page says the second sign-out is still owed. Every run is audited: EmergencyDisable_SecondSignOut for a run that sent the revoke, and EmergencyDisable_SecondSignOut_Refused, naming the step, for one that sent none (a missing ticket, a protected account, an unavailable Graph secret, a cloud state that is still enabled or unreadable); a run that sent a revoke is mailed as a disable is. It runs under the module's permission, protected-principal check and Graph secret. Nothing runs it unattended: the app has no background worker, so the second sign-out is an operator's action
  • Notice on every disable action to the security team (NotifySecurityTeam) and to the administrators (Email:AdminNotificationEmail), both, one mail per address (sweep-d item 32). Either list may be comma- or semicolon-separated. A blank NotifySecurityTeam still warns, on the page and in the result, that the security team is not notified; the administrators are
  • Lockdown OU (LockdownOuDn, optional): the OU a disabled account is moved into, where delegation does not allow routine re-enablement; blank makes the step unavailable. The field offers the OU browser. Verify on the Module Configuration pane (docs/history/DirectoryObjectVerify-Plan.md A6, slice V4) checks it as the step does, with Get-ADOrganizationalUnit: an OU is verified; nothing there, or a container that is not an OU, is missing, because the step refuses both. Verify reads with the Directory Read Credential, so it proves the OU exists, not that this module's own account can reach it
  • Requires: AD Delinea secret for account disable and Graph Delinea secret for session revocation
  • Section access key: EmergencyDisable

Risky Users (/risky-users)

Review and act on Microsoft Entra ID Protection risky users via Microsoft Graph API.

  • Filtered read of risky users by risk level, risk state, and UPN contains. The module follows Graph's paging until the matching set is complete, up to MaxTotalRows (default 10000) across all pages; past it, the list shows what it retrieved and says it is partial, never silently cut off. MaxTotalRows is a new key on purpose: the older MaxRows meant page size, and is not read
  • Per-row risk history expander
  • Remediation sits behind the RiskyUsersRemediate granular permission, fail-closed like the main module permission. Each action is one Graph call per user, never a batch, so a refusal on one row cannot be reported as success or failure for another. Button wording is deliberately plainer than Microsoft's own vocabulary (owner ruling 2026-09-02, for L2 support desk staff), each with a tooltip and confirmation line stating the consequence before it commits:
    • Close as handled -- Graph's dismiss. Clears the alert; nothing is reported as right or wrong, and it can fire again
    • This was the real user -- Graph's confirmSafe. Clears the alert and tells the risk engine this activity is normal for them
    • Account was breached -- Graph's confirmCompromised. Raises the user to high risk; their sign-in is blocked or forced to reset their password, immediately
  • A ticket number is required before any remediation action runs
  • A protected-principal check runs before every write, on the risky user's Entra object id (see "Entra users" under Security & Compliance); the ProtectedServicer:RiskyUsers override applies
  • The remediate permission is checked when the action starts, again after the protected-principal check, and a last time once the app holds its Graph sign-in, as the final step before the request is sent; an operator who lost it meanwhile is refused, nothing is sent and the refusal is recorded
  • Every remediation action produces a named per-user outcome and an admin notification
  • Reads are audited but never alert-emailed (owner ruling 2026-08-31): a triage session that refreshes the list repeatedly does not generate an alert per refresh
  • Requires: Microsoft Entra ID P2, and a dedicated Graph app registration (admin-consented IdentityRiskyUser.Read.All for reads, plus IdentityRiskyUser.ReadWrite.All for remediation) with its own Delinea secret. Outstanding as of this writing -- blocks the first live Graph call, not the code
  • Section access key: RiskyUsers

Intune Devices (/intune-devices)

Search Microsoft Intune managed devices, view device detail, and delete, retire or wipe a device via Microsoft Graph API.

  • Search by device name, user principal name, or serial number, capped at 500 rows (SearchResultLimit, defaults to 50); a truncated result is shown as such, never silently cut off. Device name and UPN match from the start of the value (startswith); a serial number must be exact. Typing the middle of a device name finds nothing, which the search box says on screen. Intune does not support a substring (contains) filter on managed devices
  • Each search sends one Graph request per field and merges the three result sets by device id: a single filter combining the three properties with or returns an empty result on this tenant instead of matching. Any one of the three requests failing fails the whole search, and a device Graph returns that does not match the term is hidden with a count shown, never rendered as a match
  • What the actions do -- the same wording appears on the page in a collapsible "What do these actions do?" panel, closed by default, plus a tooltip on each button and the first two sentences above each confirmation's ticket box:
    • Delete record -- Removes the device from Intune only. Company data and apps stay on the device until it next checks in, and if it never checks in, they stay forever. The device's Entra ID entry is not touched. Use this to clean up a device that is already gone
    • Retire -- Tells the device to remove company data, apps and settings, and to leave Intune management. Personal data stays. Happens the next time the device checks in, which for a powered-off device may be never. Use this for a device leaving the company that the person keeps
    • Wipe -- Factory reset. Everything on the device is erased, personal and company, the next time it checks in. Cannot be undone. Use this for a lost, stolen, or reassigned device
    • Also remove Entra ID entry (checkbox) -- Also deletes the device's entry in Entra ID, which is separate from Intune. Do this only when the device is gone for good; a device still in use will lose its sign-in and may need to be re-joined
    • Email the user (checkbox) -- Sends the device's primary user a plain notice that the action was taken and which ticket authorized it
  • Full device detail, including compliance state, encryption state, and enrollment info; the activation lock bypass code is excluded at the request boundary and never rendered, audited, or logged
  • Three destructive actions at two permission tiers:
    • Delete (IntuneDevicesDelete) removes the Intune management record only. Company data stays on the device until its next check-in -- forever if it never checks in again -- and the device's Entra ID object survives
    • Retire and Wipe (IntuneDevicesPrivileged) queue the action at Intune; Graph returns 204 when the request is accepted, not when the device carries it out, so results read "queued", never "done". Every parameter Graph's wipe endpoint accepts (keep user data, keep enrollment state, macOS recovery PIN and obliteration behaviour, keep eSIM data plan) is an operator control, defaulting to a full reset
  • Optional removal of the device's Entra ID object (IntuneDevicesEntraDelete), offered beside each action and standalone, always starting unticked so it is opted into by the operator confirming the action. Addressed by its alternate key (azureADDeviceId), captured before the Intune action runs since a deleted Intune record cannot be read afterward; the Intune and Entra outcomes are reported and audited independently, so a half-finished result is never shown as a plain success
  • Per-action "email the affected user" checkbox, decided by the operator running the action rather than by a deployment-wide setting -- neither this nor the Entra removal is a Module Config field. The box starts from a fixed state per action (off for Delete, on for Retire and Wipe) and is changeable at the moment of acting, which is what the lost-or-stolen case needs; if the deployment has user notifications disabled app-wide, the suppression is stated on screen and recorded in the audit event rather than silently sending nothing
  • A protected-principal check runs before every write, against the device's primary user, with the ProtectedServicer:IntuneDevices override
  • The action's permission is checked when the action starts, again after the protected-principal check, and a last time once the app holds its Graph sign-in, as the final step before the request is sent; an operator who lost it meanwhile is refused, nothing is sent and the refusal is recorded. The Entra ID removal checks its own permission the same way, as the final step before its own request
  • A ticket number is required before any action runs
  • Requires: a dedicated Entra app registration, admin-consented, with DeviceManagementManagedDevices.Read.All, .ReadWrite.All, and .PrivilegedOperations.All, plus Device.ReadWrite.All for the Entra removal -- that last one is a directory scope covering every device object in the tenant, the widest grant in the module, worth weighing before consenting -- and its own Delinea secret. Outstanding as of this writing -- blocks the first live Graph call, not the code
  • Section access key: IntuneDevices

DHCP Authorization (/dhcp-authorization)

Authorize or deauthorize DHCP servers in Active Directory.

  • Authorize a server by IP/hostname to allow DHCP service in the domain
  • Deauthorize a server to revoke DHCP serving rights
  • Confirmation dialog (high-privilege operation)
  • Results can be downloaded as CSV (DnsName,IpAddress)
  • Requires: Module-specific Delinea secret (Enterprise Admin credentials)
  • Section access key: DhcpAuthorization

BitLocker Recovery (/bitlocker-recovery)

Look up BitLocker recovery keys for a caller locked out at the pre-boot screen. Read-only: the module never writes to Active Directory or to the archive. Disabled by default and fail-closed, because a recovery key decrypts a whole disk.

  • Search by computer name fragment, full key ID GUID, short key ID prefix, or a pasted 48-digit recovery key. The key ID and recovery key are the only identifiers that survive a machine rename or reimage
  • Reads a local SQLite archive written by the scheduled Export-BitLockerKey.ps1 task. Deleting a computer object from AD deletes its msFVE-RecoveryInformation children, so for retired hardware the archive is the only surviving copy
  • Optionally also searches live Active Directory, for a key created since the latest export. Noticeably slower, so it is off by default
  • A ticket number is required before any search runs. It is written on the search and reveal audit events (and the Event Log CSV Ticket column), and the ValidateTickets module switch controls whether it is merely required (default) or validated against ServiceNow -- On while that integration is dormant refuses every search rather than silently validating nothing
  • Results are masked until an operator reveals one. The reveal is the audited security event, not the search; the recovery key itself never enters an audit record, log line, or error message
  • An unreachable source is an error, never an empty result: on a recovery call "no key exists" and "I could not look" must not look alike. If live AD fails but the archive succeeds, archive rows are shown with a warning
  • Results can be downloaded as CSV (Computer,RecoveryKey,Created,KeyId,Source,LastSeenInAd,Ticket), with the recovery keys included in the file -- the export's whole purpose is bulk key retrieval. The download is itself an audited disclosure event (ExportRecoveryKeysCsv, recording the search ticket and row count), and as with every other BitLocker audit event the key material itself never enters the audit log
  • Requires: ArchiveDatabasePath pointing at a local path (SQLite WAL needs shared memory that SMB does not provide, so UNC paths are refused). Live AD fallback additionally needs a module-specific Delinea secret for an account that can read msFVE-RecoveryPassword, plus the ActiveDirectory PowerShell module on the web server
  • Active Directory Search Base (optional): one DN that live searches start at; the field offers the OU browser. Verify on the Module Configuration pane (docs/history/DirectoryObjectVerify-Plan.md A7, slice V4) reads it at its DN in its own domain: any object there - an OU, a container or a domain root - is verified, nothing is missing. Verify reads with the Directory Read Credential, so it proves the object exists, not that this module's own account, against its configured server, can reach it
  • Section access key: BitLockerRecovery
  • Full operator and maintainer notes: docs/BitLockerRecovery.md

Named Locations (/named-locations)

Manage Entra ID Conditional Access named locations via Microsoft Graph API.

  • Create, edit, and delete IP range locations (IPv4/IPv6 CIDR)
  • Create, edit, and delete country/region locations
  • Mark locations as trusted
  • A ticket number is required before any create, edit or delete runs: a blank one, or one ServiceNow rejects where that integration is enabled, is refused with an audited denial and nothing is sent to Graph
  • Full pagination support for large tenants
  • Results can be downloaded as CSV (Name,Type,Trusted,IpRanges,CountryCodes,IncludeUnknownCountries,Created,Modified)
  • Requires: Graph app registration with Policy.ReadWrite.ConditionalAccess permission
  • Section access key: NamedLocations

Account Lockout Remediation (/account-lockout-remediation)

Identify the source machine of an account lockout and log the affected accounts off the implicated or scoped domain computers. Disabled by default; both permissions fail-closed.

  • Discover lockout sources from Security 4740 events on the PDC Emulator (or named DCs)
  • Log selected accounts off the implicated source machines
  • Scoped sweep: log accounts off every machine in an OU/computer list (with a MaxSweepTargets cap and a WinRM fan-out throttle)
  • Dry-run by default; execution requires a ticket number and typed "LOG OFF" confirmation
  • An execute request is checked for its ticket and for the Logoff permission before any credential is fetched or directory read. Administrators are mailed for every execute request - one refused for the permission included - except one refused for a missing ticket; a dry run mails nobody
  • Targets are re-resolved through Protected Principals with an immutable-GUID re-check immediately before logoff; all paths audited and traced
  • Granular Logoff permission gates execution separately from Access
  • Requires: module-scoped AD credential (DelineaSecretId) with rights to read lockout events, query sessions, and log off sessions; WinRM to target machines
  • Section access keys: AccountLockoutRemediation, AccountLockoutRemediationLogoff

Blocked Senders (/blocked-senders)

View and unblock Exchange Online accounts blocked from sending mail for outbound spam.

  • Lists all currently blocked senders with reason and blocked date
  • Unblock a sender; the target is re-checked through the protected-principal check before the unblock runs
  • The unblock permission is checked when the unblock starts, again after the protected-principal check, and a last time once the app holds its Exchange Online connection - waiting for one can take minutes - as the final step before the unblock command is sent, and again if that connection proves dead and a fresh one is used; an operator who lost it meanwhile is refused, nothing is sent and the refusal is recorded
  • A configurable protected-principal servicer group can be granted access to unblock otherwise-protected senders for this module only (see Protected Users / Excluded Users)
  • Results can be downloaded as CSV (SenderAddress,Reason,Blocked)
  • Requires: Exchange Online connection (no module-specific Delinea secret)
  • Section access key: BlockedSenders (granular: BlockedSendersUnblock)

Defender for Endpoint Devices (/defender-endpoint-devices)

List and export Microsoft Defender for Endpoint devices, including the devices Defender has discovered on the network that can be onboarded and are not. Read-only: the module cannot onboard, isolate, scan or offboard anything, and the app registration behind it holds no permission that could. Disabled by default and fail-closed.

  • Filters on onboarding status (defaults to "can be onboarded") and a Windows-only toggle. The Windows rule is applied client-side after the fetch: osPlatform carries Windows10, Windows11 and the server variants as separate values, so there is no single server-side "Windows" filter to ask for
  • A run returns the complete matching set or it refuses in words. No table and no export button when completeness cannot be proved: more devices match than MaxDevices (default 20000), the API returned exactly the page it was asked for with no continuation link, or any request in the chain failed. A partial CSV that looks whole is the one output this module must never produce. A 404 on the first request is the documented empty inventory, not a failure
  • Discovery sources, device type, category, vendor and model come from a second call: one constant DeviceInfo advanced hunting query on Microsoft Graph. Its failure never takes the page down -- those five columns read (unavailable) with the reason named above the table, never merely blank. A 429 (the tenant's hunting quota) is waited out once per load when Microsoft Graph's Retry-After asks for a minute or less; a second 429, or one with no or a longer Retry-After, stops the hunting there and the reason says how many devices were not queried (sweep-d item 31). 401 and 403 stop it at once, as before
  • The detail panel renders from the row the list already returned. The module never calls get-machine-by-id, which Microsoft documents only under Machine.ReadWrite.All
  • Results can be downloaded as CSV (27 columns: device identity and DNS name, OS, health, IP and MAC addresses, first/last seen in UTC, risk and exposure, machine tags and group, Entra join state, and the five discovery columns), audited with the row count
  • Requires: a module-specific Delinea secret holding Tenant ID, Application ID and Client Secret for an app registration with Machine.Read.All on WindowsDefenderATP and, for discovery sources, ThreatHunting.Read.All on Microsoft Graph. Both need admin consent, and the Graph one must be consented by a Privileged Role Administrator or Global Administrator. No redirect URI; a client secret, not a certificate
  • Section access key: DefenderEndpointDevices
  • Full operator and maintainer notes, including the app-registration steps and the manual validation checklist that has not yet been run: docs/DefenderEndpointDevices.md

True Last Logon (/true-last-logon)

When one account really last logged on: every domain controller is asked, together with the Entra ID sign-in logs, and the answer says how far it can be trusted.

  • Requires, for the cloud half: a Graph app registration holding both AuditLog.Read.All and User.Read.All (User.ReadBasic.All is not enough), in the module's Graph App Delinea Secret ID. AuditLog.Read.All is used nowhere else in this app, so an existing module's registration is unlikely to carry it, and consenting it needs a Privileged Role Administrator or Global Administrator
  • With no secret set, the cloud half reports itself as not checked; it never reports the account as dormant
  • Read-only; section access key: TrueLastLogon. Plan: docs/TrueLastLogon-Plan.md

Security & Compliance

  • Windows Authentication — Seamless SSO with Active Directory
  • Group-based Authorization — Restrict access to specific AD groups per module
  • Self-grant Prevention — Users cannot grant themselves permissions
    • Mailbox Permissions and Calendar Permissions check the grantee against Exchange Online and the on-premises directory, including every group that holds the operator - nested, through their primary group, or, for a group only Exchange Online holds, through its members. A check that cannot be completed refuses; it never clears a grant
    • A grant to a group the operator is in is refused too - it would grant them - and the refusal and its audit row name the group and how they are in it: directly, through the nested groups between (innermost first), or through their primary group. When the membership is confirmed but the groups between cannot be read, the refusal says so
    • A grantee typed DOMAIN\name is the account of that domain only, the same object a write is bound to: an account of the operator's name in another domain of the forest is not the operator. The domain half (NetBIOS or DNS name) is read against the forest's own domains for every grantee typed that way, whoever it names, before anything else is compared. A domain the forest does not hold - a trailing dot, an alias, a domain of another forest - refuses the grant ("... is not an account of this forest: the forest holds no domain named ..."): the checks can examine only an account or group of this forest, so an account of a trusted forest cannot be granted to here; name a grantee of this forest by an address or by its own domain. A domain that cannot be read refuses the grant as incomplete. The operator's own account under either name of their domain is refused as a self-grant, told from their account's own sAMAccountName, whatever name they signed in with. The string is read as a name once, for every check: white space round it is not part of it, and a backslash that separates no well-formed domain and name (a half missing, white space beside the backslash, a control character) is refused as malformed before anything is asked
    • Needs the Directory Read Credential (Admin Settings, Protected principals) - the credential the protected-principal check reads with. While the check is on (Prevent Self-Grant, the default), every grant needs it: without it, every grant is refused as incomplete, naming the setting - to a person or to a group, whichever directory holds the grantee - and nothing is written. A removal is not checked, so the check never needs it for one; a removal whose grantee is bound in the on-premises directory - any on an on-premises mailbox, and Send As on a synced one - needs it for that binding (see "The grantee a permission write names"). With it configured, each check fetches it once (a bulk file once for the whole file)
    • Needs the Graph Directory Read Credential (Admin Settings, Protected principals, beside the Directory Read Credential) for a synced mailbox - the Secret Server secret (Tenant ID, Application ID, Client Secret) of an app registration holding the application permissions User.Read.All and Group.Read.All (the second is read only to bind a synced group named as a Send As grantee). The protection check reads the mailbox's on-premises SID (onPremisesSecurityIdentifier) from Microsoft Graph with it and checks the one Active Directory account holding that SID, read at a global catalog, so a mailbox in another domain resolves and an account that only carries the mailbox's address is never the one checked. Empty until an admin fills it, with no fallback: while it is empty, or Graph cannot be read, every protection-checked change to a synced mailbox (Mailbox Permissions, Calendar Permissions, Out of Office, Conference Rooms) is refused as unavailable, and so is every protection check of a synced recipient Active Directory does not find by what was typed - an alias, or an account in another domain of the forest, by any of its addresses (Blocked Senders included) - never re-resolved by its address, which another account could carry. Cloud-only mailboxes do not need it; a synced mailbox Graph reports no SID for is checked by its address and logged ("bound by address")
    • Entra users - MFA Reset, Risky Users, Intune Devices (the device's primary user), Microsoft 365 group members and owners, Cloud Password Reset - are checked by the object id the write touches: Graph is asked for that user's on-premises SID with the Graph Directory Read Credential, and the account holding it is checked in whichever domain of the forest holds it. A cloud-only user is checked by its address and object id. While the credential is empty or Graph cannot be read, or Graph reports the user synced but gives no SID, every such write is refused as unavailable, cloud-only users included
    • A dynamic distribution group is checked against the members Exchange Online last calculated for it - Exchange refreshes them about every 24 hours, and within about two hours of a change to the group's filter - so a recipient its filter matches only since then is not compared. One Exchange reports no member of is refused as incomplete, naming it: an empty calculated membership cannot be told from one Exchange has not calculated yet
  • Protected User Lists — Block modifications to C-suite/executive mailboxes (with AD group expansion)
  • Audit Logging — JSONL format logs with full operation details (always active)
  • Extended Diagnostic Logging — Configurable log level (None/Error/Warning/Info/Debug) with separate log file, viewable in Event Log page
  • Email Notifications — Admin notifications on all operations, optional user notifications
  • Fail-closed Design — Corrupt config or credential failures block operations rather than bypassing security

Requirements

Server Prerequisites

  • Windows Server 2016+ (IIS with Windows Authentication)
  • .NET 10 SDK and ASP.NET Core 10 Runtime (Windows Hosting Bundle)
  • PowerShell 7.4+
  • ExchangeOnlineManagement PowerShell Module (v3.7.0+ required for Get-MessageTraceV2)
  • No SQLite tooling. The deploy/promote/installer scripts make the verified, consistent online backup of the runtime config database (the shared exchangeadmin.db, see "Shared config database" below) by running the app's own db command-line mode through <ProgramFiles>\dotnet\dotnet.exe, using the build they are about to deploy. The scripts fail fast if that build is missing or predates the db mode (app 2.34.0) rather than fall back to an unverified file copy. sqlite3.exe is not used by any script. The sqlite3 shell is only needed for the manual ad-hoc SQL and .recover recipes in docs/ConfigDbOperations.md, which says how to install it safely.

Exchange Online Prerequisites

  • Azure App Registration with:
    • Exchange.ManageAsApp API permission (application permission, admin consented)
    • Certificate authentication configured
    • Service principal assigned Exchange Administrator role or scoped RBAC role
  • Certificate installed in server's certificate store (LocalMachine\My or CurrentUser\My)
    • Must match CertificateSubject in appsettings.json
    • Private key must be accessible to IIS app pool identity

Active Directory

  • AD Security Groups for authorization (e.g., IT-Helpdesk, Exchange-Admins)
  • Users must be authenticated via Windows Authentication (domain-joined)
  • ActiveDirectory PowerShell Module (RSAT-AD-PowerShell) required for migration eligibility checks
  • IIS App Pool Identity must have AD read permissions to query user group memberships
    • The deployment script requires -ServiceAccount on fresh install (prompts interactively if omitted); on upgrade it retains the existing app pool identity
    • Configure IIS manually if using ApplicationPoolIdentity or a gMSA instead

Installation

1. Install Prerequisites

Install .NET 10:

# Download and install .NET 10 SDK
# https://dotnet.microsoft.com/download/dotnet/10.0

# Download and install ASP.NET Core Windows Hosting Bundle
# https://dotnet.microsoft.com/download/dotnet/10.0

Install IIS Features:

Enable-WindowsOptionalFeature -Online -FeatureName IIS-WebServer -All
Enable-WindowsOptionalFeature -Online -FeatureName IIS-WindowsAuthentication -All
Enable-WindowsOptionalFeature -Online -FeatureName IIS-ASPNET45 -All

Install PowerShell Modules:

# Exchange Online Management module
Install-Module -Name ExchangeOnlineManagement -Force -AllowClobber -Scope AllUsers

# Active Directory module (required for migration eligibility checks)
Install-WindowsFeature RSAT-AD-PowerShell

2. Configure Exchange Online App Registration

  1. Create Azure App Registration with certificate authentication
  2. Grant Exchange.ManageAsApp API permission (admin consent required)
  3. Assign service principal Exchange Administrator role in Entra ID
  4. Install certificate on web server

3. Configure Application Settings

Copy appsettings.json.sample to appsettings.json and configure:

{
  "ExchangeOnline": {
    "AppId": "your-app-id-here",
    "Organization": "yourorg.onmicrosoft.com",
    "CertificateSubject": "CN=EXO-Automation"
  },
  "Audit": {
    "LogRoot": "D:\\Logs\\ExchangeAdminWeb",
    "RotationPeriod": "daily",
    "MaxFileMB": 50,
    "MaxFilesPerPeriod": 5
  },
  "OperationTrace": {
    "Enabled": true
  },
  "Email": {
    "SmtpHost": "smtp.yourcompany.com",
    "SmtpPort": 25,
    "SmtpUseSsl": false,
    "FromAddress": "exchangeadmin@yourcompany.com",
    "FromName": "Exchange Admin",
    "AdminNotificationEmail": "itadmin@yourcompany.com",
    "NotifyUsersOnPermissionGrant": false
  },
  "Security": {
    "AllowedGroups": [
      "DOMAIN\\IT-Helpdesk",
      "DOMAIN\\Exchange-Admins",
      "DOMAIN\\Migration-Team"
    ],
    "AdminGroups": [
      "DOMAIN\\Exchange-Admins"
    ]
  }
}

Important: appsettings.json is excluded from git for security. Never commit production credentials.

Required: Audit:LogRoot must be set to an absolute path outside the deploy folder (the app deploys to D:\inetpub\<app name>, which is the content root; logs must not live under it or under wwwroot). There is no baked-in default: the app will not start if Audit:LogRoot is unset or blank, so audit logs are never silently misplaced. Each environment sets its own value.

Number settings and the trace switch: Audit:MaxFileMB (default 50), Audit:MaxFileBytes (not set), Audit:MaxFilesPerPeriod (5), ExtendedLog:MaxFileMB (10), ExtendedLog:MaxFileBytes (not set), ExtendedLog:MaxFilesPerDay (5), Email:SmtpPort (25), BulkJobs:StaleHeartbeatMinutes (5), BulkJobs:RecentJobLimit (25) and BulkJobs:RetentionDays (30) take a number, and OperationTrace:Enabled (true) takes true or false. Left out or blank, each is its default. A value that cannot be read - 50MB, five, yes - is logged once as a warning naming the setting and the value, and is read as the default until it is corrected; a MaxFileBytes that cannot be read is not set, so its MaxFileMB applies. Before, such a value stopped the audit and trace writer, the trace, the extended log, the mail service or the bulk job runner from being built: every page that needs one failed, and for the job runner the app did not start.

The three bulk-job settings also have a range, and a number outside it is read as the default and named the same way: BulkJobs:StaleHeartbeatMinutes 1 to 1440 (a minute to a day before a running job with no heartbeat shows as Stalled), BulkJobs:RecentJobLimit 1 to 1000 (finished jobs listed) and BulkJobs:RetentionDays 1 to 3650 (a day to ten years of finished job records kept). Before, any finite number was taken: a very large one threw out of the runner's constructor so the app did not start, a negative or zero retention made the start-up prune delete every finished job record, and a negative limit became no limit at all.

4. Deploy to IIS

Generic / new environments — use the standalone product installer in elevated PowerShell. It is environment-neutral, prompts for environment-specific values, and preserves existing appsettings.json and config/ fragments on update:

.\tools\Install-ExchangeAdminWeb.ps1            # interactive fresh install or update
.\tools\Install-ExchangeAdminWeb.ps1 -PlanOnly  # dry run, no changes

-NarrowPublishAcl (opt-in; validate on dev first) replaces the publish folder's ACL: inheritance removed, and exactly Administrators and SYSTEM Full control plus the app pool identity Read and execute; logs\ and config\ keep Modify. It reads the ACL back and refuses if anyone else can still change the code there. -PlanOnly prints the intended ACL.

ADI environment only — deploy.ps1 is the ADI-specific deployment helper (it targets ADI aliases/app pools and the ExchangeAdminWebDev dev path). Do not use it in other environments; it is intentionally separate from the standalone installer.

.\deploy.ps1
.\deploy.ps1 -PlanOnly   # elevated: prints every step, runs only the reads, changes nothing

-PlanOnly means the same in each ops script: every step is printed, and the read-only checks the real run makes before it stops anything are made and their answers printed - the IIS application and pool lookups, which pool serves the folder (Assert-AppPoolServesPath), the other applications the pool serves, the config database's path and the db tool's folder check (the app folder, what is in it, and every folder above it up to the drive root: docs/ConfigDbOperations.md, "Who can change the app folder"). A refusal one of those checks would make - a read that fails included, such as the pool's identity or an appsettings.json that cannot be parsed - is printed, marked ! and counted, and the plan goes on; nothing is published, backed up, configured, stopped, copied or written. deploy-pipeline.ps1 -Dev -PlanOnly runs deploy.ps1 -PlanOnly; the promotion's dry run makes its IIS checks before the stop; a cutover plan on a host already cut over prints the shared database check's answer and still makes the IIS checks. Run plans elevated: without elevation, or without the IIS: drive, a plan says which IIS checks it did not run.

On the ADI host the entry point is tools\deploy-pipeline.ps1 (elevated): -Dev builds and deploys dev through deploy.ps1, -Prod promotes dev's build to prod without rebuilding. -Prod refuses a stale dev - one built from a commit whose build inputs differ from HEAD's. A commit that touches only .agents/, docs/, Markdown files or tests/ps/ does not make dev stale, and with -PlanOnly a stale dev is a warning, so the dry run still prints.

deploy.ps1 updates in place when the publish folder already holds appsettings.json. -Force (which regenerates appsettings.json) and -ConfirmFreshInstall take the fresh-install path, which points the IIS application at the run's -PublishPath and -AppPoolName: if the application already exists with another folder or pool, the run is refused before anything is configured, unless -AllowRepoint says the move is intended. An upgrade is checked the same way, before it configures the pool or grants any folder access, and is refused, -AllowRepoint or not: an upgrade never moves the application. A -AllowRepoint move to another folder takes its backups from the folder the application is leaving and carries that configuration's ConfigStore:Path into the new appsettings.json; it is refused if that folder keeps its own config database (move the database to a shared path first with tools\Move-ConfigDbToShared.ps1).

The deploy/install scripts will:

  • Stop the application pool
  • Build and publish the application
  • Create/configure the IIS application pool
  • Create the web application under Default Web Site
  • Enable Windows Authentication and disable Anonymous Authentication
  • Grant app pool access to certificate private key
  • Grant app pool write access to audit log folder
  • Restart the application pool

Every script that takes the verified config-database backup runs the app's own db mode elevated from the publish or staging folder, and refuses to when anyone but the administrators, SYSTEM, TrustedInstaller or the account running it can change that folder's code, or can replace the folder through any folder above it up to the drive root (it names the grant and the folder; a plan prints the verdict instead). See docs/ConfigDbOperations.md, "Who can change the app folder", for what is checked and how to narrow a folder.

Before each pool stop the scripts ask IIS which pool serves the folder about to be replaced (Assert-AppPoolServesPath in tools\AppPoolControl.psm1) and refuse unless it is the named pool alone. A site, application or virtual directory IIS cannot read refuses when it could reach that folder - its own path at, inside or above it, a path that cannot be placed, or the named pool - and so does any site or application whose applications or virtual directories cannot be read, wherever it is (rev-f2): one of those could point into the folder. The refusal names the node and the read that failed (another team's site with a missing root virtual directory, say); fix it in IIS and retry.

A stop is confirmed, not assumed: the scripts poll IIS until the pool reports Stopped. They wait 60 seconds, and past that as long as IIS lets the worker exit - the pool's processModel.shutdownTimeLimit (90 seconds unless changed) plus 30 seconds - before refusing. The promotion restarts prod on every failure after it asked prod to stop, a stop that never confirmed included; it rolls back only once the mirror has started. deploy.ps1 still leaves its pool stopped after a failed mirror (cdt-16): it keeps no copy of the previous build to roll back to, and starting the pool would serve a mix of old and new files.

Default URL: http://yourserver/ExchangeAdminWeb

Shared config database (dev and prod on one server)

All runtime settings that admins change in the app (which modules are on, who can see which section, module settings, protected principals, editable attributes) live in one SQLite file, exchangeadmin.db. When a server hosts both a dev and a prod instance, they open the same file: each instance's appsettings.json names it under ConfigStore:Path (on the ADI host: D:\inetpub\ExchangeAdminWebShared\config\exchangeadmin.db). What this means day to day:

  • A setting saved on dev is live on prod within a couple of seconds. Dev is not a place to try a setting first; there is one set of settings, on purpose.
  • Promotion copies binaries only. It never copies, replaces or merges the config database, and its rollback never restores the database either (that would undo dev's changes too). Every deploy of either instance first takes a verified backup of the shared file into <LogRoot>\ExchangeAdminWeb\ConfigBackups\config.<timestamp>.bak\.
  • New database tables reach prod through the shared file: whichever instance starts first adds them, and the other accepts a database newer than itself. Schema changes are therefore additive-only.
  • If ConfigStore:Path names a file that does not exist, the app refuses to start and the deploy/promote scripts stop before changing anything. Nothing ever creates the shared database silently.
  • The bulk-job database (config\exchangeadmin-jobs.db) stays per instance.

A single instance without ConfigStore:Path keeps using its own config\exchangeadmin.db, created on first start, exactly as before.

Moving to the shared file (one-time, elevated, both instances already on a build that accepts a newer database - 2.19.0 or later):

.\tools\Move-ConfigDbToShared.ps1 -PlanOnly   # prints the eight steps, changes nothing
.\tools\Move-ConfigDbToShared.ps1 -Apply      # stops both pools, backs up both databases,
                                              # copies dev's to the shared path, writes the key
                                              # into both appsettings.json, starts both pools

Dev's database becomes the shared one (prod's only ever held copies of it). The script prints the commands that return to two databases, both after success and on any failure. A new instance that should join an existing shared database is installed with .\tools\Install-ExchangeAdminWeb.ps1 -ConfigStorePath <path>; the file must already exist.

Shared log root (dev and prod on one server)

Two instances on one server may write under the same Audit:LogRoot; the ADI deploy scripts default both to one root. They then append to the same daily audit, trace and extended diagnostic files. That is safe only because every writer serialises across processes:

  • Before it touches a log file, each writer takes that file's lock: <file>.lock beside it, opened exclusively. The open handle is the lock, not the file. After the write the file is removed if the folder allows it, and otherwise left in place, empty and harmless.
  • It holds the lock through rotation, the write, and the take-back of a write that fails part-way.
  • A write that cannot take the lock within 2 seconds, because the other instance holds it, is dropped and logged as a failed audit write: its trace step says the row was not written. It is never written over the other instance's row.
  • A lock file the folder refuses - this instance's account may not create it, or may not read and write the one already there - is not a wait. The write is dropped at once and logged as a failed audit write, and the error says the log folder refused the lock file.
  • The lock is the file system's, so it holds whichever account each app pool runs as.
  • Readers never take it, and a .lock file is not a log.

What you need to do:

  • Give each instance's account these rights on <LogRoot>\ExchangeAdminWeb: create files, and read and write the files there - the other instance's too, its log files and lock files alike. The lock does not need delete, but rotation does: without it, a file that reaches its size limit cannot be rotated. The writes to it still land, in that file past its limit, and the failure is logged as a warning (see Rotation below). deploy.ps1 and the installer grant each instance Modify on the folder, which covers all of it.
  • Both instances must run the same build. A build older than the lock writes without it, and while one does, the two can still overwrite each other's rows. The first build with the lock also needs delete rights to open a lock file that is already there.
  • To avoid the question altogether, give each instance its own Audit:LogRoot. That is a deploy-config change: -LogRoot on deploy.ps1 and tools/deploy-pipeline.ps1, or the installer's prompt.

5. Configure IIS Windows Authentication (if needed)

The deploy script configures Windows Authentication automatically. If authentication issues occur:

# Ensure only NTLM provider is enabled
Import-Module WebAdministration
Clear-WebConfiguration -Filter '/system.webServer/security/authentication/windowsAuthentication/providers' -PSPath 'IIS:\' -Location 'Default Web Site/ExchangeAdminWeb'
Add-WebConfigurationProperty -Filter '/system.webServer/security/authentication/windowsAuthentication/providers' -Name '.' -Value @{value='NTLM'} -PSPath 'IIS:\' -Location 'Default Web Site/ExchangeAdminWeb'
Set-WebConfigurationProperty -Filter '/system.webServer/security/authentication/windowsAuthentication' -Name 'useAppPoolCredentials' -Value 'True' -PSPath 'IIS:\' -Location 'Default Web Site/ExchangeAdminWeb'

Architecture

  • EXO Connection Pool: 5 pooled PowerShell runspaces for Exchange Online operations; connections idle longer than 20 minutes are automatically recycled. A call whose caller has cancelled - the operator leaving the page - stops waiting for a free connection (up to two minutes) or for its turn to connect (up to ninety seconds) at once, and gives back a connection it has not used yet. No command already sent to Exchange is ever stopped: it runs to its end. A connection whose command was ever stopped is discarded, never lent to the next caller.
  • Bulk CSV Optimization: Bulk operations borrow a single pooled session for the entire batch (not per-row), reducing 50-row CSV processing from minutes to seconds.
  • On-Prem Throttle: On-premises Exchange operations limited to 2 concurrent PSSession connections with retry (3 attempts, exponential backoff). The on-premises work that takes the operator's cancel - Recipient Lookup's reads, the permission pages' mailbox location read, both permission pages' on-premises changes and Message Analysis' on-premises search and detail - stops waiting for one of the two (up to two minutes) at once, and looks at the cancel again as the session opens, before each connect attempt, during the pause between attempts, between its reads and, for a change, immediately before its first command is sent; a connect attempt or a command already sent runs to its end, and the session is still removed.
  • Blazor Server: Interactive Server rendering mode with per-circuit state.
  • Leaving a page while work runs: the app asks first, and the prompt says what leaving does to each operation still running. Work that takes the cancel - today Recipient Lookup's lookup, a single Mailbox or Calendar Permissions change, an on-premises Mailbox or Calendar Permissions change, a Conference Rooms single-room setup, a Message Analysis search, delivery detail or detail download, and a Blocked Senders unblock - is cancelled on OK, and the prompt says what that does: work still waiting its turn is cancelled; a command already sent to Exchange or the directory finishes and is recorded, and anything already changed stays changed; a bulk job is not affected, because it never depended on the page. For any other work it says "Leaving will not stop the operation in progress; it will complete and be recorded."
  • Audit + Operation Trace: Append-only JSONL files rotated daily/weekly/monthly; every audit transaction includes a correlated operationId plus structured operation.* records for SIEM ingestion.
  • Extended Logging: Separate JSONL diagnostic log with runtime-configurable level (Admin Settings). Viewable from Event Log page.
  • Credential Management: Delinea Secret Server SDK auth via Windows PasswordVault. Per-module secrets isolated in Secret Server.
  • Thread Safety: PermissionValidator uses immutable collections with atomic swap; SectionAccessService uses in-memory cache invalidated on save.

Configuration Details

Group-Based Authorization

Each module is gated by its own section access groups. Security:AllowedGroups is only a backward-compatibility fallback for modules that are not fail-closed while section access has never been saved to the config database and no legacy Security:SectionAccess block exists:

"AllowedGroups": [
  "DOMAIN\\IT-Helpdesk",
  "DOMAIN\\Exchange-Admins",
  "DOMAIN\\Migration-Team"
]
  • Groups are checked using Windows role claims
  • Both simple names (IT-Helpdesk) and domain-qualified names (DOMAIN\IT-Helpdesk) are supported
  • Once section access is configured, the section's groups are the gate; users do not also need to be in AllowedGroups
  • Fail-closed modules deny access until explicit section access groups are configured

Admin Groups

Members of Security:AdminGroups can access Admin Settings. Admin Event Log is controlled by its own EventLog section access policy:

"AdminGroups": ["DOMAIN\\Exchange-Admins"]
  • Empty or missing = Admin Settings is inaccessible to everyone (fail-closed).

Section-Level Access (SectionAccess)

Each application feature is independently gated by AD group membership via its section access groups, managed on each module's config page (/module-config/{ModuleId}) and stored, as group SIDs, in the section_access table of the config database (docs/ConfigDbOperations.md). Until the first save, the legacy Security:SectionAccess block in appsettings.json applies, in this shape:

"SectionAccess": {
  "MailboxPermissions": ["DOMAIN\\Exchange-Admins"],
  "CalendarPermissions": ["DOMAIN\\Exchange-Admins"],
  "MailboxPermissionsOnPrem": ["DOMAIN\\Exchange-Admins"],
  "CalendarPermissionsOnPrem": ["DOMAIN\\Exchange-Admins"],
  "MigrationCheck": ["DOMAIN\\Exchange-Admins", "DOMAIN\\Migration-Team"],
  "MigrationCreate": ["DOMAIN\\Exchange-Admins", "DOMAIN\\Migration-Team"],
  "MigrationManage": ["DOMAIN\\Exchange-Admins"],
  "DelegationReport": ["DOMAIN\\Exchange-Admins", "DOMAIN\\IT-Helpdesk"],
  "MessageTrace": ["DOMAIN\\Exchange-Admins", "DOMAIN\\IT-Helpdesk"],
  "RecipientLookup": ["DOMAIN\\Exchange-Admins", "DOMAIN\\IT-Helpdesk"],
  "OutOfOffice": ["DOMAIN\\Exchange-Admins"],
  "MfaReset": ["DOMAIN\\Exchange-Admins"],
  "NamedLocations": ["DOMAIN\\Exchange-Admins"],
  "GroupManagement": ["DOMAIN\\Exchange-Admins"],
  "GroupManagementOnPrem": ["DOMAIN\\Exchange-Admins"],
  "Comms10k": ["DOMAIN\\Exchange-Admins"],
  "ConferenceRooms": ["DOMAIN\\Exchange-Admins"],
  "DhcpAuthorization": ["DOMAIN\\Exchange-Admins"],
  "EventLog": ["DOMAIN\\Exchange-Admins"]
}
  • Fail-closed: when section access is configured, missing or empty section keys deny access to that feature for all users
  • On-prem sections (MailboxPermissionsOnPrem, CalendarPermissionsOnPrem) are always fail-closed even when no SectionAccess configuration exists at all
  • Migration hierarchy: MigrationCreate requires MigrationCheck groups AND MigrationCreate groups; MigrationManage requires MigrationCheck groups AND MigrationManage groups
  • NavMenu links and Home page cards are hidden for unauthorized sections
  • Section access is managed per-module via /module-config/{ModuleId} (collapsible tree in sidebar)

Background Jobs

A background job - a Conference Rooms bulk CSV, a Comms-10k replace, a Message Analysis detail export, a Migration report export - runs with no browser behind it, so it carries the section's groups that authorized its operator when it was queued. Before every row the job runner checks that the job's module is still enabled and that one of those groups is still allowed for the module. If not - or if the job carries no such record, or either setting cannot be read - the row is refused, recorded as Failed with the reason, and audited; the rows after it are refused the same way. The same check is made once more as a job ends, however it ended - cancelled while queued and interrupted by a restart included, which run no row - and a job refused then hands over no export and no link. The outcome mail a Comms-10k or Conference Rooms job sends its administrators is not a result and is still sent. This re-reads the app's settings, not the operator's Windows group membership.

Session Revalidation

An open tab keeps its Windows sign-in for as long as it stays connected, so the app re-checks it against Active Directory: once when the tab connects, then every Authentication:RevalidationInterval (aud-a29b) - and every page request before the page is rendered (aud-a29g).

"Authentication": {
  "RevalidationInterval": "00:05:00",
  "RevalidationEnabled": true
}
  • Default 00:05:00 when the key is absent. The app refuses to start on a value that is not a time span, is below 00:00:30, or is above 01:00:00 - a bare 5 is read as five days.
  • Off-switch: RevalidationEnabled is true when absent. Setting it to false (and restarting) stops every re-check and every revocation. Nothing then re-checks an operator's group membership against the directory - not an open tab, not a reload, not a page request - so an operator removed from an AD group, or disabled, keeps the access their Windows sign-in carries: under Kerberos every reload and page request brings back the same groups until their ticket is renewed or expires, and a tab already open keeps its access until it is closed or the app restarts. Use it only while a wrong revocation is being fixed. It is never silent: at startup the app logs a warning and writes one audit line (action SessionRevalidation, reason Disabled). Anything other than true or false stops startup. The interval is still validated while the switch is off.
  • Static groups must be domain groups while revalidation is on. An entry in Security:AllowedGroups or Security:AdminGroups that is, or translates to, a built-in or well-known group - for example BUILTIN\Administrators, S-1-5-32-544, Everyone - can grant access through Windows but cannot be re-checked against Active Directory, so the app refuses to start and the startup error names the entry. Replace it with a domain group, or set RevalidationEnabled to false. A name that cannot be translated at startup is logged as a warning instead; until it translates, every check fails closed.
  • What is checked: the groups the operator's sign-in carries that some access rule uses (section access, module admins, Security:AllowedGroups, Security:AdminGroups), compared by SID with the account's current group membership (tokenGroups), and whether the account is enabled. Gaining a group never ends a session.
  • The app's own access settings are checked too. Each open session remembers the grants it was confirmed through - a group in a module's section access or module admins, or one of the static groups. If an administrator removes one of them, even from one section while the group keeps another, the session ends at its next check, although nothing changed in Active Directory. A grant added later is remembered from the first check after it appears. If the access settings cannot be read, the check fails closed and the session ends.
  • A lookup asks a second domain controller when the first does not answer. The app asks Windows to locate a domain controller of the account's domain and asks that controller by its host name. If it does not answer - it cannot be contacted, the connection fails, the request times out, or it has said nothing after 30 seconds, half of the lookup's 60 - the app at once asks Windows to locate another and asks that one, never the one that did not answer. A read the second controller answers is an ordinary answer and counts nothing; only when that one does not answer either, or Windows names no other controller, is the lookup one failed lookup under the rule below. A controller that does answer is believed, whatever it answers: "no such account", or an account whose groups cannot be read, is one failed lookup at once and is never asked of a second controller, which might not have heard of a deletion yet. So is any failure the app cannot tell from an answer. To find another controller the app tells Windows to discard the one it remembers for the domain (Get-ADDomainController -Discover -ForceDiscover); that changes the controller every program on the server is handed for that domain, so the app does it only after a controller did not answer and at most once in 60 seconds for a domain, asking without discarding in between. If two controllers disagree because a change has not replicated yet, the answer is the one of the read that succeeded. When Windows can name no controller, the read is made by the domain's name, as it was before, and the log says so; a directory session that cannot be opened at all is one failed lookup. No controller, site or domain is named in any setting. The log names each controller with the kind of failure, and says when a second one answered; the audit line of a session ended for failed lookups says which controllers the failed lookup asked, what each was asked for (the route to the account's domain, or the account), and which answered, which answered with a failure and which did not answer.
  • One failed lookup does not end a session (sweep-c item 15). When the directory read fails or does not answer within 60 seconds, the account's last answer is used instead if it was read within one interval plus two minutes - so the answer of the tab's previous check, or of a recent page load - and is compared exactly as a fresh one: it confirms, or it refuses for its own reason. Each such fallback is logged as a warning with a running count. Two failed lookups in a row end the session, whatever the interval (rev-b5, rev-e1). The count is the account's, not one tab's: a failed read seen by an open tab's check, a new tab's first check, a page request or a reload all charge the same count, so a reload whose read is the second failure in a row is refused ("This page was not shown") rather than shown from the old answer, and a new tab does not start the count again. A read the directory answers starts the count again. Tabs whose reads were already under way when a failure was counted, and fail with it, are that same failure and are not counted again; a read started after it is.
  • The session ends when one of those groups is gone, the account is disabled, or the check cannot be completed within 60 seconds with no recent answer to fall back to (fail closed). The tab stops responding and shows "This session has ended" with a Reload link; reloading signs in again with the access the operator has now. Each ended session writes one audit line (action SessionRevalidation, category Authentication).
  • When a tab connects it does not respond until that first check has answered - normally the time of one directory read, at most 60 seconds. The page is shown meanwhile, but nothing on it runs. If the check ends the session there, nothing in the tab was ever started: it shows the app's error banner ("An unhandled error has occurred") with its Reload link instead of the notice, and the audit line says why.
  • Before a page is shown the request itself is checked the same way (aud-a29g), because a page's first, server-side render runs its initialization before the tab connects. A refused request gets a short "This page was not shown" page (HTTP 403) instead of the page - nothing of the page, its menu or its initialization runs - with the reason and a Reload link, and writes one audit line (trigger PageRequest, path the page asked for - path base and path, never the query string, at most 256 characters; aud-a29i). If the check cannot be completed, and no recent answer stands in for it as above, the page is refused (fail closed); during a directory outage a page load waits for the lookup, at most 60 seconds, and the status frame shows it loading. The directory is not read for every page: an answer read for the same account within RevalidationInterval - by an earlier page request or by one of its open tabs' checks - confirms the request (unless the account has already had two failed lookups in a row, when the request reads again), while a refusal is always decided by a fresh read, so restored access works at the next request. So page loads cost at most one extra directory read per account per interval, made by the first page load after a quiet interval. An operator removed from a group within one interval of their account's last check can therefore still have one page rendered; the tab it opens is ended by its own check on connect, and every later page request is refused. The off-switch turns this check off too.
  • Under Kerberos a reload brings back the same group list until Windows renews its ticket, so an operator who keeps being signed out after their access was restored should sign out of Windows and back in.

Protected Users / Excluded Users

Prevent modifications to specific mailboxes. Configure via Module Config page under Mailbox Permissions → Excluded Users field (comma-separated). Applies to both mailbox and calendar permission operations:

C-Suite, Board of Directors, ceo@example.com
  • Supports distribution groups (auto-expanded to members on first use, cached 30 min)
  • Supports individual users (SMTP, UPN, or SamAccountName)
  • All formats are intelligently matched (case-insensitive)
  • Read only from the MailboxPermissions module config; the legacy Security:ExcludedUsers appsettings fallback was retired 2026-07-28 (it was invisible to the Protected Principals admin UI)
  • Cache is invalidated immediately when module config is saved via UI

The app-wide protection rules - Admin Settings → Protected principals (users, groups, OUs, sAMAccountName patterns, group targets) - store a user or group added there by its SID and an OU by its object GUID, each beside a companion row by name that an older build sharing the database keeps enforcing; removing the entry removes both. The check compares a user by SID alone (another account given the same address is not protected in its place, and a user renamed since stays protected; an on-premises target read without its SID refuses: "the target's objectSid was not read, so it cannot be compared with the protected user rows"), a group by SID against the target's token, and an OU by the object GUIDs of the target's containers, so a renamed OU still protects the accounts beneath it. A user or OU is looked up in any domain of the forest; an ambiguous name, a built-in group and an object whose identifier cannot be read are refused. The check never resolves or matches a stored name. An entry stored by name only - added before identifiers were stored, or left by an older build's save, which drops the identifier rows - makes every protection check that finds no other match refuse, naming the entry: "not converted - run db convert-identifiers". The app's db convert-identifiers command gives each its identifier row (see Troubleshooting), and Verify below offers the same conversion for one entry. A legacy group entry stored as a SID is compared by that SID. A protected group whose SID no group carries any more, or whose read fails, also refuses every check that finds no other match, and the refusal names the entry.

Verify (the button at the top of the pane; docs/history/DirectoryObjectVerify-Plan.md, slice V1). The page asks the directory nothing when it opens; pressing Verify asks Active Directory about every stored user, group, OU and group target, read with the Directory Read Credential in one session (batched global-catalog reads by SID and object GUID), and marks each entry: verified; missing (the directory answered and holds no such object); name changed (the object's current name - a user's UPN, else its mail; a group's, OU's or target's DN - is not the one stored; a user with neither is never flagged); not converted (stored by name only, with what the conversion's own lookup finds: one object, none, several, or no answer); several objects; wrong type; could not verify (the directory could not be asked, or the stored DN names a domain that is not in this forest - never read as missing); or ignored. The summary line reads "Verified N entries at : M findings, K ignored, J could not be verified", and the last press is shown to the next admin. An edit made in the pane while Verify reads, or while one of its actions writes, is kept: the findings are not shown against it, the pane says so, and a Save is then checked against the rules as they were read before. Beside each finding are its actions, each written at once (not at Save), checked against the rules as Verify read them (a change since refuses: "run Verify again"), re-authorized at the click and audited under Verify:ProtectedPrincipals: Rename (store the current name as the entry's label and as its companion for an older build; the check itself never compares names - an OU protects the groups and accounts beneath it by its object GUID, in a group write-target check too), Convert (one entry, as db convert-identifiers would), Replace... (pick the object it should name; checked as an Add is), Remove now (the entry, its companion and any ignore of it), and Ignore (keep the entry and stop the finding being reported until what Verify sees changes; never offered for an entry not converted or one that could not be verified). One ignore changes a protection check (slice V2, docs/history/DirectoryObjectVerify-Plan.md B.4): a protected group ignored as missing stops refusing writes while the directory confirms it is gone. The check still looks the group up on every write; a group restored with the same SID is found and protects again at once, and the ignore then shows as no longer matching on the next Verify; a lookup that fails or a domain that cannot be read still refuses. Every other ignore - a missing user or OU, a changed name, a wrong type, several objects - changes only what Verify reports. Verify is not offered while the pane has unsaved changes, and the ordinary Remove and Save also deletes a removed entry's ignores. The ignore list is the verify_ignores setting; db identifier-status prints it at the end of its report.

Protected principal servicing (authorised bypass)

Named groups can be allowed to act on protected principals within one specific module — built for the executive support team, who service VIP mailboxes as their ordinary job. It is routine authorised work, not an emergency override, so there is no per-operation confirmation and no alert on use; the actions are audited like every other action, and additionally record which group authorised them.

  • Configured per module, on Module Config → Access → Protected principal servicing
  • Offered only for modules whose code consults the servicer service - the list is ModulesWithProtectedPrincipalServicing in Components/Pages/ModuleConfig.razor; a grant elsewhere would confer nothing, so no editor is shown. Conference Rooms is not among them: protected principals do not apply to it (owner ruling 2026-11-03), and a servicer group already stored for it is left in the store, not shown, and logged once at startup
  • Separate from the module's own access groups: being able to use a module never implies being able to act on protected principals in it
  • Fail-closed and inert by default. With no group configured — the shipped state — the capability does not exist anywhere
  • Membership in a servicing group for one module confers nothing in any other
  • The Access tab's Verify checks the servicing groups with the module's access groups (see Per-Module Config Pages); an ignore there changes only what Verify reports, never who may service

Ticket numbers

Where a page asks for a ticket number, the ticket recorded is the typed value with every non-printing character removed - control characters, Unicode format characters (a zero-width space, byte-order mark, soft hyphen, bidi mark and the rest) and unpaired surrogates, usually carried in by a paste - then trimmed; spaces inside it are kept. The box keeps what was typed; the check, the ServiceNow query and the audit row all use the cleaned value. "Ticket number is required" is the only refusal of a ticket while ServiceNow is dormant, given when nothing visible is left, and it reads the same on every page. Every page uses one ticket box (TicketBox) and each page's buttons are enabled by the same rule as the check behind them (TicketGate; decision 2026-11-09).

Each ticket-gated action checks the ticket again behind its button, before anything is written, in one place (TicketGate.CheckAsync): presence by this rule, then the one registered ticket lookup - ServiceNow, which passes every ticket unless ServiceNow:Enabled is on; its answer is shown as "Ticket validation failed: ...". A refusal is recorded in the audit log. AD Attribute Editor saves, Blocked Senders unblocks, Licensing Updates applies, Out of Office changes, Event Log undos and Migration's batch and mailbox actions record theirs with refusedAt TicketValidation and mutationAttempted false. Comms-10k's ticket is optional: an empty one passes, an entered one is checked the same way. Some checks are presence alone and never ask ServiceNow: Account Lockout Remediation, Emergency Disable, a Message Trace report download, creating a migration batch, and a Conference Rooms bulk job's row. BitLocker Recovery and Cloud Password Reset ask ServiceNow only where their own ValidateTickets switch is on.

Audit Logging

All operations are logged as JSON Lines (.jsonl). Business audit records and diagnostic operation trace records are separate files:

Audit location: <Audit:LogRoot>\ExchangeAdminWeb\exchangeadmin_YYYYMMDD.jsonl

Trace location: <Audit:LogRoot>\ExchangeAdminWeb\exchangeadmin_YYYYMMDD_trace.jsonl

(Audit:LogRoot is a required setting; see the configuration section above. Two instances may share one root: see Shared log root.)

Common audit fields: eventType, operationId, ts, user, ip, action, category, result, ticket

Category-specific fields:

  • MailboxPermission: target, affectedUser, permissionType, autoMapping
  • CalendarPermission: target, affectedUser, accessRight
  • MigrationCheck: target, status, reasons
  • MigrationBatch: batchName, direction, userCount, autoStart, autoComplete
  • MigrationAction: target
  • Lookup: target; Recipient Lookup also resolvedAddress, the primary address the lookup found, when it found one
  • AdminSettings: section, added, removed
  • MfaReset: target, methodsRemoved
  • GroupManagement: target, member, operation, backend
  • Comms10k: target (carries the members requested, the outcome, and the observed final count). There is no removal count: clear-then-fill never reads the prior membership, so the earlier membersAdded / membersRemoved fields documented here were never emitted and could not be
  • ConferenceRooms: target, properties, policyTemplate
  • DhcpAuthorization: target, operation

Null fields are omitted. error appears on every result but Success.

result - the closed list of values (for Splunk searches). Every audit record's result is one of:

Value Meaning
Success The operation succeeded.
Failed The operation failed or was refused. A refusal is a Failed row too; see the conventions below to tell one from a write that failed.
Undetermined Whether the change was made could not be confirmed. The command was sent and either no answer to it came back or the error that came back does not show a refusal (Mailbox and Calendar Permissions, an Out of Office change, a Migration batch create, a Conference Rooms Room Type apply); or a read-back could not be made (Send As, an on-premises Out of Office change, a Conference Rooms on-premises room type); or a Blocked Senders unblock stalled; or a Migration eligibility check could not decide. The change may have landed. See "What makes a result Undetermined" below.
Cancelled The operator cancelled - a change stopped before its write was sent (nothing written; a Conference Rooms bulk job's row stopped by the job's cancel included), or a read cancelled (Message Analysis, Recipient Lookup).
Ineligible Migration eligibility checks only (CheckMigrationEligibility): the check found the mailbox not eligible.

A search for result="Failed" therefore misses changes filed Undetermined that may have landed, and cancels. Search result!="Success" for everything that did not plainly succeed. error carries the reason on every value but Success.

What makes a result Undetermined. Mailbox Permissions, Calendar Permissions, an Out of Office change, a Migration batch create and the Exchange Online steps of a Conference Rooms Room Type apply tell a write whose outcome is unknown from one that failed. A write command that fails once it was sent is read by what the failure is - the types of its exceptions, and the id, category and reason of its error records - and not by what its sentence says of a connection, a session or a timeout. Its words are read in three places only, each named below: the pre-flight error, the names an error quotes, and Calendar's "no existing permission entry" sentence. It is Failed only on evidence that it was refused; every other failure is Undetermined:

  • No answer came back - the request timed out, failed in transit or was cancelled by something other than the operator, or the session to on-premises Exchange broke. The write may have been made: Undetermined, "... could not be confirmed ...", and the operator is told to check before repeating it.
  • Exchange refused the command - the error came from Exchange (the Exchange Online module built it from an error response, or it came back over the on-premises session) and it names a refusal: its category is object not found, invalid argument, permission denied or already exists, or the exception it names is a not-found, a permission entry that is missing or already there, or a parameter that could not be bound. A refusal for an object counts only when the object it names - its target, or a name it quotes - is one the command itself sent, or it names none: one about something else may be a later step's, after the command's own change was made, and is Undetermined. So is a refusal that names the command's own object otherwise than the command did - a display name or an alias for the address it sent: the app does not guess that two names are one object, and says "could not be confirmed". Or PowerShell could not start the command at all: the session does not have it, one of its parameters could not be bound, or the endpoint's language mode ran none of it (read by that error's id, ScriptsNotAllowed, not by its words). Failed, even when the sentence speaks of a connection or a session. This is a reading of the error; except for Send As, the mailbox is not read to check it.
  • Anything else - an error from Exchange that names no refusal (a server-side or transient error, a throttling answer, a directory or store timeout that on-premises Exchange reports, a kind the app does not recognise), an error made on this server, or a command PowerShell flagged as failed without any error: Undetermined. An error response proves only that something answered, not that the write was not made.

So Undetermined means "check before repeating", not "probably made": a command Exchange did refuse is filed Undetermined whenever its error carries none of those marks. Exchange Online's "couldn't be found" error for a recipient has been seen to carry none. For that reason nothing the app does in ordinary use waits on a refusal being recognised. The one refusal that is part of an ordinary change is Calendar's: a Set for a user with no entry yet is answered "There is no existing permission entry found for user: ...", and that sentence - read in its words, the user it names left out, and only when nothing in the failure says its session failed - is what sends the Add; on a removal the same sentence is the plain failure that says there was nothing to remove.

The pre-flight error ("You must call Connect-ExchangeOnline ...") is also read in its words: the module raises it before a cmdlet runs, so nothing was written: Failed, never Undetermined - unless the same failure also shows a lost answer.

A failure before the command was sent - a check, the connection, a credential - is Failed with nothing written, and the operator's own cancel before the send is Cancelled. "Sent" means handed to PowerShell to run. An Exchange Online cmdlet makes its request inside that call, so a transport failure there is Undetermined whether it struck before the request left this server (a token that could not be fetched, a name that did not resolve) or after Exchange received it: the two cannot be told apart. On-premises, a session that could not be opened is before the send; one that breaks once the command was handed to it is Undetermined.

The connection pool never sends a write a second time because its answer was lost: it runs a command again only on the one error that proves the first attempt never ran, and - for any call that may write - not when the same failure also shows a lost answer, and not once another command of the same attempt that may write has failed some other way: the app never sends again a write whose outcome it calls unknown. A call the app makes as a read alone is run again on that error whatever else the failure shows: a read is safe to repeat.

The Exchange Online module has a retry of its own, inside the cmdlet: it sends a request again on a 401, 503 or 504 response and on some transient server errors. So an answer that says the state asked for already holds - "already exists" on an add, "no existing permission entry" on a removal - can follow a change the module's own first send made. Such an answer tells what Exchange holds now, not that this attempt changed nothing, and the app's message says only that: a calendar removal answered "no existing permission entry" is Failed in Exchange's words, followed by "Exchange reports no permission entry for on this calendar now." Send As is read back instead.

Some writes are also read back once Exchange or the directory accepted them (Send As, an on-premises Out of Office change, a Conference Rooms directory write): a read-back that cannot be made leaves the result Undetermined as well. Send As in Exchange Online also lets the mailbox settle an error. After any error - a refusal, or one that names none - it is read back up to three times, as an accepted write is. If the requested state shows, the right is in place: the result says so as found ("in place", not "granted"), keeps Exchange's error, and tells the grantee and the owner nothing of that side, because the read-back cannot show whether this change made it so. If it does not show, a refusal is Failed and an error that names no refusal is Undetermined; a read-back that cannot be made is Undetermined. A lost answer is Undetermined without a read.

The other Exchange Online writes do not make this distinction: a Blocked Senders unblock that fails inside its time bound, Migration's user actions and its batch actions other than the create, and a Conference Rooms Room Finder step in Exchange Online report a command that failed as failed, whatever became of it.

How a refusal is recorded - the current conventions. A refusal (the operation was stopped before its write) is filed Failed, but its shape differs by page. The shapes in use today:

  1. A *_Refused action with the refusal fields refusedAt (the step that refused, e.g. TicketValidation, Authorization) and mutationAttempted false - for example ADAttributeEdit_Refused.
  2. The operation's own action with the refusal fields - for example MfaReset_Execute, DHCP_Deauthorize, the Mailbox and Calendar Permissions changes' own actions, LicensingUpdates_Update with target (bulk) N rows, the module's own undo action for an Event Log undo.
  3. A *_Denied action with error only and no refusal fields - for example UnblockSender_Denied, OutOfOffice_Denied, Add_Denied/Remove_Denied on Mailbox Permissions, SetCalendar_Denied/RemoveCalendar_Denied (authorization and protected-principal refusals). Since sweep-e item 41 the ticket refusals on Blocked Senders and Out of Office use the same *_Denied action with the refusal fields added.
  4. A {action}_Denied action with mutationAttempted false - Migration's authorization denials (with targetCount and targets for a bulk run); its ticket refusals (sweep-e item 41) add refusedAt TicketValidation.
  5. The operation's own action, Failed, with the reason in error and no refusal fields - authorization refusals on DHCP Authorization, Named Locations, M365 Groups, AD Group Management, Self-Service Groups, MFA Reset, Intune Devices and Risky Users.
  6. The outcome in the action name - _PARTIAL (some rights applied) and _UNCONFIRMED (administrator notification of an Undetermined change) on Mailbox Permissions.

To find every refusal, search for refusedAt=* OR action="*_Denied" OR action="*_Refused"; shape 5 is told apart from a failed write only by its error text. Unifying these shapes would change what existing Splunk searches match, so it is left as it is pending an owner decision.

Operation trace records: Each audit transaction writes structured trace events with the same operationId:

  • operation.start — transaction accepted by the logging pipeline
  • operation.step — significant step such as AuditWritten, plus shared backend steps where available
  • operation.complete — final transaction result and elapsed duration

Trace fields are SIEM-friendly: eventType, operationId, parentOperationId, module, action, stage, backend, command, target, ticket, result, durationMs, details, and errorType. Raw exception messages are not written to trace records. Secret-like detail keys (password, secret, token, apiKey, clientSecret) are masked as ***. Shared backend services also emit standalone operation trace records when no operation scope is active, so vault and EXO connection failures are still visible in the trace stream. Disable trace records with OperationTrace:Enabled = false if needed; audit records remain active.

Rotation:

  • daily (default): New file each day
  • weekly: New file each week
  • monthly: New file each month
  • Audit:MaxFileMB and Audit:MaxFilesPerPeriod cap both audit and trace file growth
  • A file that reaches its size limit is rotated before the next write. A rotation that fails - the folder does not let this instance's account delete, or another program holds the file open without delete sharing - does not lose the write: it goes to the full file, past its limit, and every later write tries the rotation again. The failure is logged as a warning naming the file, the reason, its size and how far past its limit it is. While the rotation keeps failing it is logged again each time the file has grown by another limit, or once an hour, whichever comes first, until a write finds the file rotated or under its limit. The Admin Event Log shows each file this instance cannot rotate, since when, its size and how far over it is, with diagnostics on or off. A retried rotation deletes nothing a completed one would have kept. The same holds for the extended diagnostic log. Nothing bounds the file while its rotation fails: release whatever holds it open, or let this instance's account delete in the log folder.
  • The log folder is created before every write, so a <LogRoot>\ExchangeAdminWeb deleted while the app runs is created again by the next write. A folder that cannot be created is reported the way a lock file the folder refuses is (see Shared log root).

Extended diagnostics: Admin Settings can enable a separate UI-viewable diagnostic stream for troubleshooting Delinea/on-prem connectivity. It defaults to off, writes to exchangeadmin_YYYYMMDD_extended.jsonl, rotates at 10 MB by default, and keeps 5 files per day including the active file. Tune with ExtendedLog:MaxFileMB and ExtendedLog:MaxFilesPerDay if needed. The queue is bounded and drops oldest entries under sustained bursts, so this is best-effort diagnostics, not an audit trail. Every entry it drops is counted - one it could not write, or one the full queue discarded - and with Show diagnostics on, the Admin Event Log shows that count and names any trace or extended log file it could not read. At shutdown it waits for its queue in proportion to the queue's length - about 26 seconds for a full one, and never less than 5 - and counts as dropped whatever it still could not write. Keep Admin Event Log access tightly scoped.

Delinea Secret Server

The app uses one shared Delinea API bootstrap credential, then each module retrieves its own privileged secret by module config. Do not put on-prem Exchange, AD, DHCP, or Graph application credentials in global appsettings.

"Delinea": {
  "SecretServerUrl": "https://secretserver.yourcompany.com/secretserver",
  "CredentialTarget": "Delinea_Client"
}
Key Purpose
SecretServerUrl Base URL of Delinea/Thycotic Secret Server
CredentialTarget Windows Credential Manager entry name storing Delinea API client credentials

Modules that need privileged on-prem or AD access expose their own DelineaSecretId field on that module's config page. Those secrets must contain fields named Username, Password, and Domain. Graph-backed modules use their own Delinea secret containing Tenant ID, Application ID, and Client Secret.

Module secrets must be directly readable by the Delinea API bootstrap credential and must not require checkout, approval, or another interactive Secret Server workflow. The web app cannot complete a checkout prompt during background API calls.

Delinea Platform login (temporary, during the vault cutover)

An instance logs in through the Delinea Platform when its own appsettings.json carries Delinea:PlatformTokenUrl; without that line it uses the Secret Server login above, unchanged. The choice is made once at start-up and there is no fallback either way. Everything this section describes is marked PlatformCutover in the source and is removed once every instance has moved (docs/DelineaPlatform-Plan.md, slice 3).

"Delinea": {
  "PlatformTokenUrl": "https://<platform host>/<token path>",
  "SecretServerUrl": "https://<platform vault host>",
  "CredentialTarget": "Delinea_Platform_Client"
}
Key On the Platform
PlatformTokenUrl The full https address the token is asked for at (client credentials, scope xpmheadless). Must be absolute https, or the app refuses to start and names the setting.
SecretServerUrl The address secrets are read from (/api/v2/secrets/<id>). Required.
CredentialTarget The Windows Credential Manager entry holding the Platform client ID (user name, sent exactly as stored) and client secret (password).

Secret IDs. The two vaults number secrets differently and the config database is shared between instances, so every secret-ID setting has a Platform counterpart, stored under the same key with Platform in front. An instance on the Platform reads only the counterpart; an instance on the old vault reads only the original. A missing counterpart means "not configured" for that module on that instance - the old ID is never sent to the new vault. On a Platform instance the "required fields" notice on Module Config looks at the counterpart, and a message that says which field to set names the counterpart.

Setting Where it is edited Platform counterpart
DelineaSecretId (each module) Module Config, the field marked "(Delinea Platform)" beside it PlatformDelineaSecretId
GraphDelineaSecretId (each module) Module Config, the field marked "(Delinea Platform)" beside it PlatformGraphDelineaSecretId
Directory Read Credential (ProtectedPrincipals / DirectoryReadSecretId) Admin Settings, Protected principals, opened on the Platform instance: the field there shows and saves the counterpart PlatformDirectoryReadSecretId
Graph Directory Read Credential (ProtectedPrincipals / GraphDirectoryReadSecretId) The same PlatformGraphDirectoryReadSecretId

The appsettings fallback Security:ProtectedPrincipalDirectoryReadSecretId holds an old-vault ID and is ignored on the Platform. On the Platform a secret's field is found by its display name or, where the response carries none, by its slug compared ignoring case, spaces, hyphens and underscores (tenant-id is Tenant ID).

To switch an instance:

  1. On that server, as the app pool identity, store the Platform client ID and secret in Windows Credential Manager under the name you will give CredentialTarget.
  2. Enter each secret's new ID: the "(Delinea Platform)" fields on Module Config (from any instance), and - after step 3 - the two Directory Read Credential fields on the Platform instance's Admin Settings.
  3. Edit that instance's appsettings.json: add PlatformTokenUrl, change SecretServerUrl and CredentialTarget. Recycle its app pool.
  4. Run tools\test-delinea.ps1 -ServerUrl <vault> -PlatformTokenUrl <token address> -SecretId <id> and check it lists the field names you expect. It prints names and slugs only, never a value; -PlanOnly prints the two requests and sends nothing.

To go back: remove PlatformTokenUrl, restore the old SecretServerUrl and CredentialTarget, recycle the app pool. The old IDs and the old stored credential were never touched.

tools\Install-ExchangeAdminWeb.ps1 and deploy.ps1 take -DelineaPlatformTokenUrl (with -DelineaCredentialTarget on the installer, -DelineaTargetName on deploy.ps1) when they generate a new appsettings.json; neither rewrites an existing one, so an instance already installed is switched by hand as above. The installer's -RegenerateAppSettings rebuilds the file from its parameters: pass -DelineaPlatformTokenUrl again or the instance returns to the Secret Server login.

Application Settings

"Application": {
  "PathBase": "/ExchangeAdminWeb",
  "ContactEmail": "exchangeadmin@yourcompany.com",
  "PublicBaseUrl": "https://yourserver/ExchangeAdminWeb"
}
Key Purpose
Application:PathBase IIS sub-application path
Application:ContactEmail Displayed in the UI as the support contact (nav footer)
Application:PublicBaseUrl Absolute external URL of the app, used to build links in notification emails. Optional: when unset or not an absolute URL, emails describe the page in prose instead of linking to it (an email client cannot resolve a relative path, so a partial URL would be a dead link). Set it per environment - dev and prod must not share one value.

Config Store

"ConfigStore": {
  "Path": "D:\\inetpub\\ExchangeAdminWebShared\\config\\exchangeadmin.db"
}
Key Purpose
ConfigStore:Path Absolute local path of the SQLite config database this instance opens. Set the same value on every instance that should share settings (see "Shared config database" under Deploy to IIS). The file must already exist - a missing file, a network (UNC) path or a relative path stops the app at startup with a message naming this key. Leave the key out for a standalone instance: it then uses config\exchangeadmin.db under its own folder, created on first start.

Email Notifications

Admin Notifications (always sent):

  • Every permission operation (success or failure)
  • Includes full details: who, what, when, IP address, ticket number
  • Migration and Out of Office mails carry rows named for what they hold (Mailbox, Batch, CSV File, Eligibility, Mailboxes, Options, Succeeded) under a subject starting [Admin]. The mailbox-permission mail ([Exchange Admin], with Target Mailbox, Affected User and Permission Type rows) is sent by the permission modules only

User Notifications (optional):

  • Set NotifyUsersOnPermissionGrant: true to enable
  • Sent when permissions are granted or removed
  • Friendly email with mailbox details and security notice
  • A bulk CSV run (Mailbox or Calendar Permissions) sends each affected person one mail after the run, not one per row: the trustee gets one mail listing every mailbox or calendar the run changed for them, and each owner one mail listing every user whose access to their mailbox or calendar changed. A person with a single change gets the same mail a single change sends. A row Exchange answers as changing nothing (the right already in place, already absent, or the calendar entry already at that level) is shown as "No change" in the run's results and mails nobody. A Send As row on a synced mailbox that completes one side after a half-applied change names that side in the mail, and says the other was already in place.

Boolean settings: Email:SmtpUseSsl, Email:NotifyUsersOnPermissionGrant and ServiceNow:Enabled take true or false, in any case. Left out or blank, each is false. A value that is neither - yes, 1 - is logged once as a warning naming the setting and the value, and until it is corrected it is read as:

  • Email:SmtpUseSsl: true, TLS when connecting, so a mistyped value never sends mail in clear text. A relay that does not offer TLS on connect then refuses the mail, and each failure is logged.
  • ServiceNow:Enabled: true, so a mistyped value never passes every ticket unchecked. Without a reachable ServiceNow instance, each ticket's check then fails.
  • Email:NotifyUsersOnPermissionGrant: false, as when it is left out, and the Home, Mailbox Permissions and Calendar Permissions pages then do not say that users are notified.

Before, such a value stopped the Home page, and every page that sends mail or checks a ticket.

Bulk Operations

CSV Format - Mailbox Permissions

Add/Remove:

Target,User,FullAccess,SendAs,AutoMapping
helpdesk@company.com,john.doe@company.com,True,True,True
finance@company.com,jane.smith@company.com,True,False,False

See docs/CSV_FORMAT.md for complete documentation.

CSV Format - Calendar Permissions

Set:

Target,User,AccessRight
exec@company.com,assistant@company.com,Editor
manager@company.com,team@company.com,Reviewer

Remove:

Target,User
exec@company.com,old-assistant@company.com

Security Features

Configure email notifications, group-based access control, self-grant prevention, protected user lists, and audit logging in appsettings.json.

Troubleshooting

"... (time zone not reported)" after a time

  • Migration, Recipient Lookup and Out of Office Check Status show each time Exchange reports in the browser's zone (in UTC on Migration), with the zone and its offset. A time that arrives naming its instant - in UTC, with an offset, or as the remoting layer hands one over (converted into this server's zone) - is shown that way
  • Only a time that names no zone at all is shown as its bare clock with "(time zone not reported)": nothing says which zone's clock it is, so the app does not guess. If every time reads that way, report it with the page and the field

"Exchange refused the mailbox GUID identity ..."

  • Every Exchange change and the read-back before it name the mailbox by its Exchange mailbox GUID - the mailbox the protection check validated, never the string typed (aud-a2d). That Exchange accepts this form for every cmdlet used (Get-Mailbox, Add/Remove-MailboxPermission, Add/Remove-RecipientPermission, the calendar folder cmdlets, Set-MailboxAutoReplyConfiguration, Set-Place, Add-DistributionGroupMember -Member) is checked at the first deployment
  • When Exchange answers "couldn't be found" for that GUID, the message begins with this text and names the cmdlet; the application log has a Warning with the cmdlet and the GUID. Nothing was changed by that step. A Conference Rooms read whose Get-Place returns nothing for the GUID logs a Warning too (its city, building and capacity read blank)
  • Report it with the cmdlet named: it is sweep item 13's check, not a problem with the mailbox

"... matches N recipients in Exchange Online"

  • Exchange Online answered a name with more than one recipient. The app never takes the first: the mailbox, grantee or operator named that way is refused, and the message names the identity. Type an identity that names exactly one recipient (a primary SMTP address does)
  • "Protected-user list is unavailable: the protected-user entry '...' matches N recipients ..." is the same answer for an entry of the Mailbox Permissions protected-user list (ExcludedUsers). The whole list stays unavailable, and every Mailbox Permissions, Calendar Permissions and Out of Office target is refused, until that entry is corrected or removed; the application log has an Error naming the entry. A failed load is retried after a minute

"... not converted - run db convert-identifiers"

  • A protected user, group or OU (Admin Settings, Protected principals) is stored by name only, and this build never matches a stored name, so every protection check that finds no other match is refused, naming the entry. Module-admin grants stored by name grant nothing and are listed on Module Configuration's Admins pane with the same text
  • Usual cause: the conversion was not run before this build was deployed, or prod's older build saved Admin Settings since (an older build's save drops every identifier row)
  • Fix: run the app's db convert-identifiers command against the settings database, from an elevated shell on the deploy host, as docs/ConfigDbOperations.md "Converting protected principals and module-admin grants to identifiers" describes - on a copy first, then the live file. db identifier-status lists every row and exits 0 when nothing is left stored by name. An entry the command cannot resolve to exactly one object is named by it; remove or re-pick that entry and run it again
  • For a few entries: press Verify on the Protected principals pane; an entry the lookup resolves to exactly one object offers Convert, one it does not offers Replace... and Remove now

"... protected group '...': no such group - run Verify on Admin Settings"

  • A protected group (Admin Settings, Protected principals) is stored by its SID and the directory confirms no group carries that SID any more - usually the group was deleted. The check cannot say the target is not in it, so every protection check that finds no other match is refused, naming the entry
  • Fix: press Verify on the Protected principals pane. The entry shows as missing; choose Replace... (pick the group it should name), Remove now, or Ignore (keep it; the check then stops refusing on it while the directory confirms it is gone - it is still looked up on every check, so a restored group protects again at once, and a lookup that fails still refuses)

"401 Unauthorized" when accessing the app

  • Verify Windows Authentication is enabled in IIS for the application
  • Check user is member of an allowed AD group
  • Verify AllowedGroups configuration in appsettings.json
  • Check IIS logs: C:\inetpub\logs\LogFiles\W3SVC1\

"Cannot connect to Exchange Online"

  • Verify certificate is installed and accessible to app pool identity
  • Check certificate subject matches CertificateSubject in appsettings.json
  • Verify app registration has Exchange.ManageAsApp permission
  • Verify service principal has Exchange Administrator role
  • Check application logs: D:\inetpub\ExchangeAdminWeb\logs\app-*.log

"User not found" errors

  • Ensure ExchangeOnlineManagement module is installed
  • Verify service principal permissions in Exchange Online
  • Check user exists in Exchange Online (Get-Mailbox)

Emails not sending

  • Check SMTP host/port is accessible from web server
  • Verify firewall allows outbound SMTP traffic
  • Check application logs for SMTP errors
  • Test SMTP credentials if using authenticated SMTP

Migration eligibility checks show AD group warning

  • Ensure ActiveDirectory PowerShell module is installed: Install-WindowsFeature RSAT-AD-PowerShell
  • Verify IIS app pool identity has AD read permissions
  • If using ApplicationPoolIdentity, ensure server computer account has domain access
  • To use domain service account:
    Import-Module WebAdministration
    Set-ItemProperty "IIS:\AppPools\ExchangeAdminWeb" -Name processModel.identityType -Value 3
    Set-ItemProperty "IIS:\AppPools\ExchangeAdminWeb" -Name processModel.userName -Value "DOMAIN\svc_exchangeadmin"
    Set-ItemProperty "IIS:\AppPools\ExchangeAdminWeb" -Name processModel.password -Value "<secure-password>"
  • Check application logs for detailed AD errors: D:\inetpub\ExchangeAdminWeb\logs\app-*.log
  • Test AD access: Run Get-ADUser -Identity username in PowerShell as the app pool identity

Development

Local Development

  1. Clone repository
  2. Copy appsettings.json.sample to appsettings.json
  3. Configure settings (or use appsettings.Development.json)
  4. Run: dotnet run
  5. Access: http://localhost:5226

Note: Windows Authentication works automatically on domain-joined dev machines using IIS Express or Kestrel with NegotiateDefaults.

Project Structure

ExchangeAdminWeb/
├── Modules/           # Descriptor-based module system (the architecture)
│   ├── ModuleCatalog.cs        # All module descriptors (nav, auth, enablement)
│   └── AdminModuleDescriptor.cs # Descriptor record contract
├── Components/         # Blazor components
│   ├── Pages/         # One Razor page per module (MailboxPermissions, ConferenceRooms, ...)
│   └── Layout/        # Layout components
├── Authorization/     # Policy handlers and authorization wiring
├── Middleware/        # Request pipeline middleware
├── Models/            # Data models and enums
├── Services/          # Per-feature services (one per module + shared infra)
│   ├── AuditService.cs          # JSONL business audit records
│   ├── OperationTraceService.cs # Correlated operation trace records
│   ├── JsonlLogService.cs       # Shared JSONL writer
│   ├── ExoConnectionPool.cs     # Pooled Exchange Online connections
│   ├── EmailService.cs          # SMTP notifications
│   └── PermissionValidator.cs   # Security validation
├── config/            # Runtime config fragments (preserved across deploys)
├── tools/             # Standalone installer + ops scripts (Install-ExchangeAdminWeb.ps1)
├── tests/ps/          # Pester tests for PowerShell
├── docs/              # ProjectConstitution, specs, plans
├── .agents/           # Agent guidance (state.md, decisions.md, repo-map.json)
├── ExchangeAdminWeb.Tests/  # xUnit test project
├── Program.cs         # Application entry point
├── web.config         # IIS configuration
└── deploy.ps1         # ADI-specific deploy helper (generic install: tools/Install-ExchangeAdminWeb.ps1)

Tech Stack

  • ASP.NET Core 10 - Blazor Server with Interactive Server rendering
  • Authentication - Windows Authentication (Negotiate/NTLM)
  • Authorization - Role-based with AD groups
  • Exchange Operations - PowerShell SDK with ExchangeOnlineManagement module
  • Logging - Serilog (file + console)
  • Email - MailKit/MimeKit
  • CSV - CsvHelper

License

For internal administrative use. Configure all environment-specific settings before deployment.

Support

For issues or questions, contact the IT Service Desk or create an issue in the repository.

About

No description, website, or topics provided.

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages