Launching NICE CXone Outbound Campaigns with Go

What You Will Build

• This tutorial builds a Go service that constructs campaign definition payloads, validates contact list and DNC associations, launches campaigns asynchronously, and exposes a control API for orchestration.
• The implementation uses the NICE CXone REST API for campaign management, contact list verification, and real-time statistics.
• The programming language covered is Go, using standard library packages for HTTP, concurrency, and JSON serialization.

Prerequisites

• OAuth 2.0 Client Credentials flow with scopes: campaign:read campaign:write contactlist:read dnc:read statistics:read
• CXone API v2 (REST)
• Go 1.21 or later
• No external dependencies required. All code uses the standard library.

Authentication Setup

CXone uses OAuth 2.0 Client Credentials for server-to-server communication. The token endpoint returns a JWT that expires after one hour. You must cache the token and refresh it before expiration to avoid 401 errors during campaign polling.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"sync"
	"time"
)

type OAuthConfig struct {
	BaseURL        string
	ClientID       string
	ClientSecret   string
	Scope          string
}

type TokenResponse struct {
	AccessToken string `json:"access_token"`
	TokenType   string `json:"token_type"`
	ExpiresIn   int    `json:"expires_in"`
}

type TokenCache struct {
	mu        sync.Mutex
	token     string
	expiresAt time.Time
	config    OAuthConfig
	client    *http.Client
}

func NewTokenCache(cfg OAuthConfig) *TokenCache {
	return &TokenCache{
		config: cfg,
		client: &http.Client{Timeout: 10 * time.Second},
	}
}

func (c *TokenCache) GetToken(ctx context.Context) (string, error) {
	c.mu.Lock()
	if time.Now().Before(c.expiresAt.Add(-5 * time.Minute)) {
		token := c.token
		c.mu.Unlock()
		return token, nil
	}
	c.mu.Unlock()

	return c.refreshToken(ctx)
}

