gorm_models/util/extract.go

package util

import (
	"encoding/json"
	"fmt"
	"time"

	"huron.connectingnow.net/fholland/gorm_models/models"
)

func ExtractWithoutAttributes(base models.AnalyticsConversationWithoutAttributes) (models.DBConversation, []models.DBParticipant, []models.DBSession, []models.DBSegment) {

	var startTime *time.Time

	parsedStartTime, err := time.Parse(time.RFC3339, base.ConversationStart)
	if err != nil {
		startTime = nil
	} else {
		startTime = &parsedStartTime
	}

	var endTime *time.Time
	parsedEndTime, err := time.Parse(time.RFC3339, base.ConversationEnd)
	if err != nil {
		startTime = nil
	} else {
		startTime = &parsedEndTime
	}

	divisionIdsBytes, err := json.Marshal(base.DivisionIds)
	if err != nil {
		divisionIdsBytes = nil
	}
	divisionIdsBytesStr := string(divisionIdsBytes)

	currentTime := time.Now()

	conversation := models.DBConversation{
		DivisionIds:          &divisionIdsBytesStr,
		End:                  endTime,
		Id:                   base.ConversationId,
		MinMos:               &base.MediaStatsMinConversationMos,
		MinRFactor:           &base.MediaStatsMinConversationRFactor,
		OriginatingDirection: &base.OriginatingDirection,
		Start:                startTime,
		SemiLiveUpdate:       &currentTime,
	}
	var participants []models.DBParticipant
	var sessions []models.DBSession
	var segments []models.DBSegment

	for _, p := range base.Participants {

		participant := models.DBParticipant{
			ConnectedTime:     nil,
			ConversationId:    base.ConversationId,
			EndTime:           nil,
			ExternalContactId: &p.ExternalContactId,
			Id:                p.ParticipantId,
			Name:              &p.ParticipantName,
			Purpose:           &p.Purpose,
		}
		participants = append(participants, participant)

		for _, sess := range p.Sessions {
			mediaEndpointStatsBytes, err := json.Marshal(sess.MediaEndpointStats)
			if err != nil {
				mediaEndpointStatsBytes = nil
			}

			metricsBytes, err := json.Marshal(sess.Metrics)
			if err != nil {
				metricsBytes = nil
			}

			session := models.DBSession{
				Ani:                   sess.ANI,
				Direction:             sess.Direction,
				Dnis:                  sess.DNIS,
				EdgeId:                sess.EdgeId,
				Id:                    sess.SessionId,
				MediaEndpointStats:    string(mediaEndpointStatsBytes),
				MediaType:             sess.MediaType,
				Metrics:               string(metricsBytes),
				ParticipantId:         p.ParticipantId,
				ProtocolCallId:        sess.ProtocolCallId,
				Provider:              sess.Provider,
				Recording:             sess.Recording,
				RemoteNameDisplayable: sess.RemoteNameDisplayable,
				SessionDnis:           sess.SessionDNIS,
			}
			sessions = append(sessions, session)

			for _, seg := range sess.Segments {

				segmentStart, err := time.Parse(time.RFC3339, seg.SegmentStart)
				if err != nil {
					segmentStart = time.Now()
				}

				segmentEnd, err := time.Parse(time.RFC3339, seg.SegmentEnd)
				if err != nil {
					segmentEnd = time.Now()
				}

				q850ResponseCodesBytes, err := json.Marshal(seg.Q850ResponseCodes)
				if err != nil {
					q850ResponseCodesBytes = nil
				}

				segment := models.DBSegment{
					Id:                fmt.Sprintf("%s_%s", session.Id, seg.SegmentType),
					Conference:        seg.Conference,
					DisconnectType:    seg.DisconnectType,
					Q850ResponseCodes: string(q850ResponseCodesBytes),
					SegmentEnd:        segmentEnd,
					SegmentStart:      segmentStart,
					SegmentType:       seg.SegmentType,
					SessionId:         sess.SessionId,
					WrapUpCode:        seg.WrapUpCode,
				}

				segments = append(segments, segment)
			}
		}
	}

	return conversation, participants, sessions, segments
}

