@whitewall/blip-sdk 0.0.136 → 0.0.137

package/src/namespaces/desk.ts

@@ -0,0 +1,679 @@
+import type { BlipClient } from '../client.ts'
+import { BlipError } from '../sender/bliperror.ts'
+import {
+    type AttendanceHour,
+    type DetailedAttendanceHour,
+    type Identity,
+    Node,
+    type ThreadItem,
+    type Ticket,
+    type TicketStatus,
+} from '../types/index.ts'
+import type { ODataFilter } from '../utils/odata.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class DeskNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'desk', defaultOptions)
+    }
+
+    public async createTicket(contact: Identity, opts?: ConsumeOptions): Promise<Ticket> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/tickets`,
+                type: 'application/vnd.iris.ticket+json',
+                resource: {
+                    customerIdentity: contact,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async getTicket(ticket: string, opts?: ConsumeOptions): Promise<Ticket> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/ticket/${ticket}`,
+            },
+            opts,
+        )
+    }
+
+    public async getTicketMessages(ticket: Ticket, opts?: Omit<ConsumeOptions, 'skip'>): Promise<Array<ThreadItem>>
+    public async getTicketMessages(ticket: string, opts?: Omit<ConsumeOptions, 'skip'>): Promise<Array<ThreadItem>>
+    public async getTicketMessages(
+        ticketOrTicketId: Ticket | string,
+        opts?: Omit<ConsumeOptions, 'skip'>,
+    ): Promise<Array<ThreadItem>> {
+        const ticket =
+            typeof ticketOrTicketId === 'string' ? await this.getTicket(ticketOrTicketId, opts) : ticketOrTicketId
+
+        // Include the message that originated the ticket
+        const storageDate = new Date(ticket.storageDate)
+        storageDate.setSeconds(storageDate.getSeconds() - 10)
+
+        const thread = await this.blipClient.account.getThread(
+            ticket.customerIdentity,
+            {
+                referenceDate: storageDate,
+                referenceDateDirection: 'after',
+            },
+            opts,
+        )
+        return thread
+            .filter((item) => new Date(item.date) >= new Date(storageDate))
+            .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(
+            {
+                method: 'get',
+                uri: uri`/monitoring/ticket-metrics?${{ version: 2 }}`,
+            },
+            opts,
+        )
+    }
+
+    public async getWaitingTicketsMetrics(
+        filters?: {
+            teams?: Array<string>
+            tags?: Array<string>
+            operators?: Array<string>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<
+        Array<{
+            id: string
+            sequentialId: number
+            customerIdentity: Identity
+            customerName: string
+            team: string
+            queueTime: string
+            priority: number
+            agentIdentity?: Identity
+            agentName?: string
+        }>
+    > {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/monitoring/waiting-tickets?${{
+                    teams: filters?.teams?.join(','),
+                    tags: filters?.tags?.join(','),
+                    operators: filters?.operators?.join(','),
+                }}`,
+            },
+            {
+                collection: true,
+                take: opts?.fetchall ? (opts?.max ?? 1_000_000) : opts?.take,
+                fetchall: false,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTickets(filter?: ODataFilter<Ticket>, opts?: ConsumeOptions): Promise<Array<Ticket>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tickets?${{ $filter: filter?.toString() }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getContactTickets(contact: Identity, opts?: ConsumeOptions): Promise<Array<Ticket>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tickets/history-merged/${contact}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async changeTicketStatus(
+        ticket: string,
+        status: TicketStatus,
+        settings?: {
+            agent?: Identity
+            closedBy?: Identity
+            tags?: Array<string>
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        try {
+            return await this.sendCommand(
+                {
+                    method: 'set',
+                    uri: uri`/tickets/change-status`,
+                    type: 'application/vnd.iris.ticket+json',
+                    resource: {
+                        id: ticket,
+                        status,
+                        tags: settings?.tags,
+                        agentIdentity: settings?.agent,
+                        closedBy: settings?.closedBy,
+                    },
+                },
+                opts,
+            )
+        } catch (err) {
+            if (err instanceof BlipError && err.code === 64) {
+                return
+            }
+
+            throw err
+        }
+    }
+
+    public async changeTicketTags(ticket: string, tags: Array<string>, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/tickets/${ticket}/change-tags`,
+                type: 'application/vnd.iris.ticket+json',
+                resource: {
+                    id: ticket,
+                    tags,
+                },
+            },
+            opts,
+        )
+    }
+
+    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 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 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
+            }
+
+            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()) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    public async getApprovedMessageTemplates(opts?: ConsumeOptions): Promise<
+        Array<{
+            id: string
+            is_favorite: boolean
+            category: string
+            language: string
+            last_updated_time: string
+            name: string
+            status: 'APPROVED' | 'REJECTED' | 'PENDING'
+        }>
+    > {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/active-message/approved-message-templates`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getMessageTemplateParams(opts?: ConsumeOptions) {
+        const params: Array<{
+            params?: {
+                paramsId: number
+                ownerIdentity: string
+                templateId: string
+                stateId: string
+                isEnabled: boolean
+                storageDate: string
+                modifyDate: string
+            }
+            template: {
+                Id: string
+                Category: string
+                Components: Array<
+                    {
+                        Type: string
+                    } & Record<string, unknown>
+                >
+                Language: string
+                LastUpdatedTime: string
+                Name: string
+                RejectedReason: string
+                Status: 'APPROVED' | 'REJECTED' | 'PENDING'
+            }
+        }> = await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/active-message/message-templates-params`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+
+        return params.map((param) => ({
+            template: param.template.Name,
+            category: param.template.Category,
+            language: param.template.Language,
+            status: param.template.Status,
+            ownerIdentity: param.params?.ownerIdentity,
+            stateId: param.params?.stateId,
+            isEnabled: param.params?.isEnabled,
+            components: param.template.Components.map((c) => ({
+                type: c.Type,
+                text: c.Text as string | undefined,
+            })),
+        }))
+    }
+
+    public async sendIndividualActiveMessage(
+        phoneNumber: string,
+        message: { template: string; language: string; variables: Array<string> },
+        sender: Node,
+        opts?: ConsumeOptions,
+    ) {
+        await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/active-message/send-active-message`,
+                type: 'application/vnd.iris.activecampaign.full-campaign+json',
+                resource: {
+                    campaign: {
+                        campaignType: 'Individual',
+                        CampaignSender: sender,
+                        attendanceRedirect: sender,
+                    },
+                    audience: {
+                        recipient: phoneNumber,
+                        recipientType: 'phoneNumber',
+                        channelType: 'whatsApp',
+                        messageParams: { ...message.variables },
+                    },
+                    message: {
+                        messageTemplate: message.template,
+                        channelType: 'whatsapp',
+                        messageParams: message.variables.length ? Object.keys(message.variables).map(Number) : '',
+                        messageTemplateLanguage: message.language,
+                    },
+                },
+            },
+            opts,
+        )
+    }
+
+    public async getTeamsAgentsOnline(opts?: ConsumeOptions): Promise<
+        Array<{
+            name: string
+            agentsOnline: number
+        }>
+    > {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/teams/agents-online`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getAgents(opts?: ConsumeOptions): Promise<
+        Array<{
+            email: string
+            fullName: string
+            identity: Identity
+            isEnabled: boolean
+            status: 'Offline' | 'Pause' | 'Online' | 'Invisible'
+            teams: Array<string>
+            lastServiceDate: string
+        }>
+    > {
+        try {
+            return await this.sendCommand(
+                {
+                    method: 'get',
+                    uri: uri`/agents`,
+                },
+                {
+                    collection: true,
+                    ...opts,
+                },
+            )
+        } catch (err) {
+            if (err instanceof BlipError && err.code === 67) {
+                return []
+            }
+
+            throw err
+        }
+    }
+
+    /** @returns The new child ticket created from the transfer */
+    public async transferTicket(
+        ticket: string,
+        teamOrAgentIdentity: Identity | string,
+        transferredBy?: Identity,
+        opts?: ConsumeOptions,
+    ): Promise<Ticket> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/tickets/${ticket}/transfer`,
+                type: 'application/vnd.iris.ticket+json',
+                resource: {
+                    team: Node.isValid(teamOrAgentIdentity) ? 'DIRECT_TRANSFER' : teamOrAgentIdentity,
+                    agentIdentity: Node.isValid(teamOrAgentIdentity) ? teamOrAgentIdentity : undefined,
+                    closedBy: transferredBy,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async sendTicketSurveyAnswer(
+        ticket: string,
+        survey: string,
+        details: {
+            answer: string
+            answerScore: number
+            comment?: string
+        },
+        opts?: ConsumeOptions,
+    ) {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/attendance-survey-answer`,
+                type: 'application/vnd.iris.desk.attendance-survey-answer+json',
+                resource: {
+                    ticketId: ticket,
+                    survey: survey,
+                    answer: details.answer,
+                    answerScore: details.answerScore.toString(),
+                    comment: details.comment ?? '',
+                },
+            },
+            opts,
+        )
+    }
+
+    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 getSummary(
+        ticket: string,
+        opts?: ConsumeOptions,
+    ): Promise<{
+        summary: {
+            customer_data: {
+                name: string
+            }
+            contact: {
+                date: string
+                reason: string
+                conclusion: string
+                sentiment: string
+            }
+        }
+    }> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tickets/${ticket}/copilot/thread-end-summary`,
+            },
+            opts,
+        )
+    }
+
+    public async setCustomChannel(
+        url: string,
+        settings?: {
+            token?: string
+        },
+        opts?: ConsumeOptions,
+    ) {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+        if (!configurations || !configurations.DefaultProvider) {
+            throw new Error('No default provider found, Blip Desk is not enabled')
+        }
+
+        await this.blipClient.account.setConfigurations(
+            {
+                DefaultProvider: 'Webhook',
+                'Webhook.ApiEndpoint': url,
+                'Webhook.AuthenticationToken': settings?.token ?? '',
+            },
+            {
+                ...opts,
+                ownerIdentity: this.identity,
+            },
+        )
+    }
+
+    public async getCustomChannel(opts?: ConsumeOptions): Promise<{
+        url: string
+        token: string
+    }> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        if (!configurations || !configurations.DefaultProvider) {
+            throw new Error('No default provider found')
+        }
+
+        if (configurations.DefaultProvider !== 'Webhook') {
+            throw new Error('Default provider is not Webhook')
+        }
+
+        return {
+            url: configurations['Webhook.ApiEndpoint'],
+            token: configurations['Webhook.AuthenticationToken'],
+        }
+    }
+
+    public async addExtension(
+        id: string,
+        settings: {
+            name: string
+            view: 'ticket' | 'agent'
+            url: string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        const extensions = 'Extensions' in configurations ? JSON.parse(configurations.Extensions) : {}
+        extensions[id] = settings
+
+        return await this.blipClient.account.setConfigurations(
+            { Extensions: JSON.stringify(extensions) },
+            { ...opts, ownerIdentity: this.identity },
+        )
+    }
+
+    public async updateExtension(
+        id: string,
+        settings: Partial<{
+            name: string
+            view: 'ticket' | 'agent'
+            url: string
+        }>,
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        if ('Extensions' in configurations) {
+            const extensions = JSON.parse(configurations.Extensions) as Record<string, { name: string; url: string }>
+            if (id in extensions) {
+                extensions[id] = { ...extensions[id], ...settings }
+                return await this.blipClient.account.setConfigurations(
+                    { Extensions: JSON.stringify(extensions) },
+                    { ...opts, ownerIdentity: this.identity },
+                )
+            } else {
+                throw new Error(`Extension with id "${id}" not found`)
+            }
+        } else {
+            throw new Error('No extensions found')
+        }
+    }
+
+    public async deleteExtension(id: string, opts?: ConsumeOptions): Promise<void>
+    public async deleteExtension(url: string | RegExp, opts?: ConsumeOptions): Promise<void>
+    public async deleteExtension(idOrUrl: string | RegExp, opts?: ConsumeOptions): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        if ('Extensions' in configurations) {
+            const extensions = JSON.parse(configurations.Extensions) as Record<string, { name: string; url: string }>
+            for (const id in extensions) {
+                if (
+                    (idOrUrl instanceof RegExp && idOrUrl.test(extensions[id].url)) ||
+                    (typeof idOrUrl === 'string' && (idOrUrl === id || extensions[id].url === idOrUrl))
+                ) {
+                    delete extensions[id]
+                }
+
+                return await this.blipClient.account.setConfigurations(
+                    { Extensions: JSON.stringify(extensions) },
+                    { ...opts, ownerIdentity: this.identity },
+                )
+            }
+        }
+    }
+
+    public async createAgent(
+        agent: {
+            identity: Identity
+            teams: Array<string>
+            agentSlots?: number
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/agents`,
+                type: 'application/vnd.iris.desk.attendant+json',
+                resource: agent,
+            },
+            opts,
+        )
+    }
+
+    public async deleteAgent(identity: Identity, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/agents/${identity}`,
+            },
+            {
+                ...opts,
+            },
+        )
+    }
+}

package/src/namespaces/media.ts

@@ -0,0 +1,39 @@
+import type { BlipClient } from '../client.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class MediaNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'media', defaultOptions)
+    }
+
+    public async getMediaUploadUrl(opts?: ConsumeOptions): Promise<string> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/upload-media-uri`,
+            },
+            opts,
+        )
+    }
+
+    public async uploadMedia(
+        mimetype: string,
+        media: BufferSource | Blob | string | ReadableStream,
+        opts?: ConsumeOptions,
+    ): Promise<string> {
+        const url = await this.getMediaUploadUrl(opts)
+        const uploadResponse = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': mimetype,
+            },
+            body: media,
+        })
+        if (!uploadResponse.ok) {
+            throw new Error(`Failed to upload media: ${uploadResponse.statusText}`)
+        }
+        const { mediaUri } = await uploadResponse.json()
+        return mediaUri
+    }
+}