@whitewall/blip-sdk 0.0.173 → 0.0.175

package/src/namespaces/desk.ts

@@ -2,6 +2,9 @@ import type { BlipClient } from '../client.ts'
 import { BlipError } from '../sender/bliperror.ts'
 import {
     type AttendanceHour,
+    type DeskAttendanceQueue,
+    type DeskPriorityRule,
+    type DeskRule,
     type DetailedAttendanceHour,
     type Identity,
     Node,
@@ -10,6 +13,10 @@ import {
     type TicketStatus,
 } from '../types/index.ts'
 import type { WhatsAppTemplateLanguage } from '../types/whatsapp.ts'
+import {
+    isOnAttendanceTime as isDetailedAttendanceHourOnAttendanceTime,
+    matchesAttendanceHourQueue,
+} from '../utils/desk.ts'
 import type { ODataFilter } from '../utils/odata.ts'
 import { uri } from '../utils/uri.ts'
 import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
@@ -69,23 +76,31 @@ export class DeskNamespace extends Namespace {
             .filter((item) => !ticket.closeDate || new Date(item.date) <= new Date(ticket.closeDate))
     }
 
-    public async getTicketsMetrics(opts?: ConsumeOptions): Promise<{
-        maxQueueTime: string
-        maxFirstResponseTime: string
-        avgQueueTime: string
-        avgFirstResponseTime: string
-        avgWaitTime: string
-        avgResponseTime: string
-        avgAttendanceTime: string
-        ticketsPerAttendant: number
-    }> {
-        return await this.sendCommand(
+    public async getTicketsMetrics(opts?: ConsumeOptions) {
+        const metrics = await this.sendCommand<
+            'get',
+            {
+                maxQueueTime: string
+                maxFirstResponseTime: string
+                avgQueueTime: string
+                avgFirstResponseTime: string
+                avgWaitTime: string
+                avgResponseTime: string
+                avgAttendanceTime: string
+                ticketsPerAttendant: number
+            }
+        >(
             {
                 method: 'get',
                 uri: uri`/monitoring/ticket-metrics?${{ version: 2 }}`,
             },
             opts,
         )
+
+        return {
+            ...metrics,
+            ticketsPerAttendant: Number(metrics.ticketsPerAttendant),
+        }
     }
 
     public async getWaitingTicketsMetrics(
@@ -126,6 +141,318 @@ export class DeskNamespace extends Namespace {
         )
     }
 
+    /** @param filters.filter - Optional OData filter applied by the Desk backend when listing queues. */
+    public async getQueues(
+        filters?: {
+            filter?: ODataFilter<DeskAttendanceQueue>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<DeskAttendanceQueue>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/attendance-queues?${{
+                    $filter: filters?.filter?.toString(),
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getQueue(queueId: string, opts?: ConsumeOptions): Promise<DeskAttendanceQueue> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/attendance-queues/${queueId}`,
+            },
+            opts,
+        )
+    }
+
+    public async getQueueByName(queueName: string, opts?: ConsumeOptions): Promise<DeskAttendanceQueue> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/attendance-queues/name/${queueName}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param queue.id - Optional queue id. If omitted, Iris generates one from `uniqueId`.
+     * @param queue.ownerIdentity - Optional owner identity. Iris usually infers it from the command context.
+     * @param queue.name - Queue display name.
+     * @param queue.isActive - Whether the queue should accept new tickets.
+     * @param queue.storageDate - Optional original creation date for updates.
+     * @param queue.Priority - Optional queue ordering priority.
+     * @param queue.uniqueId - Optional queue unique id. Iris generates one when missing.
+     * @param queue.attendanceHourId - Optional attendance hour id linked to this queue.
+     */
+    public async setQueue(queue: DeskAttendanceQueue, opts?: ConsumeOptions): Promise<DeskAttendanceQueue> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/attendance-queues`,
+                type: 'application/vnd.iris.desk.attendancequeue+json',
+                resource: queue,
+            },
+            opts,
+        )
+    }
+
+    public async deleteQueue(queueId: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/attendance-queues/${queueId}`,
+            },
+            opts,
+        )
+    }
+
+    /** @param filters.filter - Optional OData filter applied to the stored rules. */
+    public async getRules(
+        filters?: {
+            filter?: ODataFilter<DeskRule>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<DeskRule>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/rules?${{
+                    $filter: filters?.filter?.toString(),
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getRule(ruleId: string, opts?: ConsumeOptions): Promise<DeskRule> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/rules/${ruleId}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param queue - Queue selector used by `/rules/queue/{queue}`. Iris matches this value against the rule `team` field.
+     * @param filters.filter - Optional OData filter applied after the queue selector.
+     */
+    public async getRulesByQueue(
+        queue: string,
+        filters?: {
+            filter?: ODataFilter<DeskRule>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<DeskRule>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/rules/queue/${queue}?${{
+                    $filter: filters?.filter?.toString(),
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    /**
+     * @param rule.id - Optional existing rule id.
+     * @param rule.ownerIdentity - Optional owner identity override.
+     * @param rule.title - Rule display name.
+     * @param rule.team - Queue name that receives matching tickets.
+     * @param rule.property - Legacy single-condition property. Prefer `conditions`.
+     * @param rule.relation - Legacy single-condition relation. Prefer `conditions`.
+     * @param rule.isActive - Whether the rule can be applied to new tickets.
+     * @param rule.values - Legacy single-condition values. Prefer `conditions`.
+     * @param rule.conditions - Preferred list of rule conditions evaluated by Iris.
+     * @param rule.operator - Logical operator used between `conditions`.
+     * @param rule.priority - Optional explicit processing order.
+     * @param rule.storageDate - Optional original creation date for updates.
+     * @param rule.queueId - Optional queue unique id. When omitted, Iris resolves it from `team`.
+     */
+    public async setRule(rule: DeskRule, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/rules`,
+                type: 'application/vnd.iris.desk.rule+json',
+                resource: rule,
+            },
+            opts,
+        )
+    }
+
+    public async deleteRule(ruleId: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/rules/${ruleId}`,
+            },
+            opts,
+        )
+    }
+
+    public async getPriorityRules(opts?: ConsumeOptions): Promise<Array<DeskPriorityRule>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/priority-rules`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getPriorityRule(ruleId: string, opts?: ConsumeOptions): Promise<DeskPriorityRule> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/priority-rules/${ruleId}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param queueId - Queue unique id used by the priority rule engine.
+     * @param filters.filter - Optional OData filter applied after the queue selector.
+     */
+    public async getPriorityRulesByQueue(
+        queueId: string,
+        filters?: {
+            filter?: ODataFilter<DeskPriorityRule>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<DeskPriorityRule>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/priority-rules/queue/${queueId}?${{
+                    $filter: filters?.filter?.toString(),
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    /**
+     * @param rule.id - Optional existing rule id. Iris generates one when missing.
+     * @param rule.ownerIdentity - Optional owner identity override.
+     * @param rule.title - Rule display name.
+     * @param rule.queueId - Queue unique id that receives the urgency.
+     * @param rule.isActive - Whether the rule can be applied to new tickets.
+     * @param rule.conditions - Conditions evaluated when `applyConditions` is true.
+     * @param rule.operator - Logical operator used between `conditions`.
+     * @param rule.priority - Optional explicit processing order.
+     * @param rule.urgency - Priority boost applied to matching tickets.
+     * @param rule.applyConditions - When false, Iris applies the rule without evaluating `conditions`.
+     * @param rule.storageDate - Optional original creation date for updates.
+     */
+    public async setPriorityRule(rule: DeskPriorityRule, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/priority-rules`,
+                type: 'application/vnd.iris.desk.priority-rules+json',
+                resource: rule,
+            },
+            opts,
+        )
+    }
+
+    public async deletePriorityRule(ruleId: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/priority-rules/${ruleId}`,
+            },
+            opts,
+        )
+    }
+
+    /** @param filters.filter - Optional OData filter applied to the attendance-hour summary list. */
+    public async getAttendanceHours(
+        filters?: {
+            filter?: ODataFilter<AttendanceHour>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<AttendanceHour>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/attendance-hour?${{
+                    $filter: filters?.filter?.toString(),
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getAttendanceHourContainer(
+        attendanceHourId: string,
+        opts?: ConsumeOptions,
+    ): Promise<DetailedAttendanceHour> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/attendance-hour-container/${attendanceHourId}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param attendanceHour.attendanceHour - Summary fields for the attendance hour itself.
+     * @param attendanceHour.attendanceHourScheduleItems - Required weekly schedules for the attendance hour.
+     * @param attendanceHour.attendanceHourOffItems - Optional date ranges where attendance is suspended.
+     * @param attendanceHour.queues - Queue ids linked to this attendance hour.
+     * @param attendanceHour.attendants - Agent identities linked to this attendance hour.
+     */
+    public async setAttendanceHour(attendanceHour: DetailedAttendanceHour, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/attendance-hour`,
+                type: 'application/vnd.iris.desk.attendance-hour-container+json',
+                resource: attendanceHour,
+            },
+            opts,
+        )
+    }
+
+    public async deleteAttendanceHour(attendanceHourId: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/attendance-hour/${attendanceHourId}`,
+            },
+            opts,
+        )
+    }
+
     public async getTickets(filter?: ODataFilter<Ticket>, opts?: ConsumeOptions): Promise<Array<Ticket>> {
         return await this.sendCommand(
             {
@@ -139,6 +466,68 @@ export class DeskNamespace extends Namespace {
         )
     }
 
+    /**
+     * @param filters.beginDate - Required. Start of the `storageDate` range, applied inclusively.
+     * @param filters.endDate - Required. End of the `storageDate` range. Exact-second timestamps are treated as exclusive,
+     * while timestamps with a non-zero seconds component are treated as inclusive.
+     * @param filters.teams - Filters by ticket team. Values are combined as alternatives.
+     * @param filters.agentIdentities - Filters by ticket agent identity. Values are combined as alternatives.
+     * @param filters.customerIdentities - Filters by ticket customer identity. Values are combined as alternatives.
+     * @param filters.tags - Matches tickets that contain at least one of the provided tags.
+     * @param filters.ticketIds - Filters by the Desk sequential ticket id, not the ticket UUID `id`.
+     * @param filters.includeIdentitiesNames - Makes the backend try to resolve `agentName` and `customerName`.
+     */
+    public async getTicketsHistory(
+        filters: {
+            beginDate: string | Date
+            endDate: string | Date
+            teams?: Array<string>
+            agentIdentities?: Array<Identity>
+            customerIdentities?: Array<Identity>
+            tags?: Array<string>
+            ticketIds?: Array<string | number>
+            includeIdentitiesNames?: boolean
+        },
+        opts?: ConsumeOptions,
+    ): Promise<
+        Array<{
+            id: string
+            sequentialId: number
+            customerIdentity: Identity
+            customerName?: string
+            agentIdentity?: Identity
+            agentName?: string
+            status: TicketStatus
+            team?: string
+            waitingTimeInSeconds?: number
+            firstResponseTimeInSeconds?: number
+            attendanceTimeInSeconds?: number
+            hasWaitingTimeSlaExceeded: boolean
+            hasFirstResponseTimeSlaExceeded: boolean
+            hasAttendanceTimeSlaExceeded: boolean
+        }>
+    > {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tickets/history/v2?${{
+                    beginDate: filters.beginDate,
+                    endDate: filters.endDate,
+                    teams: filters.teams?.join(','),
+                    agentIdentities: filters.agentIdentities?.join(','),
+                    customerIdentities: filters.customerIdentities?.join(','),
+                    tags: filters.tags?.join(','),
+                    ticketIds: filters.ticketIds?.join(','),
+                    includeIdentitiesNames: filters.includeIdentitiesNames,
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
     public async getContactTickets(contact: Identity, opts?: ConsumeOptions): Promise<Array<Ticket>> {
         return await this.sendCommand(
             {
@@ -203,69 +592,26 @@ export class DeskNamespace extends Namespace {
     }
 
     public async isOnAttendanceTime(queueIdOrName = 'Default', timezone = -3): Promise<boolean> {
-        const attendanceHours: Array<AttendanceHour> = await this.sendCommand(
-            {
-                method: 'get',
-                uri: uri`/attendance-hour`,
-            },
-            { collection: true },
-        )
+        const attendanceHours = await this.getAttendanceHours()
 
         const orderedAttendanceHours = attendanceHours
             // Prioritize non-main attendance hours
             .sort((a, b) => Number(a.isMain) - Number(b.isMain))
 
         for (const attendanceHour of orderedAttendanceHours) {
-            const detailedAttendanceHour: DetailedAttendanceHour = await this.sendCommand({
-                method: 'get',
-                uri: uri`/attendance-hour-container/${attendanceHour.id}`,
-            })
-
-            if (
-                detailedAttendanceHour.queues.every(
-                    (queue) => queue.id !== queueIdOrName && queue.description !== queueIdOrName,
-                ) &&
-                !detailedAttendanceHour.attendanceHour.isMain
-            ) {
-                // Should keep trying other attendance hours to match the queue
-                continue
-            }
-
+            const detailedAttendanceHour = await this.getAttendanceHourContainer(attendanceHour.id)
             const now = new Date(Date.now() + timezone * 60 * 60 * 1000)
 
-            const isInsideOffTime = detailedAttendanceHour.attendanceHourOffItems.some((offItem) => {
-                const startDate = new Date(offItem.startDate)
-                const endDate = new Date(offItem.endDate)
-
-                return now.getTime() >= startDate.getTime() && now.getTime() <= endDate.getTime()
-            })
-            if (isInsideOffTime) {
-                return false
-            }
-
-            const nowDayOfWeek = now.getDay()
-            const daysOfWeek = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
-            const todaySchedule = detailedAttendanceHour.attendanceHourScheduleItems.find(
-                (schedule) => schedule.dayOfWeek === daysOfWeek[nowDayOfWeek],
-            )
-            if (!todaySchedule) {
-                return false
+            if (!matchesAttendanceHourQueue(detailedAttendanceHour, queueIdOrName)) {
+                // Should keep trying other attendance hours to match the queue
+                continue
             }
 
-            const startTime = new Date(now)
-            const endTime = new Date(now)
-
-            const [startHours, startMinutes] = todaySchedule.startTime.split(':')
-            startTime.setHours(Number(startHours))
-            startTime.setMinutes(Number(startMinutes))
-
-            const [endHours, endMinutes] = todaySchedule.endTime.split(':')
-            endTime.setHours(Number(endHours))
-            endTime.setMinutes(Number(endMinutes))
-
-            if (now.getTime() >= startTime.getTime() && now.getTime() <= endTime.getTime()) {
+            if (isDetailedAttendanceHourOnAttendanceTime(detailedAttendanceHour, now)) {
                 return true
             }
+
+            return false
         }
 
         return false
@@ -406,7 +752,6 @@ export class DeskNamespace extends Namespace {
             isEnabled: boolean
             status: 'Offline' | 'Pause' | 'Online' | 'Invisible'
             teams: Array<string>
-            lastServiceDate: string
         }>
     > {
         try {
@@ -478,18 +823,24 @@ export class DeskNamespace extends Namespace {
         )
     }
 
-    public async getTags(team: string, opts?: ConsumeOptions): Promise<Array<string>> {
-        const result = await this.sendCommand<'get', Array<{ tag: string }>>(
-            {
-                method: 'get',
-                uri: uri`/attendance-queues/name/${team}/tags`,
-            },
-            {
-                collection: true,
-                ...opts,
-            },
-        )
-        return result.map((tag) => tag.tag)
+    public async getTags(team?: string, opts?: ConsumeOptions): Promise<Array<string>> {
+        if (team && team !== 'DIRECT_TRANSFER') {
+            const result = await this.sendCommand<'get', Array<{ tag: string }>>(
+                {
+                    method: 'get',
+                    uri: uri`/attendance-queues/name/${team}/tags`,
+                },
+                {
+                    collection: true,
+                    ...opts,
+                },
+            )
+            return result.map((tag) => tag.tag)
+        } else {
+            const bucketTags = await this.blipClient.account.getBucket('blip:desk:tags')
+            const { tags } = JSON.parse(bucketTags ?? '{}')
+            return tags?.map((tag: { text: string }) => tag.text) ?? []
+        }
     }
 
     public async getSummary(
@@ -528,7 +879,7 @@ export class DeskNamespace extends Namespace {
             ...opts,
             ownerIdentity: this.identity,
         })
-        if (!configurations || !configurations.DefaultProvider) {
+        if (!configurations?.DefaultProvider) {
             throw new Error('No default provider found, Blip Desk is not enabled')
         }
 
@@ -554,7 +905,7 @@ export class DeskNamespace extends Namespace {
             ownerIdentity: this.identity,
         })
 
-        if (!configurations || !configurations.DefaultProvider) {
+        if (!configurations?.DefaultProvider) {
             throw new Error('No default provider found')
         }
 

package/src/namespaces/plugins.ts

@@ -370,6 +370,7 @@ export class PluginsNamespace extends Namespace {
         plugin: Partial<
             Pick<DetailedPlugin, 'name' | 'overview' | 'description' | 'icon' | 'documentation' | 'price'> & {
                 url: string
+                isPublished: boolean
             }
         >,
         opts?: ConsumeOptions,
@@ -388,6 +389,7 @@ export class PluginsNamespace extends Namespace {
                     url: plugin.url,
                     price: plugin.price,
                     isPaid: plugin.price !== undefined && plugin.price > 0,
+                    isPublished: plugin.isPublished,
                 },
             },
             opts,