Skip to main content

badgeServiceUtil

An utility module for working with BadgeService.

Types​

DEFAULT_BADGE_INFO​

Constant
</>
interface DEFAULT_BADGE_INFO {
Name: ""
Description: ""
IconImageId: ""
IsEnabled: false
}
Not Accessible

Constant, not accesible within badgeServiceUtil.

Functions​

badgeInfoPromise​

</>
badgeServiceUtil.badgeInfoPromise(badgeId: number) → Promise<BadgeInfo>

Types

​

interface BadgeInfo {
Name: string
Description: string
IconImageId: string
IsEnabled: boolean
}

Returns a promise which is resolved wih the badge info of the given badge id. This is just a wrapper over BadgeService:GetBadgeInfoAsync.

If the promise rejects, it will reject with a shallow copy of DEFAULT_BADGE_INFO (for badgeInfo) and an error message. 

badgeServiceUtil.badgeInfoPromise(badgeId):andThen(function(badgeInfo)

end):catch(function(defaultBadgeInfo, errorMessage)

end)

checkPlayerBadgesPromise​

</>
badgeServiceUtil.checkPlayerBadgesPromise(
playerUserId: number,
badgeIds: {number}
) → Promise<{number}>

Returns a promise which is resolved wih an array of badge ids the given player owns. This is just a wrapper over BadgeService:GetBadgeInfoAsync.

If the promise rejects, it will reject with an empty table (for playerOwnedBadgeIds) and an error message.

badgeServiceUtil.checkPlayerBadgesPromise(playerUserId, badgeIds):andThen(function(playerOwnedBadgeIds)

end):catch(function(playerOwnedBadgeIds, errorMessage)
	-- `playerOwnedBadgeIds` will be an empty array
end)

playerHasBadgePromise​

</>
badgeServiceUtil.playerHasBadgePromise(
playerUserId: number,
badgeId: number
) → Promise<boolean>

Returns a promise which is resolved wih a boolean indicating whether or not the given player has the specified badge or not. This is just a wrapper over BadgeService:UserHasBadgeAsync.

If the promise rejects, it will reject with false (for playerHasBadge) and an error message.

badgeServiceUtil.playerHasBadgePromise(playerUserId, badgeId):andThen(function(playerHasBadge)

end):catch(function(playerHasBadge, errorMessage)
	-- `playerHasBadge` will always be `false` here
end)

awardBadgeToPlayerPromise​

</>
badgeServiceUtil.awardBadgeToPlayerPromise(
playerUserId: number,
badgeId: number
) → Promise<boolean>

Returns a promise which is resolved once the given player has being successfully awarded with the given badge. This is just a wrapper over BadgeService:AwardBadge. 

badgeServiceUtil.awardBadgeToPlayerPromise(playerUserId, badgeId):andThen(function(playerWasAwardedBadge)

end):catch(function(playerWasAwardedBadge, errorMessage)
	-- `playerWasAwardedBadge` will always be `false` here
end)

If the promise rejects, it will reject with false (for playerWasAwardedBadge) and an error message.

