Platform.announcement_recipient.GetAnnouncementRecipientGroupMembership

Call as

addon.Platform:GetAnnouncementRecipientGroupMembership(recipient, raidOnly)

Available directly through addon; no dependency is needed.

What it does

Resolve an exact cast-recipient name against the current bounded party or raid roster, then observe membership through a unit token. Missing, ambiguous or changing roster data remains unavailable; never reads the selected target or retains state across casts.

Arguments

Name	Type	What it does
`self`	`RMPlatform`	Rotation Master platform adapter (implicit with colon calls).
`recipient`	`string`	Exact readable recipient name recorded for this cast.
`raidOnly`	`boolean \| nil`	True checks raid membership only; false or nil checks party or raid.

Returns

1	`boolean \| nil`	Observed membership, or nil when unavailable.
2	`string \| nil`	Validation or availability reason for a nil result.

Editions

Built In helpers are registered on every edition. What differs is the game API they read; where one is missing the helper falls back or returns nil with a reason.

Not available on that edition (the reason is in the tooltip)
Only while Blizzard's deprecation fallbacks are on

Game API
`GetNormalizedRealmName`
`UnitExists`
`UnitGUID`
`UnitName`
`canaccessvalue`

Secret values (Retail and Forever)

On Retail and Forever the game hands addons secret values. This helper checks what it reads (addon.Platform:CanReadValue) and returns nil with a reason such as restricted-value instead of a secret it cannot compare. Treat nil as unavailable, not as false.

Example

local name = UnitName("target")
if type(name) ~= "string" then return nil end
local member = addon.Platform:GetAnnouncementRecipientGroupMembership(name, false)
if member == nil then return nil end
return member

Source

Platform/announcement_recipient.lua, line 24. Read only in game; Duplicate makes an editable copy.

Platform.announcement_recipient.GetAnnouncementRecipientGroupMembership(self, recipient, raidOnly)

    if not self:CanReadValue(recipient) or not self:CanReadValue(raidOnly) then return nil,'restricted-value' end
    if type(recipient)~='string' or recipient=='' or #recipient>256 then return nil,'cast-recipient-unavailable' end
    if raidOnly~=nil and type(raidOnly)~='boolean' then return nil,'invalid-group-query' end
    local grouped,reason=self:GetGroupMembership(raidOnly)
    if grouped~=true then return grouped,reason end
    local raid,why=self:GetGroupMembership(true)
    if raid==nil then return nil,why end
    local exists,name,guid,normalized=UnitExists,UnitName,UnitGUID,GetNormalizedRealmName
    local groupQuery=self.GetGroupMembership
    local membership=self.GetUnitGroupMembership
    if type(exists)~='function' or type(name)~='function' or type(guid)~='function' or type(membership)~='function' then return nil,'missing-api' end
    local function read(unit)
        local ok,present=pcall(exists,unit)
        if not ok or not self:CanReadValue(present) or type(present)~='boolean' then return nil end
        if not present then return false end
        local named,first,realm=pcall(name,unit)
        local identified,identity=pcall(guid,unit)
        if not named or not identified or not self:CanReadValue(first) or not self:CanReadValue(realm) or not self:CanReadValue(identity) then return nil end
        if canaccessvalue and not canaccessvalue(first) then return nil end
        if canaccessvalue and not canaccessvalue(realm) then return nil end
        if canaccessvalue and not canaccessvalue(identity) then return nil end
        if type(first)~='string' or first=='' or #first>256 or type(identity)~='string' or identity=='' or #identity>256 then return nil end
        if realm~=nil and type(realm)~='string' then return nil end
        if realm==nil or realm=='' then
            if type(normalized)=='function' then
                local got,value=pcall(normalized)
                if not got or not self:CanReadValue(value) then return nil end
                if canaccessvalue and not canaccessvalue(value) then return nil end
                if type(value)=='string' and value~='' and #value<=256 then realm=value end
            end
        end
        return {first=first,full=type(realm)=='string' and realm~='' and first..'-'..realm or nil,guid=identity}
    end
    local function scan()
        local rows,selected,count={},nil,0
        for index=raid and 1 or 0,raid and 40 or 4 do
            local unit=raid and 'raid'..index or index==0 and 'player' or 'party'..index
            local record=read(unit)
            if record==nil then return nil,'group-data-unavailable' end
            rows[unit]=record
            if record then
                count=count+1
                if recipient==record.first or recipient==record.full then
                    if selected then return nil,'cast-recipient-ambiguous' end
                    selected=unit
                elseif not record.full and recipient:sub(1,#record.first+1)==record.first..'-' then
                    return nil,'cast-recipient-unavailable'
                end
            end
        end
        if count==0 then return nil,'group-data-unavailable' end
        return rows,selected
    end
    local before,selected=scan()
    if not before then return nil,selected end
    local member,failure=false,nil
    if selected then member,failure=membership(self,selected,raidOnly) end
    -- Native calls and extension callbacks may reenter. Re-read the complete
    -- bounded roster after membership/context reads, including negative results:
    -- a stale false must not turn a NOT condition into permission to announce.
    local currentGroup=self:GetGroupMembership(raidOnly)
    local currentRaid=self:GetGroupMembership(true)
    local after,matched=scan()
    if exists~=UnitExists or name~=UnitName or guid~=UnitGUID or normalized~=GetNormalizedRealmName
        or membership~=self.GetUnitGroupMembership or groupQuery~=self.GetGroupMembership
        or currentGroup~=grouped or currentRaid~=raid or not after or matched~=selected then return nil,'group-data-unavailable' end
    for unit,record in pairs(before) do
        local fresh=after[unit]
        if type(record)~=type(fresh) then return nil,'group-data-unavailable' end
        if record and (fresh.guid~=record.guid or fresh.first~=record.first or fresh.full~=record.full) then return nil,'group-data-unavailable' end
    end
    return member,failure

Back to Function reference