commit 87bd77a48681f8967d9fedebcf6287a7f328d2ee · julien.rbrt.fr/tangled-core

+22 -1

appview/db/repos.go

···

       31
       31
        
       }

     

       32
       32
        
       

     

       33
       33
        
       func (r *Repo) AsRecord() tangled.Repo {

     

       34
       34
       -
       	return tangled.Repo{}

     

       34
       34
       +
       	var source, spindle, description *string

     

       35
       35
       +
       

     

       36
       36
       +
       	if r.Source != "" {

     

       37
       37
       +
       		source = &r.Source

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	if r.Spindle != "" {

     

       41
       41
       +
       		spindle = &r.Spindle

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	if r.Description != "" {

     

       45
       45
       +
       		description = &r.Description

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	return tangled.Repo{

     

       49
       49
       +
       		Knot:        r.Knot,

     

       50
       50
       +
       		Name:        r.Name,

     

       51
       51
       +
       		Description: description,

     

       52
       52
       +
       		CreatedAt:   r.Created.Format(time.RFC3339),

     

       53
       53
       +
       		Source:      source,

     

       54
       54
       +
       		Spindle:     spindle,

     

       55
       55
       +
       	}

     

       35
       56
        
       }

     

       36
       57
        
       

     

       37
       58
        
       func (r Repo) RepoAt() syntax.ATURI {

+29 -41

appview/repo/repo.go

···

       295
       295
        
       			return

     

       296
       296
        
       		}

     

       297
       297
        
       

     

       298
       298
       +
       		newRepo := f.Repo

     

       299
       299
       +
       		newRepo.Description = newDescription

     

       300
       300
       +
       		record := newRepo.AsRecord()

     

       301
       301
       +
       

     

       298
       302
        
       		// this is a bit of a pain because the golang atproto impl does not allow nil SwapRecord field

     

       299
       303
        
       		//

     

       300
       304
        
       		// SwapRecord is optional and should happen automagically, but given that it does not, we have to perform two requests

     

       301
       301
       -
       		ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)

     

       305
       305
       +
       		ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       302
       306
        
       		if err != nil {

     

       303
       307
        
       			// failed to get record

     

       304
       308
        
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, no record found on PDS.")

     
···

       306
       310
        
       		}

     

       307
       311
        
       		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       308
       312
        
       			Collection: tangled.RepoNSID,

     

       309
       309
       -
       			Repo:       user.Did,

     

       310
       310
       -
       			Rkey:       rkey,

     

       313
       313
       +
       			Repo:       newRepo.Did,

     

       314
       314
       +
       			Rkey:       newRepo.Rkey,

     

       311
       315
        
       			SwapRecord: ex.Cid,

     

       312
       316
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       313
       313
       -
       				Val: &tangled.Repo{

     

       314
       314
       -
       					Knot:        f.Knot,

     

       315
       315
       -
       					Name:        f.Name,

     

       316
       316
       -
       					CreatedAt:   f.Created.Format(time.RFC3339),

     

       317
       317
       -
       					Description: &newDescription,

     

       318
       318
       -
       					Spindle:     &f.Spindle,

     

       319
       319
       -
       				},

     

       317
       317
       +
       				Val: &record,

     

       320
       318
        
       			},

     

       321
       319
        
       		})

     

       322
       320
        
       

     
···

       894
       892
        
       		return

     

       895
       893
        
       	}

     

       896
       894
        
       

     

       897
       897
       -
       	repoAt := f.RepoAt()

     

       898
       898
       -
       	rkey := repoAt.RecordKey().String()

     

       899
       899
       -
       	if rkey == "" {

     

       900
       900
       -
       		fail("Failed to resolve repo. Try again later", err)

     

       901
       901
       -
       		return

     

       902
       902
       -
       	}

     

       903
       903
       -
       

     

       904
       895
        
       	newSpindle := r.FormValue("spindle")

     

       905
       896
        
       	removingSpindle := newSpindle == "[[none]]" // see pages/templates/repo/settings/pipelines.html for more info on why we use this value

     

       906
       897
        
       	client, err := rp.oauth.AuthorizedClient(r)

     
···

       923
       914
        
       		}

     

       924
       915
        
       	}

     

       925
       916
        
       

     

       917
       917
       +
       	newRepo := f.Repo

     

       918
       918
       +
       	newRepo.Spindle = newSpindle

     

       919
       919
       +
       	record := newRepo.AsRecord()

     

       920
       920
       +
       

     

       926
       921
        
       	spindlePtr := &newSpindle

     

       927
       922
        
       	if removingSpindle {

     

       928
       923
        
       		spindlePtr = nil

     

       924
       924
       +
       		newRepo.Spindle = ""

     

       929
       925
        
       	}

     

       930
       926
        
       

     

       931
       927
        
       	// optimistic update

     

       932
       932
       -
       	err = db.UpdateSpindle(rp.db, string(repoAt), spindlePtr)

     

       928
       928
       +
       	err = db.UpdateSpindle(rp.db, newRepo.RepoAt().String(), spindlePtr)

     

       933
       929
        
       	if err != nil {

     

       934
       930
        
       		fail("Failed to update spindle. Try again later.", err)

     

       935
       931
        
       		return

     

       936
       932
        
       	}

     

       937
       933
        
       

     

       938
       938
       -
       	ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)

     

       934
       934
       +
       	ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       939
       935
        
       	if err != nil {

     

       940
       936
        
       		fail("Failed to update spindle, no record found on PDS.", err)

     

       941
       937
        
       		return

     

       942
       938
        
       	}

     

       943
       939
        
       	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       944
       940
        
       		Collection: tangled.RepoNSID,

     

       945
       945
       -
       		Repo:       user.Did,

     

       946
       946
       -
       		Rkey:       rkey,

     

       941
       941
       +
       		Repo:       newRepo.Did,

     

       942
       942
       +
       		Rkey:       newRepo.Rkey,

     

       947
       943
        
       		SwapRecord: ex.Cid,

     

       948
       944
        
       		Record: &lexutil.LexiconTypeDecoder{

     

       949
       949
       -
       			Val: &tangled.Repo{

     

       950
       950
       -
       				Knot:        f.Knot,

     

       951
       951
       -
       				Name:        f.Name,

     

       952
       952
       -
       				CreatedAt:   f.Created.Format(time.RFC3339),

     

       953
       953
       -
       				Description: &f.Description,

     

       954
       954
       -
       				Spindle:     spindlePtr,

     

       955
       955
       -
       			},

     

       945
       945
       +
       			Val: &record,

     

       956
       946
        
       		},

     

       957
       947
        
       	})

     

       958
       948
        
       

     
