commit 1f7e1fadb89d964aa068d27d94932669276ce6af · julien.rbrt.fr/tangled-core

knotserver/handler.go

···

       68
       68
        
       	r.Route("/{did}", func(r chi.Router) {

     

       69
       69
        
       		// Repo routes

     

       70
       70
        
       		r.Route("/{name}", func(r chi.Router) {

     

       71
       71
       +
       			r.Post("/collaborator/add", h.AddRepoCollaborator)

     

       72
       72
       +
       

     

       71
       73
        
       			r.Get("/", h.RepoIndex)

     

       72
       74
        
       			r.Get("/info/refs", h.InfoRefs)

     

       73
       75
        
       			r.Post("/git-upload-pack", h.UploadPack)

+59 -29

knotserver/routes.go

···

       420
       420
        
       	l := h.l.With("handler", "AddMember")

     

       421
       421
        
       

     

       422
       422
        
       	data := struct {

     

       423
       423
       -
       		Did        string   `json:"did"`

     

       424
       424
       -
       		PublicKeys []string `json:"keys"`

     

       423
       423
       +
       		Did string `json:"did"`

     

       425
       424
        
       	}{}

     

       426
       425
        
       

     

       427
       426
        
       	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     
···

       430
       429
        
       	}

     

       431
       430
        
       

     

       432
       431
        
       	did := data.Did

     

       433
       433
       -
       	for _, k := range data.PublicKeys {

     

       434
       434
       -
       		pk := db.PublicKey{

     

       435
       435
       -
       			Did: did,

     

       436
       436
       -
       		}

     

       437
       437
       -
       		pk.Key = k

     

       438
       438
       -
       		err := h.db.AddPublicKey(pk)

     

       439
       439
       -
       		if err != nil {

     

       440
       440
       -
       			writeError(w, err.Error(), http.StatusInternalServerError)

     

       441
       441
       -
       			return

     

       442
       442
       -
       		}

     

       432
       432
       +
       

     

       433
       433
       +
       	if err := h.db.AddDid(did); err != nil {

     

       434
       434
       +
       		l.Error("adding did", "error", err.Error())

     

       435
       435
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       436
       436
       +
       		return

     

       443
       437
        
       	}

     

       444
       438
        
       

     

       445
       439
        
       	h.js.UpdateDids([]string{did})

     
···

       449
       443
        
       		return

     

       450
       444
        
       	}

     

       451
       445
        
       

     

       446
       446
       +
       	if err := h.fetchAndAddKeys(r.Context(), did); err != nil {

     

       447
       447
       +
       		l.Error("fetching and adding keys", "error", err.Error())

     

       448
       448
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       449
       449
       +
       		return

     

       450
       450
       +
       	}

     

       451
       451
       +
       

     

       452
       452
        
       	w.WriteHeader(http.StatusNoContent)

     

       453
       453
        
       }

     

       454
       454
        
       

     

       455
       455
       +
       func (h *Handle) AddRepoCollaborator(w http.ResponseWriter, r *http.Request) {

     

       456
       456
       +
       	l := h.l.With("handler", "AddRepoCollaborator")

     

       457
       457
       +
       

     

       458
       458
       +
       	data := struct {

     

       459
       459
       +
       		Did string `json:"did"`

     

       460
       460
       +
       	}{}

     

       461
       461
       +
       

     

       462
       462
       +
       	ownerDid := chi.URLParam(r, "did")

     

       463
       463
       +
       	repo := chi.URLParam(r, "name")

     

       464
       464
       +
       

     

       465
       465
       +
       	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     

       466
       466
       +
       		writeError(w, "invalid request body", http.StatusBadRequest)

     

       467
       467
       +
       		return

     

       468
       468
       +
       	}

     

       469
       469
       +
       

     

       470
       470
       +
       	if err := h.db.AddDid(data.Did); err != nil {

     

       471
       471
       +
       		l.Error("adding did", "error", err.Error())

     

       472
       472
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       473
       473
       +
       		return

     

       474
       474
       +
       	}

     

       475
       475
       +
       	h.js.UpdateDids([]string{data.Did})

     

       476
       476
       +
       

     

       477
       477
       +
       	repoName := filepath.Join(ownerDid, repo)

     

       478
       478
       +
       	if err := h.e.AddRepo(data.Did, ThisServer, repoName); err != nil {

     

       479
       479
       +
       		l.Error("adding repo collaborator", "error", err.Error())

     

       480
       480
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       481
       481
       +
       		return

     

       482
       482
       +
       	}

     

       483
       483
       +
       

     

       484
       484
       +
       	if err := h.fetchAndAddKeys(r.Context(), data.Did); err != nil {

     

       485
       485
       +
       		l.Error("fetching and adding keys", "error", err.Error())

     

       486
       486
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       487
       487
       +
       		return

     

       488
       488
       +
       	}

     

       489
       489
       +
       

     

       490
       490
       +
       	w.WriteHeader(http.StatusOK)

     

       491
       491
       +
       }

     

       492
       492
       +
       

     

       455
       493
        
       func (h *Handle) Init(w http.ResponseWriter, r *http.Request) {

     

       456
       494
        
       	l := h.l.With("handler", "Init")

     

       457
       495
        
       

     
···

       461
       499
        
       	}

     

       462
       500
        
       

     

       463
       501
        
       	data := struct {

     

       464
       464
       -
       		Did        string   `json:"did"`

     

       465
       465
       -
       		PublicKeys []string `json:"keys"`

     

       502
       502
       +
       		Did string `json:"did"`

     

       466
       503
        
       	}{}

     

       467
       504
        
       

     

       468
       505
        
       	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     
···

       472
       509
        
       	}

     

       473
       510
        
       

     

       474
       511
        
       	if data.Did == "" {

     

       475
       475
       -
       		l.Error("empty DID in request")

     

       512
       512
       +
       		l.Error("empty DID in request", "did", data.Did)

     

       476
       513
        
       		writeError(w, "did is empty", http.StatusBadRequest)

     

       477
       514
        
       		return

     

       478
       515
        
       	}

     

       479
       516
        
       

     

       480
       480
       -
       	if err := h.db.AddDid(data.Did); err == nil {

     

       481
       481
       -
       		for _, k := range data.PublicKeys {

     

       482
       482
       -
       			pk := db.PublicKey{

     

       483
       483
       -
       				Did: data.Did,

     

       484
       484
       -
       			}

     

       485
       485
       -
       			pk.Key = k

     

       486
       486
       -
       			err := h.db.AddPublicKey(pk)

     

       487
       487
       -
       			if err != nil {

     

       488
       488
       -
       				l.Error("failed to add public key", "error", err.Error())

     

       489
       489
       -
       				writeError(w, err.Error(), http.StatusInternalServerError)

     

       490
       490
       -
       				return

     

       491
       491
       -
       			}

     

       492
       492
       -
       		}

     

       493
       493
       -
       	} else {

     

       517
       517
       +
       	if err := h.db.AddDid(data.Did); err != nil {

     

       494
       518
        
       		l.Error("failed to add DID", "error", err.Error())

     

       495
       519
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       496
       520
        
       		return

     
···

       499
       523
        
       	h.js.UpdateDids([]string{data.Did})

     

       500
       524
        
       	if err := h.e.AddOwner(ThisServer, data.Did); err != nil {

     

       501
       525
        
       		l.Error("adding owner", "error", err.Error())

     

       526
       526
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       527
       527
       +
       		return

     

       528
       528
       +
       	}

     

       529
       529
       +
       

     

       530
       530
       +
       	if err := h.fetchAndAddKeys(r.Context(), data.Did); err != nil {

     

       531
       531
       +
       		l.Error("fetching and adding keys", "error", err.Error())

     

       502
       532
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       503
       533
        
       		return

     

       504
       534
        
       	}