analyticsconversationsegment.go

package platformclientv2
import (
	"time"
	"github.com/leekchan/timeutil"
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
)

// Analyticsconversationsegment
type Analyticsconversationsegment struct { 
	// AudioMuted - Flag indicating if audio is muted or not (true/false)
	AudioMuted *bool `json:"audioMuted,omitempty"`


	// Conference - Indicates whether the segment was a conference
	Conference *bool `json:"conference,omitempty"`


	// DestinationConversationId - The unique identifier of a new conversation when a conversation is ended for a conference
	DestinationConversationId *string `json:"destinationConversationId,omitempty"`


	// DestinationSessionId - The unique identifier of a new session when a session is ended for a conference
	DestinationSessionId *string `json:"destinationSessionId,omitempty"`


	// DisconnectType - The session disconnect type
	DisconnectType *string `json:"disconnectType,omitempty"`


	// ErrorCode - A code corresponding to the error that occurred
	ErrorCode *string `json:"errorCode,omitempty"`


	// GroupId - Unique identifier for a PureCloud group
	GroupId *string `json:"groupId,omitempty"`


	// Q850ResponseCodes - Q.850 response code(s)
	Q850ResponseCodes *[]int `json:"q850ResponseCodes,omitempty"`


	// QueueId - Queue identifier
	QueueId *string `json:"queueId,omitempty"`


	// RequestedLanguageId - Unique identifier for the language requested for an interaction
	RequestedLanguageId *string `json:"requestedLanguageId,omitempty"`


	// RequestedRoutingSkillIds - Unique identifier(s) for skill(s) requested for an interaction
	RequestedRoutingSkillIds *[]string `json:"requestedRoutingSkillIds,omitempty"`


	// RequestedRoutingUserIds - Unique identifier(s) for agent(s) requested for an interaction
	RequestedRoutingUserIds *[]string `json:"requestedRoutingUserIds,omitempty"`


	// SegmentEnd - The end time of a segment. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss[.mmm]Z
	SegmentEnd *time.Time `json:"segmentEnd"`


	// SegmentStart - The start time of a segment. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss[.mmm]Z
	SegmentStart *time.Time `json:"segmentStart"`


	// SegmentType - The activity that takes place in the segment, such as hold or interact
	SegmentType *string `json:"segmentType,omitempty"`


	// SipResponseCodes - SIP response code(s)
	SipResponseCodes *[]int `json:"sipResponseCodes,omitempty"`


	// SourceConversationId - The unique identifier of the previous conversation when a new conversation is created for a conference
	SourceConversationId *string `json:"sourceConversationId,omitempty"`


	// SourceSessionId - The unique identifier of the previous session when a new session is created for a conference
	SourceSessionId *string `json:"sourceSessionId,omitempty"`


	// Subject - The subject for the initial email that started this conversation
	Subject *string `json:"subject,omitempty"`


	// VideoMuted - Flag indicating if video is muted/paused or not (true/false)
	VideoMuted *bool `json:"videoMuted,omitempty"`


	// WrapUpCode - Wrap up code
	WrapUpCode *string `json:"wrapUpCode,omitempty"`


	// WrapUpNote - Note entered by an agent during after-call work
	WrapUpNote *string `json:"wrapUpNote,omitempty"`


	// WrapUpTags - Tag(s) assigned during after-call work
	WrapUpTags *[]string `json:"wrapUpTags,omitempty"`


	// ScoredAgents - Scored agents
	ScoredAgents *[]Analyticsscoredagent `json:"scoredAgents"`


	// Properties - Additional segment properties
	Properties *[]Analyticsproperty `json:"properties"`

}

