/helpers.go at 0ad2174ed0956f3a1a8a57752b3f98b29db48e9c

package activitypub

import (
	"errors"
	"fmt"
	"github.com/go-ap/activitystreams"
)

type withObjectFn func (*Object) error
type withActivityFn func (*activitystreams.Activity) error
type withIntransitiveActivityFn func (*activitystreams.IntransitiveActivity) error
type withQuestionFn func (*activitystreams.Question) error
type withPersonFn func (*Person) error
type withCollectionInterfaceFn func (collection activitystreams.CollectionInterface) error
type withCollectionFn func (collection *activitystreams.Collection) error
type withCollectionPageFn func (*activitystreams.CollectionPage) error
type withOrderedCollectionFn func (*activitystreams.OrderedCollection) error
type withOrderedCollectionPageFn func (*activitystreams.OrderedCollectionPage) error
type withItemCollectionFn func (collection *activitystreams.ItemCollection) error

// OnObject
func OnObject(it activitystreams.Item, fn withObjectFn) error {
	if activitystreams.ActivityTypes.Contains(it.GetType()) {
		return OnActivity(it, func(a *activitystreams.Activity) error {
			ob, err := ToObject(&a.Parent)
			if err != nil {
				return err
			}
			return fn(ob)
		})
	} else if activitystreams.ActorTypes.Contains(it.GetType()) {
		return OnPerson(it, func(p *Person) error {
			ob, err := ToObject(&p.Parent)
			if err != nil {
				return err
			}
			return fn(ob)
		})
	} else if it.IsCollection() {
		return OnCollection(it, func(col activitystreams.CollectionInterface) error {
			for _, it := range col.Collection() {
				err := OnObject(it, fn)
				if err != nil {
					return err
				}
			}
			return nil
		})
	} else {
		ob, err  := ToObject(it)
		if err != nil {
			return err
		}
		return fn(ob)
	}
}

// OnActivity
func OnActivity(it activitystreams.Item, fn withActivityFn) error {
	if !activitystreams.ActivityTypes.Contains(it.GetType()) {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to Activity", it, it.GetType()))
	}
	act, err  := activitystreams.ToActivity(it)
	if err != nil {
		return err
	}
	return fn(act)
}

// OnIntransitiveActivity
func OnIntransitiveActivity(it activitystreams.Item, fn withIntransitiveActivityFn) error {
	if !activitystreams.IntransitiveActivityTypes.Contains(it.GetType()) {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to Activity", it, it.GetType()))
	}
	if it.GetType() == activitystreams.QuestionType {
		errors.New(fmt.Sprintf("For %T[%s] you need to use OnQuestion function", it, it.GetType()))
	}
	act, err  := activitystreams.ToIntransitiveActivity(it)
	if err != nil {
		return err
	}
	return fn(act)
}

// OnQuestion
func OnQuestion(it activitystreams.Item, fn withQuestionFn) error {
	if it.GetType() != activitystreams.QuestionType {
		errors.New(fmt.Sprintf("For %T[%s] can't be converted to Question", it, it.GetType()))
	}
	act, err  := activitystreams.ToQuestion(it)
	if err != nil {
		return err
	}
	return fn(act)
}

// OnPerson
func OnPerson(it activitystreams.Item, fn withPersonFn) error {
	if !activitystreams.ActorTypes.Contains(it.GetType()) {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to Person", it, it.GetType()))
	}
	pers, err  := ToPerson(it)
	if err != nil {
		return err
	}
	return fn(pers)
}

// OnCollection
func OnCollection(it activitystreams.Item, fn withCollectionInterfaceFn) error {
	switch it.GetType() {
	case activitystreams.CollectionOfItems:
		col, err := activitystreams.ToItemCollection(it)
		if err != nil {
			return err
		}
		c := activitystreams.Collection{
			TotalItems: uint(len(*col)),
			Items:      *col,
		}
		return fn(&c)
	case activitystreams.CollectionType:
		col, err := activitystreams.ToCollection(it)
		if err != nil {
			return err
		}
		return fn(col)
	case activitystreams.CollectionPageType:
		return OnCollectionPage(it, func(p *activitystreams.CollectionPage) error {
			col, err := activitystreams.ToCollection(&p.ParentCollection)
			if err != nil {
				return err
			}
			return fn(col)
		})
	default:
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to Collection", it, it.GetType()))
	}
}

// OnCollectionPage
func OnCollectionPage(it activitystreams.Item, fn withCollectionPageFn) error {
	if it.GetType() != activitystreams.CollectionPageType {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to Collection Page", it, it.GetType()))
	}
	col, err  := activitystreams.ToCollectionPage(it)
	if err != nil {
		return err
	}
	return fn(col)
}

// OnOrderedCollection
func OnOrderedCollection(it activitystreams.Item, fn withOrderedCollectionFn) error {
	switch it.GetType() {
	case activitystreams.OrderedCollectionType:
		col, err := activitystreams.ToOrderedCollection(it)
		if err != nil {
			return err
		}
		return fn(col)
	case activitystreams.OrderedCollectionPageType:
		return OnOrderedCollectionPage(it, func(p *activitystreams.OrderedCollectionPage) error {
			col, err := activitystreams.ToOrderedCollection(&p.OrderedCollection)
			if err != nil {
				return err
			}
			return fn(col)
		})
	default:
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to OrderedCollection", it, it.GetType()))
	}
}

// OnOrderedCollectionPage
func OnOrderedCollectionPage(it activitystreams.Item, fn withOrderedCollectionPageFn) error {
	if it.GetType() != activitystreams.OrderedCollectionPageType {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to OrderedCollection Page", it, it.GetType()))
	}
	col, err  := activitystreams.ToOrderedCollectionPage(it)
	if err != nil {
		return err
	}
	return fn(col)
}

// OnOrderedCollectionPage
func OnItemCOllection(it activitystreams.Item, fn withOrderedCollectionPageFn) error {
	if it.GetType() != activitystreams.OrderedCollectionPageType {
		return errors.New(fmt.Sprintf("%T[%s] can't be converted to OrderedCollection Page", it, it.GetType()))
	}
	col, err  := activitystreams.ToOrderedCollectionPage(it)
	if err != nil {
		return err
	}
	return fn(col)
}