code.oscarkilo.com/okg/authz.go

package main

import "encoding/json"
import "flag"
import "fmt"
import "os"
import "text/tabwriter"

import "oscarkilo.com/okg/who"

func runAuthz(cfg *Config, args []string) error {
  if len(args) == 0 {
    return fmt.Errorf(
      "usage: okg authz SUBCOMMAND ... " +
        "(try `okg --help`)")
  }
  switch args[0] {
  case "list":
    return runAuthzList(cfg, args[1:])
  case "set":
    return runAuthzSet(cfg, args[1:])
  case "delete":
    return runAuthzDelete(cfg, args[1:])
  default:
    return fmt.Errorf(
      "unknown authz subcommand: %s", args[0])
  }
}

func runAuthzList(cfg *Config, args []string) error {
  fs := flag.NewFlagSet("authz list", flag.ContinueOnError)
  asJSON := fs.Bool("json", false, "output raw JSON")
  if err := fs.Parse(args); err != nil {
    return err
  }

  c, err := newWhoClient(cfg)
  if err != nil {
    return err
  }
  uris, err := c.ListAuthz()
  if err != nil {
    return err
  }

  if *asJSON {
    buf, err := json.MarshalIndent(uris, "", "  ")
    if err != nil {
      return err
    }
    fmt.Println(string(buf))
    return nil
  }

  tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
  fmt.Fprintln(tw, "URI\tOWNER\tREADER\tYOU")
  for _, e := range uris {
    owner, reader := "", ""
    if e.Owner != nil {
      owner = e.Owner.Username
    }
    if e.Reader != nil {
      reader = e.Reader.Username
    }
    fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n",
      e.Uri, owner, reader, rights(e))
  }
  return tw.Flush()
}

// rights is the human-friendly summary of the caller's
// effective rights on an authz entry.
func rights(e who.AuthzEntry) string {
  switch {
  case e.IsOwner && e.IsReader:
    return "owner+reader"
  case e.IsOwner:
    return "owner"
  case e.IsReader:
    return "reader"
  default:
    return "-"
  }
}

func runAuthzSet(cfg *Config, args []string) error {
  fs := flag.NewFlagSet("authz set", flag.ContinueOnError)
  if err := fs.Parse(args); err != nil {
    return err
  }
  positional := fs.Args()
  if len(positional) != 3 {
    return fmt.Errorf(
      "usage: okg authz set URI OWNER READER")
  }
  uri := positional[0]
  owner := positional[1]
  reader := positional[2]

  c, err := newWhoClient(cfg)
  if err != nil {
    return err
  }
  if err := c.SetAuthz(who.AuthzSetRequest{
    Uri:            uri,
    OwnerUsername:  owner,
    ReaderUsername: reader,
  }); err != nil {
    return err
  }
  fmt.Printf(
    "Set authz on %s (owner=%s, reader=%s)\n",
    uri, owner, reader)
  return nil
}

func runAuthzDelete(cfg *Config, args []string) error {
  fs := flag.NewFlagSet(
    "authz delete", flag.ContinueOnError)
  if err := fs.Parse(args); err != nil {
    return err
  }
  positional := fs.Args()
  if len(positional) != 1 {
    return fmt.Errorf(
      "usage: okg authz delete URI")
  }
  uri := positional[0]

  c, err := newWhoClient(cfg)
  if err != nil {
    return err
  }
  if err := c.DeleteAuthz(who.AuthzDeleteRequest{
    Uri: uri,
  }); err != nil {
    return err
  }
  fmt.Printf("Deleted authz on %s\n", uri)
  return nil
}