forgejo/models/activitypub/actor.go

198 lines
5 KiB
Go
Raw Normal View History

package activitypub
import (
"fmt"
"net/url"
"strconv"
"strings"
2023-12-06 15:06:30 +03:00
"code.gitea.io/gitea/modules/log"
2023-12-08 20:08:54 +03:00
"code.gitea.io/gitea/modules/validation"
)
2023-11-23 16:50:32 +03:00
type Validatable interface { // ToDo: What is the right package for this interface?
validate_is_not_nil() error
validate_is_not_empty() error
Validate() error
IsValid() (bool, error)
PanicIfInvalid()
}
2023-12-08 21:43:49 +03:00
type PersonId struct {
2023-12-08 21:41:22 +03:00
userId string
source string
schema string
path string
host string
port string
unvalidatedInput string
}
2023-12-07 13:24:27 +03:00
func validate_is_not_empty(str string) error {
if str == "" {
2023-12-07 13:24:27 +03:00
return fmt.Errorf("the given string was empty")
}
return nil
}
/*
2023-12-06 13:24:42 +03:00
Validate collects error strings in a slice and returns this
*/
2023-12-08 21:43:49 +03:00
func (value PersonId) Validate() []string {
2023-12-08 21:41:22 +03:00
var result = []string{}
result = append(result, validation.ValidateNotEmpty(value.userId, "userId")...)
result = append(result, validation.ValidateNotEmpty(value.source, "source")...)
result = append(result, validation.ValidateNotEmpty(value.schema, "schema")...)
result = append(result, validation.ValidateNotEmpty(value.path, "path")...)
result = append(result, validation.ValidateNotEmpty(value.host, "host")...)
result = append(result, validation.ValidateNotEmpty(value.unvalidatedInput, "unvalidatedInput")...)
result = append(result, validation.ValidateOneOf(value.source, []string{"forgejo", "gitea"})...)
switch value.source {
case "forgejo", "gitea":
2023-12-08 21:41:22 +03:00
if !strings.Contains(value.path, "api/v1/activitypub/user-id") {
result = append(result, fmt.Sprintf("path has to be a api path"))
}
}
2023-12-08 21:41:22 +03:00
return result
}
2023-12-06 13:24:42 +03:00
/*
IsValid concatenates the error messages with newlines and returns them if there are any
*/
2023-12-08 21:43:49 +03:00
func (a PersonId) IsValid() (bool, error) {
if err := a.Validate(); len(err) > 0 {
errString := strings.Join(err, "\n")
return false, fmt.Errorf(errString)
}
return true, nil
}
2023-12-08 21:43:49 +03:00
func (a PersonId) PanicIfInvalid() {
if valid, err := a.IsValid(); !valid {
panic(err)
}
}
2023-12-08 21:43:49 +03:00
func (a PersonId) GetUserId() int {
result, err := strconv.Atoi(a.userId)
if err != nil {
panic(err)
}
return result
}
2023-12-08 21:43:49 +03:00
func (a PersonId) GetNormalizedUri() string {
result := fmt.Sprintf("%s://%s:%s/%s/%s", a.schema, a.host, a.port, a.path, a.userId)
return result
}
// Returns the combination of host:port if port exists, host otherwise
2023-12-08 21:43:49 +03:00
func (a PersonId) GetHostAndPort() string {
if a.port != "" {
return strings.Join([]string{a.host, a.port}, ":")
}
return a.host
}
2023-12-06 15:06:30 +03:00
func containsEmptyString(ar []string) bool {
for _, elem := range ar {
if elem == "" {
return true
}
}
return false
}
func removeEmptyStrings(ls []string) []string {
var rs []string
for _, str := range ls {
if str != "" {
rs = append(rs, str)
}
}
return rs
}
2023-12-08 13:54:07 +03:00
func ValidateAndParseIRI(unvalidatedIRI string) (url.URL, error) { // ToDo: Validate that it is not the same host as ours.
err := validate_is_not_empty(unvalidatedIRI) // url.Parse seems to accept empty strings?
if err != nil {
return url.URL{}, err
2023-12-06 18:14:39 +03:00
}
validatedURL, err := url.Parse(unvalidatedIRI)
if err != nil {
return url.URL{}, err
}
2023-12-07 14:03:28 +03:00
if len(validatedURL.Path) <= 1 {
return url.URL{}, fmt.Errorf("path was empty")
}
return *validatedURL, nil
}
// TODO: This parsing is very Person-Specific. We should adjust the name & move to a better location (maybe forgefed package?)
2023-12-08 21:43:49 +03:00
func ParseActorID(validatedURL url.URL, source string) PersonId { // ToDo: Turn this into a factory function and do not split parsing and validation rigurously
pathWithUserID := strings.Split(validatedURL.Path, "/")
2023-12-06 15:06:30 +03:00
if containsEmptyString(pathWithUserID) {
pathWithUserID = removeEmptyStrings(pathWithUserID)
}
length := len(pathWithUserID)
pathWithoutUserID := strings.Join(pathWithUserID[0:length-1], "/")
userId := pathWithUserID[length-1]
log.Info("Actor: pathWithUserID: %s", pathWithUserID)
log.Info("Actor: pathWithoutUserID: %s", pathWithoutUserID)
log.Info("Actor: UserID: %s", userId)
2023-12-08 21:43:49 +03:00
return PersonId{ // ToDo: maybe keep original input to validate against (maybe extra method)
userId: userId,
source: source,
schema: validatedURL.Scheme,
host: validatedURL.Hostname(), // u.Host returns hostname:port
2023-12-06 15:06:30 +03:00
path: pathWithoutUserID,
port: validatedURL.Port(),
}
}
2023-12-08 20:08:54 +03:00
2023-12-08 21:43:49 +03:00
func NewPersonId(uri string, source string) (PersonId, error) {
2023-12-08 20:08:54 +03:00
if !validation.IsValidExternalURL(uri) {
2023-12-08 21:43:49 +03:00
return PersonId{}, fmt.Errorf("uri %s is not a valid external url", uri)
2023-12-08 20:08:54 +03:00
}
2023-12-08 21:41:22 +03:00
validatedUri, _ := url.Parse(uri)
pathWithUserID := strings.Split(validatedUri.Path, "/")
if containsEmptyString(pathWithUserID) {
pathWithUserID = removeEmptyStrings(pathWithUserID)
}
length := len(pathWithUserID)
pathWithoutUserID := strings.Join(pathWithUserID[0:length-1], "/")
userId := pathWithUserID[length-1]
2023-12-08 21:43:49 +03:00
actorId := PersonId{
2023-12-08 21:41:22 +03:00
userId: userId,
source: source,
schema: validatedUri.Scheme,
host: validatedUri.Hostname(),
path: pathWithoutUserID,
port: validatedUri.Port(),
unvalidatedInput: uri,
}
if valid, err := actorId.IsValid(); !valid {
2023-12-08 21:43:49 +03:00
return PersonId{}, err
2023-12-08 21:41:22 +03:00
}
return actorId, nil
2023-12-08 20:08:54 +03:00
}