// Ctkapi ticket functions // https://ws.core.rackspace.com/ctkapi/browse/Ticket package goctk import ( "encoding/json" "errors" "fmt" "strconv" ) // Start ticket by queue status, requires queue name, limit, offset and status you are looking for. // status types and additional info type ( TicketByQueueStatus struct { Class string `json:"class"` LoadArg json.RawMessage `json:"load_arg"` Count int `json:"count"` Limit int `json:"limit"` Offset int `json:"offset"` Result []*TicketByQueueResult `json:"result"` } TicketByQueueResult struct { Number string `json:"number"` Account string `json:"account.number"` Status string `json:"status.name"` Assignee string `json:"assignee.name"` QueueID int `json:"queue.id"` Computers []int `json:"computers.number"` Subject string `json:"subject,omitempty"` Messages []*string `json:"all_messages.text,omitempty"` LastResponse string `json:"last_response_data,omitempty"` } // TicketData type represents the data returned from CTK containing details // about a ticket TicketData struct { Number string `json:"number"` Account string `json:"account.number"` Status string `json:"status.name"` Assignee string `json:"assignee.name"` QueueID int `json:"queue.id"` Computers []int `json:"computers.number"` Subject string `json:"subject,omitempty"` Messages []string `json:"all_messages.text,omitempty"` Modified string `json:"modified,omitempty"` } DeviceListByTicket struct { Count int `json:"count"` Limit int `json:"limit"` Result []TicketDeviceList `json:"result"` Offset int `json:"offset"` Class string `json:"class"` } TicketDeviceList struct { Ticket string `json:"ticket"` Computers []int `json:"computers"` } TicketsByUser struct { Class string `json:"class"` LoadArg json.RawMessage `json:"load_arg"` Count int `json:"count"` Limit int `json:"limit"` Offset int `json:"offset"` Result []*TicketListForUser `json:"result"` } TicketListForUser struct { Number string `json:"number"` Modified string `json:"modified"` Status string `json:"status.name"` Computers []int `json:"computers.number"` Subject string `json:"subject"` Queue string `json:"queue.description"` IdleTime string `json:"idle"` TicketAge string `json:"age"` } // TicketQueue type represents the result struct received from the // CTK Ticket.Queue class TicketQueue struct { ID int `json:"id"` Name string `json:"name"` Status map[int]string `json:"status"` } ) func (c *Client) TicketByDevicesQueue(devices []int, queue string, limit, offset int) (*TicketByQueueStatus, error) { type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "account.number", "status.name", "assignee.name", "computers.number"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []string{"queue_name", "=", queue}, "&", []interface{}{"computer", "in", devices}, }, Limit: &limit, Offset: &offset, }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r TicketByQueueStatus err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) TicketByQueueStatus(queue string, limit, offset, status int) (*TicketByQueueStatus, error) { type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "status.name", "assignee.name", "computers.number"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []string{"queue_name", "=", queue}, "&", []interface{}{"status_type", "=", status}, }, Limit: &limit, Offset: &offset, }, } js, err := json.Marshal(t) if err != nil { return nil, err } fmt.Println(string(js)) res, err := c.Query(js) if err != nil { return nil, err } var r TicketByQueueStatus err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) TicketByQueueAndDevice(queue string, limit, offset, device int) (*TicketByQueueStatus, error) { type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "status.name", "assignee.name", "computers.number"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []string{"queue_name", "=", queue}, "&", []interface{}{"computer", "=", device}, }, Limit: &limit, Offset: &offset, }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r TicketByQueueStatus err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) QueueTicketAndMessages(queue string, limit, offset, status int) (*TicketByQueueStatus, error) { type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "account.number", "status.name", "assignee.name", "computers.number", "subject", "all_messages.text", "queue.id"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []string{"queue_name", "=", queue}, "&", []interface{}{"status_type", "=", status}, }, Limit: &limit, Offset: &offset, }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r TicketByQueueStatus err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) QueueTicketTitle(queue string, limit, offset, status int) (*TicketByQueueStatus, error) { type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "account.number", "status.name", "assignee.name", "computers.number", "subject"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []string{"queue_name", "=", queue}, "&", []interface{}{"status_type", "=", status}, }, Limit: &limit, Offset: &offset, }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r TicketByQueueStatus err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) TicketsDevices(tickets []string) (*DeviceListByTicket, error) { type attributes struct { Computers string `json:"computers"` Ticket string `json:"ticket"` } type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes attributes `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{"number", "in", tickets}, }, Attributes: attributes{ Computers: "computers.number", Ticket: "number", }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r DeviceListByTicket err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return &r, nil } func (c *Client) TicketDevices(ticket string) (*TicketDeviceList, error) { type attributes struct { Computers string `json:"computers"` Ticket string `json:"ticket"` } type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes attributes `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{"number", "=", ticket}, }, Attributes: attributes{ Computers: "computers.number", Ticket: "number", }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r DeviceListByTicket err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } for _, t := range r.Result { if t.Ticket == ticket { return &t, nil } } return nil, errors.New("goctk.Client.TicketDevices: unable to find ticket data") } func (c *Client) TicketsForUserByDay(sso string, date string) ([]*TicketListForUser, error) { user, err := c.ContactBySso(sso) if err != nil { return nil, err } type ctk struct { Class string `json:"class"` LoadArg LoadArg `json:"load_arg"` Attributes []string `json:"attributes"` } t := ctk{ Class: "Ticket.Ticket", Attributes: []string{"number", "modified", "status.name", "subject", "computers.number", "idle", "age", "queue.description"}, LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{ []interface{}{"message_operative", "=", user.ID}, "&", []string{"message_date", ">=", date + " 00:00:00"}, "&", []string{"message_date", "<=", date + " 23:59:59"}, }, }, } js, err := json.Marshal(t) if err != nil { return nil, err } res, err := c.Query(js) if err != nil { return nil, err } var r TicketsByUser err = json.Unmarshal(res, &[]interface{}{&r}) if err != nil { return nil, err } return r.Result, nil } var ( ticketAddMsg = `{"class": "Ticket.Ticket", "load_arg": "%s", "method":"addMessage", "args":[%s, 3, %t], "keyword_args":{"has_bbcode": true}, "result_map": { "status": "status.name", "number":"number" }}` ticketSetStatus = `{"class": "Ticket.Ticket","load_arg": "%s","method":"setStatusByName","args":["%s"],"keyword_args":{}}` ticketChangeQueue = `{"class":"Ticket.Ticket","load_arg": "%s","set_attribute": {"queue": %d }}` ) type ( AddMsg struct { Count int `json:"count"` LoadArg string `json:"load_arg"` Limit int `json:"limit"` Success bool `json:"success"` Class string `json:"class"` Method string `json:"method"` } ChangeQueueQry struct { Count int `json:"count"` LoadArg string `json:"load_arg"` Limit int `json:"limit"` Class string `json:"class"` Result []ChangeResult `json:"result"` } ChangeResult struct { Queue string `json:"queue"` ID string `json:"id"` } ) // AddMessage method will take a core ticket number, message, and boolean to determine // private/public, and update the specified ticket with the message. func (c *Client) AddMessage(ticket, msg string, private bool) (AddMsg, error) { var tm AddMsg res, err := c.Query([]byte(fmt.Sprintf(ticketAddMsg, ticket, strconv.Quote(msg), private))) if err != nil { return tm, err } err = json.Unmarshal(res, &[]interface{}{&tm}) return tm, err } // ChangeStatus method will change the status of the specified ticket number to // the status passed in. The status will be set by the setStatusByName function, // so the passed in status will need to be status name (i.e. Confirm Solved) func (c *Client) ChangeStatus(ticket, status string) ([]byte, error) { return c.Query([]byte(fmt.Sprintf(ticketSetStatus, ticket, status))) } // ChangeQueue method will issue a query to CTK to set the specified ticket number // to the queue defined in the request. func (c *Client) ChangeQueue(ticket string, queue int) (ChangeResult, error) { var tc ChangeQueueQry res, err := c.Query([]byte(fmt.Sprintf(ticketChangeQueue, ticket, queue))) if err != nil { return ChangeResult{}, err } err = json.Unmarshal(res, &[]interface{}{&tc}) if err != nil { return ChangeResult{}, err } for _, r := range tc.Result { if r.ID == ticket { return r, nil } } return ChangeResult{}, errors.New("unable to find ticket close result") } // TicketData method takes a client receiver and a ticket to pull details about the passed in // ticket. Pass a bool of messages to return the messages contained within the ticket. func (c *Client) TicketData(ticket string, messages bool) (TicketData, error) { var ( attrs = []string{ "number", "account.number", "status.name", "assignee.name", "computers.number", "subject", "queue.id", "modified", } t = ctkWhereQuery{ Class: "Ticket.Ticket", LoadArg: LoadArg{ Class: "Ticket.TicketWhere", Values: []interface{}{"number", "=", ticket}, }, } ticketData = TicketData{} ) if messages { attrs = append(attrs, "all_messages.text") } t.Attributes = attrs js, err := json.Marshal(t) if err != nil { return ticketData, err } res, err := c.Query(js) if err != nil { return ticketData, err } var r coreResponse if err := json.Unmarshal(res, &r); err != nil { return ticketData, err } if len(r) != 1 { return ticketData, fmt.Errorf("response length incorrect: %v", r) } if len(r[0].Result) == 0 { return ticketData, fmt.Errorf("respons.Result length incorrect: %v", r[0].Result) } err = json.Unmarshal(r[0].Result[0], &ticketData) return ticketData, err } // Queues method will pull a listing of all queues from CORE, with optional like and not-like // parameters to filter the queues returned. func (c *Client) Queues(like, notLike []string) ([]TicketQueue, error) { var ( // Set a boolean to catch the last iteration when // the returned result is less than max. last = false // Base offset to start with offset = 0 limit = 250 // Make the response var queues = make([]TicketQueue, 0) ) type queuePayload struct { ID int `json:"id"` Name string `json:"name"` StatusNames []string `json:"statuses.name"` StatusIDs []int `json:"statuses.id"` } t := ctkWhereQuery{ Class: "Ticket.Queue", Attributes: []string{ "id", "name", "statuses.name", "statuses.id", }, LoadArg: LoadArg{ Class: "Ticket.QueueWhere", Values: []interface{}{ []interface{}{"active", "=", true}, }, Limit: &limit, Offset: &offset, }, } // Filter items that do not contain values for _, item := range notLike { t.LoadArg.Values = append(t.LoadArg.Values, "&", []interface{}{"name", "not like", item}, ) } // Filter items that do contain values for _, item := range like { t.LoadArg.Values = append(t.LoadArg.Values, "&", []interface{}{"name", "like", item}, ) } for { t.LoadArg.Limit = &limit t.LoadArg.Offset = &offset js, err := json.Marshal(t) if err != nil { return queues, err } res, err := c.Query(js) if err != nil { return queues, err } var r coreResponse if err := json.Unmarshal(res, &r); err != nil { return queues, err } if len(r) != 1 { return queues, fmt.Errorf("response length incorrect: %v", r) } if len(r[0].Result) == 0 { return queues, fmt.Errorf("respons.Result length incorrect: %v", r[0].Result) } for _, rawMsg := range r[0].Result { var q queuePayload if err := json.Unmarshal(rawMsg, &q); err != nil { return nil, err } queues = append(queues, TicketQueue{ ID: q.ID, Name: q.Name, Status: func() map[int]string { r := make(map[int]string) for i, v := range q.StatusNames { if len(q.StatusIDs) > i { r[q.StatusIDs[i]] = v } } return r }(), }) } // Increment the offset to the next iteration offset += 250 // If the returned count is less than the max returned, // then that means we are on our last iteration. if r[0].Count < 250 { last = true } // If the last flag was set, break out of the loop if last { break } } return queues, nil }