func (o *Analyticsconversationsegment) MarshalJSON() ([]byte, error) {
	// Redundant initialization to avoid unused import errors for models with no Time values
	_  = timeutil.Timedelta{}
	type Alias Analyticsconversationsegment
	
	SegmentEnd := new(string)
	if o.SegmentEnd != nil {
		
		*SegmentEnd = timeutil.Strftime(o.SegmentEnd, "%Y-%m-%dT%H:%M:%S.%fZ")
	} else {
		SegmentEnd = nil
	}
	
	SegmentStart := new(string)
	if o.SegmentStart != nil {
		
		*SegmentStart = timeutil.Strftime(o.SegmentStart, "%Y-%m-%dT%H:%M:%S.%fZ")
	} else {
		SegmentStart = nil
	}
	
	return json.Marshal(&struct { 
		AudioMuted *bool `json:"audioMuted,omitempty"`
		
		Conference *bool `json:"conference,omitempty"`
		
		DestinationConversationId *string `json:"destinationConversationId,omitempty"`
		
		DestinationSessionId *string `json:"destinationSessionId,omitempty"`
		
		DisconnectType *string `json:"disconnectType,omitempty"`
		
		ErrorCode *string `json:"errorCode,omitempty"`
		
		GroupId *string `json:"groupId,omitempty"`
		
		Q850ResponseCodes *[]int `json:"q850ResponseCodes,omitempty"`
		
		QueueId *string `json:"queueId,omitempty"`
		
		RequestedLanguageId *string `json:"requestedLanguageId,omitempty"`
		
		RequestedRoutingSkillIds *[]string `json:"requestedRoutingSkillIds,omitempty"`
		
		RequestedRoutingUserIds *[]string `json:"requestedRoutingUserIds,omitempty"`
		
		SegmentEnd *string `json:"segmentEnd,omitempty"`
		
		SegmentStart *string `json:"segmentStart,omitempty"`
		
		SegmentType *string `json:"segmentType,omitempty"`
		
		SipResponseCodes *[]int `json:"sipResponseCodes,omitempty"`
		
		SourceConversationId *string `json:"sourceConversationId,omitempty"`
		
		SourceSessionId *string `json:"sourceSessionId,omitempty"`
		
		Subject *string `json:"subject,omitempty"`
		
		VideoMuted *bool `json:"videoMuted,omitempty"`
		
		WrapUpCode *string `json:"wrapUpCode,omitempty"`
		
		WrapUpNote *string `json:"wrapUpNote,omitempty"`
		
		WrapUpTags *[]string `json:"wrapUpTags,omitempty"`
		
		ScoredAgents *[]Analyticsscoredagent `json:"scoredAgents"`
		
		Properties *[]Analyticsproperty `json:"properties"`
		*Alias
	}{ 
		AudioMuted: o.AudioMuted,
		
		Conference: o.Conference,
		
		DestinationConversationId: o.DestinationConversationId,
		
		DestinationSessionId: o.DestinationSessionId,
		
		DisconnectType: o.DisconnectType,
		
		ErrorCode: o.ErrorCode,
		
		GroupId: o.GroupId,
		
		Q850ResponseCodes: o.Q850ResponseCodes,
		
		QueueId: o.QueueId,
		
		RequestedLanguageId: o.RequestedLanguageId,
		
		RequestedRoutingSkillIds: o.RequestedRoutingSkillIds,
		
		RequestedRoutingUserIds: o.RequestedRoutingUserIds,
		
		SegmentEnd: SegmentEnd,
		
		SegmentStart: SegmentStart,
		
		SegmentType: o.SegmentType,
		
		SipResponseCodes: o.SipResponseCodes,
		
		SourceConversationId: o.SourceConversationId,
		
		SourceSessionId: o.SourceSessionId,
		
		Subject: o.Subject,
		
		VideoMuted: o.VideoMuted,
		
		WrapUpCode: o.WrapUpCode,
		
		WrapUpNote: o.WrapUpNote,
		
		WrapUpTags: o.WrapUpTags,
		
		ScoredAgents: o.ScoredAgents,
		
		Properties: o.Properties,
		Alias:    (*Alias)(o),
	})
}

