searching for the local person

routers/api/v1/activitypub/repository.go

@@ -10,12 +10,12 @@ import (
 	"strings"
 
 	"code.gitea.io/gitea/models/activitypub"
+	"code.gitea.io/gitea/models/db"
 	api "code.gitea.io/gitea/modules/activitypub"
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/forgefed"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
-	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/modules/web"
 
 	user_model "code.gitea.io/gitea/models/user"
@@ -75,14 +75,14 @@ func RepositoryInbox(ctx *context.APIContext) {
 	//     "$ref": "#/responses/empty"
 
 	log.Info("RepositoryInbox: repo %v, %v", ctx.Repo.Repository.OwnerName, ctx.Repo.Repository.Name)
-	opt := web.GetForm(ctx).(*forgefed.Star)
+	activity := web.GetForm(ctx).(*forgefed.Star)
 
-	log.Info("RepositoryInbox: Activity.Source %v", opt.Source)
+	log.Info("RepositoryInbox: Activity.Source %v", activity.Source)
-	log.Info("RepositoryInbox: Activity.Actor %v", opt.Actor)
+	log.Info("RepositoryInbox: Activity.Actor %v", activity.Actor)
 
 	// assume actor is: "actor": "https://codeberg.org/api/v1/activitypub/user-id/12345" - NB: This might be actually the ID? Maybe check vocabulary.
 	// parse actor
-	actor, err := activitypub.ParseActorIDFromStarActivity(opt)
+	actor, err := activitypub.ParseActorIDFromStarActivity(activity)
 
 	// Is the actor IRI well formed?
 	if err != nil {
@@ -102,15 +102,16 @@ func RepositoryInbox(ctx *context.APIContext) {
 	*/
 
 	// make http client
-	host := opt.To.GetID().String()
+	// TODO: this should also work without autorizing the api call // doer might be empty
-	client, err := api.NewClient(ctx, ctx.Doer, host) // ToDo: This is hacky, we need a hostname from somewhere
+	host := activity.To.GetID().String()
+	client, err := api.NewClient(ctx, ctx.ContextUser, host) // ToDo: This is hacky, we need a hostname from somewhere
 	if err != nil {
 		panic(err)
 	}
 
 	// get_person_by_rest
 	bytes := []byte{0}                        // no body needed for getting user actor
-	target := opt.Actor.GetID().String() // target is the person actor that originally performed the star activity
+	target := activity.Actor.GetID().String() // target is the person actor that originally performed the star activity
 	response, err := client.Get(bytes, target)
 	if err != nil {
 		panic(err)
@@ -135,35 +136,25 @@ func RepositoryInbox(ctx *context.APIContext) {
 	log.Info("Person Name is: %v", person.PreferredUsername)
 	log.Info("Person URL is: %v", person.URL)
 
-	// create_user_from_person (if not alreaydy present)
-
 	// Check if user already exists
-
+	// TODO: If we where able to search for federated id there would be no need to get the remote person.
-	// Create user
+	options := &user_model.SearchUserOptions{
-	email := generateUUIDMail(person)
+		Keyword: person.PreferredUsername.Get("en").String(),
-	username := getUserName(person)
+		Actor:   ctx.Doer,
-
+		Type:    user_model.UserTypeRemoteUser,
-	u := &user_model.User{
+		OrderBy: db.SearchOrderByAlphabetically,
-		LowerName:                    username.ToLower(),
+		ListOptions: db.ListOptions{
-		Name:                         username,
+			Page:     0,
-		Email:                        email,
+			PageSize: 1,
-		EmailNotificationsPreference: "disabled",
+			ListAll:  true,
-		Passwd:                       generateRandomPassword(),
+		},
-		MustChangePassword:           false,
-		Type:                         UserType.UserTypeRemoteUser,
-		Location:                     getUserLocation(person),
-		Website:                      getAPUserID(person),
-		IsAdmin:                      false,
 	}
+	users, usersCount, err := user_model.SearchUsers(db.DefaultContext, options)
 
-	overwriteDefault := &user_model.CreateUserOverwriteOptions{
+	log.Info("local found users: %v", usersCount)
-		IsActive:     util.OptionalBoolFalse,
-		IsRestricted: util.OptionalBoolFalse,
-	}
 
-	if err := user_model.CreateUser(ctx, u, overwriteDefault); err != nil {
+	if usersCount == 0 {
-		panic(fmt.Errorf("CreateUser: %w", err))
+		// create user
-	}
 
 		/*
 			ToDo: Make user
@@ -189,6 +180,41 @@ func RepositoryInbox(ctx *context.APIContext) {
 			And depending on implementation check if the person already exists in federated user db.
 		*/
 
+		/*
+			email := generateUUIDMail(person)
+			username := getUserName(person)
+
+			user := &user_model.User{
+				LowerName:                    username.ToLower(),
+				Name:                         username,
+				Email:                        email,
+				EmailNotificationsPreference: "disabled",
+				Passwd:                       generateRandomPassword(),
+				MustChangePassword:           false,
+				Type:                         UserType.UserTypeRemoteUser,
+				Location:                     getUserLocation(person),
+				Website:                      getAPUserID(person),
+				IsAdmin:                      false,
+			}
+
+			overwriteDefault := &user_model.CreateUserOverwriteOptions{
+				IsActive:     util.OptionalBoolFalse,
+				IsRestricted: util.OptionalBoolFalse,
+			}
+
+			if err := user_model.CreateUser(ctx, user, overwriteDefault); err != nil {
+				panic(fmt.Errorf("CreateUser: %w", err))
+			}
+		*/
+	} else {
+		// use first user
+		user := users[0]
+		log.Info("%v", user)
+	}
+	// TODO: handle case of count > 1
+
+	// execute star action
+
 	// wait 15 sec.
 
 	ctx.Status(http.StatusNoContent)