Show raw api
{
    "functions": [
        {
            "name": "badgeInfoPromise",
            "desc": "Returns a [promise](https://eryn.io/roblox-lua-promise/) which is resolved wih the badge info of the given\nbadge id. This is just a wrapper over [BadgeService:GetBadgeInfoAsync](https://create.roblox.com/docs/reference/engine/classes/BadgeService#GetBadgeInfoAsync).\n\nIf the promise rejects, it will reject with a **shallow copy** of [DEFAULT_BADGE_INFO] (for `badgeInfo)` \nand an error message.\n\n```lua\nbadgeServiceUtil.badgeInfoPromise(badgeId):andThen(function(badgeInfo)\n\nend):catch(function(defaultBadgeInfo, errorMessage)\n\nend)\n```",
            "params": [
                {
                    "name": "badgeId",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "Promise<BadgeInfo>"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 61,
                "path": "src/badgeServiceUtil/init.luau"
            }
        },
        {
            "name": "checkPlayerBadgesPromise",
            "desc": "Returns a [promise](https://eryn.io/roblox-lua-promise/) which is resolved wih an array of badge ids the given player owns.\nThis is just a wrapper over [BadgeService:GetBadgeInfoAsync](https://create.roblox.com/docs/reference/engine/classes/BadgeService#GetBadgeInfoAsync).\n\nIf the promise rejects, it will reject with an empty table (for `playerOwnedBadgeIds`) and an error message.\n\n```lua\nbadgeServiceUtil.checkPlayerBadgesPromise(playerUserId, badgeIds):andThen(function(playerOwnedBadgeIds)\n\nend):catch(function(playerOwnedBadgeIds, errorMessage)\n\t-- `playerOwnedBadgeIds` will be an empty array\nend)\n```",
            "params": [
                {
                    "name": "playerUserId",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "badgeIds",
                    "desc": "",
                    "lua_type": "{ number }"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "Promise<{number}>"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 90,
                "path": "src/badgeServiceUtil/init.luau"
            }
        },
        {
            "name": "playerHasBadgePromise",
            "desc": "Returns a [promise](https://eryn.io/roblox-lua-promise/) which is resolved wih a boolean indicating\nwhether or not the given player has the specified badge or not. This is just a wrapper over \n[BadgeService:UserHasBadgeAsync](https://create.roblox.com/docs/reference/engine/classes/BadgeService#UserHasBadgeAsync).\n\nIf the promise rejects, it will reject with `false` (for `playerHasBadge`) and an error message.\n\n```lua\nbadgeServiceUtil.playerHasBadgePromise(playerUserId, badgeId):andThen(function(playerHasBadge)\n\nend):catch(function(playerHasBadge, errorMessage)\n\t-- `playerHasBadge` will always be `false` here\nend)\n```",
            "params": [
                {
                    "name": "playerUserId",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "badgeId",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "Promise<boolean>"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 121,
                "path": "src/badgeServiceUtil/init.luau"
            }
        },
        {
            "name": "awardBadgeToPlayerPromise",
            "desc": "Returns a [promise](https://eryn.io/roblox-lua-promise/) which is resolved once the given player\nhas being successfully awarded with the given badge. This is just a wrapper over \n[BadgeService:AwardBadge](https://create.roblox.com/docs/reference/engine/classes/BadgeService#AwardBadge).\n\n```lua\nbadgeServiceUtil.awardBadgeToPlayerPromise(playerUserId, badgeId):andThen(function(playerWasAwardedBadge)\n\nend):catch(function(playerWasAwardedBadge, errorMessage)\n\t-- `playerWasAwardedBadge` will always be `false` here\nend)\n```\n\nIf the promise rejects, it will reject with `false` (for `playerWasAwardedBadge`) and an error message.",
            "params": [
                {
                    "name": "playerUserId",
                    "desc": "",
                    "lua_type": "number"
                },
                {
                    "name": "badgeId",
                    "desc": "",
                    "lua_type": "number"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "Promise<boolean>"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 152,
                "path": "src/badgeServiceUtil/init.luau"
            }
        }
    ],
    "properties": [],
    "types": [
        {
            "name": "BadgeInfo",
            "desc": "",
            "fields": [
                {
                    "name": "Name",
                    "lua_type": "string",
                    "desc": ""
                },
                {
                    "name": "Description",
                    "lua_type": "string",
                    "desc": ""
                },
                {
                    "name": "IconImageId",
                    "lua_type": "string",
                    "desc": ""
                },
                {
                    "name": "IsEnabled",
                    "lua_type": "boolean",
                    "desc": ""
                }
            ],
            "source": {
                "line": 15,
                "path": "src/badgeServiceUtil/init.luau"
            }
        },
        {
            "name": "DEFAULT_BADGE_INFO",
            "desc": ":::warning Not Accessible\nConstant, not accesible within `badgeServiceUtil`.\n:::",
            "fields": [
                {
                    "name": "Name",
                    "lua_type": "\"\"",
                    "desc": ""
                },
                {
                    "name": "Description",
                    "lua_type": "\"\"",
                    "desc": ""
                },
                {
                    "name": "IconImageId",
                    "lua_type": "\"\"",
                    "desc": ""
                },
                {
                    "name": "IsEnabled",
                    "lua_type": "false",
                    "desc": ""
                }
            ],
            "tags": [
                "Constant"
            ],
            "source": {
                "line": 30,
                "path": "src/badgeServiceUtil/init.luau"
            }
        }
    ],
    "name": "badgeServiceUtil",
    "desc": " \n\nAn utility module for working with [BadgeService](https://create.roblox.com/docs/reference/engine/classes/BadgeService).",
    "source": {
        "line": 6,
        "path": "src/badgeServiceUtil/init.luau"
    }
}