func (c *TokenCache) refreshToken(ctx context.Context) (string, error) {
	data := map[string]string{
		"grant_type":    "client_credentials",
		"client_id":     c.config.ClientID,
		"client_secret": c.config.ClientSecret,
		"scope":         c.config.Scope,
	}
	body := new(strings.Builder)
	for k, v := range data {
		if body.Len() > 0 {
			body.WriteString("&")
		}
		body.WriteString(fmt.Sprintf("%s=%s", k, v))
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.config.BaseURL+"/oauth/token", strings.NewReader(body.String()))
	if err != nil {
		return "", fmt.Errorf("failed to create token request: %w", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := c.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("token request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		b, _ := io.ReadAll(resp.Body)
		return "", fmt.Errorf("oauth error %d: %s", resp.StatusCode, string(b))
	}

	var tr TokenResponse
	if err := json.NewDecoder(resp.Body).Decode(&tr); err != nil {
		return "", fmt.Errorf("failed to decode token response: %w", err)
	}

	c.mu.Lock()
	c.token = tr.AccessToken
	c.expiresAt = time.Now().Add(time.Duration(tr.ExpiresIn) * time.Second)
	c.mu.Unlock()

	return tr.AccessToken, nil
}

Implementation

Step 1: Construct Campaign Definition and Validate Contact List Associations

Campaign creation requires a structured payload containing dialer type, pacing rules, and contact list references. You must verify that the contact list exists and that DNC compliance is enforced before submission.

type CampaignRequest struct {
	Name          string            `json:"name"`
	Description   string            `json:"description"`
	DialerType    string            `json:"dialerType"`
	Pacing        PacingConfig      `json:"pacing"`
	ContactListID string            `json:"contactListId"`
	DNC           DNCConfig         `json:"dnc"`
}

type PacingConfig struct {
	CallsPerMinute int `json:"callsPerMinute"`
	MaxConcurrent  int `json:"maxConcurrent"`
}

type DNCConfig struct {
	EnforceNational bool `json:"enforceNational"`
	EnforceLocal    bool `json:"enforceLocal"`
}

type ContactListResponse struct {
	ID             string `json:"id"`
	Name           string `json:"name"`
	RecordCount    int    `json:"recordCount"`
	DNCCompliant   bool   `json:"dncCompliant"`
	LastValidated  string `json:"lastValidated"`
}

func validateContactList(ctx context.Context, apiBaseURL, token, contactListID string) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/api/contactlists/%s", apiBaseURL, contactListID), nil)
	if err != nil {
		return fmt.Errorf("failed to create validation request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 15 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("contact list validation failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNotFound {
		return fmt.Errorf("contact list %s does not exist", contactListID)
	}
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("validation returned status %d", resp.StatusCode)
	}

	var cl ContactListResponse
	if err := json.NewDecoder(resp.Body).Decode(&cl); err != nil {
		return fmt.Errorf("failed to decode contact list: %w", err)
	}

	if !cl.DNCCompliant {
		return fmt.Errorf("contact list %s is not DNC compliant", contactListID)
	}
	return nil
}

HTTP Cycle Example:

GET /api/contactlists/CL-839201-AJF2
Authorization: Bearer eyJhbGci...
Accept: application/json

Response: 200 OK
{
  "id": "CL-839201-AJF2",
  "name": "Q3-Enterprise-Outbound",
  "recordCount": 15420,
  "dncCompliant": true,
  "lastValidated": "2024-06-15T08:30:00Z"
}

Step 2: Launch Campaign and Handle Asynchronous Start via Jittered Polling

The POST /api/campaigns/{id}/start endpoint returns 202 Accepted. The campaign transitions through QUEUED, INITIALIZING, and RUNNING. You must poll GET /api/campaigns/{id} with jittered intervals to avoid thundering herd effects on the CXone API gateway.

func pollCampaignStatus(ctx context.Context, apiBaseURL, token, campaignID string) (string, error) {
	client := &http.Client{Timeout: 15 * time.Second}
	baseInterval := 3 * time.Second
	jitterRange := 2 * time.Second

	for {
		select {
		case <-ctx.Done():
			return "", ctx.Err()
		default:
		}

		req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/api/campaigns/%s", apiBaseURL, campaignID), nil)
		if err != nil {
			return "", fmt.Errorf("poll request failed: %w", err)
		}
		req.Header.Set("Authorization", "Bearer "+token)
		req.Header.Set("Accept", "application/json")

		resp, err := client.Do(req)
		if err != nil {
			return "", fmt.Errorf("poll request error: %w", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode == http.StatusTooManyRequests {
			reset := resp.Header.Get("Retry-After")
			backoff := 5 * time.Second
			if reset != "" {
				if secs, parseErr := time.ParseDuration(reset + "s"); parseErr == nil {
					backoff = secs
				}
			}
			time.Sleep(backoff)
			continue
		}

		var statusResp map[string]interface{}
		if err := json.NewDecoder(resp.Body).Decode(&statusResp); err != nil {
			return "", fmt.Errorf("failed to decode status response: %w", err)
		}

		status, ok := statusResp["status"].(string)
		if !ok {
			return "", fmt.Errorf("status field missing in response")
		}

		if status == "RUNNING" || status == "STOPPED" || status == "ERROR" {
			return status, nil
		}

		jitter := time.Duration(rand.Intn(int(jitterRange.Milliseconds()))) * time.Millisecond
		time.Sleep(baseInterval + jitter)
	}
}

Step 3: Monitor Status Transitions and Error Codes

Campaign status transitions require explicit handling. The ERROR state returns a lastError object containing errorCode and errorMessage. You must capture these for operational logging.

type CampaignStatusResponse struct {
	ID        string                 `json:"id"`
	Status    string                 `json:"status"`
	LastError map[string]interface{} `json:"lastError,omitempty"`
}

func monitorCampaignTransitions(ctx context.Context, apiBaseURL, token, campaignID string) error {
	client := &http.Client{Timeout: 15 * time.Second}
	
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/api/campaigns/%s", apiBaseURL, campaignID), nil)
	if err != nil {
		return fmt.Errorf("monitor request failed: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Accept", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("monitor request error: %w", err)
	}
	defer resp.Body.Close()

	var csr CampaignStatusResponse
	if err := json.NewDecoder(resp.Body).Decode(&csr); err != nil {
		return fmt.Errorf("failed to decode campaign status: %w", err)
	}

	if csr.Status == "ERROR" {
		if csr.LastError != nil {
			code := csr.LastError["errorCode"]
			msg := csr.LastError["errorMessage"]
			return fmt.Errorf("campaign error: code=%v, message=%v", code, msg)
		}
		return fmt.Errorf("campaign entered ERROR state without details")
	}

	if csr.Status == "RUNNING" {
		fmt.Printf("Campaign %s is running successfully\n", campaignID)
	}
	return nil
}

Step 4: Adjust Pacing Parameters Dynamically Based on Real-Time Answer Rates

You can modify pacing while the campaign runs by calling PATCH /api/campaigns/{id}. The real-time endpoint GET /api/campaigns/{id}/realtime returns answerRate, abandonRate, and activeCalls. You adjust callsPerMinute when answer rates drop below a threshold.

type RealtimeStats struct {
	AnswerRate   float64 `json:"answerRate"`
	AbandonRate  float64 `json:"abandonRate"`
	ActiveCalls  int     `json:"activeCalls"`
	TotalCalls   int     `json:"totalCalls"`
}

func adjustPacingDynamically(ctx context.Context, apiBaseURL, token, campaignID string, targetAnswerRate float64) error {
	client := &http.Client{Timeout: 15 * time.Second}

	// Fetch real-time stats
	statsReq, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/api/campaigns/%s/realtime", apiBaseURL, campaignID), nil)
	if err != nil {
		return fmt.Errorf("realtime request failed: %w", err)
	}
	statsReq.Header.Set("Authorization", "Bearer "+token)
	statsReq.Header.Set("Accept", "application/json")

	statsResp, err := client.Do(statsReq)
	if err != nil {
		return fmt.Errorf("realtime fetch error: %w", err)
	}
	defer statsResp.Body.Close()

	var rt RealtimeStats
	if err := json.NewDecoder(statsResp.Body).Decode(&rt); err != nil {
		return fmt.Errorf("failed to decode realtime stats: %w", err)
	}

	// Determine new pacing
	newCPM := 10
	if rt.AnswerRate >= targetAnswerRate {
		newCPM = 25
	} else if rt.AnswerRate < targetAnswerRate*0.5 {
		newCPM = 5
	}

	// Apply pacing update
	payload := map[string]interface{}{
		"pacing": map[string]interface{}{
			"callsPerMinute": newCPM,
		},
	}
	body, err := json.Marshal(payload)
	if err != nil {
		return fmt.Errorf("failed to marshal pacing payload: %w", err)
	}

	patchReq, err := http.NewRequestWithContext(ctx, http.MethodPatch, fmt.Sprintf("%s/api/campaigns/%s", apiBaseURL, campaignID), strings.NewReader(string(body)))
	if err != nil {
		return fmt.Errorf("patch request failed: %w", err)
	}
	patchReq.Header.Set("Authorization", "Bearer "+token)
	patchReq.Header.Set("Content-Type", "application/json")
	patchReq.Header.Set("Accept", "application/json")

	patchResp, err := client.Do(patchReq)
	if err != nil {
		return fmt.Errorf("patch request error: %w", err)
	}
	defer patchResp.Body.Close()

	if patchResp.StatusCode != http.StatusOK && patchResp.StatusCode != http.StatusAccepted {
		return fmt.Errorf("pacing update failed with status %d", patchResp.StatusCode)
	}

	fmt.Printf("Adjusted pacing to %d CPM based on answer rate %.2f\n", newCPM, rt.AnswerRate)
	return nil
}

Step 5: Implement Circuit Breakers for Failing Dialer Sessions

Repeated API failures or dialer session timeouts require a circuit breaker to prevent cascading failures. This implementation tracks consecutive failures and opens the circuit after a threshold.

type CircuitState int

const (
	StateClosed CircuitState = iota
	StateOpen
	StateHalfOpen
)

type CircuitBreaker struct {
	mu              sync.Mutex
	state           CircuitState
	failureCount    int
	successCount    int
	failureThreshold int
	successThreshold int
	lastFailureTime  time.Time
	openTimeout      time.Duration
}

func NewCircuitBreaker(failureThreshold, successThreshold int, openTimeout time.Duration) *CircuitBreaker {
	return &CircuitBreaker{
		state:            StateClosed,
		failureThreshold: failureThreshold,
		successThreshold: successThreshold,
		openTimeout:      openTimeout,
	}
}

func (cb *CircuitBreaker) AllowRequest() bool {
	cb.mu.Lock()
	defer cb.mu.Unlock()

	switch cb.state {
	case StateClosed:
		return true
	case StateOpen:
		if time.Since(cb.lastFailureTime) > cb.openTimeout {
			cb.state = StateHalfOpen
			cb.successCount = 0
			return true
		}
		return false
	case StateHalfOpen:
		return true
	default:
		return false
	}
}

func (cb *CircuitBreaker) RecordSuccess() {
	cb.mu.Lock()
	defer cb.mu.Unlock()

	if cb.state == StateHalfOpen {
		cb.successCount++
		if cb.successCount >= cb.successThreshold {
			cb.state = StateClosed
			cb.failureCount = 0
			cb.successCount = 0
		}
	} else if cb.state == StateClosed {
		cb.failureCount = 0
	}
}

func (cb *CircuitBreaker) RecordFailure() {
	cb.mu.Lock()
	defer cb.mu.Unlock()

	cb.failureCount++
	cb.lastFailureTime = time.Now()

	if cb.state == StateHalfOpen {
		cb.state = StateOpen
		cb.successCount = 0
	} else if cb.failureCount >= cb.failureThreshold {
		cb.state = StateOpen
	}
}

Step 6: Generate Performance Summaries and Expose Control API

You retrieve historical performance via GET /api/campaigns/{id}/statistics. The control API exposes endpoints for launch orchestration, pacing adjustments, and status queries.

type CampaignSummary struct {
	TotalCalls    int     `json:"totalCalls"`
	Answered      int     `json:"answered"`
	Abandoned     int     `json:"abandoned"`
	AvgTalkTime   float64 `json:"avgTalkTime"`
	ConnectRate   float64 `json:"connectRate"`
}

func fetchPerformanceSummary(ctx context.Context, apiBaseURL, token, campaignID string) (CampaignSummary, error) {
	client := &http.Client{Timeout: 15 * time.Second}
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/api/campaigns/%s/statistics", apiBaseURL, campaignID), nil)
	if err != nil {
		return CampaignSummary{}, fmt.Errorf("summary request failed: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Accept", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return CampaignSummary{}, fmt.Errorf("summary fetch error: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return CampaignSummary{}, fmt.Errorf("summary returned status %d", resp.StatusCode)
	}

	var summary CampaignSummary
	if err := json.NewDecoder(resp.Body).Decode(&summary); err != nil {
		return CampaignSummary{}, fmt.Errorf("failed to decode summary: %w", err)
	}
	return summary, nil
}

Complete Working Example

This module combines authentication, circuit breaking, polling, pacing adjustment, and HTTP routing into a single executable service.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"os"
	"strings"
	"sync"
	"time"
)

// [OAuthConfig, TokenResponse, TokenCache structs and methods from Authentication Setup]
// [CampaignRequest, PacingConfig, DNCConfig, ContactListResponse structs]
// [CircuitState, CircuitBreaker struct and methods]
// [RealtimeStats, CampaignSummary, CampaignStatusResponse structs]

func main() {
	apiBaseURL := os.Getenv("CXONE_API_BASE")
	clientID := os.Getenv("CXONE_CLIENT_ID")
	clientSecret := os.Getenv("CXONE_CLIENT_SECRET")
	scope := "campaign:read campaign:write contactlist:read dnc:read statistics:read"

	if apiBaseURL == "" || clientID == "" || clientSecret == "" {
		fmt.Println("Missing required environment variables: CXONE_API_BASE, CXONE_CLIENT_ID, CXONE_CLIENT_SECRET")
		os.Exit(1)
	}

	tokenCache := NewTokenCache(OAuthConfig{
		BaseURL:      apiBaseURL,
		ClientID:     clientID,
		ClientSecret: clientSecret,
		Scope:        scope,
	})

	cb := NewCircuitBreaker(3, 2, 30*time.Second)
	campaignID := ""

	mux := http.NewServeMux()

	mux.HandleFunc("/orchestrate/launch", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
			return
		}

		var payload CampaignRequest
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			http.Error(w, "Invalid JSON payload", http.StatusBadRequest)
			return
		}

		ctx := r.Context()
		token, err := tokenCache.GetToken(ctx)
		if err != nil {
			http.Error(w, fmt.Sprintf("Auth failed: %v", err), http.StatusInternalServerError)
			return
		}

		// Validate contact list
		if err := validateContactList(ctx, apiBaseURL, token, payload.ContactListID); err != nil {
			http.Error(w, fmt.Sprintf("Validation failed: %v", err), http.StatusBadRequest)
			return
		}

		// Submit campaign (simplified creation step)
		body, _ := json.Marshal(payload)
		createReq, _ := http.NewRequestWithContext(ctx, http.MethodPost, fmt.Sprintf("%s/api/campaigns", apiBaseURL), strings.NewReader(string(body)))
		createReq.Header.Set("Authorization", "Bearer "+token)
		createReq.Header.Set("Content-Type", "application/json")
		createReq.Header.Set("Accept", "application/json")

		client := &http.Client{Timeout: 15 * time.Second}
		createResp, err := client.Do(createReq)
		if err != nil {
			http.Error(w, fmt.Sprintf("Create failed: %v", err), http.StatusInternalServerError)
			return
		}
		defer createResp.Body.Close()

		if createResp.StatusCode != http.StatusCreated {
			http.Error(w, fmt.Sprintf("Create returned %d", createResp.StatusCode), http.StatusInternalServerError)
			return
		}

		var respBody map[string]interface{}
		json.NewDecoder(createResp.Body).Decode(&respBody)
		campaignID = respBody["id"].(string)

		// Start campaign
		startReq, _ := http.NewRequestWithContext(ctx, http.MethodPost, fmt.Sprintf("%s/api/campaigns/%s/start", apiBaseURL, campaignID), nil)
		startReq.Header.Set("Authorization", "Bearer "+token)
		startReq.Header.Set("Accept", "application/json")

		startResp, err := client.Do(startReq)
		if err != nil {
			http.Error(w, fmt.Sprintf("Start failed: %v", err), http.StatusInternalServerError)
			return
		}
		defer startResp.Body.Close()

		if startResp.StatusCode != http.StatusAccepted {
			http.Error(w, fmt.Sprintf("Start returned %d", startResp.StatusCode), http.StatusInternalServerError)
			return
		}

		// Async polling
		go func() {
			status, pollErr := pollCampaignStatus(ctx, apiBaseURL, token, campaignID)
			if pollErr != nil {
				fmt.Printf("Polling error: %v\n", pollErr)
				return
			}
			fmt.Printf("Campaign %s reached status: %s\n", campaignID, status)
			if status == "RUNNING" {
				cb.RecordSuccess()
			} else {
				cb.RecordFailure()
			}
		}()

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{"campaignId": campaignID, "status": "launched"})
	})

	mux.HandleFunc("/orchestrate/pacing", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPatch {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
			return
		}

		ctx := r.Context()
		token, err := tokenCache.GetToken(ctx)
		if err != nil {
			http.Error(w, fmt.Sprintf("Auth failed: %v", err), http.StatusInternalServerError)
			return
		}

		if !cb.AllowRequest() {
			http.Error(w, "Circuit breaker open", http.StatusServiceUnavailable)
			return
		}

		if err := adjustPacingDynamically(ctx, apiBaseURL, token, campaignID, 0.35); err != nil {
			cb.RecordFailure()
			http.Error(w, fmt.Sprintf("Pacing adjustment failed: %v", err), http.StatusInternalServerError)
			return
		}

		cb.RecordSuccess()
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("Pacing adjusted successfully"))
	})

	mux.HandleFunc("/orchestrate/summary", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
			return
		}

		ctx := r.Context()
		token, err := tokenCache.GetToken(ctx)
		if err != nil {
			http.Error(w, fmt.Sprintf("Auth failed: %v", err), http.StatusInternalServerError)
			return
		}

		summary, err := fetchPerformanceSummary(ctx, apiBaseURL, token, campaignID)
		if err != nil {
			http.Error(w, fmt.Sprintf("Summary fetch failed: %v", err), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(summary)
	})

	fmt.Println("Campaign Control API listening on :8080")
	http.ListenAndServe(":8080", mux)
}

