2f6d731993
renames /internal/connector to /internal/m365. No logic changes in this PR. Only the dir rename, import renames, and one linter shadowing rename. --- #### Does this PR need a docs update or release note? - [x] ⛔ No #### Type of change - [x] 🧹 Tech Debt/Cleanup #### Issue(s) * #1996 #### Test Plan - [x] ⚡ Unit test - [x] 💚 E2E
481 lines
13 KiB
Go
481 lines
13 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/alcionai/clues"
|
|
"github.com/microsoft/kiota-abstractions-go/serialization"
|
|
kjson "github.com/microsoft/kiota-serialization-json-go"
|
|
"github.com/microsoftgraph/msgraph-sdk-go/models"
|
|
"github.com/microsoftgraph/msgraph-sdk-go/users"
|
|
|
|
"github.com/alcionai/corso/src/internal/common/ptr"
|
|
"github.com/alcionai/corso/src/internal/m365/graph"
|
|
"github.com/alcionai/corso/src/pkg/backup/details"
|
|
"github.com/alcionai/corso/src/pkg/fault"
|
|
"github.com/alcionai/corso/src/pkg/selectors"
|
|
)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// controller
|
|
// ---------------------------------------------------------------------------
|
|
|
|
func (c Client) Contacts() Contacts {
|
|
return Contacts{c}
|
|
}
|
|
|
|
// Contacts is an interface-compliant provider of the client.
|
|
type Contacts struct {
|
|
Client
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// containers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// CreateContainer makes a contact folder with the displayName of folderName.
|
|
// If successful, returns the created folder object.
|
|
func (c Contacts) CreateContainer(
|
|
ctx context.Context,
|
|
userID, containerName string,
|
|
_ string, // parentContainerID needed for iface, doesn't apply to contacts
|
|
) (graph.Container, error) {
|
|
body := models.NewContactFolder()
|
|
body.SetDisplayName(ptr.To(containerName))
|
|
|
|
mdl, err := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
Post(ctx, body, nil)
|
|
if err != nil {
|
|
return nil, graph.Wrap(ctx, err, "creating contact folder")
|
|
}
|
|
|
|
return mdl, nil
|
|
}
|
|
|
|
// DeleteContainer deletes the ContactFolder associated with the M365 ID if permissions are valid.
|
|
func (c Contacts) DeleteContainer(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
) error {
|
|
// deletes require unique http clients
|
|
// https://github.com/alcionai/corso/issues/2707
|
|
srv, err := NewService(c.Credentials)
|
|
if err != nil {
|
|
return graph.Stack(ctx, err)
|
|
}
|
|
|
|
err = srv.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(containerID).
|
|
Delete(ctx, nil)
|
|
if err != nil {
|
|
return graph.Stack(ctx, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// prefer GetContainerByID where possible.
|
|
// use this only in cases where the models.ContactFolderable
|
|
// is required.
|
|
func (c Contacts) GetFolder(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
) (models.ContactFolderable, error) {
|
|
config := &users.ItemContactFoldersContactFolderItemRequestBuilderGetRequestConfiguration{
|
|
QueryParameters: &users.ItemContactFoldersContactFolderItemRequestBuilderGetQueryParameters{
|
|
Select: idAnd(displayName, parentFolderID),
|
|
},
|
|
}
|
|
|
|
resp, err := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(containerID).
|
|
Get(ctx, config)
|
|
if err != nil {
|
|
return nil, graph.Stack(ctx, err)
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// interface-compliant wrapper of GetFolder
|
|
func (c Contacts) GetContainerByID(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
) (graph.Container, error) {
|
|
return c.GetFolder(ctx, userID, containerID)
|
|
}
|
|
|
|
func (c Contacts) PatchFolder(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
body models.ContactFolderable,
|
|
) error {
|
|
_, err := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(containerID).
|
|
Patch(ctx, body, nil)
|
|
if err != nil {
|
|
return graph.Wrap(ctx, err, "patching contact folder")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// container pager
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// EnumerateContainers iterates through all of the users current
|
|
// contacts folders, converting each to a graph.CacheFolder, and calling
|
|
// fn(cf) on each one.
|
|
// Folder hierarchy is represented in its current state, and does
|
|
// not contain historical data.
|
|
func (c Contacts) EnumerateContainers(
|
|
ctx context.Context,
|
|
userID, baseContainerID string,
|
|
fn func(graph.CachedContainer) error,
|
|
errs *fault.Bus,
|
|
) error {
|
|
config := &users.ItemContactFoldersItemChildFoldersRequestBuilderGetRequestConfiguration{
|
|
QueryParameters: &users.ItemContactFoldersItemChildFoldersRequestBuilderGetQueryParameters{
|
|
Select: idAnd(displayName, parentFolderID),
|
|
},
|
|
}
|
|
|
|
el := errs.Local()
|
|
builder := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(baseContainerID).
|
|
ChildFolders()
|
|
|
|
for {
|
|
if el.Failure() != nil {
|
|
break
|
|
}
|
|
|
|
resp, err := builder.Get(ctx, config)
|
|
if err != nil {
|
|
return graph.Stack(ctx, err)
|
|
}
|
|
|
|
for _, fold := range resp.GetValue() {
|
|
if el.Failure() != nil {
|
|
return el.Failure()
|
|
}
|
|
|
|
if err := graph.CheckIDNameAndParentFolderID(fold); err != nil {
|
|
errs.AddRecoverable(graph.Stack(ctx, err).Label(fault.LabelForceNoBackupCreation))
|
|
continue
|
|
}
|
|
|
|
fctx := clues.Add(
|
|
ctx,
|
|
"container_id", ptr.Val(fold.GetId()),
|
|
"container_display_name", ptr.Val(fold.GetDisplayName()))
|
|
|
|
temp := graph.NewCacheFolder(fold, nil, nil)
|
|
if err := fn(&temp); err != nil {
|
|
errs.AddRecoverable(graph.Stack(fctx, err).Label(fault.LabelForceNoBackupCreation))
|
|
continue
|
|
}
|
|
}
|
|
|
|
link, ok := ptr.ValOK(resp.GetOdataNextLink())
|
|
if !ok {
|
|
break
|
|
}
|
|
|
|
builder = users.NewItemContactFoldersItemChildFoldersRequestBuilder(link, c.Stable.Adapter())
|
|
}
|
|
|
|
return el.Failure()
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// items
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// GetItem retrieves a Contactable item.
|
|
func (c Contacts) GetItem(
|
|
ctx context.Context,
|
|
userID, itemID string,
|
|
immutableIDs bool,
|
|
_ *fault.Bus, // no attachments to iterate over, so this goes unused
|
|
) (serialization.Parsable, *details.ExchangeInfo, error) {
|
|
options := &users.ItemContactsContactItemRequestBuilderGetRequestConfiguration{
|
|
Headers: newPreferHeaders(preferImmutableIDs(immutableIDs)),
|
|
}
|
|
|
|
cont, err := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
Contacts().
|
|
ByContactId(itemID).
|
|
Get(ctx, options)
|
|
if err != nil {
|
|
return nil, nil, graph.Stack(ctx, err)
|
|
}
|
|
|
|
return cont, ContactInfo(cont), nil
|
|
}
|
|
|
|
func (c Contacts) PostItem(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
body models.Contactable,
|
|
) (models.Contactable, error) {
|
|
itm, err := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(containerID).
|
|
Contacts().
|
|
Post(ctx, body, nil)
|
|
if err != nil {
|
|
return nil, graph.Wrap(ctx, err, "creating contact")
|
|
}
|
|
|
|
return itm, nil
|
|
}
|
|
|
|
func (c Contacts) DeleteItem(
|
|
ctx context.Context,
|
|
userID, itemID string,
|
|
) error {
|
|
// deletes require unique http clients
|
|
// https://github.com/alcionai/corso/issues/2707
|
|
srv, err := c.Service()
|
|
if err != nil {
|
|
return graph.Stack(ctx, err)
|
|
}
|
|
|
|
err = srv.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
Contacts().
|
|
ByContactId(itemID).
|
|
Delete(ctx, nil)
|
|
if err != nil {
|
|
return graph.Wrap(ctx, err, "deleting contact")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// item pager
|
|
// ---------------------------------------------------------------------------
|
|
|
|
var _ itemPager = &contactPager{}
|
|
|
|
type contactPager struct {
|
|
gs graph.Servicer
|
|
builder *users.ItemContactFoldersItemContactsRequestBuilder
|
|
options *users.ItemContactFoldersItemContactsRequestBuilderGetRequestConfiguration
|
|
}
|
|
|
|
func (c Contacts) NewContactPager(
|
|
ctx context.Context,
|
|
userID, containerID string,
|
|
immutableIDs bool,
|
|
) itemPager {
|
|
config := &users.ItemContactFoldersItemContactsRequestBuilderGetRequestConfiguration{
|
|
QueryParameters: &users.ItemContactFoldersItemContactsRequestBuilderGetQueryParameters{
|
|
Select: idAnd(parentFolderID),
|
|
},
|
|
Headers: newPreferHeaders(preferPageSize(maxNonDeltaPageSize), preferImmutableIDs(immutableIDs)),
|
|
}
|
|
|
|
builder := c.Stable.
|
|
Client().
|
|
Users().
|
|
ByUserId(userID).
|
|
ContactFolders().
|
|
ByContactFolderId(containerID).
|
|
Contacts()
|
|
|
|
return &contactPager{c.Stable, builder, config}
|
|
}
|
|
|
|
func (p *contactPager) getPage(ctx context.Context) (DeltaPageLinker, error) {
|
|
resp, err := p.builder.Get(ctx, p.options)
|
|
if err != nil {
|
|
return nil, graph.Stack(ctx, err)
|
|
}
|
|
|
|
return EmptyDeltaLinker[models.Contactable]{PageLinkValuer: resp}, nil
|
|
}
|
|
|
|
func (p *contactPager) setNext(nextLink string) {
|
|
p.builder = users.NewItemContactFoldersItemContactsRequestBuilder(nextLink, p.gs.Adapter())
|
|
}
|
|
|
|
// non delta pagers don't need reset
|
|
func (p *contactPager) reset(context.Context) {}
|
|
|
|
func (p *contactPager) valuesIn(pl PageLinker) ([]getIDAndAddtler, error) {
|
|
return toValues[models.Contactable](pl)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// delta item pager
|
|
// ---------------------------------------------------------------------------
|
|
|
|
var _ itemPager = &contactDeltaPager{}
|
|
|
|
type contactDeltaPager struct {
|
|
gs graph.Servicer
|
|
userID string
|
|
containerID string
|
|
builder *users.ItemContactFoldersItemContactsDeltaRequestBuilder
|
|
options *users.ItemContactFoldersItemContactsDeltaRequestBuilderGetRequestConfiguration
|
|
}
|
|
|
|
func getContactDeltaBuilder(
|
|
ctx context.Context,
|
|
gs graph.Servicer,
|
|
userID, containerID string,
|
|
options *users.ItemContactFoldersItemContactsDeltaRequestBuilderGetRequestConfiguration,
|
|
) *users.ItemContactFoldersItemContactsDeltaRequestBuilder {
|
|
builder := gs.Client().Users().ByUserId(userID).ContactFolders().ByContactFolderId(containerID).Contacts().Delta()
|
|
return builder
|
|
}
|
|
|
|
func (c Contacts) NewContactDeltaPager(
|
|
ctx context.Context,
|
|
userID, containerID, oldDelta string,
|
|
immutableIDs bool,
|
|
) itemPager {
|
|
options := &users.ItemContactFoldersItemContactsDeltaRequestBuilderGetRequestConfiguration{
|
|
QueryParameters: &users.ItemContactFoldersItemContactsDeltaRequestBuilderGetQueryParameters{
|
|
Select: idAnd(parentFolderID),
|
|
},
|
|
Headers: newPreferHeaders(preferPageSize(maxDeltaPageSize), preferImmutableIDs(immutableIDs)),
|
|
}
|
|
|
|
var builder *users.ItemContactFoldersItemContactsDeltaRequestBuilder
|
|
if oldDelta != "" {
|
|
builder = users.NewItemContactFoldersItemContactsDeltaRequestBuilder(oldDelta, c.Stable.Adapter())
|
|
} else {
|
|
builder = getContactDeltaBuilder(ctx, c.Stable, userID, containerID, options)
|
|
}
|
|
|
|
return &contactDeltaPager{c.Stable, userID, containerID, builder, options}
|
|
}
|
|
|
|
func (p *contactDeltaPager) getPage(ctx context.Context) (DeltaPageLinker, error) {
|
|
resp, err := p.builder.Get(ctx, p.options)
|
|
if err != nil {
|
|
return nil, graph.Stack(ctx, err)
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
func (p *contactDeltaPager) setNext(nextLink string) {
|
|
p.builder = users.NewItemContactFoldersItemContactsDeltaRequestBuilder(nextLink, p.gs.Adapter())
|
|
}
|
|
|
|
func (p *contactDeltaPager) reset(ctx context.Context) {
|
|
p.builder = getContactDeltaBuilder(ctx, p.gs, p.userID, p.containerID, p.options)
|
|
}
|
|
|
|
func (p *contactDeltaPager) valuesIn(pl PageLinker) ([]getIDAndAddtler, error) {
|
|
return toValues[models.Contactable](pl)
|
|
}
|
|
|
|
func (c Contacts) GetAddedAndRemovedItemIDs(
|
|
ctx context.Context,
|
|
userID, containerID, oldDelta string,
|
|
immutableIDs bool,
|
|
canMakeDeltaQueries bool,
|
|
) ([]string, []string, DeltaUpdate, error) {
|
|
ctx = clues.Add(
|
|
ctx,
|
|
"category", selectors.ExchangeContact,
|
|
"container_id", containerID)
|
|
|
|
pager := c.NewContactPager(ctx, userID, containerID, immutableIDs)
|
|
deltaPager := c.NewContactDeltaPager(ctx, userID, containerID, oldDelta, immutableIDs)
|
|
|
|
return getAddedAndRemovedItemIDs(ctx, c.Stable, pager, deltaPager, oldDelta, canMakeDeltaQueries)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Serialization
|
|
// ---------------------------------------------------------------------------
|
|
|
|
func BytesToContactable(bytes []byte) (models.Contactable, error) {
|
|
v, err := createFromBytes(bytes, models.CreateContactFromDiscriminatorValue)
|
|
if err != nil {
|
|
return nil, clues.Wrap(err, "deserializing bytes to contact")
|
|
}
|
|
|
|
return v.(models.Contactable), nil
|
|
}
|
|
|
|
func (c Contacts) Serialize(
|
|
ctx context.Context,
|
|
item serialization.Parsable,
|
|
userID, itemID string,
|
|
) ([]byte, error) {
|
|
contact, ok := item.(models.Contactable)
|
|
if !ok {
|
|
return nil, clues.New(fmt.Sprintf("item is not a Contactable: %T", item))
|
|
}
|
|
|
|
ctx = clues.Add(ctx, "item_id", ptr.Val(contact.GetId()))
|
|
writer := kjson.NewJsonSerializationWriter()
|
|
|
|
defer writer.Close()
|
|
|
|
if err := writer.WriteObjectValue("", contact); err != nil {
|
|
return nil, graph.Stack(ctx, err)
|
|
}
|
|
|
|
bs, err := writer.GetSerializedContent()
|
|
if err != nil {
|
|
return nil, graph.Wrap(ctx, err, "serializing contact")
|
|
}
|
|
|
|
return bs, nil
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
func ContactInfo(contact models.Contactable) *details.ExchangeInfo {
|
|
name := ptr.Val(contact.GetDisplayName())
|
|
created := ptr.Val(contact.GetCreatedDateTime())
|
|
|
|
return &details.ExchangeInfo{
|
|
ItemType: details.ExchangeContact,
|
|
ContactName: name,
|
|
Created: created,
|
|
Modified: ptr.OrNow(contact.GetLastModifiedDateTime()),
|
|
}
|
|
}
|