Merge branch 'lash/purify-more' into lash/purify-max

Reviewed-on: urdt/ussd#239

.dockerignore

@@ -1,5 +1,6 @@
 /**
 !/cmd/africastalking
+!/cmd/ssh
 !/common
 !/config
 !/initializers

.env.example

@@ -14,3 +14,7 @@ DB_CONN=postgres://postgres:strongpass@localhost:5432/urdt_ussd
 CUSTODIAL_URL_BASE=http://localhost:5003
 BEARER_TOKEN=eyJeSIsInRcCI6IkpXVCJ.yJwdWJsaWNLZXkiOiIwrrrrrr
 DATA_URL_BASE=http://localhost:5006
+
+#Language
+DEFAULT_LANGUAGE=eng
+LANGUAGES=eng, swa

Dockerfile

@@ -19,6 +19,7 @@ WORKDIR /build
 RUN echo "Building on $BUILDPLATFORM, building for $TARGETPLATFORM"
 RUN go mod download
 RUN go build -tags logtrace -o ussd-africastalking -ldflags="-X main.build=${BUILD} -s -w" cmd/africastalking/main.go
+RUN go build -tags logtrace -o ussd-ssh -ldflags="-X main.build=${BUILD} -s -w" cmd/ssh/main.go
 
 FROM debian:bookworm-slim
 
@@ -30,6 +31,7 @@ RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 WORKDIR /service
 
 COPY --from=build /build/ussd-africastalking .
+COPY --from=build /build/ussd-ssh .
 COPY --from=build /build/LICENSE .
 COPY --from=build /build/README.md .
 COPY --from=build /build/services ./services
@@ -37,5 +39,6 @@ COPY --from=build /build/.env.example .
 RUN mv .env.example .env
 
 EXPOSE 7123
+EXPOSE 7122
 
 CMD ["./ussd-africastalking"]

cmd/africastalking/main.go

@@ -1,161 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"path"
-	"strconv"
-	"syscall"
-
-	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/logging"
-	"git.defalsify.org/vise.git/resource"
-
-	"git.grassecon.net/urdt/ussd/config"
-	"git.grassecon.net/urdt/ussd/initializers"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
-	"git.grassecon.net/urdt/ussd/internal/http/at"
-	"git.grassecon.net/urdt/ussd/internal/storage"
-	"git.grassecon.net/urdt/ussd/remote"
-)
-
-var (
-	logg          = logging.NewVanilla().WithDomain("AfricasTalking").WithContextKey("at-session-id")
-	scriptDir     = path.Join("services", "registration")
-	build         = "dev"
-	menuSeparator = ": "
-)
-
-func init() {
-	initializers.LoadEnvVariables()
-}
-
-func main() {
-	config.LoadConfig()
-
-	var connStr string
-	var resourceDir string
-	var size uint
-	var database string
-	var engineDebug bool
-	var host string
-	var port uint
-	var err error
-
-	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", "", "connection string")
-	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
-	flag.UintVar(&size, "s", 160, "max size of output")
-	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
-	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
-	flag.Parse()
-
-	if connStr != "" {
-		connStr = config.DbConn
-	}
-	connData, err := storage.ToConnData(config.DbConn)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-		os.Exit(1)
-	}
-
-	logg.Infof("start command", "build", build, "conn", connData, "resourcedir", resourceDir, "outputsize", size)
-
-	ctx := context.Background()
-	ctx = context.WithValue(ctx, "Database", database)
-	pfp := path.Join(scriptDir, "pp.csv")
-
-	cfg := engine.Config{
-		Root:          "root",
-		OutputSize:    uint32(size),
-		FlagCount:     uint32(128),
-		MenuSeparator: menuSeparator,
-	}
-
-	if engineDebug {
-		cfg.EngineDebug = true
-	}
-
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	rs, err := menuStorageService.GetResource(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	userdataStore, err := menuStorageService.GetUserdataDb(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-	defer userdataStore.Close()
-
-	dbResource, ok := rs.(*resource.DbResource)
-	if !ok {
-		os.Exit(1)
-	}
-
-	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-	lhs.SetDataStore(&userdataStore)
-
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	accountService := remote.AccountService{}
-	hl, err := lhs.GetHandler(&accountService)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	stateStore, err := menuStorageService.GetStateStore(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-	defer stateStore.Close()
-
-	rp := &at.ATRequestParser{}
-	bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
-	sh := at.NewATSessionHandler(bsh)
-
-	mux := http.NewServeMux()
-	mux.Handle(initializers.GetEnv("AT_ENDPOINT", "/"), sh)
-
-	s := &http.Server{
-		Addr:    fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
-		Handler: mux,
-	}
-	s.RegisterOnShutdown(sh.Shutdown)
-
-	cint := make(chan os.Signal)
-	cterm := make(chan os.Signal)
-	signal.Notify(cint, os.Interrupt, syscall.SIGINT)
-	signal.Notify(cterm, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		select {
-		case _ = <-cint:
-		case _ = <-cterm:
-		}
-		s.Shutdown(ctx)
-	}()
-	err = s.ListenAndServe()
-	if err != nil {
-		logg.Infof("Server closed with error", "err", err)
-	}
-}

cmd/async/main.go

@@ -12,12 +12,15 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/lang"
 
 	"git.grassecon.net/urdt/ussd/config"
 	"git.grassecon.net/urdt/ussd/initializers"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
+	"git.grassecon.net/urdt/ussd/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/remote"
+	"git.grassecon.net/urdt/ussd/request"
+	"git.grassecon.net/urdt/ussd/internal/args"
 )
 
 var (
@@ -55,6 +58,8 @@ func main() {
 	var host string
 	var port uint
 	var err error
+	var gettextDir string
+	var langs args.LangVar
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
@@ -63,6 +68,8 @@ func main() {
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
 	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
+	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
+	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
 	if connStr != "" {
@@ -78,6 +85,14 @@ func main() {
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "Database", database)
+
+	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "default language set error: %v", err)
+		os.Exit(1)
+	}
+	ctx = context.WithValue(ctx, "Language", ln)
+
 	pfp := path.Join(scriptDir, "pp.csv")
 
 	cfg := engine.Config{
@@ -138,7 +153,7 @@ func main() {
 	}
 	sh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
 	cfg.SessionId = sessionId
-	rqs := handlers.RequestSession{
+	rqs := request.RequestSession{
 		Ctx:    ctx,
 		Writer: os.Stdout,
 		Config: cfg,

cmd/http/main.go

@@ -14,13 +14,15 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/lang"
 
 	"git.grassecon.net/urdt/ussd/config"
 	"git.grassecon.net/urdt/ussd/initializers"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
+	"git.grassecon.net/urdt/ussd/handlers"
 	httpserver "git.grassecon.net/urdt/ussd/internal/http"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/remote"
+	"git.grassecon.net/urdt/ussd/internal/args"
 )
 
 var (
@@ -44,6 +46,8 @@ func main() {
 	var host string
 	var port uint
 	var err error
+	var gettextDir string
+	var langs args.LangVar
 
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
 	flag.StringVar(&connStr, "c", "", "connection string")
@@ -51,6 +55,8 @@ func main() {
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
 	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
+	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
+	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
 	if connStr != "" {
@@ -66,6 +72,14 @@ func main() {
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "Database", database)
+
+	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "default language set error: %v", err)
+		os.Exit(1)
+	}
+	ctx = context.WithValue(ctx, "Language", ln)
+
 	pfp := path.Join(scriptDir, "pp.csv")
 
 	cfg := engine.Config{
@@ -123,7 +137,11 @@ func main() {
 
 	rp := &httpserver.DefaultRequestParser{}
 	bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
-	sh := httpserver.ToSessionHandler(bsh)
+	// TODO: less hacky way of making session handler
+	//sh := request.ToSessionHandler(bsh)
+	sh := &httpserver.SessionHandler{
+		RequestHandler: bsh,
+	}
 	s := &http.Server{
 		Addr:    fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
 		Handler: sh,

cmd/main.go

@@ -10,10 +10,12 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/lang"
 	"git.grassecon.net/urdt/ussd/config"
+	"git.grassecon.net/urdt/ussd/handlers"
 	"git.grassecon.net/urdt/ussd/initializers"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
+	"git.grassecon.net/urdt/ussd/internal/args"
 	"git.grassecon.net/urdt/ussd/remote"
 )
 
@@ -27,6 +29,7 @@ func init() {
 	initializers.LoadEnvVariables()
 }
 
+// TODO: external script automatically generate language handler list from select language vise code OR consider dynamic menu generation script possibility
 func main() {
 	config.LoadConfig()
 
@@ -37,12 +40,16 @@ func main() {
 	var engineDebug bool
 	var resourceDir string
 	var err error
+	var gettextDir string
+	var langs args.LangVar
 
 	flag.StringVar(&resourceDir, "resourcedir", scriptDir, "resource dir")
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&connStr, "c", "", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
+	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
+	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
 	if connStr != "" {
@@ -56,9 +63,21 @@ func main() {
 
 	logg.Infof("start command", "conn", connData, "outputsize", size)
 
+	if len(langs.Langs()) == 0 {
+		langs.Set(config.DefaultLanguage)
+	}
+
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
 	ctx = context.WithValue(ctx, "Database", database)
+
+	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "default language set error: %v", err)
+		os.Exit(1)
+	}
+	ctx = context.WithValue(ctx, "Language", ln)
+
 	pfp := path.Join(scriptDir, "pp.csv")
 
 	cfg := engine.Config{
@@ -70,6 +89,10 @@ func main() {
 	}
 
 	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
+	
+	if gettextDir != "" {
+		menuStorageService = menuStorageService.WithGettext(gettextDir, langs.Langs())
+	}
 
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {

cmd/ssh/main.go

@@ -4,9 +4,9 @@ import (
 	"context"
 	"flag"
 	"fmt"
-	"path"
 	"os"
 	"os/signal"
+	"path"
 	"sync"
 	"syscall"
 
@@ -21,10 +21,12 @@ import (
 )
 
 var (
-	wg sync.WaitGroup
+	wg        sync.WaitGroup
-	keyStore db.Db
+	keyStore  db.Db
 	logg      = logging.NewVanilla()
 	scriptDir = path.Join("services", "registration")
+
+	build = "dev"
 )
 
 func init() {
@@ -94,7 +96,7 @@ func main() {
 		fmt.Fprintf(os.Stderr, "keystore file open error: %v", err)
 		os.Exit(1)
 	}
-	defer func () {
+	defer func() {
 		logg.TraceCtxf(ctx, "shutdown auth key store reached")
 		err = authKeyStore.Close()
 		if err != nil {
@@ -113,9 +115,9 @@ func main() {
 		FlagFile: pfp,
 		Conn: connData,
 		ResourceDir: resourceDir,
-		SrvKeyFile: sshKeyFile,
+		SrvKeyFile:  sshKeyFile,
-		Host: host,
+		Host:        host,
-		Port: port,
+		Port:        port,
 	}
 	go func() {
 		select {
@@ -127,7 +129,7 @@ func main() {
 		if err != nil {
 			logg.ErrorCtxf(ctx, "runner stop error", "err", err)
 		}
-		
+
 	}()
 	runner.Run(ctx, authKeyStore)
 }

common/storage.go

@@ -11,6 +11,10 @@ import (
 	dbstorage "git.grassecon.net/urdt/ussd/internal/storage/db"
 )
 
+var (
+	ToConnData = storage.ToConnData
+)
+
 func StoreToDb(store *UserDataStore) db.Db {
 	return store.Db
 }
@@ -36,6 +40,12 @@ func NewStorageService(conn storage.ConnData) (*StorageService, error) {
 	return svc, nil
 }
 
+// TODO: simplify enable poresource, conndata instead
+func(ss *StorageService) SetResourceDir(resourceDir string) error {
+	ss.svc = ss.svc.WithResourceDir(resourceDir)
+	return nil
+}
+
 func(ss *StorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
 	return ss.svc.GetPersister(ctx)
 }
@@ -47,3 +57,7 @@ func(ss *StorageService) GetUserdataDb(ctx context.Context) (db.Db, error) {
 func(ss *StorageService) GetResource(ctx context.Context) (resource.Resource, error) {
 	return nil, errors.New("not implemented")
 }
+
+func(ss *StorageService) GetStateStore(ctx context.Context) (db.Db, error) {
+	return ss.svc.GetStateStore(ctx)
+}

config/config.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"net/url"
+	"strings"
 
 	"git.grassecon.net/urdt/ussd/initializers"
 )
@@ -18,6 +19,11 @@ const (
 	AliasPrefix                = "api/v1/alias"
 )
 
+var (
+	defaultLanguage		   = "eng"
+	languages []string
+)
+
 var (
 	custodialURLBase string
 	dataURLBase      string
@@ -35,8 +41,28 @@ var (
 	VoucherDataURL      string
 	CheckAliasURL       string
 	DbConn		string
+	DefaultLanguage	    string
+	Languages	[]string
 )
 
+func setLanguage() error {
+	defaultLanguage = initializers.GetEnv("DEFAULT_LANGUAGE", defaultLanguage)
+	languages = strings.Split(initializers.GetEnv("LANGUAGES", defaultLanguage), ",")
+	haveDefaultLanguage := false
+	for i, v := range(languages) {
+		languages[i] = strings.ReplaceAll(v, " ", "")
+		if languages[i] == defaultLanguage {
+			haveDefaultLanguage = true
+		}
+	}
+
+	if !haveDefaultLanguage {
+		languages = append([]string{defaultLanguage}, languages...)
+	}
+
+	return nil
+}
+
 func setBase() error {
 	var err error
 
@@ -71,6 +97,10 @@ func LoadConfig() error {
 	if err != nil {
 		return err
 	}
+	err = setLanguage()
+	if err != nil {
+		return err
+	}
 	CreateAccountURL, _ = url.JoinPath(custodialURLBase, createAccountPath)
 	TrackStatusURL, _ = url.JoinPath(custodialURLBase, trackStatusPath)
 	BalanceURL, _ = url.JoinPath(custodialURLBase, balancePathPrefix)
@@ -80,6 +110,8 @@ func LoadConfig() error {
 	VoucherTransfersURL, _ = url.JoinPath(dataURLBase, voucherTransfersPathPrefix)
 	VoucherDataURL, _ = url.JoinPath(dataURLBase, voucherDataPathPrefix)
 	CheckAliasURL, _ = url.JoinPath(dataURLBase, AliasPrefix)
+	DefaultLanguage = defaultLanguage
+	Languages = languages
 
 	return nil
 }

devtools/lang/main.go

@@ -0,0 +1,126 @@
+// create language files from environment
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+
+	"git.defalsify.org/vise.git/logging"
+	"git.defalsify.org/vise.git/lang"
+	"git.grassecon.net/urdt/ussd/config"
+	"git.grassecon.net/urdt/ussd/initializers"
+)
+
+const (
+	
+	changeHeadSrc = `LOAD reset_account_authorized 0
+LOAD reset_incorrect 0
+CATCH incorrect_pin flag_incorrect_pin 1
+CATCH pin_entry flag_account_authorized 0
+` 
+
+	selectSrc = `LOAD set_language 6
+RELOAD set_language
+CATCH terms flag_account_created 0
+MOVE language_changed
+`
+)
+
+var (
+	logg = logging.NewVanilla()
+	mouts string
+	incmps string
+)
+
+func init() {
+	initializers.LoadEnvVariables()
+}
+
+func toLanguageLabel(ln lang.Language) string {
+	s := ln.Name
+	v := strings.Split(s, " (")
+	if len(v) > 1 {
+		s = v[0]
+	}
+	return s
+}
+
+func toLanguageKey(ln lang.Language) string {
+	s := toLanguageLabel(ln)
+	return strings.ToLower(s)
+}
+
+func main() {
+	var srcDir string
+
+	flag.StringVar(&srcDir, "o", ".", "resource dir write to")
+	flag.Parse()
+
+	logg.Infof("start command", "dir", srcDir)
+
+	err := config.LoadConfig()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "config load error: %v", err)
+		os.Exit(1)
+	}
+	logg.Tracef("using languages", "lang", config.Languages)
+
+	for i, v := range(config.Languages) {
+		ln, err := lang.LanguageFromCode(v)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error parsing language: %s\n", v)
+			os.Exit(1)
+		}
+		n := i + 1
+		s := toLanguageKey(ln)
+		mouts += fmt.Sprintf("MOUT %s %v\n", s, n)
+		v = "set_" + ln.Code
+		incmps += fmt.Sprintf("INCMP %s %v\n", v, n)
+
+		p := path.Join(srcDir, v)
+		w, err := os.OpenFile(p, os.O_WRONLY | os.O_CREATE | os.O_EXCL, 0600)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed open language set template output: %v\n", err)
+			os.Exit(1)
+		}
+		s = toLanguageLabel(ln)
+		defer w.Close()
+		_, err = w.Write([]byte(s))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed write select language vis output: %v\n", err)
+			os.Exit(1)
+		}
+	}
+	src := mouts + "HALT\n" + incmps
+	src += "INCMP . *\n"
+
+	p := path.Join(srcDir, "select_language.vis")
+	w, err := os.OpenFile(p, os.O_WRONLY | os.O_CREATE | os.O_EXCL, 0600)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed open select language vis output: %v\n", err)
+		os.Exit(1)
+	}
+	defer w.Close()
+	_, err = w.Write([]byte(src))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed write select language vis output: %v\n", err)
+		os.Exit(1)
+	}
+
+	src = changeHeadSrc + src
+	p = path.Join(srcDir, "change_language.vis")
+	w, err = os.OpenFile(p, os.O_WRONLY | os.O_CREATE | os.O_EXCL, 0600)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed open select language vis output: %v\n", err)
+		os.Exit(1)
+	}
+	defer w.Close()
+	_, err = w.Write([]byte(src))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed write select language vis output: %v\n", err)
+		os.Exit(1)
+	}
+}

devtools/store/dump/main.go

@@ -25,6 +25,15 @@ func init() {
 }
 
 
+func formatItem(k []byte, v []byte) (string, error) {
+	o, err := debug.FromKey(k)
+	if err != nil {
+		return "", err
+	}
+	s := fmt.Sprintf("%vValue: %v\n\n", o, string(v))
+	return s, nil
+}
+
 func main() {
 	config.LoadConfig()
 
@@ -75,12 +84,12 @@ func main() {
 		if k == nil {
 			break
 		}
-		o, err := debug.FromKey(k)
+		r, err := formatItem(k, v)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
+			fmt.Fprintf(os.Stderr, "format db item error: %v", err)
 			os.Exit(1)
 		}
-		fmt.Printf("%vValue: %v\n\n", o, string(v))
+		fmt.Printf(r)
 	}
 
 	err = store.Close()

errors/errors.go

@@ -0,0 +1,15 @@
+package errors
+
+import (
+	"git.grassecon.net/urdt/ussd/internal/handlers"
+)
+
+var (
+	ErrInvalidRequest = handlers.ErrInvalidRequest
+	ErrSessionMissing = handlers.ErrSessionMissing
+	ErrInvalidInput = handlers.ErrInvalidInput
+	ErrStorage = handlers.ErrStorage
+	ErrEngineType = handlers.ErrEngineType
+	ErrEngineInit = handlers.ErrEngineInit
+	ErrEngineExec = handlers.ErrEngineExec
+)

handlers/base.go

@@ -5,20 +5,27 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/logging"
 
+	"git.grassecon.net/urdt/ussd/request"
+	"git.grassecon.net/urdt/ussd/errors"
 	"git.grassecon.net/urdt/ussd/internal/handlers/ussd"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 )
 
+var (
+	logg = logging.NewVanilla().WithDomain("handlers")
+)
+
 type BaseSessionHandler struct {
 	cfgTemplate engine.Config
-	rp RequestParser
+	rp request.RequestParser
 	rs resource.Resource
 	hn *ussd.Handlers
 	provider storage.StorageProvider
 }
 
-func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp RequestParser, hn *ussd.Handlers) *BaseSessionHandler {
+func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp request.RequestParser, hn *ussd.Handlers) *BaseSessionHandler {
 	return &BaseSessionHandler{
 		cfgTemplate: cfg,
 		rs: rs,
@@ -41,7 +48,7 @@ func(f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, p
 	return en
 }
 
-func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
+func(f *BaseSessionHandler) Process(rqs request.RequestSession) (request.RequestSession, error) {
 	var r bool
 	var err error
 	var ok bool
@@ -51,7 +58,7 @@ func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error)
 	rqs.Storage, err = f.provider.Get(rqs.Config.SessionId)
 	if err != nil {
 		logg.ErrorCtxf(rqs.Ctx, "", "storage get error", err)
-		return rqs, ErrStorage
+		return rqs, errors.ErrStorage
 	}
 
 	f.hn = f.hn.WithPersister(rqs.Storage.Persister)
@@ -66,7 +73,7 @@ func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error)
 		if perr != nil {
 			logg.ErrorCtxf(rqs.Ctx, "", "storage put error", perr)
 		}
-		return rqs, ErrEngineType
+		return rqs, errors.ErrEngineType
 	}
 	en = en.WithFirst(f.hn.Init)
 	if rqs.Config.EngineDebug {
@@ -88,13 +95,13 @@ func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error)
 	return rqs, nil
 }
 
-func(f *BaseSessionHandler) Output(rqs RequestSession) (RequestSession,  error) {
+func(f *BaseSessionHandler) Output(rqs request.RequestSession) (request.RequestSession,  error) {
 	var err error
 	_, err = rqs.Engine.Flush(rqs.Ctx, rqs.Writer)
 	return rqs, err
 }
 
-func(f *BaseSessionHandler) Reset(rqs RequestSession) (RequestSession, error) {
+func(f *BaseSessionHandler) Reset(rqs request.RequestSession) (request.RequestSession, error) {
 	defer f.provider.Put(rqs.Config.SessionId, rqs.Storage)
 	return rqs, rqs.Engine.Finish()
 }
@@ -103,6 +110,6 @@ func(f *BaseSessionHandler) GetConfig() engine.Config {
 	return f.cfgTemplate
 }
 
-func(f *BaseSessionHandler) GetRequestParser() RequestParser {
+func(f *BaseSessionHandler) GetRequestParser() request.RequestParser {
 	return f.rp
 }

internal/args/lang.go

@@ -0,0 +1,34 @@
+package args
+
+import (
+	"strings"
+
+	"git.defalsify.org/vise.git/lang"
+)
+
+type LangVar struct {
+	v []lang.Language
+}
+
+func(lv *LangVar) Set(s string) error {
+	v, err := lang.LanguageFromCode(s)
+	if err != nil {
+		return err
+	}
+	lv.v = append(lv.v, v)
+	return err
+}
+
+func(lv *LangVar) String() string {
+	var s []string
+	for _, v := range(lv.v) {
+		s = append(s, v.Code)
+	}
+	return strings.Join(s, ",")
+}
+
+func(lv *LangVar) Langs() []lang.Language {
+	return lv.v
+}
+
+

internal/http/at/parse.go

@@ -1,119 +0,0 @@
-package at
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"git.grassecon.net/urdt/ussd/common"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
-)
-
-type ATRequestParser struct {
-}
-
-func (arp *ATRequestParser) GetSessionId(ctx context.Context, rq any) (string, error) {
-	rqv, ok := rq.(*http.Request)
-	if !ok {
-		logg.Warnf("got an invalid request", "req", rq)
-		return "", handlers.ErrInvalidRequest
-	}
-	// Capture body (if any) for logging
-	body, err := io.ReadAll(rqv.Body)
-	if err != nil {
-		logg.Warnf("failed to read request body", "err", err)
-		return "", fmt.Errorf("failed to read request body: %v", err)
-	}
-	// Reset the body for further reading
-	rqv.Body = io.NopCloser(bytes.NewReader(body))
-
-	// Log the body as JSON
-	bodyLog := map[string]string{"body": string(body)}
-	logBytes, err := json.Marshal(bodyLog)
-	if err != nil {
-		logg.Warnf("failed to marshal request body", "err", err)
-	} else {
-		decodedStr := string(logBytes)
-		sessionId, err := extractATSessionId(decodedStr)
-		if err != nil {
-			ctx = context.WithValue(ctx, "AT-SessionId", sessionId)
-		}
-		logg.DebugCtxf(ctx, "Received request:", decodedStr)
-	}
-
-	if err := rqv.ParseForm(); err != nil {
-		logg.Warnf("failed to parse form data", "err", err)
-		return "", fmt.Errorf("failed to parse form data: %v", err)
-	}
-
-	phoneNumber := rqv.FormValue("phoneNumber")
-	if phoneNumber == "" {
-		return "", fmt.Errorf("no phone number found")
-	}
-
-	formattedNumber, err := common.FormatPhoneNumber(phoneNumber)
-	if err != nil {
-		logg.Warnf("failed to format phone number", "err", err)
-		return "", fmt.Errorf("failed to format number")
-	}
-
-	return formattedNumber, nil
-}
-
-func (arp *ATRequestParser) GetInput(rq any) ([]byte, error) {
-	rqv, ok := rq.(*http.Request)
-	if !ok {
-		return nil, handlers.ErrInvalidRequest
-	}
-	if err := rqv.ParseForm(); err != nil {
-		return nil, fmt.Errorf("failed to parse form data: %v", err)
-	}
-
-	text := rqv.FormValue("text")
-
-	parts := strings.Split(text, "*")
-	if len(parts) == 0 {
-		return nil, fmt.Errorf("no input found")
-	}
-
-	return []byte(parts[len(parts)-1]), nil
-}
-
-func parseQueryParams(query string) map[string]string {
-	params := make(map[string]string)
-
-	queryParams := strings.Split(query, "&")
-	for _, param := range queryParams {
-		// Split each key-value pair by '='
-		parts := strings.SplitN(param, "=", 2)
-		if len(parts) == 2 {
-			params[parts[0]] = parts[1]
-		}
-	}
-	return params
-}
-
-func extractATSessionId(decodedStr string) (string, error) {
-	var data map[string]string
-	err := json.Unmarshal([]byte(decodedStr), &data)
-
-	if err != nil {
-		logg.Errorf("Error unmarshalling JSON: %v", err)
-		return "", nil
-	}
-	decodedBody, err := url.QueryUnescape(data["body"])
-	if err != nil {
-		logg.Errorf("Error URL-decoding body: %v", err)
-		return "", nil
-	}
-	params := parseQueryParams(decodedBody)
-
-	sessionId := params["sessionId"]
-	return sessionId, nil
-
-}

internal/http/at/server.go

@@ -1,98 +0,0 @@
-package at
-
-import (
-	"io"
-	"net/http"
-
-	"git.defalsify.org/vise.git/logging"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
-	httpserver "git.grassecon.net/urdt/ussd/internal/http"
-)
-
-var (
-	logg = logging.NewVanilla().WithDomain("atserver").WithContextKey("SessionId").WithContextKey("AT-SessionId")
-)
-
-type ATSessionHandler struct {
-	*httpserver.SessionHandler
-}
-
-func NewATSessionHandler(h handlers.RequestHandler) *ATSessionHandler {
-	return &ATSessionHandler{
-		SessionHandler: httpserver.ToSessionHandler(h),
-	}
-}
-
-func (ash *ATSessionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	var code int
-	var err error
-
-	rqs := handlers.RequestSession{
-		Ctx:    req.Context(),
-		Writer: w,
-	}
-
-	rp := ash.GetRequestParser()
-	cfg := ash.GetConfig()
-	cfg.SessionId, err = rp.GetSessionId(req.Context(), req)
-	if err != nil {
-		logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
-		ash.WriteError(w, 400, err)
-		return
-	}
-	rqs.Config = cfg
-	rqs.Input, err = rp.GetInput(req)
-	if err != nil {
-		logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
-		ash.WriteError(w, 400, err)
-		return
-	}
-
-	rqs, err = ash.Process(rqs)
-	switch err {
-	case nil: // set code to 200 if no err
-		code = 200
-	case handlers.ErrStorage, handlers.ErrEngineInit, handlers.ErrEngineExec, handlers.ErrEngineType:
-		code = 500
-	default:
-		code = 500
-	}
-
-	if code != 200 {
-		ash.WriteError(w, 500, err)
-		return
-	}
-
-	w.WriteHeader(200)
-	w.Header().Set("Content-Type", "text/plain")
-	rqs, err = ash.Output(rqs)
-	if err != nil {
-		ash.WriteError(w, 500, err)
-		return
-	}
-
-	rqs, err = ash.Reset(rqs)
-	if err != nil {
-		ash.WriteError(w, 500, err)
-		return
-	}
-}
-
-func (ash *ATSessionHandler) Output(rqs handlers.RequestSession) (handlers.RequestSession, error) {
-	var err error
-	var prefix string
-
-	if rqs.Continue {
-		prefix = "CON "
-	} else {
-		prefix = "END "
-	}
-
-	_, err = io.WriteString(rqs.Writer, prefix)
-	if err != nil {
-		return rqs, err
-	}
-
-	_, err = rqs.Engine.Flush(rqs.Ctx, rqs.Writer)
-	return rqs, err
-}

internal/http/at/server_test.go

@@ -1,234 +0,0 @@
-package at
-
-import (
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-
-	"git.defalsify.org/vise.git/engine"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
-	"git.grassecon.net/urdt/ussd/internal/testutil/mocks/httpmocks"
-)
-
-func TestNewATSessionHandler(t *testing.T) {
-	mockHandler := &httpmocks.MockRequestHandler{}
-	ash := NewATSessionHandler(mockHandler)
-
-	if ash == nil {
-		t.Fatal("NewATSessionHandler returned nil")
-	}
-
-	if ash.SessionHandler == nil {
-		t.Fatal("SessionHandler is nil")
-	}
-}
-
-func TestATSessionHandler_ServeHTTP(t *testing.T) {
-	tests := []struct {
-		name           string
-		setupMocks     func(*httpmocks.MockRequestHandler, *httpmocks.MockRequestParser, *httpmocks.MockEngine)
-		formData       url.Values
-		expectedStatus int
-		expectedBody   string
-	}{
-		{
-			name: "Successful request",
-			setupMocks: func(mh *httpmocks.MockRequestHandler, mrp *httpmocks.MockRequestParser, me *httpmocks.MockEngine) {
-				mrp.GetSessionIdFunc = func(rq any) (string, error) {
-					req := rq.(*http.Request)
-					return req.FormValue("phoneNumber"), nil
-				}
-				mrp.GetInputFunc = func(rq any) ([]byte, error) {
-					req := rq.(*http.Request)
-					text := req.FormValue("text")
-					parts := strings.Split(text, "*")
-					return []byte(parts[len(parts)-1]), nil
-				}
-				mh.ProcessFunc = func(rqs handlers.RequestSession) (handlers.RequestSession, error) {
-					rqs.Continue = true
-					rqs.Engine = me
-					return rqs, nil
-				}
-				mh.GetConfigFunc = func() engine.Config { return engine.Config{} }
-				mh.GetRequestParserFunc = func() handlers.RequestParser { return mrp }
-				mh.OutputFunc = func(rs handlers.RequestSession) (handlers.RequestSession, error) { return rs, nil }
-				mh.ResetFunc = func(rs handlers.RequestSession) (handlers.RequestSession, error) { return rs, nil }
-				me.FlushFunc = func(context.Context, io.Writer) (int, error) { return 0, nil }
-			},
-			formData: url.Values{
-				"phoneNumber": []string{"+1234567890"},
-				"text":        []string{"1*2*3"},
-			},
-			expectedStatus: http.StatusOK,
-			expectedBody:   "CON ",
-		},
-		{
-			name: "GetSessionId error",
-			setupMocks: func(mh *httpmocks.MockRequestHandler, mrp *httpmocks.MockRequestParser, me *httpmocks.MockEngine) {
-				mrp.GetSessionIdFunc = func(rq any) (string, error) {
-					return "", errors.New("no phone number found")
-				}
-				mh.GetConfigFunc = func() engine.Config { return engine.Config{} }
-				mh.GetRequestParserFunc = func() handlers.RequestParser { return mrp }
-			},
-			formData: url.Values{
-				"text": []string{"1*2*3"},
-			},
-			expectedStatus: http.StatusBadRequest,
-			expectedBody:   "",
-		},
-		{
-			name: "GetInput error",
-			setupMocks: func(mh *httpmocks.MockRequestHandler, mrp *httpmocks.MockRequestParser, me *httpmocks.MockEngine) {
-				mrp.GetSessionIdFunc = func(rq any) (string, error) {
-					req := rq.(*http.Request)
-					return req.FormValue("phoneNumber"), nil
-				}
-				mrp.GetInputFunc = func(rq any) ([]byte, error) {
-					return nil, errors.New("no input found")
-				}
-				mh.GetConfigFunc = func() engine.Config { return engine.Config{} }
-				mh.GetRequestParserFunc = func() handlers.RequestParser { return mrp }
-			},
-			formData: url.Values{
-				"phoneNumber": []string{"+1234567890"},
-			},
-			expectedStatus: http.StatusBadRequest,
-			expectedBody:   "",
-		},
-		{
-			name: "Process error",
-			setupMocks: func(mh *httpmocks.MockRequestHandler, mrp *httpmocks.MockRequestParser, me *httpmocks.MockEngine) {
-				mrp.GetSessionIdFunc = func(rq any) (string, error) {
-					req := rq.(*http.Request)
-					return req.FormValue("phoneNumber"), nil
-				}
-				mrp.GetInputFunc = func(rq any) ([]byte, error) {
-					req := rq.(*http.Request)
-					text := req.FormValue("text")
-					parts := strings.Split(text, "*")
-					return []byte(parts[len(parts)-1]), nil
-				}
-				mh.ProcessFunc = func(rqs handlers.RequestSession) (handlers.RequestSession, error) {
-					return rqs, handlers.ErrStorage
-				}
-				mh.GetConfigFunc = func() engine.Config { return engine.Config{} }
-				mh.GetRequestParserFunc = func() handlers.RequestParser { return mrp }
-			},
-			formData: url.Values{
-				"phoneNumber": []string{"+1234567890"},
-				"text":        []string{"1*2*3"},
-			},
-			expectedStatus: http.StatusInternalServerError,
-			expectedBody:   "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockHandler := &httpmocks.MockRequestHandler{}
-			mockRequestParser := &httpmocks.MockRequestParser{}
-			mockEngine := &httpmocks.MockEngine{}
-			tt.setupMocks(mockHandler, mockRequestParser, mockEngine)
-
-			ash := NewATSessionHandler(mockHandler)
-
-			req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(tt.formData.Encode()))
-			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-			w := httptest.NewRecorder()
-
-			ash.ServeHTTP(w, req)
-
-			if w.Code != tt.expectedStatus {
-				t.Errorf("Expected status %d, got %d", tt.expectedStatus, w.Code)
-			}
-
-			if tt.expectedBody != "" && w.Body.String() != tt.expectedBody {
-				t.Errorf("Expected body %q, got %q", tt.expectedBody, w.Body.String())
-			}
-		})
-	}
-}
-
-func TestATSessionHandler_Output(t *testing.T) {
-	tests := []struct {
-		name           string
-		input          handlers.RequestSession
-		expectedPrefix string
-		expectedError  bool
-	}{
-		{
-			name: "Continue true",
-			input: handlers.RequestSession{
-				Continue: true,
-				Engine: &httpmocks.MockEngine{
-					FlushFunc: func(context.Context, io.Writer) (int, error) {
-						return 0, nil
-					},
-				},
-				Writer: &httpmocks.MockWriter{},
-			},
-			expectedPrefix: "CON ",
-			expectedError:  false,
-		},
-		{
-			name: "Continue false",
-			input: handlers.RequestSession{
-				Continue: false,
-				Engine: &httpmocks.MockEngine{
-					FlushFunc: func(context.Context, io.Writer) (int, error) {
-						return 0, nil
-					},
-				},
-				Writer: &httpmocks.MockWriter{},
-			},
-			expectedPrefix: "END ",
-			expectedError:  false,
-		},
-		{
-			name: "Flush error",
-			input: handlers.RequestSession{
-				Continue: true,
-				Engine: &httpmocks.MockEngine{
-					FlushFunc: func(context.Context, io.Writer) (int, error) {
-						return 0, errors.New("write error")
-					},
-				},
-				Writer: &httpmocks.MockWriter{},
-			},
-			expectedPrefix: "CON ",
-			expectedError:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ash := &ATSessionHandler{}
-			_, err := ash.Output(tt.input)
-
-			if tt.expectedError && err == nil {
-				t.Error("Expected an error, but got nil")
-			}
-
-			if !tt.expectedError && err != nil {
-				t.Errorf("Unexpected error: %v", err)
-			}
-
-			mw := tt.input.Writer.(*httpmocks.MockWriter)
-			if !mw.WriteStringCalled {
-				t.Error("WriteString was not called")
-			}
-
-			if mw.WrittenString != tt.expectedPrefix {
-				t.Errorf("Expected prefix %q, got %q", tt.expectedPrefix, mw.WrittenString)
-			}
-		})
-	}
-}
-
-

internal/http/server.go

@@ -7,22 +7,16 @@ import (
 	"git.defalsify.org/vise.git/logging"
 
 	"git.grassecon.net/urdt/ussd/internal/handlers"
+	"git.grassecon.net/urdt/ussd/request"
 )
 
 var (
 	logg = logging.NewVanilla().WithDomain("httpserver")
 )
 
-type SessionHandler struct {
+type SessionHandler request.SessionHandler
-	handlers.RequestHandler
-}
-
-func ToSessionHandler(h handlers.RequestHandler) *SessionHandler {
-	return &SessionHandler{
-		RequestHandler: h,
-	}
-}
 
+// TODO: duplicated
 func (f *SessionHandler) WriteError(w http.ResponseWriter, code int, err error) {
 	s := err.Error()
 	w.Header().Set("Content-Length", strconv.Itoa(len(s)))
@@ -39,7 +33,7 @@ func (f *SessionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	var err error
 	var perr error
 
-	rqs := handlers.RequestSession{
+	rqs := request.RequestSession{
 		Ctx:    req.Context(),
 		Writer: w,
 	}

internal/http/server_test.go

@@ -10,7 +10,8 @@ import (
 
 	"git.defalsify.org/vise.git/engine"
 	"git.grassecon.net/urdt/ussd/internal/handlers"
-	"git.grassecon.net/urdt/ussd/internal/testutil/mocks/httpmocks"
+	"git.grassecon.net/urdt/ussd/testutil/mocks/httpmocks"
+	"git.grassecon.net/urdt/ussd/request"
 )
 
 // invalidRequestType is a custom type to test invalid request scenarios
@@ -81,16 +82,16 @@ func TestSessionHandler_ServeHTTP(t *testing.T) {
 			}
 
 			mockRequestHandler := &httpmocks.MockRequestHandler{
-				ProcessFunc: func(rs handlers.RequestSession) (handlers.RequestSession, error) {
+				ProcessFunc: func(rs request.RequestSession) (request.RequestSession, error) {
 					return rs, tt.processErr
 				},
-				OutputFunc: func(rs handlers.RequestSession) (handlers.RequestSession, error) {
+				OutputFunc: func(rs request.RequestSession) (request.RequestSession, error) {
 					return rs, tt.outputErr
 				},
-				ResetFunc: func(rs handlers.RequestSession) (handlers.RequestSession, error) {
+				ResetFunc: func(rs request.RequestSession) (request.RequestSession, error) {
 					return rs, tt.resetErr
 				},
-				GetRequestParserFunc: func() handlers.RequestParser {
+				GetRequestParserFunc: func() request.RequestParser {
 					return mockRequestParser
 				},
 				GetConfigFunc: func() engine.Config {
@@ -98,7 +99,10 @@ func TestSessionHandler_ServeHTTP(t *testing.T) {
 				},
 			}
 
-			sessionHandler := ToSessionHandler(mockRequestHandler)
+			sessionHandler := &SessionHandler{
+				RequestHandler: mockRequestHandler,
+			}
+			//sessionHandler := request.ToSessionHandler(mockRequestHandler)
 
 			req := httptest.NewRequest(http.MethodPost, "/", bytes.NewBuffer(tt.input))
 			req.Header.Set("X-Vise-Session", tt.sessionID)

internal/ssh/ssh.go

@@ -17,7 +17,7 @@ import (
 	"git.defalsify.org/vise.git/resource"
 	"git.defalsify.org/vise.git/state"
 
-	"git.grassecon.net/urdt/ussd/internal/handlers"
+	"git.grassecon.net/urdt/ussd/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/remote"
 )

internal/storage/storageservice.go

@@ -9,6 +9,7 @@ import (
 	"git.defalsify.org/vise.git/db"
 	fsdb "git.defalsify.org/vise.git/db/fs"
 	"git.defalsify.org/vise.git/db/postgres"
+	"git.defalsify.org/vise.git/lang"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
@@ -28,6 +29,7 @@ type StorageService interface {
 type MenuStorageService struct {
 	conn ConnData
 	resourceDir   string
+	poResource    resource.Resource
 	resourceStore db.Db
 	stateStore    db.Db
 	userDataStore db.Db
@@ -40,6 +42,11 @@ func NewMenuStorageService(conn ConnData, resourceDir string) *MenuStorageServic
 	}
 }
 
+func (ms *MenuStorageService) WithResourceDir(resourceDir string) *MenuStorageService {
+	ms.resourceDir = resourceDir
+	return ms
+}
+
 func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.Db, section string) (db.Db, error) {
 	var newDb db.Db
 	var err error
@@ -72,6 +79,28 @@ func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.D
 	return newDb, nil
 }
 
+// WithGettext triggers use of gettext for translation of templates and menus.
+//
+// The first language in `lns` will be used as default language, to resolve node keys to 
+// language strings.
+//
+// If `lns` is an empty array, gettext will not be used.
+func (ms *MenuStorageService) WithGettext(path string, lns []lang.Language) *MenuStorageService {
+	if len(lns) == 0 {
+		logg.Warnf("Gettext requested but no languages supplied")
+		return ms
+	}
+	rs := resource.NewPoResource(lns[0], path)
+
+	for _, ln := range(lns) {
+		rs = rs.WithLanguage(ln)
+	}
+
+	ms.poResource = rs
+
+	return ms
+}
+
 func (ms *MenuStorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
 	stateStore, err := ms.GetStateStore(ctx)
 	if err != nil {
@@ -104,6 +133,11 @@ func (ms *MenuStorageService) GetResource(ctx context.Context) (resource.Resourc
 		return nil, err
 	}
 	rfs := resource.NewDbResource(ms.resourceStore)
+	if ms.poResource != nil {
+		logg.InfoCtxf(ctx, "using poresource for menu and template")
+		rfs.WithMenuGetter(ms.poResource.GetMenu)
+		rfs.WithTemplateGetter(ms.poResource.GetTemplate)
+	}
 	return rfs, nil
 }
 

internal/testutil/engine.go

@@ -11,7 +11,7 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/resource"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
+	"git.grassecon.net/urdt/ussd/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/internal/testutil/testservice"
 	"git.grassecon.net/urdt/ussd/internal/testutil/testtag"

internal/testutil/mocks/httpmocks/requesthandlermock.go

@@ -1,47 +0,0 @@
-package httpmocks
-
-import (
-	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/persist"
-	"git.defalsify.org/vise.git/resource"
-	"git.grassecon.net/urdt/ussd/internal/handlers"
-)
-
-// MockRequestHandler implements handlers.RequestHandler interface for testing
-type MockRequestHandler struct {
-	ProcessFunc          func(handlers.RequestSession) (handlers.RequestSession, error)
-	GetConfigFunc        func() engine.Config
-	GetEngineFunc        func(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine
-	OutputFunc           func(rs handlers.RequestSession) (handlers.RequestSession, error)
-	ResetFunc            func(rs handlers.RequestSession) (handlers.RequestSession, error)
-	ShutdownFunc         func()
-	GetRequestParserFunc func() handlers.RequestParser
-}
-
-func (m *MockRequestHandler) Process(rqs handlers.RequestSession) (handlers.RequestSession, error) {
-	return m.ProcessFunc(rqs)
-}
-
-func (m *MockRequestHandler) GetConfig() engine.Config {
-	return m.GetConfigFunc()
-}
-
-func (m *MockRequestHandler) GetEngine(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine {
-	return m.GetEngineFunc(cfg, rs, pe)
-}
-
-func (m *MockRequestHandler) Output(rs handlers.RequestSession) (handlers.RequestSession, error) {
-	return m.OutputFunc(rs)
-}
-
-func (m *MockRequestHandler) Reset(rs handlers.RequestSession) (handlers.RequestSession, error) {
-	return m.ResetFunc(rs)
-}
-
-func (m *MockRequestHandler) Shutdown() {
-	m.ShutdownFunc()
-}
-
-func (m *MockRequestHandler) GetRequestParser() handlers.RequestParser {
-	return m.GetRequestParserFunc()
-}

request/request.go

@@ -0,0 +1,65 @@
+package request
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strconv"
+
+	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/persist"
+	"git.defalsify.org/vise.git/engine"
+	"git.defalsify.org/vise.git/logging"
+	"git.grassecon.net/urdt/ussd/internal/storage"
+)
+
+var (
+	logg = logging.NewVanilla().WithDomain("visedriver.request")
+)
+
+type RequestSession struct {
+	Ctx context.Context
+	Config engine.Config
+	Engine engine.Engine
+	Input []byte
+	Storage *storage.Storage
+	Writer io.Writer
+	Continue bool
+}
+
+
+// TODO: seems like can remove this.
+type RequestParser interface {
+	GetSessionId(ctx context.Context, rq any) (string, error)
+	GetInput(rq any) ([]byte, error)
+}
+
+type RequestHandler interface {
+	GetConfig() engine.Config
+	GetRequestParser() RequestParser
+	GetEngine(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine 
+	Process(rs RequestSession) (RequestSession, error)
+	Output(rs RequestSession) (RequestSession, error)
+	Reset(rs RequestSession) (RequestSession, error)
+	Shutdown()
+}
+type SessionHandler struct {
+	RequestHandler
+}
+
+func (f *SessionHandler) WriteError(w http.ResponseWriter, code int, err error) {
+	s := err.Error()
+	w.Header().Set("Content-Length", strconv.Itoa(len(s)))
+	w.WriteHeader(code)
+	_, err = w.Write([]byte(s))
+	if err != nil {
+		logg.Errorf("error writing error!!", "err", err, "olderr", s)
+		w.WriteHeader(500)
+	}
+}
+
+func ToSessionHandler(h RequestHandler) *SessionHandler {
+	return &SessionHandler{
+		RequestHandler: h,
+	}
+}

testutil/mocks/httpmocks/requesthandlermock.go

@@ -0,0 +1,47 @@
+package httpmocks
+
+import (
+	"git.defalsify.org/vise.git/engine"
+	"git.defalsify.org/vise.git/persist"
+	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/urdt/ussd/request"
+)
+
+// MockRequestHandler implements request.RequestHandler interface for testing
+type MockRequestHandler struct {
+	ProcessFunc          func(request.RequestSession) (request.RequestSession, error)
+	GetConfigFunc        func() engine.Config
+	GetEngineFunc        func(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine
+	OutputFunc           func(rs request.RequestSession) (request.RequestSession, error)
+	ResetFunc            func(rs request.RequestSession) (request.RequestSession, error)
+	ShutdownFunc         func()
+	GetRequestParserFunc func() request.RequestParser
+}
+
+func (m *MockRequestHandler) Process(rqs request.RequestSession) (request.RequestSession, error) {
+	return m.ProcessFunc(rqs)
+}
+
+func (m *MockRequestHandler) GetConfig() engine.Config {
+	return m.GetConfigFunc()
+}
+
+func (m *MockRequestHandler) GetEngine(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine {
+	return m.GetEngineFunc(cfg, rs, pe)
+}
+
+func (m *MockRequestHandler) Output(rs request.RequestSession) (request.RequestSession, error) {
+	return m.OutputFunc(rs)
+}
+
+func (m *MockRequestHandler) Reset(rs request.RequestSession) (request.RequestSession, error) {
+	return m.ResetFunc(rs)
+}
+
+func (m *MockRequestHandler) Shutdown() {
+	m.ShutdownFunc()
+}
+
+func (m *MockRequestHandler) GetRequestParser() request.RequestParser {
+	return m.GetRequestParserFunc()
+}