func (o *Analyticsconversationsegment) UnmarshalJSON(b []byte) error {
	var AnalyticsconversationsegmentMap map[string]interface{}
	err := json.Unmarshal(b, &AnalyticsconversationsegmentMap)
	if err != nil {
		return err
	}
	
	if AudioMuted, ok := AnalyticsconversationsegmentMap["audioMuted"].(bool); ok {
		o.AudioMuted = &AudioMuted
	}
    
	if Conference, ok := AnalyticsconversationsegmentMap["conference"].(bool); ok {
		o.Conference = &Conference
	}
    
	if DestinationConversationId, ok := AnalyticsconversationsegmentMap["destinationConversationId"].(string); ok {
		o.DestinationConversationId = &DestinationConversationId
	}
    
	if DestinationSessionId, ok := AnalyticsconversationsegmentMap["destinationSessionId"].(string); ok {
		o.DestinationSessionId = &DestinationSessionId
	}
    
	if DisconnectType, ok := AnalyticsconversationsegmentMap["disconnectType"].(string); ok {
		o.DisconnectType = &DisconnectType
	}
    
	if ErrorCode, ok := AnalyticsconversationsegmentMap["errorCode"].(string); ok {
		o.ErrorCode = &ErrorCode
	}
    
	if GroupId, ok := AnalyticsconversationsegmentMap["groupId"].(string); ok {
		o.GroupId = &GroupId
	}
    
	if Q850ResponseCodes, ok := AnalyticsconversationsegmentMap["q850ResponseCodes"].([]interface{}); ok {
		Q850ResponseCodesString, _ := json.Marshal(Q850ResponseCodes)
		json.Unmarshal(Q850ResponseCodesString, &o.Q850ResponseCodes)
	}
	
	if QueueId, ok := AnalyticsconversationsegmentMap["queueId"].(string); ok {
		o.QueueId = &QueueId
	}
    
	if RequestedLanguageId, ok := AnalyticsconversationsegmentMap["requestedLanguageId"].(string); ok {
		o.RequestedLanguageId = &RequestedLanguageId
	}
    
	if RequestedRoutingSkillIds, ok := AnalyticsconversationsegmentMap["requestedRoutingSkillIds"].([]interface{}); ok {
		RequestedRoutingSkillIdsString, _ := json.Marshal(RequestedRoutingSkillIds)
		json.Unmarshal(RequestedRoutingSkillIdsString, &o.RequestedRoutingSkillIds)
	}
	
	if RequestedRoutingUserIds, ok := AnalyticsconversationsegmentMap["requestedRoutingUserIds"].([]interface{}); ok {
		RequestedRoutingUserIdsString, _ := json.Marshal(RequestedRoutingUserIds)
		json.Unmarshal(RequestedRoutingUserIdsString, &o.RequestedRoutingUserIds)
	}
	
	if segmentEndString, ok := AnalyticsconversationsegmentMap["segmentEnd"].(string); ok {
		SegmentEnd, _ := time.Parse("2006-01-02T15:04:05.999999Z", segmentEndString)
		o.SegmentEnd = &SegmentEnd
	}
	
	if segmentStartString, ok := AnalyticsconversationsegmentMap["segmentStart"].(string); ok {
		SegmentStart, _ := time.Parse("2006-01-02T15:04:05.999999Z", segmentStartString)
		o.SegmentStart = &SegmentStart
	}
	
	if SegmentType, ok := AnalyticsconversationsegmentMap["segmentType"].(string); ok {
		o.SegmentType = &SegmentType
	}
    
	if SipResponseCodes, ok := AnalyticsconversationsegmentMap["sipResponseCodes"].([]interface{}); ok {
		SipResponseCodesString, _ := json.Marshal(SipResponseCodes)
		json.Unmarshal(SipResponseCodesString, &o.SipResponseCodes)
	}
	
	if SourceConversationId, ok := AnalyticsconversationsegmentMap["sourceConversationId"].(string); ok {
		o.SourceConversationId = &SourceConversationId
	}
    
	if SourceSessionId, ok := AnalyticsconversationsegmentMap["sourceSessionId"].(string); ok {
		o.SourceSessionId = &SourceSessionId
	}
    
	if Subject, ok := AnalyticsconversationsegmentMap["subject"].(string); ok {
		o.Subject = &Subject
	}
    
	if VideoMuted, ok := AnalyticsconversationsegmentMap["videoMuted"].(bool); ok {
		o.VideoMuted = &VideoMuted
	}
    
	if WrapUpCode, ok := AnalyticsconversationsegmentMap["wrapUpCode"].(string); ok {
		o.WrapUpCode = &WrapUpCode
	}
    
	if WrapUpNote, ok := AnalyticsconversationsegmentMap["wrapUpNote"].(string); ok {
		o.WrapUpNote = &WrapUpNote
	}
    
	if WrapUpTags, ok := AnalyticsconversationsegmentMap["wrapUpTags"].([]interface{}); ok {
		WrapUpTagsString, _ := json.Marshal(WrapUpTags)
		json.Unmarshal(WrapUpTagsString, &o.WrapUpTags)
	}
	
	if ScoredAgents, ok := AnalyticsconversationsegmentMap["scoredAgents"].([]interface{}); ok {
		ScoredAgentsString, _ := json.Marshal(ScoredAgents)
		json.Unmarshal(ScoredAgentsString, &o.ScoredAgents)
	}
	
	if Properties, ok := AnalyticsconversationsegmentMap["properties"].([]interface{}); ok {
		PropertiesString, _ := json.Marshal(Properties)
		json.Unmarshal(PropertiesString, &o.Properties)
	}
	

	return nil
}

// String returns a JSON representation of the model
func (o *Analyticsconversationsegment) String() string {
	j, _ := json.Marshal(o)
	str, _ := strconv.Unquote(strings.Replace(strconv.Quote(string(j)), `\\u`, `\u`, -1))
	str = strings.Replace(str, strconv.Quote(*NullString()), "null", -1)
	str = strings.Replace(str, fmt.Sprintf("%v", *NullInt()), "null", -1)
	str = strings.Replace(str, fmt.Sprintf("%v", *NullFloat32()), "null", -1)
	str = strings.Replace(str, fmt.Sprintf("%v", *NullFloat64()), "null", -1)
	str = strings.Replace(str, fmt.Sprintf("%v", NullTime().Format("2006-01-02T15:04:05Z07:00")), "null", -1)

	return str
}