···

       1073
       1063
        
       		return

     

       1074
       1064
        
       	}

     

       1075
       1065
        
       

     

       1076
       1076
       -
       	err = db.AddCollaborator(rp.db, db.Collaborator{

     

       1066
       1066
       +
       	err = db.AddCollaborator(tx, db.Collaborator{

     

       1077
       1067
        
       		Did:        syntax.DID(currentUser.Did),

     

       1078
       1068
        
       		Rkey:       rkey,

     

       1079
       1069
        
       		SubjectDid: collaboratorIdent.DID,

     
···

       1610
       1600
        
       		// create an atproto record for this fork

     

       1611
       1601
        
       		rkey := tid.TID()

     

       1612
       1602
        
       		repo := &db.Repo{

     

       1613
       1613
       -
       			Did:    user.Did,

     

       1614
       1614
       -
       			Name:   forkName,

     

       1615
       1615
       -
       			Knot:   targetKnot,

     

       1616
       1616
       -
       			Rkey:   rkey,

     

       1617
       1617
       -
       			Source: sourceAt,

     

       1603
       1603
       +
       			Did:         user.Did,

     

       1604
       1604
       +
       			Name:        forkName,

     

       1605
       1605
       +
       			Knot:        targetKnot,

     

       1606
       1606
       +
       			Rkey:        rkey,

     

       1607
       1607
       +
       			Source:      sourceAt,

     

       1608
       1608
       +
       			Description: existingRepo.Description,

     

       1609
       1609
       +
       			Created:     time.Now(),

     

       1618
       1610
        
       		}

     

       1611
       1611
       +
       		record := repo.AsRecord()

     

       1619
       1612
        
       

     

       1620
       1613
        
       		xrpcClient, err := rp.oauth.AuthorizedClient(r)

     

       1621
       1614
        
       		if err != nil {

     
···

       1624
       1617
        
       			return

     

       1625
       1618
        
       		}

     

       1626
       1619
        
       

     

       1627
       1627
       -
       		createdAt := time.Now().Format(time.RFC3339)

     

       1628
       1620
        
       		atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       1629
       1621
        
       			Collection: tangled.RepoNSID,

     

       1630
       1622
        
       			Repo:       user.Did,

     

       1631
       1623
        
       			Rkey:       rkey,

     

       1632
       1624
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       1633
       1633
       -
       				Val: &tangled.Repo{

     

       1634
       1634
       -
       					Knot:      repo.Knot,

     

       1635
       1635
       -
       					Name:      repo.Name,

     

       1636
       1636
       -
       					CreatedAt: createdAt,

     

       1637
       1637
       -
       					Source:    &sourceAt,

     

       1638
       1638
       -
       				}},

     

       1625
       1625
       +
       				Val: &record,

     

       1626
       1626
       +
       			},

     

       1639
       1627
        
       		})

     

       1640
       1628
        
       		if err != nil {

     

       1641
       1629
        
       			l.Error("failed to write to PDS", "err", err)

+4 -6

appview/state/state.go

···

       434
       434
        
       			Knot:        domain,

     

       435
       435
        
       			Rkey:        rkey,

     

       436
       436
        
       			Description: description,

     

       437
       437
       +
       			Created:     time.Now(),

     

       437
       438
        
       		}

     

       439
       439
       +
       		record := repo.AsRecord()

     

       438
       440
        
       

     

       439
       441
        
       		xrpcClient, err := s.oauth.AuthorizedClient(r)

     

       440
       442
        
       		if err != nil {

     
···

       443
       445
        
       			return

     

       444
       446
        
       		}

     

       445
       447
        
       

     

       446
       446
       -
       		createdAt := time.Now().Format(time.RFC3339)

     

       447
       448
        
       		atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       448
       449
        
       			Collection: tangled.RepoNSID,

     

       449
       450
        
       			Repo:       user.Did,

     

       450
       451
        
       			Rkey:       rkey,

     

       451
       452
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       452
       452
       -
       				Val: &tangled.Repo{

     

       453
       453
       -
       					Knot:      repo.Knot,

     

       454
       454
       -
       					Name:      repoName,

     

       455
       455
       -
       					CreatedAt: createdAt,

     

       456
       456
       -
       				}},

     

       453
       453
       +
       				Val: &record,

     

       454
       454
       +
       			},

     

       457
       455
        
       		})

     

       458
       456
        
       		if err != nil {

     

       459
       457
        
       			l.Info("PDS write failed", "err", err)