···

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

     

       
69
       
 
       
		// Repo routes

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

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

     

···

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

     

       
69
       
 
       
		// Repo routes

     

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

     

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

     

       
72
       
+
       


     

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

     

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

     

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

     

···

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

     

       
421
       
 
       


     

       
422
       
 
       
	data := struct {

     

       
423
       
-
       
		Did        string   `json:"did"`

     

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

     

       
425
       
 
       
	}{}

     

       
426
       
 
       


     

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

     
···

       
430
       
 
       
	}

     

       
431
       
 
       


     

       
432
       
 
       
	did := data.Did

     

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

     

       
434
       
-
       
		pk := db.PublicKey{

     

       
435
       
-
       
			Did: did,

     

       
436
       
-
       
		}

     

       
437
       
-
       
		pk.Key = k

     

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

     

       
439
       
-
       
		if err != nil {

     

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

     

       
441
       
-
       
			return

     

       
442
       
-
       
		}

     

       
443
       
 
       
	}

     

       
444
       
 
       


     

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

     
···

       
449
       
 
       
		return

     

       
450
       
 
       
	}

     

       
451
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
452
       
 
       
	w.WriteHeader(http.StatusNoContent)

     

       
453
       
 
       
}

     

       
454
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
457
       
 
       


     
···

       
461
       
 
       
	}

     

       
462
       
 
       


     

       
463
       
 
       
	data := struct {

     

       
464
       
-
       
		Did        string   `json:"did"`

     

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

     

       
466
       
 
       
	}{}

     

       
467
       
 
       


     

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

     
···

       
472
       
 
       
	}

     

       
473
       
 
       


     

       
474
       
 
       
	if data.Did == "" {

     

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

     

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

     

       
477
       
 
       
		return

     

       
478
       
 
       
	}

     

       
479
       
 
       


     

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

     

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

     

       
482
       
-
       
			pk := db.PublicKey{

     

       
483
       
-
       
				Did: data.Did,

     

       
484
       
-
       
			}

     

       
485
       
-
       
			pk.Key = k

     

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

     

       
487
       
-
       
			if err != nil {

     

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

     

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

     

       
490
       
-
       
				return

     

       
491
       
-
       
			}

     

       
492
       
-
       
		}

     

       
493
       
-
       
	} else {

     

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

     

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

     

       
496
       
 
       
		return

     
···

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
503
       
 
       
		return

     

       
504
       
 
       
	}

     

···

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

     

       
421
       
 
       


     

       
422
       
 
       
	data := struct {

     

       
423
       
+
       
		Did string `json:"did"`

     

       
0
       
 
       

     

       
424
       
 
       
	}{}

     

       
425
       
 
       


     

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

     
···

       
429
       
 
       
	}

     

       
430
       
 
       


     

       
431
       
 
       
	did := data.Did

     

       
432
       
+
       


     

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

     

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

     

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

     

       
436
       
+
       
		return

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
437
       
 
       
	}

     

       
438
       
 
       


     

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

     
···

       
443
       
 
       
		return

     

       
444
       
 
       
	}

     

       
445
       
 
       


     

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

     

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

     

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

     

       
449
       
+
       
		return

     

       
450
       
+
       
	}

     

       
451
       
+
       


     

       
452
       
 
       
	w.WriteHeader(http.StatusNoContent)

     

       
453
       
 
       
}

     

       
454
       
 
       


     

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

     

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

     

       
457
       
+
       


     

       
458
       
+
       
	data := struct {

     

       
459
       
+
       
		Did string `json:"did"`

     

       
460
       
+
       
	}{}

     

       
461
       
+
       


     

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

     

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

     

       
464
       
+
       


     

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

     

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

     

       
467
       
+
       
		return

     

       
468
       
+
       
	}

     

       
469
       
+
       


     

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

     

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

     

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

     

       
473
       
+
       
		return

     

       
474
       
+
       
	}

     

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

     

       
476
       
+
       


     

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

     

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

     

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

     

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

     

       
481
       
+
       
		return

     

       
482
       
+
       
	}

     

       
483
       
+
       


     

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

     

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

     

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

     

       
487
       
+
       
		return

     

       
488
       
+
       
	}

     

       
489
       
+
       


     

       
490
       
+
       
	w.WriteHeader(http.StatusOK)

     

       
491
       
+
       
}

     

       
492
       
+
       


     

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

     

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

     

       
495
       
 
       


     
···

       
499
       
 
       
	}

     

       
500
       
 
       


     

       
501
       
 
       
	data := struct {

     

       
502
       
+
       
		Did string `json:"did"`

     

       
0
       
 
       

     

       
503
       
 
       
	}{}

     

       
504
       
 
       


     

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

     
···

       
509
       
 
       
	}

     

       
510
       
 
       


     

       
511
       
 
       
	if data.Did == "" {

     

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

     

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

     

       
514
       
 
       
		return

     

       
515
       
 
       
	}

     

       
516
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
520
       
 
       
		return

     
···

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

     

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

     

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

     

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

     

       
527
       
+
       
		return

     

       
528
       
+
       
	}

     

       
529
       
+
       


     

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

     

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

     

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

     

       
533
       
 
       
		return

     

       
534
       
 
       
	}