func ExtractLive(base models.NotificationConversationWithAttributes) (models.DBConversation, []models.DBParticipant, []models.DBCall) {
	currentTime := time.Now()

	conversation := models.DBConversation{
		Id:                 base.Id,
		Address:            &base.Address,
		ExternalTag:        &base.ExternalTag,
		RecordingState:     &base.RecordingState,
		SecurePause:        &base.SecurePause,
		UtilizationLabelId: &base.UtilizationLabelId,
		LiveUpdate:         &currentTime,
	}

	var participants []models.DBParticipant
	var calls []models.DBCall

	for _, partPayload := range base.Participants {
		attributesBytes, err := json.Marshal(partPayload.Attributes)
		if err != nil {
			attributesBytes = nil
		}
		attributesBytesStr := string(attributesBytes)

		mediaRolesBytes, err := json.Marshal(partPayload.MediaRoles)
		if err != nil {
			mediaRolesBytes = nil
		}
		mediaRolesBytesStr := string(mediaRolesBytes)

		wrapupBytes, err := json.Marshal(partPayload.Wrapup)
		if err != nil {
			wrapupBytes = nil
		}
		wrapupBytesStr := string(wrapupBytes)

		var connectedTime *time.Time
		parsedConnectedTime, err := time.Parse(time.RFC3339, partPayload.ConnectedTime)
		if err != nil {
			connectedTime = nil
		} else {
			connectedTime = &parsedConnectedTime
		}

		var endTime *time.Time
		parsedEndTime, err := time.Parse(time.RFC3339, partPayload.EndTime)
		if err != nil {
			endTime = nil
		} else {
			endTime = &parsedEndTime
		}

		participant := models.DBParticipant{
			ConversationId:                   base.Id,
			Id:                               partPayload.Id,
			Address:                          &partPayload.Address,
			Attributes:                       &attributesBytesStr,
			ConnectedTime:                    connectedTime,
			EndTime:                          endTime,
			ExternalContactId:                &partPayload.ExternalContactId,
			ExternalContactInitialDivisionId: &partPayload.ExternalContactInitialDivisionId,
			MediaRoles:                       &mediaRolesBytesStr,
			Name:                             &partPayload.Name,
			Purpose:                          &partPayload.Purpose,
			QueueId:                          &partPayload.QueueId,
			Wrapup:                           &wrapupBytesStr,
			WrapupExpected:                   &partPayload.WrapupExpected,
			WrapupRequired:                   &partPayload.WrapupRequired,
		}
		participants = append(participants, participant)

		for _, callPayload := range partPayload.Calls {
			var connectedTime *time.Time
			parsedConnectedTime, err := time.Parse(time.RFC3339, callPayload.ConnectedTime)
			if err != nil {
				connectedTime = nil
			} else {
				connectedTime = &parsedConnectedTime
			}

			var disconnectedTime *time.Time
			parsedDisconnectedTime, err := time.Parse(time.RFC3339, callPayload.DisconnectedTime)
			if err != nil {
				disconnectedTime = nil
			} else {
				disconnectedTime = &parsedDisconnectedTime
			}

			otherBytes, err := json.Marshal(callPayload.Other)
			if err != nil {
				otherBytes = nil
			}

			selfBytes, err := json.Marshal(callPayload.Self)
			if err != nil {
				selfBytes = nil
			}

			disconnectReasonsBytes, err := json.Marshal(callPayload.DisconnectReasons)
			if err != nil {
				disconnectReasonsBytes = nil
			}

			call := models.DBCall{
				ParticipantId:         partPayload.Id,
				AfterCallWorkRequired: callPayload.AfterCallWorkRequired,
				Confined:              callPayload.Confined,
				ConnectedTime:         connectedTime,
				DisconnectedTime:      disconnectedTime,
				Direction:             callPayload.Direction,
				DisconnectReasons:     string(disconnectReasonsBytes),
				DisconnectType:        callPayload.DisconnectType,
				Held:                  callPayload.Held,
				Id:                    callPayload.Id,
				InitialState:          callPayload.InitialState,
				Muted:                 callPayload.Muted,
				Other:                 string(otherBytes),
				Provider:              callPayload.Provider,
				Recording:             callPayload.Recording,
				RecordingState:        callPayload.RecordingState,
				SecurePause:           callPayload.SecurePause,
				Self:                  string(selfBytes),
				State:                 callPayload.State,
			}

			calls = append(calls, call)
		}
	}

	return conversation, participants, calls

}

