GC: Backup: Kiota Serialization Patch no longer required. (#1255)

## Description
Kiota serialization patch found located `exchange_data_collection.go`L 316 required a large collection of functions to make the message object serializable. Kiota upgrades since instantiation no longer require this collection of functions. 

Dead code removed from m365Transform.go

<!-- Insert PR description-->

## Type of change
- [x] 🗺️ Documentation


## Issue(s)

<!-- Can reference multiple issues. Use one of the following "magic words" - "closes, fixes" to auto-close the Github issue. -->
* #<issue>

## Test Plan

- [x] ⚡ Unit test

src/internal/connector/exchange/exchange_data_collection.go

@@ -347,14 +347,6 @@ func messageToDataCollection(
 		return 0, fmt.Errorf("expected Messageable, got %T", parsable)
 	}
 
-	adtl := aMessage.GetAdditionalData()
-	if len(adtl) > 2 {
-		aMessage, err = support.ConvertFromMessageable(adtl, aMessage)
-		if err != nil {
-			return 0, err
-		}
-	}
-
 	if *aMessage.GetHasAttachments() {
 		// getting all the attachments might take a couple attempts due to filesize
 		var retriesErr error

src/internal/connector/support/m365Transform.go

@@ -1,18 +1,9 @@
 package support
 
 import (
-	"fmt"
-	"strconv"
 	"strings"
 
-	kw "github.com/microsoft/kiota-serialization-json-go"
 	"github.com/microsoftgraph/msgraph-sdk-go/models"
-	"github.com/pkg/errors"
-)
-
-var (
-	eventResponsableFields = []string{"responseType"}
-	eventRequestableFields = []string{"allowNewTimeProposals", "meetingRequestType", "responseRequested"}
 )
 
 // CloneMessageableFields places data from original data into new message object.
@@ -64,346 +55,6 @@ func ToMessage(orig models.Messageable) models.Messageable {
 	return aMessage
 }
 
-func SetEventMessageRequest(orig models.Messageable, adtl map[string]any) (models.EventMessageRequestable, error) {
-	aMessage := models.NewEventMessageRequest()
-	temp := CloneMessageableFields(orig, aMessage)
-
-	message, ok := temp.(models.EventMessageRequestable)
-	if !ok {
-		return nil, errors.New(*orig.GetId() + " failed to convert to eventMessageRequestable")
-	}
-
-	newMessage, err := SetAdditionalDataToEventMessage(adtl, message)
-	if err != nil {
-		return nil, errors.Wrap(err, *orig.GetId()+" eventMessageRequest could not set additional data")
-	}
-
-	additional, err := buildMapFromAdditional(eventRequestableFields, adtl)
-	if err != nil {
-		return nil, errors.Wrap(err, *orig.GetId()+" eventMessageRequest failed on method buildMapFromAdditional")
-	}
-
-	message, ok = newMessage.(models.EventMessageRequestable)
-	if !ok {
-		return nil, errors.New(*orig.GetId() + " failed to convert to eventMessageRequestable")
-	}
-
-	eventMessage, err := setEventRequestableFields(message, additional)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to set all fields for eventMessageRequestable")
-	}
-
-	return eventMessage, nil
-}
-
-func SetEventMessageResponse(orig models.Messageable, adtl map[string]any) (models.EventMessageResponseable, error) {
-	aMessage := models.NewEventMessageResponse()
-	temp := CloneMessageableFields(orig, aMessage)
-
-	message, ok := temp.(models.EventMessageResponseable)
-	if !ok {
-		return nil, errors.New(*orig.GetId() + " failed to convert to eventMessageRequestable")
-	}
-
-	newMessage, err := SetAdditionalDataToEventMessage(adtl, message)
-	if err != nil {
-		return nil, errors.Wrap(err, *orig.GetId()+" eventMessageResponse could not set additional data")
-	}
-
-	message, ok = newMessage.(models.EventMessageResponseable)
-	if !ok {
-		return nil, errors.New("unable to create event message responseable from " + *orig.GetId())
-	}
-
-	additional, err := buildMapFromAdditional(eventResponsableFields, adtl)
-	if err != nil {
-		return nil, errors.Wrap(err, *orig.GetId()+" eventMessageResponse failed on method buildMapFromAdditional")
-	}
-
-	for key, val := range additional {
-		switch key {
-		case "responseType":
-			temp, err := models.ParseResponseType(*val)
-			if err != nil {
-				return nil, errors.Wrap(err, *orig.GetId()+"failure to parse response type")
-			}
-
-			rType, ok := temp.(*models.ResponseType)
-			if !ok {
-				return nil, fmt.Errorf(
-					"%s : responseType not returned from models.ParseResponseType: %v\t%T",
-					*orig.GetId(),
-					temp,
-					temp,
-				)
-			}
-
-			message.SetResponseType(rType)
-
-		default:
-			return nil, errors.New(key + " not supported for setEventMessageResponse")
-		}
-	}
-
-	return message, nil
-}
-
-// ConvertFromMessageable temporary function. Converts incorrect cast of messageable object to known
-// type until upstream can make the appropriate changes
-func ConvertFromMessageable(adtl map[string]any, orig models.Messageable) (models.EventMessageable, error) {
-	var aType string
-
-	aPointer, ok := adtl["@odata.type"]
-	if !ok {
-		return nil, errors.New("unknown data type: no @odata.type field")
-	}
-
-	ptr, ok := aPointer.(*string)
-	if !ok {
-		return nil, errors.New("unknown map type encountered")
-	}
-
-	aType = *ptr
-	if aType == "#microsoft.graph.eventMessageRequest" {
-		eventRequest, err := SetEventMessageRequest(orig, adtl)
-		if err != nil {
-			return nil, err
-		}
-
-		eventRequest.SetId(orig.GetId())
-
-		return eventRequest, err
-	}
-
-	if aType == "#microsoft.graph.eventMessageResponse" {
-		eventMessage, err := SetEventMessageResponse(orig, adtl)
-		if err != nil {
-			return nil, err
-		}
-
-		eventMessage.SetId(orig.GetId())
-
-		return eventMessage, nil
-	}
-
-	return nil, errors.New("unknown data type: " + aType)
-}
-
-// buildMapFromAdditional returns a submap of map[string]*string from map[string]any
-func buildMapFromAdditional(list []string, adtl map[string]any) (map[string]*string, error) {
-	returnMap := make(map[string]*string)
-
-	for _, entry := range list {
-		ptr, ok := adtl[entry]
-		if !ok {
-			continue
-		}
-
-		value, ok := ptr.(*string)
-		if !ok {
-			boolConvert, ok := ptr.(*bool)
-			if !ok {
-				return nil, errors.New("unsupported value type: key: " + entry + fmt.Sprintf(" with type: %T", ptr))
-			}
-
-			aBool := *boolConvert
-			boolString := strconv.FormatBool(aBool)
-			returnMap[entry] = &boolString
-
-			continue
-		}
-
-		returnMap[entry] = value
-	}
-
-	return returnMap, nil
-}
-
-func setEventRequestableFields(
-	em models.EventMessageRequestable,
-	adtl map[string]*string,
-) (models.EventMessageRequestable, error) {
-	for key, value := range adtl {
-		switch key {
-		case "meetingRequestType":
-			temp, err := models.ParseMeetingRequestType(*value)
-			if err != nil {
-				return nil, errors.Wrap(err, *em.GetId()+": failed on models.ParseMeetingRequestType")
-			}
-
-			rType, ok := temp.(*models.MeetingRequestType)
-			if !ok {
-				return nil, errors.New(*em.GetId() + ": failed to set meeting request type")
-			}
-
-			em.SetMeetingRequestType(rType)
-
-		case "responseRequested":
-			boolValue, err := strconv.ParseBool(*value)
-			if err != nil {
-				return nil, errors.Wrap(err, *em.GetId()+": failed to set responseRequested")
-			}
-
-			em.SetResponseRequested(&boolValue)
-
-		case "allowNewTimeProposals":
-			boolValue, err := strconv.ParseBool(*value)
-			if err != nil {
-				return nil, errors.Wrap(err, *em.GetId()+": failed to set  allowNewTimeProposals")
-			}
-
-			em.SetAllowNewTimeProposals(&boolValue)
-		}
-	}
-
-	return em, nil
-}
-
-// SetAdditionalDataToEventMessage sets shared fields for 2 types of EventMessage: Response and Request
-func SetAdditionalDataToEventMessage(
-	adtl map[string]any,
-	newMessage models.EventMessageable,
-) (models.EventMessageable, error) {
-	for key, entry := range adtl {
-		if key == "endDateTime" {
-			dateTime := models.NewDateTimeTimeZone()
-
-			mapped, ok := entry.(map[string]*kw.JsonParseNode)
-			if ok {
-				for key, val := range mapped {
-					node := *val
-
-					value, err := node.GetStringValue()
-					if err != nil {
-						return nil, errors.Wrapf(err, "could not parse string value for %s", key)
-					}
-
-					switch key {
-					case "dateTime":
-						dateTime.SetDateTime(value)
-					case "timeZone":
-						dateTime.SetTimeZone(value)
-					default:
-						return nil, errors.New("key not supported DateTime")
-					}
-
-					newMessage.SetEndDateTime(dateTime)
-				}
-
-				continue
-			}
-		}
-
-		if key == "startDateTime" {
-			dateTime := models.NewDateTimeTimeZone()
-
-			mapped, ok := entry.(map[string]*kw.JsonParseNode)
-			if ok {
-				for key, val := range mapped {
-					node := *val
-
-					value, err := node.GetStringValue()
-					if err != nil {
-						return nil, errors.Wrapf(err, "could not parse string value for %s", key)
-					}
-
-					switch key {
-					case "dateTime":
-						dateTime.SetDateTime(value)
-					case "timeZone":
-						dateTime.SetTimeZone(value)
-					default:
-						return nil, errors.New("key not supported DateTime")
-					}
-
-					newMessage.SetStartDateTime(dateTime)
-				}
-
-				continue
-			}
-		}
-
-		if key == "location" {
-			aLocation := models.NewLocation()
-
-			mapped, ok := entry.(map[string]*kw.JsonParseNode)
-			if ok {
-				for key, val := range mapped {
-					node := *val
-
-					value, err := node.GetStringValue()
-					if err != nil {
-						return nil, errors.Wrapf(err, "could not parse string value for key %s", key)
-					}
-
-					switch key {
-					case "displayName":
-						aLocation.SetDisplayName(value)
-					case "locationType":
-						temp, err := models.ParseLocationType(*value)
-						if err != nil {
-							return nil, errors.New("location type parse failure")
-						}
-
-						lType, ok := temp.(*models.LocationType)
-						if !ok {
-							return nil, errors.New("location type interface failure")
-						}
-
-						aLocation.SetLocationType(lType)
-					}
-				}
-			}
-
-			newMessage.SetLocation(aLocation)
-		}
-
-		value, ok := entry.(*string)
-		if ok {
-			switch key {
-			case "isAllDay":
-				boolValue, err := strconv.ParseBool(*value)
-				if err != nil {
-					return nil, err
-				}
-
-				newMessage.SetIsAllDay(&boolValue)
-
-			case "isDelegated":
-				boolValue, err := strconv.ParseBool(*value)
-				if err != nil {
-					return nil, err
-				}
-
-				newMessage.SetIsDelegated(&boolValue)
-
-			case "isOutOfDate":
-				boolValue, err := strconv.ParseBool(*value)
-				if err != nil {
-					return nil, err
-				}
-
-				newMessage.SetIsOutOfDate(&boolValue)
-
-			case "meetingMessageType":
-				temp, err := models.ParseMeetingMessageType(*value)
-				if err != nil {
-					return nil, err
-				}
-
-				mType, ok := temp.(*models.MeetingMessageType)
-				if !ok {
-					return nil, errors.New("failed to create meeting message type")
-				}
-
-				newMessage.SetMeetingMessageType(mType)
-			}
-		}
-	}
-
-	return newMessage, nil
-}
-
 // ToEventSimplified transforms an event to simplifed restore format
 // To overcome some of the MS Graph API challenges, the event object is modified in the following ways:
 //   - Instead of adding attendees and generating spurious notifications,