parcoursmob/handlers/application/administration.go

package application

import (
	"context"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
	"net/http"
	"sort"
	"strings"
	"time"

	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"github.com/google/uuid"
	"github.com/gorilla/mux"
	"google.golang.org/protobuf/types/known/structpb"
)

type GroupsByName []groupstorage.Group

func (a GroupsByName) Len() int { return len(a) }
func (a GroupsByName) Less(i, j int) bool {
	return strings.Compare(a[i].Data["name"].(string), a[j].Data["name"].(string)) < 0
}
func (a GroupsByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) {

	request := &groupsmanagement.GetGroupsRequest{
		Namespaces: []string{"parcoursmob_organizations"},
	}

	resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	var groups = []groupstorage.Group{}

	for _, group := range resp.Groups {
		g := group.ToStorageType()
		groups = append(groups, g)
	}

	sort.Sort(GroupsByName(groups))

	h.Renderer.Administration(w, r, groups)
}

func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r *http.Request) {
	if r.Method == "POST" {
		r.ParseForm()

		if r.FormValue("name") == "" {

			fmt.Println("invalid name")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		modules := map[string]any{
			"beneficiaries":       r.FormValue("modules.beneficiaries") == "on",
			"journeys":            r.FormValue("modules.journeys") == "on",
			"vehicles":            r.FormValue("modules.vehicles") == "on",
			"vehicles_management": r.FormValue("modules.vehicles_management") == "on",
			"events":              r.FormValue("modules.events") == "on",
			"administration":      r.FormValue("modules.administration") == "on",
		}

		groupid := uuid.NewString()

		dataMap := map[string]any{
			"name":    r.FormValue("name"),
			"modules": modules,
		}

		data, err := structpb.NewValue(dataMap)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		request_organization := &groupsmanagement.AddGroupRequest{
			Group: &groupsmanagement.Group{
				Id:        groupid,
				Namespace: "parcoursmob_organizations",
				Data:      data.GetStructValue(),
			},
		}

		request_role := &groupsmanagement.AddGroupRequest{
			Group: &groupsmanagement.Group{
				Id:        groupid + ":admin",
				Namespace: "parcoursmob_roles",
			},
		}

		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		// Create the admin role for the organization
		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
		return
	}
	h.Renderer.AdministrationCreateGroup(w, r)
}

func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupid := vars["groupid"]

	request := &groupsmanagement.GetGroupRequest{
		Id: groupid,
	}

	resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	members, err := h.members()
	if err != nil {
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
	}

	groupmembers := []any{}
	admins := []any{}

	for _, m := range members {
		mm := m.ToStorageType()
		for _, g := range mm.Data["groups"].([]any) {
			if g.(string) == groupid {
				groupmembers = append(groupmembers, mm)
			}
			if g.(string) == groupid+":admin" {
				admins = append(admins, mm)
			}
		}
	}

	h.Renderer.AdministrationGroupDisplay(w, r, resp.Group.ToStorageType(), groupmembers, admins)
}

func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupid := vars["groupid"]

	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
		Id:        groupid,
		Namespace: "parcoursmob_organizations",
	})

	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	r.ParseForm()

	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
		Username:  r.FormValue("username"),
		Namespace: "parcoursmob",
	})

	if err == nil {
		// Account already exists : adding the existing account to admin list
		account := accountresp.Account.ToStorageType()
		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid)
		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid+":admin")

		as, _ := accounts.AccountFromStorageType(&account)

		_, err = h.services.GRPC.MobilityAccounts.UpdateData(
			context.TODO(),
			&accounts.UpdateDataRequest{
				Account: as,
			},
		)

		fmt.Println(err)

		data := map[string]any{
			"group": groupresp.Group.ToStorageType().Data["name"],
		}

		if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
		}

		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
		return
	} else {
		// Onboard now administrator
		onboarding := map[string]any{
			"username": r.FormValue("username"),
			"group":    groupid,
			"admin":    true,
		}

		b := make([]byte, 16)
		if _, err := io.ReadFull(rand.Reader, b); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		key := base64.RawURLEncoding.EncodeToString(b)

		h.cache.PutWithTTL("onboarding/"+key, onboarding, 72*time.Hour)

		data := map[string]any{
			"group": groupresp.Group.ToStorageType().Data["name"],
			"key":   key,
		}

		if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
	}

	http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
	return
}

func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
	resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), &accounts.GetAccountsRequest{
		Namespaces: []string{"parcoursmob"},
	})
	if err != nil {
		return nil, err
	}

	return resp.Accounts, nil
}