func ExtractWithAttributes(base models.AnalyticsConversationWithAttributes) (models.DBConversation, []models.DBParticipant, []models.DBSession, []models.DBSegment) {

	var startTime *time.Time
	parsedStartTime, err := time.Parse(time.RFC3339, base.ConversationStart)
	if err != nil {
		startTime = nil
	} else {
		startTime = &parsedStartTime
	}

	var endTime *time.Time
	parsedEndTime, err := time.Parse(time.RFC3339, base.ConversationEnd)
	if err != nil {
		endTime = nil
	} else {
		endTime = &parsedEndTime
	}

	divisionIdsBytes, err := json.Marshal(base.DivisionIds)
	if err != nil {
		divisionIdsBytes = nil
	}
	divisionIdsBytesStr := string(divisionIdsBytes)

	currentTime := time.Now()

	conversation := models.DBConversation{
		DivisionIds:          &divisionIdsBytesStr,
		End:                  endTime,
		Id:                   base.ConversationId,
		MinMos:               &base.MediaStatsMinConversationMos,
		MinRFactor:           &base.MediaStatsMinConversationRFactor,
		OriginatingDirection: &base.OriginatingDirection,
		Start:                startTime,
		JobUpdate:            &currentTime,
	}
	var participants []models.DBParticipant
	var sessions []models.DBSession
	var segments []models.DBSegment

	for _, p := range base.Participants {

		attributesBytes, err := json.Marshal(p.Attributes)
		if err != nil {
			attributesBytes = nil
		}
		attributesBytesStr := string(attributesBytes)

		participant := models.DBParticipant{
			ConnectedTime:     nil,
			ConversationId:    base.ConversationId,
			EndTime:           nil,
			ExternalContactId: &p.ExternalContactId,
			Id:                p.ParticipantId,
			Name:              &p.ParticipantName,
			Purpose:           &p.Purpose,
			Attributes:        &attributesBytesStr,
		}
		participants = append(participants, participant)

		for _, sess := range p.Sessions {
			mediaEndpointStatsBytes, err := json.Marshal(sess.MediaEndpointStats)
			if err != nil {
				mediaEndpointStatsBytes = nil
			}

			metricsBytes, err := json.Marshal(sess.Metrics)
			if err != nil {
				metricsBytes = nil
			}

			session := models.DBSession{
				Ani:                   sess.ANI,
				Direction:             sess.Direction,
				Dnis:                  sess.DNIS,
				EdgeId:                sess.EdgeId,
				Id:                    sess.SessionId,
				MediaEndpointStats:    string(mediaEndpointStatsBytes),
				MediaType:             sess.MediaType,
				Metrics:               string(metricsBytes),
				ParticipantId:         p.ParticipantId,
				ProtocolCallId:        sess.ProtocolCallId,
				Provider:              sess.Provider,
				Recording:             sess.Recording,
				RemoteNameDisplayable: sess.RemoteNameDisplayable,
				SessionDnis:           sess.SessionDnis,
			}
			sessions = append(sessions, session)

			for _, seg := range sess.Segments {

				segmentStart, err := time.Parse(time.RFC3339, seg.SegmentStart)
				if err != nil {
					segmentStart = time.Now()
				}

				segmentEnd, err := time.Parse(time.RFC3339, seg.SegmentEnd)
				if err != nil {
					segmentEnd = time.Now()
				}

				q850ResponseCodesBytes, err := json.Marshal(seg.Q850ResponseCodes)
				if err != nil {
					q850ResponseCodesBytes = nil
				}

				segment := models.DBSegment{
					Id:                fmt.Sprintf("%s_%s", session.Id, seg.SegmentType),
					Conference:        seg.Conference,
					DisconnectType:    seg.DisconnectType,
					Q850ResponseCodes: string(q850ResponseCodesBytes),
					SegmentEnd:        segmentEnd,
					SegmentStart:      segmentStart,
					SegmentType:       seg.SegmentType,
					SessionId:         sess.SessionId,
					WrapUpCode:        seg.WrapUpCode,
				}

				segments = append(segments, segment)
			}
		}
	}

	return conversation, participants, sessions, segments
}