2023-11-16 16:49:05 +03:00
package activitypub
import (
"fmt"
"net/url"
2023-11-23 19:03:24 +03:00
"strconv"
2023-11-16 16:49:05 +03:00
"strings"
2023-11-24 14:48:14 +03:00
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-16 16:49:05 +03:00
)
2023-11-23 16:50:32 +03:00
type Validatable interface { // ToDo: What is the right package for this interface?
2023-11-24 13:37:29 +03:00
validate_is_not_nil ( ) error
2023-11-22 18:08:14 +03:00
validate_is_not_empty ( ) error
2023-11-22 17:25:43 +03:00
Validate ( ) error
2023-11-24 13:37:29 +03:00
IsValid ( ) ( bool , error )
PanicIfInvalid ( )
2023-11-22 17:25:43 +03:00
}
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-11-16 16:49:05 +03:00
}
2023-12-07 13:24:27 +03:00
func validate_is_not_empty ( str string ) error {
2023-11-24 13:37:29 +03:00
if str == "" {
2023-12-07 13:24:27 +03:00
return fmt . Errorf ( "the given string was empty" )
2023-11-24 13:37:29 +03:00
}
return nil
}
/ *
2023-12-06 13:24:42 +03:00
Validate collects error strings in a slice and returns this
2023-11-24 13:37:29 +03:00
* /
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 {
2023-11-24 14:48:14 +03:00
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-11-24 14:48:14 +03:00
}
2023-11-16 16:49:05 +03:00
}
2023-12-08 21:41:22 +03:00
return result
2023-11-16 16:49:05 +03:00
}
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 ) {
2023-11-24 13:37:29 +03:00
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 ( ) {
2023-11-24 13:37:29 +03:00
if valid , err := a . IsValid ( ) ; ! valid {
panic ( err )
}
}
2023-12-08 21:43:49 +03:00
func ( a PersonId ) GetUserId ( ) int {
2023-11-24 14:49:36 +03:00
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 {
2023-12-06 11:07:09 +03:00
result := fmt . Sprintf ( "%s://%s:%s/%s/%s" , a . schema , a . host , a . port , a . path , a . userId )
return result
}
2023-11-24 14:49:36 +03:00
// Returns the combination of host:port if port exists, host otherwise
2023-12-08 21:43:49 +03:00
func ( a PersonId ) GetHostAndPort ( ) string {
2023-11-24 14:49:36 +03:00
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.
2023-12-07 13:44:59 +03:00
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
}
2023-12-07 13:44:59 +03:00
validatedURL , err := url . Parse ( unvalidatedIRI )
2023-11-16 16:49:05 +03:00
if err != nil {
2023-12-07 13:44:59 +03:00
return url . URL { } , err
2023-11-16 16:49:05 +03:00
}
2023-12-07 14:03:28 +03:00
if len ( validatedURL . Path ) <= 1 {
return url . URL { } , fmt . Errorf ( "path was empty" )
}
2023-12-07 13:44:59 +03:00
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
2023-12-07 13:44:59 +03:00
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-11-16 16:49:05 +03:00
2023-12-08 21:43:49 +03:00
return PersonId { // ToDo: maybe keep original input to validate against (maybe extra method)
2023-11-16 16:49:05 +03:00
userId : userId ,
2023-12-06 17:15:39 +03:00
source : source ,
2023-12-07 13:44:59 +03:00
schema : validatedURL . Scheme ,
host : validatedURL . Hostname ( ) , // u.Host returns hostname:port
2023-12-06 15:06:30 +03:00
path : pathWithoutUserID ,
2023-12-07 13:44:59 +03:00
port : validatedURL . Port ( ) ,
}
2023-11-16 16:49:05 +03:00
}
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
}