Common Errors & Debugging

Error: 401 Unauthorized

• Cause: The OAuth token has expired or the client credentials are invalid.
• Fix: Ensure the token cache refreshes before expiration. Verify CXONE_CLIENT_ID and CXONE_CLIENT_SECRET match the CXone developer portal. Check that the token endpoint URL matches your region.
• Code Fix: The TokenCache.refreshToken method already implements pre-expiration refresh. Add logging to track ExpiresIn values.

Error: 403 Forbidden

• Cause: Missing OAuth scopes or the client lacks permission to modify campaigns.
• Fix: Request campaign:write and statistics:read scopes during token acquisition. Verify the client role in the CXone admin console.
• Code Fix: Update the scope string in OAuthConfig to include all required permissions.

Error: 429 Too Many Requests

• Cause: Exceeding CXone API rate limits during polling or pacing adjustments.
• Fix: Implement jittered backoff and respect the Retry-After header. The polling loop in Step 2 already checks for 429 and sleeps accordingly.
• Code Fix: Increase baseInterval in pollCampaignStatus if rate limits persist during high-volume orchestration.

Error: 500 Internal Server Error (Dialer Session Failure)

• Cause: CXone dialer backend is experiencing transient failures or contact list data is malformed.
• Fix: The circuit breaker in Step 5 tracks consecutive failures. When the circuit opens, subsequent requests fail fast. Monitor lastError in campaign status for specific dialer codes.
• Code Fix: Adjust failureThreshold and openTimeout in NewCircuitBreaker to match your operational tolerance.

Official References

• NICE CXone Campaign API Documentation
• NICE CXone OAuth 2.0 Authentication
• NICE CXone Real-Time Statistics Endpoint
• NICE CXone Contact List Validation