.env.example

@@ -6,9 +6,13 @@ HOST=127.0.0.1
 AT_ENDPOINT=/ussd/africastalking
 
 #PostgreSQL
-DB_CONN=postgres://postgres:strongpass@localhost:5432/urdt_ussd
-#DB_TIMEZONE=Africa/Nairobi
-#DB_SCHEMA=vise
+DB_HOST=localhost
+DB_USER=postgres
+DB_PASSWORD=strongpass
+DB_NAME=urdt_ussd
+DB_PORT=5432
+DB_SSLMODE=disable
+DB_TIMEZONE=Africa/Nairobi
 
 #External API Calls
 CUSTODIAL_URL_BASE=http://localhost:5003

cmd/africastalking/main.go

@@ -12,17 +12,18 @@ import (
 	"syscall"
 
 	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/lang"
 	"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/args"
 	"git.grassecon.net/urdt/ussd/internal/handlers"
 	"git.grassecon.net/urdt/ussd/internal/http/at"
+	httpserver "git.grassecon.net/urdt/ussd/internal/http/at"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/remote"
+	"git.grassecon.net/urdt/ussd/internal/args"
 )
 
 var (
@@ -35,22 +36,21 @@ var (
 func init() {
 	initializers.LoadEnvVariables()
 }
-
 func main() {
 	config.LoadConfig()
 
-	var connStr string
+	var dbDir string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	var host string
 	var port uint
-	var err error
 	var gettextDir string
 	var langs args.LangVar
-
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", "", "connection string")
+	flag.StringVar(&database, "db", "gdbm", "database to be used")
 	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")
@@ -59,18 +59,10 @@ func main() {
 	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
-	if connStr == "" {
-		connStr = config.DbConn
-	}
-	connData, err := storage.ToConnData(connStr)
-	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)
+	logg.Infof("start command", "build", build, "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)
 
 	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)
@@ -91,13 +83,14 @@ func main() {
 		cfg.EngineDebug = true
 	}
 
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
+	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
 
-	rs, err := menuStorageService.GetResource(ctx)
+	err = menuStorageService.EnsureDbDir()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
@@ -143,7 +136,7 @@ func main() {
 
 	rp := &at.ATRequestParser{}
 	bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
-	sh := at.NewATSessionHandler(bsh)
+	sh := httpserver.NewATSessionHandler(bsh)
 
 	mux := http.NewServeMux()
 	mux.Handle(initializers.GetEnv("AT_ENDPOINT", "/"), sh)

cmd/async/main.go

@@ -10,16 +10,16 @@ import (
 	"syscall"
 
 	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/lang"
 	"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/args"
 	"git.grassecon.net/urdt/ussd/internal/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/remote"
+	"git.grassecon.net/urdt/ussd/internal/args"
 )
 
 var (
@@ -48,20 +48,20 @@ func (p *asyncRequestParser) GetInput(r any) ([]byte, error) {
 func main() {
 	config.LoadConfig()
 
-	var connStr string
 	var sessionId string
+	var dbDir string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	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(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", "", "connection string")
+	flag.StringVar(&database, "db", "gdbm", "database to be used")
 	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")
@@ -70,18 +70,10 @@ func main() {
 	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
-	if connStr == "" {
-		connStr = config.DbConn
-	}
-	connData, err := storage.ToConnData(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-		os.Exit(1)
-	}
-
-	logg.Infof("start command", "conn", connData, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)
+	logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)
 
 	ctx := context.Background()
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {
@@ -103,13 +95,14 @@ func main() {
 		cfg.EngineDebug = true
 	}
 
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
+	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
 
-	rs, err := menuStorageService.GetResource(ctx)
+	err = menuStorageService.EnsureDbDir()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)

cmd/http/main.go

@@ -12,22 +12,22 @@ import (
 	"syscall"
 
 	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/lang"
 	"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/args"
 	"git.grassecon.net/urdt/ussd/internal/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 (
-	logg          = logging.NewVanilla()
-	scriptDir     = path.Join("services", "registration")
+	logg      = logging.NewVanilla()
+	scriptDir = path.Join("services", "registration")
 	menuSeparator = ": "
 )
 
@@ -38,18 +38,18 @@ func init() {
 func main() {
 	config.LoadConfig()
 
-	var connStr string
+	var dbDir string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	var host string
 	var port uint
-	var err error
 	var gettextDir string
 	var langs args.LangVar
-
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", "", "connection string")
+	flag.StringVar(&database, "db", "gdbm", "database to be used")
 	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")
@@ -58,18 +58,10 @@ func main() {
 	flag.Var(&langs, "language", "add symbol resolution for language")
 	flag.Parse()
 
-	if connStr == "" {
-		connStr = config.DbConn
-	}
-	connData, err := storage.ToConnData(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-		os.Exit(1)
-	}
-
-	logg.Infof("start command", "conn", connData, "resourcedir", resourceDir, "outputsize", size)
+	logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)
 
 	ctx := context.Background()
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {
@@ -91,14 +83,19 @@ func main() {
 		cfg.EngineDebug = true
 	}
 
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
-
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
 
+	err = menuStorageService.EnsureDbDir()
+	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())

cmd/main.go

@@ -8,14 +8,14 @@ import (
 	"path"
 
 	"git.defalsify.org/vise.git/engine"
-	"git.defalsify.org/vise.git/lang"
 	"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/args"
 	"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"
 )
 
@@ -33,34 +33,23 @@ func init() {
 func main() {
 	config.LoadConfig()
 
-	var connStr string
+	var dbDir string
 	var size uint
 	var sessionId string
+	var database string
 	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.StringVar(&database, "db", "gdbm", "database to be used")
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	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 == "" {
-		connStr = config.DbConn
-	}
-	connData, err := storage.ToConnData(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-		os.Exit(1)
-	}
-
-	logg.Infof("start command", "conn", connData, "outputsize", size)
+	logg.Infof("start command", "dbdir", dbDir, "outputsize", size)
 
 	if len(langs.Langs()) == 0 {
 		langs.Set(config.DefaultLanguage)
@@ -68,6 +57,7 @@ func main() {
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {
@@ -86,12 +76,18 @@ func main() {
 		MenuSeparator: menuSeparator,
 	}
 
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
-
+	resourceDir := scriptDir
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
 	if gettextDir != "" {
 		menuStorageService = menuStorageService.WithGettext(gettextDir, langs.Langs())
 	}
 
+	err = menuStorageService.EnsureDbDir()
+	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())

cmd/ssh/main.go

@@ -14,10 +14,7 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 
-	"git.grassecon.net/urdt/ussd/config"
-	"git.grassecon.net/urdt/ussd/initializers"
 	"git.grassecon.net/urdt/ussd/internal/ssh"
-	"git.grassecon.net/urdt/ussd/internal/storage"
 )
 
 var (
@@ -29,49 +26,25 @@ var (
 	build = "dev"
 )
 
-func init() {
-	initializers.LoadEnvVariables()
-}
-
 func main() {
-	config.LoadConfig()
-
-	var connStr string
-	var authConnStr string
+	var dbDir string
 	var resourceDir string
 	var size uint
 	var engineDebug bool
 	var stateDebug bool
 	var host string
 	var port uint
-	flag.StringVar(&connStr, "c", "", "connection string")
-	flag.StringVar(&authConnStr, "authdb", "", "auth connection string")
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
+	flag.BoolVar(&engineDebug, "engine-debug", false, "use engine debug output")
+	flag.BoolVar(&stateDebug, "state-debug", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
-	flag.StringVar(&host, "h", "127.0.0.1", "socket host")
-	flag.UintVar(&port, "p", 7122, "socket port")
+	flag.StringVar(&host, "h", "127.0.0.1", "http host")
+	flag.UintVar(&port, "p", 7122, "http port")
 	flag.Parse()
 
-	if connStr == "" {
-		connStr = config.DbConn
-	}
-	if authConnStr == "" {
-		authConnStr = connStr
-	}
-	connData, err := storage.ToConnData(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-		os.Exit(1)
-	}
-	authConnData, err := storage.ToConnData(authConnStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "auth connstr err: %v", err)
-		os.Exit(1)
-	}
-
 	sshKeyFile := flag.Arg(0)
-	_, err = os.Stat(sshKeyFile)
+	_, err := os.Stat(sshKeyFile)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "cannot open ssh server private key file: %v\n", err)
 		os.Exit(1)
@@ -84,7 +57,7 @@ func main() {
 	logg.WarnCtxf(ctx, "!!!!! Do not expose to internet and only use with tunnel!")
 	logg.WarnCtxf(ctx, "!!!!! (See ssh -L <...>)")
 
-	logg.Infof("start command", "conn", connData, "authconn", authConnData, "resourcedir", resourceDir, "outputsize", size, "keyfile", sshKeyFile, "host", host, "port", port)
+	logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size, "keyfile", sshKeyFile, "host", host, "port", port)
 
 	pfp := path.Join(scriptDir, "pp.csv")
 
@@ -100,7 +73,7 @@ func main() {
 		cfg.EngineDebug = true
 	}
 
-	authKeyStore, err := ssh.NewSshKeyStore(ctx, authConnData.String())
+	authKeyStore, err := ssh.NewSshKeyStore(ctx, dbDir)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "keystore file open error: %v", err)
 		os.Exit(1)
@@ -119,10 +92,10 @@ func main() {
 	signal.Notify(cterm, os.Interrupt, syscall.SIGTERM)
 
 	runner := &ssh.SshRunner{
-		Cfg: cfg,
-		Debug: engineDebug,
-		FlagFile: pfp,
-		Conn: connData,
+		Cfg:         cfg,
+		Debug:       engineDebug,
+		FlagFile:    pfp,
+		DbDir:       dbDir,
 		ResourceDir: resourceDir,
 		SrvKeyFile:  sshKeyFile,
 		Host:        host,

common/db.go

@@ -7,7 +7,7 @@ import (
 	"git.defalsify.org/vise.git/logging"
 )
 
-// DataType is a subprefix value used in association with vise/db.DATATYPE_USERDATA.
+// DataType is a subprefix value used in association with vise/db.DATATYPE_USERDATA. 
 //
 // All keys are used only within the context of a single account. Unless otherwise specified, the user context is the session id.
 //
@@ -55,10 +55,6 @@ const (
 	DATA_ACTIVE_DECIMAL
 	// EVM address of the currently active voucher
 	DATA_ACTIVE_ADDRESS
-	//Holds count of the number of incorrect PIN attempts
-	DATA_INCORRECT_PIN_ATTEMPTS
-	//ISO 639 code for the selected language.
-	DATA_SELECTED_LANGUAGE_CODE
 )
 
 const (

common/pin.go

@@ -6,13 +6,9 @@ import (
 	"golang.org/x/crypto/bcrypt"
 )
 
+// Define the regex pattern as a constant
 const (
-	// Define the regex pattern as a constant
 	pinPattern = `^\d{4}$`
-
-	//Allowed incorrect  PIN attempts
-	AllowedPINAttempts = uint8(3)
-	
 )
 
 // checks whether the given input is a 4 digit number

common/storage.go

@@ -23,17 +23,17 @@ type StorageServices interface {
 	GetPersister(ctx context.Context) (*persist.Persister, error)
 	GetUserdataDb(ctx context.Context) (db.Db, error)
 	GetResource(ctx context.Context) (resource.Resource, error)
+	EnsureDbDir() error
 }
 
 type StorageService struct {
 	svc *storage.MenuStorageService
 }
 
-func NewStorageService(conn storage.ConnData) (*StorageService, error) {
-	svc := &StorageService{
-		svc: storage.NewMenuStorageService(conn, ""),
+func NewStorageService(dbDir string) *StorageService {
+	return &StorageService{
+		svc: storage.NewMenuStorageService(dbDir, ""),
 	}
-	return svc, nil
 }
 
 func(ss *StorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
@@ -47,3 +47,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) EnsureDbDir() error {
+	return ss.svc.EnsureDbDir()
+}

config/config.go

@@ -40,7 +40,6 @@ var (
 	VoucherTransfersURL string
 	VoucherDataURL      string
 	CheckAliasURL       string
-	DbConn		string
 	DefaultLanguage	    string
 	Languages	[]string
 )
@@ -70,20 +69,14 @@ func setBase() error {
 	dataURLBase = initializers.GetEnv("DATA_URL_BASE", "http://localhost:5006")
 	BearerToken = initializers.GetEnv("BEARER_TOKEN", "")
 
-	_, err = url.Parse(custodialURLBase)
+	_, err = url.JoinPath(custodialURLBase, "/foo")
 	if err != nil {
 		return err
 	}
-	_, err = url.Parse(dataURLBase)
+	_, err = url.JoinPath(dataURLBase, "/bar")
 	if err != nil {
 		return err
 	}
-
-	return nil
-}
-
-func setConn() error {
-	DbConn = initializers.GetEnv("DB_CONN", "")
 	return nil
 }
 
@@ -93,10 +86,6 @@ func LoadConfig() error {
 	if err != nil {
 		return err
 	}
-	err = setConn()
-	if err != nil {
-		return err
-	}
 	err = setLanguage()
 	if err != nil {
 		return err

devtools/store/dump/main.go

@@ -37,34 +37,23 @@ func formatItem(k []byte, v []byte) (string, error) {
 func main() {
 	config.LoadConfig()
 
-	var connStr string
+	var dbDir string
 	var sessionId string
 	var database string
 	var engineDebug bool
-	var err error
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
-	flag.StringVar(&connStr, "c", ".state", "connection string")
+	flag.StringVar(&database, "db", "gdbm", "database to be used")
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	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", "conn", connData)
-
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
 	ctx = context.WithValue(ctx, "Database", database)
 
 	resourceDir := scriptDir
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
 
 	store, err := menuStorageService.GetUserdataDb(ctx)
 	if err != nil {

devtools/store/generate/main.go

@@ -9,16 +9,14 @@ import (
 	"path"
 
 	"git.defalsify.org/vise.git/logging"
-	"git.grassecon.net/urdt/ussd/common"
 	"git.grassecon.net/urdt/ussd/config"
-	"git.grassecon.net/urdt/ussd/initializers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
-	testdataloader "github.com/peteole/testdata-loader"
+	"git.grassecon.net/urdt/ussd/initializers"
+	"git.grassecon.net/urdt/ussd/common"
 )
 
 var (
 	logg      = logging.NewVanilla()
-	baseDir   = testdataloader.GetBasePath()
 	scriptDir = path.Join("services", "registration")
 )
 
@@ -26,38 +24,28 @@ func init() {
 	initializers.LoadEnvVariables()
 }
 
+
 func main() {
 	config.LoadConfig()
 
-	var connStr string
+	var dbDir string
 	var sessionId string
 	var database string
 	var engineDebug bool
-	var err error
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
-	flag.StringVar(&connStr, "c", "", "connection string")
+	flag.StringVar(&database, "db", "gdbm", "database to be used")
+	flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	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", "conn", connData)
-
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
 	ctx = context.WithValue(ctx, "Database", database)
 
 	resourceDir := scriptDir
-	menuStorageService := storage.NewMenuStorageService(connData, resourceDir)
-	
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
+
 	store, err := menuStorageService.GetUserdataDb(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
@@ -87,4 +75,5 @@ func main() {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
+	
 }

initializers/load.go

@@ -3,30 +3,24 @@ package initializers
 import (
 	"log"
 	"os"
-	"path"
 	"strconv"
 
 	"github.com/joho/godotenv"
 )
 
 func LoadEnvVariables() {
-	LoadEnvVariablesPath(".")
-}
-
-func LoadEnvVariablesPath(dir string) {
-	fp := path.Join(dir, ".env")
-	err := godotenv.Load(fp)
+	err := godotenv.Load()
 	if err != nil {
-		log.Fatal("Error loading .env file", err)
+		log.Fatal("Error loading .env file")
 	}
 }
 
 // Helper to get environment variables with a default fallback
 func GetEnv(key, defaultVal string) string {
-	if value, exists := os.LookupEnv(key); exists {
-		return value
+  if value, exists := os.LookupEnv(key); exists {
+   	return value
 	}
-	return defaultVal
+  return defaultVal
 }
 
 // Helper to safely convert environment variables to uint

internal/handlers/base.go

@@ -6,46 +6,46 @@ import (
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
 
-	"git.grassecon.net/urdt/ussd/internal/handlers/application"
+	"git.grassecon.net/urdt/ussd/internal/handlers/ussd"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 )
 
 type BaseSessionHandler struct {
 	cfgTemplate engine.Config
-	rp          RequestParser
-	rs          resource.Resource
-	hn          *application.Handlers
-	provider    storage.StorageProvider
+	rp 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 *application.Handlers) *BaseSessionHandler {
+func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp RequestParser, hn *ussd.Handlers) *BaseSessionHandler {
 	return &BaseSessionHandler{
 		cfgTemplate: cfg,
-		rs:          rs,
-		hn:          hn,
-		rp:          rp,
-		provider:    storage.NewSimpleStorageProvider(stateDb, userdataDb),
+		rs: rs,
+		hn: hn,
+		rp: rp,
+		provider: storage.NewSimpleStorageProvider(stateDb, userdataDb),
 	}
 }
 
-func (f *BaseSessionHandler) Shutdown() {
+func(f* BaseSessionHandler) Shutdown() {
 	err := f.provider.Close()
 	if err != nil {
 		logg.Errorf("handler shutdown error", "err", err)
 	}
 }
 
-func (f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) engine.Engine {
+func(f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) engine.Engine {
 	en := engine.NewEngine(cfg, rs)
 	en = en.WithPersister(pr)
 	return en
 }
 
-func (f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
+func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
 	var r bool
 	var err error
 	var ok bool
-
+	
 	logg.InfoCtxf(rqs.Ctx, "new request", "data", rqs)
 
 	rqs.Storage, err = f.provider.Get(rqs.Config.SessionId)
@@ -84,25 +84,25 @@ func (f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error)
 		return rqs, err
 	}
 
-	rqs.Continue = r
+	rqs.Continue = r 
 	return rqs, nil
 }
 
-func (f *BaseSessionHandler) Output(rqs RequestSession) (RequestSession, error) {
+func(f *BaseSessionHandler) Output(rqs RequestSession) (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 RequestSession) (RequestSession, error) {
 	defer f.provider.Put(rqs.Config.SessionId, rqs.Storage)
 	return rqs, rqs.Engine.Finish()
 }
 
-func (f *BaseSessionHandler) GetConfig() engine.Config {
+func(f *BaseSessionHandler) GetConfig() engine.Config {
 	return f.cfgTemplate
 }
 
-func (f *BaseSessionHandler) GetRequestParser() RequestParser {
+func(f *BaseSessionHandler) GetRequestParser() RequestParser {
 	return f.rp
 }

internal/handlers/handlerservice.go

@@ -10,13 +10,13 @@ import (
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
 
-	"git.grassecon.net/urdt/ussd/internal/handlers/application"
+	"git.grassecon.net/urdt/ussd/internal/handlers/ussd"
 	"git.grassecon.net/urdt/ussd/internal/utils"
 	"git.grassecon.net/urdt/ussd/remote"
 )
 
 type HandlerService interface {
-	GetHandler() (*application.Handlers, error)
+	GetHandler() (*ussd.Handlers, error)
 }
 
 func getParser(fp string, debug bool) (*asm.FlagParser, error) {
@@ -64,73 +64,72 @@ func (ls *LocalHandlerService) SetDataStore(db *db.Db) {
 	ls.UserdataStore = db
 }
 
-func (ls *LocalHandlerService) GetHandler(accountService remote.AccountServiceInterface) (*application.Handlers, error) {
+func (ls *LocalHandlerService) GetHandler(accountService remote.AccountServiceInterface) (*ussd.Handlers, error) {
 	replaceSeparatorFunc := func(input string) string {
 		return strings.ReplaceAll(input, ":", ls.Cfg.MenuSeparator)
 	}
 
-	appHandlers, err := application.NewHandlers(ls.Parser, *ls.UserdataStore, ls.AdminStore, accountService, replaceSeparatorFunc)
+	ussdHandlers, err := ussd.NewHandlers(ls.Parser, *ls.UserdataStore, ls.AdminStore, accountService, replaceSeparatorFunc)
 	if err != nil {
 		return nil, err
 	}
-	appHandlers = appHandlers.WithPersister(ls.Pe)
-	ls.DbRs.AddLocalFunc("set_language", appHandlers.SetLanguage)
-	ls.DbRs.AddLocalFunc("create_account", appHandlers.CreateAccount)
-	ls.DbRs.AddLocalFunc("save_temporary_pin", appHandlers.SaveTemporaryPin)
-	ls.DbRs.AddLocalFunc("verify_create_pin", appHandlers.VerifyCreatePin)
-	ls.DbRs.AddLocalFunc("check_identifier", appHandlers.CheckIdentifier)
-	ls.DbRs.AddLocalFunc("check_account_status", appHandlers.CheckAccountStatus)
-	ls.DbRs.AddLocalFunc("authorize_account", appHandlers.Authorize)
-	ls.DbRs.AddLocalFunc("quit", appHandlers.Quit)
-	ls.DbRs.AddLocalFunc("check_balance", appHandlers.CheckBalance)
-	ls.DbRs.AddLocalFunc("validate_recipient", appHandlers.ValidateRecipient)
-	ls.DbRs.AddLocalFunc("transaction_reset", appHandlers.TransactionReset)
-	ls.DbRs.AddLocalFunc("invite_valid_recipient", appHandlers.InviteValidRecipient)
-	ls.DbRs.AddLocalFunc("max_amount", appHandlers.MaxAmount)
-	ls.DbRs.AddLocalFunc("validate_amount", appHandlers.ValidateAmount)
-	ls.DbRs.AddLocalFunc("reset_transaction_amount", appHandlers.ResetTransactionAmount)
-	ls.DbRs.AddLocalFunc("get_recipient", appHandlers.GetRecipient)
-	ls.DbRs.AddLocalFunc("get_sender", appHandlers.GetSender)
-	ls.DbRs.AddLocalFunc("get_amount", appHandlers.GetAmount)
-	ls.DbRs.AddLocalFunc("reset_incorrect", appHandlers.ResetIncorrectPin)
-	ls.DbRs.AddLocalFunc("save_firstname", appHandlers.SaveFirstname)
-	ls.DbRs.AddLocalFunc("save_familyname", appHandlers.SaveFamilyname)
-	ls.DbRs.AddLocalFunc("save_gender", appHandlers.SaveGender)
-	ls.DbRs.AddLocalFunc("save_location", appHandlers.SaveLocation)
-	ls.DbRs.AddLocalFunc("save_yob", appHandlers.SaveYob)
-	ls.DbRs.AddLocalFunc("save_offerings", appHandlers.SaveOfferings)
-	ls.DbRs.AddLocalFunc("reset_account_authorized", appHandlers.ResetAccountAuthorized)
-	ls.DbRs.AddLocalFunc("reset_allow_update", appHandlers.ResetAllowUpdate)
-	ls.DbRs.AddLocalFunc("get_profile_info", appHandlers.GetProfileInfo)
-	ls.DbRs.AddLocalFunc("verify_yob", appHandlers.VerifyYob)
-	ls.DbRs.AddLocalFunc("reset_incorrect_date_format", appHandlers.ResetIncorrectYob)
-	ls.DbRs.AddLocalFunc("initiate_transaction", appHandlers.InitiateTransaction)
-	ls.DbRs.AddLocalFunc("verify_new_pin", appHandlers.VerifyNewPin)
-	ls.DbRs.AddLocalFunc("confirm_pin_change", appHandlers.ConfirmPinChange)
-	ls.DbRs.AddLocalFunc("quit_with_help", appHandlers.QuitWithHelp)
-	ls.DbRs.AddLocalFunc("fetch_community_balance", appHandlers.FetchCommunityBalance)
-	ls.DbRs.AddLocalFunc("set_default_voucher", appHandlers.SetDefaultVoucher)
-	ls.DbRs.AddLocalFunc("check_vouchers", appHandlers.CheckVouchers)
-	ls.DbRs.AddLocalFunc("get_vouchers", appHandlers.GetVoucherList)
-	ls.DbRs.AddLocalFunc("view_voucher", appHandlers.ViewVoucher)
-	ls.DbRs.AddLocalFunc("set_voucher", appHandlers.SetVoucher)
-	ls.DbRs.AddLocalFunc("get_voucher_details", appHandlers.GetVoucherDetails)
-	ls.DbRs.AddLocalFunc("reset_valid_pin", appHandlers.ResetValidPin)
-	ls.DbRs.AddLocalFunc("check_pin_mismatch", appHandlers.CheckBlockedNumPinMisMatch)
-	ls.DbRs.AddLocalFunc("validate_blocked_number", appHandlers.ValidateBlockedNumber)
-	ls.DbRs.AddLocalFunc("retrieve_blocked_number", appHandlers.RetrieveBlockedNumber)
-	ls.DbRs.AddLocalFunc("reset_unregistered_number", appHandlers.ResetUnregisteredNumber)
-	ls.DbRs.AddLocalFunc("reset_others_pin", appHandlers.ResetOthersPin)
-	ls.DbRs.AddLocalFunc("save_others_temporary_pin", appHandlers.SaveOthersTemporaryPin)
-	ls.DbRs.AddLocalFunc("get_current_profile_info", appHandlers.GetCurrentProfileInfo)
-	ls.DbRs.AddLocalFunc("check_transactions", appHandlers.CheckTransactions)
-	ls.DbRs.AddLocalFunc("get_transactions", appHandlers.GetTransactionsList)
-	ls.DbRs.AddLocalFunc("view_statement", appHandlers.ViewTransactionStatement)
-	ls.DbRs.AddLocalFunc("update_all_profile_items", appHandlers.UpdateAllProfileItems)
-	ls.DbRs.AddLocalFunc("set_back", appHandlers.SetBack)
-	ls.DbRs.AddLocalFunc("show_blocked_account", appHandlers.ShowBlockedAccount)
+	ussdHandlers = ussdHandlers.WithPersister(ls.Pe)
+	ls.DbRs.AddLocalFunc("set_language", ussdHandlers.SetLanguage)
+	ls.DbRs.AddLocalFunc("create_account", ussdHandlers.CreateAccount)
+	ls.DbRs.AddLocalFunc("save_temporary_pin", ussdHandlers.SaveTemporaryPin)
+	ls.DbRs.AddLocalFunc("verify_create_pin", ussdHandlers.VerifyCreatePin)
+	ls.DbRs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier)
+	ls.DbRs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus)
+	ls.DbRs.AddLocalFunc("authorize_account", ussdHandlers.Authorize)
+	ls.DbRs.AddLocalFunc("quit", ussdHandlers.Quit)
+	ls.DbRs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance)
+	ls.DbRs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient)
+	ls.DbRs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset)
+	ls.DbRs.AddLocalFunc("invite_valid_recipient", ussdHandlers.InviteValidRecipient)
+	ls.DbRs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount)
+	ls.DbRs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount)
+	ls.DbRs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount)
+	ls.DbRs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient)
+	ls.DbRs.AddLocalFunc("get_sender", ussdHandlers.GetSender)
+	ls.DbRs.AddLocalFunc("get_amount", ussdHandlers.GetAmount)
+	ls.DbRs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin)
+	ls.DbRs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname)
+	ls.DbRs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname)
+	ls.DbRs.AddLocalFunc("save_gender", ussdHandlers.SaveGender)
+	ls.DbRs.AddLocalFunc("save_location", ussdHandlers.SaveLocation)
+	ls.DbRs.AddLocalFunc("save_yob", ussdHandlers.SaveYob)
+	ls.DbRs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings)
+	ls.DbRs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized)
+	ls.DbRs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate)
+	ls.DbRs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo)
+	ls.DbRs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob)
+	ls.DbRs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob)
+	ls.DbRs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction)
+	ls.DbRs.AddLocalFunc("verify_new_pin", ussdHandlers.VerifyNewPin)
+	ls.DbRs.AddLocalFunc("confirm_pin_change", ussdHandlers.ConfirmPinChange)
+	ls.DbRs.AddLocalFunc("quit_with_help", ussdHandlers.QuitWithHelp)
+	ls.DbRs.AddLocalFunc("fetch_community_balance", ussdHandlers.FetchCommunityBalance)
+	ls.DbRs.AddLocalFunc("set_default_voucher", ussdHandlers.SetDefaultVoucher)
+	ls.DbRs.AddLocalFunc("check_vouchers", ussdHandlers.CheckVouchers)
+	ls.DbRs.AddLocalFunc("get_vouchers", ussdHandlers.GetVoucherList)
+	ls.DbRs.AddLocalFunc("view_voucher", ussdHandlers.ViewVoucher)
+	ls.DbRs.AddLocalFunc("set_voucher", ussdHandlers.SetVoucher)
+	ls.DbRs.AddLocalFunc("get_voucher_details", ussdHandlers.GetVoucherDetails)
+	ls.DbRs.AddLocalFunc("reset_valid_pin", ussdHandlers.ResetValidPin)
+	ls.DbRs.AddLocalFunc("check_pin_mismatch", ussdHandlers.CheckBlockedNumPinMisMatch)
+	ls.DbRs.AddLocalFunc("validate_blocked_number", ussdHandlers.ValidateBlockedNumber)
+	ls.DbRs.AddLocalFunc("retrieve_blocked_number", ussdHandlers.RetrieveBlockedNumber)
+	ls.DbRs.AddLocalFunc("reset_unregistered_number", ussdHandlers.ResetUnregisteredNumber)
+	ls.DbRs.AddLocalFunc("reset_others_pin", ussdHandlers.ResetOthersPin)
+	ls.DbRs.AddLocalFunc("save_others_temporary_pin", ussdHandlers.SaveOthersTemporaryPin)
+	ls.DbRs.AddLocalFunc("get_current_profile_info", ussdHandlers.GetCurrentProfileInfo)
+	ls.DbRs.AddLocalFunc("check_transactions", ussdHandlers.CheckTransactions)
+	ls.DbRs.AddLocalFunc("get_transactions", ussdHandlers.GetTransactionsList)
+	ls.DbRs.AddLocalFunc("view_statement", ussdHandlers.ViewTransactionStatement)
+	ls.DbRs.AddLocalFunc("update_all_profile_items", ussdHandlers.UpdateAllProfileItems)
+	ls.DbRs.AddLocalFunc("set_back", ussdHandlers.SetBack)
 
-	return appHandlers, nil
+	return ussdHandlers, nil
 }
 
 // TODO: enable setting of sessionId on engine init time

internal/handlers/ussd/menuhandler.go

@@ -1,4 +1,4 @@
-package application
+package ussd
 
 import (
 	"bytes"
@@ -161,12 +161,9 @@ func (h *Handlers) SetLanguage(ctx context.Context, sym string, input []byte) (r
 		//Fallback to english instead?
 		code = "eng"
 	}
-	err := h.persistLanguageCode(ctx, code)
-	if err != nil {
-		return res, err
-	}
-	res.Content = code
 	res.FlagSet = append(res.FlagSet, state.FLAG_LANG)
+	res.Content = code
+
 	languageSetFlag, err := h.flagManager.GetFlag("flag_language_set")
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Error setting the languageSetFlag", "error", err)
@@ -737,23 +734,11 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 			if h.st.MatchFlag(flag_account_authorized, false) {
 				res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
 				res.FlagSet = append(res.FlagSet, flag_allow_update, flag_account_authorized)
-				err := h.resetIncorrectPINAttempts(ctx, sessionId)
-				if err != nil {
-					return res, err
-				}
 			} else {
 				res.FlagSet = append(res.FlagSet, flag_allow_update)
 				res.FlagReset = append(res.FlagReset, flag_account_authorized)
-				err := h.resetIncorrectPINAttempts(ctx, sessionId)
-				if err != nil {
-					return res, err
-				}
 			}
 		} else {
-			err := h.incrementIncorrectPINAttempts(ctx, sessionId)
-			if err != nil {
-				return res, err
-			}
 			res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
 			res.FlagReset = append(res.FlagReset, flag_account_authorized)
 			return res, nil
@@ -767,34 +752,8 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 // ResetIncorrectPin resets the incorrect pin flag  after a new PIN attempt.
 func (h *Handlers) ResetIncorrectPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-	store := h.userdataStore
-
 	flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
-	flag_account_blocked, _ := h.flagManager.GetFlag("flag_account_blocked")
-
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return res, fmt.Errorf("missing session")
-	}
-
 	res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
-
-	currentWrongPinAttempts, err := store.ReadEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS)
-	if err != nil {
-		if !db.IsNotFound(err) {
-			return res, err
-		}
-	}
-	pinAttemptsValue, _ := strconv.ParseUint(string(currentWrongPinAttempts), 0, 64)
-	remainingPINAttempts := common.AllowedPINAttempts - uint8(pinAttemptsValue)
-	if remainingPINAttempts == 0 {
-		res.FlagSet = append(res.FlagSet, flag_account_blocked)
-		return res, nil
-	}
-	if remainingPINAttempts < common.AllowedPINAttempts {
-		res.Content = strconv.Itoa(int(remainingPINAttempts))
-	}
-
 	return res, nil
 }
 
@@ -876,21 +835,11 @@ func (h *Handlers) QuitWithHelp(ctx context.Context, sym string, input []byte) (
 	l := gotext.NewLocale(translationDir, code)
 	l.AddDomain("default")
 
-	res.Content = l.Get("For more help, please call: 0757628885")
+	res.Content = l.Get("For more help,please call: 0757628885")
 	res.FlagReset = append(res.FlagReset, flag_account_authorized)
 	return res, nil
 }
 
-// ShowBlockedAccount displays a message after an account has been blocked and how to reach support.
-func (h *Handlers) ShowBlockedAccount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
-	var res resource.Result
-	code := codeFromCtx(ctx)
-	l := gotext.NewLocale(translationDir, code)
-	l.AddDomain("default")
-	res.Content = l.Get("Your account has been locked. For help on how to unblock your account, contact support at: 0757628885")
-	return res, nil
-}
-
 // VerifyYob verifies the length of the given input.
 func (h *Handlers) VerifyYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
@@ -2126,68 +2075,3 @@ func (h *Handlers) UpdateAllProfileItems(ctx context.Context, sym string, input
 	}
 	return res, nil
 }
-
-// incrementIncorrectPINAttempts keeps track of the number of incorrect PIN attempts
-func (h *Handlers) incrementIncorrectPINAttempts(ctx context.Context, sessionId string) error {
-	var pinAttemptsCount uint8
-	store := h.userdataStore
-
-	currentWrongPinAttempts, err := store.ReadEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS)
-	if err != nil {
-		if db.IsNotFound(err) {
-			//First time Wrong PIN attempt: initialize with a count of 1
-			pinAttemptsCount = 1
-			err = store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(pinAttemptsCount))))
-			if err != nil {
-				logg.ErrorCtxf(ctx, "failed to write incorrect PIN attempts ", "key", common.DATA_INCORRECT_PIN_ATTEMPTS, "value", currentWrongPinAttempts, "error", err)
-				return err
-			}
-			return nil
-		}
-	}
-	pinAttemptsValue, _ := strconv.ParseUint(string(currentWrongPinAttempts), 0, 64)
-	pinAttemptsCount = uint8(pinAttemptsValue) + 1
-
-	err = store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(pinAttemptsCount))))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write incorrect PIN attempts ", "key", common.DATA_INCORRECT_PIN_ATTEMPTS, "value", pinAttemptsCount, "error", err)
-		return err
-	}
-	return nil
-}
-
-// resetIncorrectPINAttempts resets the number of incorrect PIN attempts after a correct PIN entry
-func (h *Handlers) resetIncorrectPINAttempts(ctx context.Context, sessionId string) error {
-	store := h.userdataStore
-	currentWrongPinAttempts, err := store.ReadEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS)
-	if err != nil {
-		if db.IsNotFound(err) {
-			return nil
-		}
-		return err
-	}
-	currentWrongPinAttemptsCount, _ := strconv.ParseUint(string(currentWrongPinAttempts), 0, 64)
-	if currentWrongPinAttemptsCount <= uint64(common.AllowedPINAttempts) {
-		err = store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(string("0")))
-		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to reset incorrect PIN attempts ", "key", common.DATA_INCORRECT_PIN_ATTEMPTS, "value", common.AllowedPINAttempts, "error", err)
-			return err
-		}
-	}
-	return nil
-}
-
-// persistLanguageCode persists the selected ISO 639 language code
-func (h *Handlers) persistLanguageCode(ctx context.Context, code string) error {
-	store := h.userdataStore
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return fmt.Errorf("missing session")
-	}
-	err := store.WriteEntry(ctx, sessionId, common.DATA_SELECTED_LANGUAGE_CODE, []byte(code))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to persist language code", "key", common.DATA_SELECTED_LANGUAGE_CODE, "value", code, "error", err)
-		return err
-	}
-	return nil
-}

internal/handlers/ussd/menuhandler_test.go

@@ -1,11 +1,10 @@
-package application
+package ussd
 
 import (
 	"context"
 	"fmt"
 	"log"
 	"path"
-	"strconv"
 	"strings"
 	"testing"
 
@@ -775,11 +774,6 @@ func TestSetLanguage(t *testing.T) {
 		log.Fatal(err)
 	}
 
-	sessionId := "session123"
-	ctx, store := InitializeTestStore(t)
-
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
-
 	// Define test cases
 	tests := []struct {
 		name           string
@@ -812,13 +806,12 @@ func TestSetLanguage(t *testing.T) {
 
 			// Create the Handlers instance with the mock flag manager
 			h := &Handlers{
-				flagManager:   fm.parser,
-				userdataStore: store,
-				st:            mockState,
+				flagManager: fm.parser,
+				st:          mockState,
 			}
 
 			// Call the method
-			res, err := h.SetLanguage(ctx, "set_language", nil)
+			res, err := h.SetLanguage(context.Background(), "set_language", nil)
 			if err != nil {
 				t.Error(err)
 			}
@@ -914,79 +907,37 @@ func TestResetAccountAuthorized(t *testing.T) {
 }
 
 func TestIncorrectPinReset(t *testing.T) {
-	sessionId := "session123"
-	ctx, store := InitializeTestStore(t)
 	fm, err := NewFlagManager(flagsPath)
-
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	flag_incorrect_pin, _ := fm.parser.GetFlag("flag_incorrect_pin")
-	flag_account_blocked, _ := fm.parser.GetFlag("flag_account_blocked")
-
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
 
 	// Define test cases
 	tests := []struct {
 		name           string
 		input          []byte
-		attempts       uint8
 		expectedResult resource.Result
 	}{
 		{
-			name:  "Test when incorrect PIN attempts is 2",
+			name:  "Test incorrect pin reset",
 			input: []byte(""),
 			expectedResult: resource.Result{
 				FlagReset: []uint32{flag_incorrect_pin},
-				Content:   "1", //Expected remaining PIN attempts
 			},
-			attempts: 2,
-		},
-		{
-			name:  "Test incorrect pin reset when incorrect PIN attempts is 1",
-			input: []byte(""),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_incorrect_pin},
-				Content:   "2", //Expected remaining PIN attempts
-			},
-			attempts: 1,
-		},
-		{
-			name:  "Test incorrect pin reset when incorrect PIN attempts is 1",
-			input: []byte(""),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_incorrect_pin},
-				Content:   "2", //Expected remaining PIN attempts
-			},
-			attempts: 1,
-		},
-		{
-			name:  "Test incorrect pin reset when incorrect PIN attempts is 3(account expected to be blocked)",
-			input: []byte(""),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_incorrect_pin},
-				FlagSet:   []uint32{flag_account_blocked},
-			},
-			attempts: 3,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-
-			if err := store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(tt.attempts)))); err != nil {
-				t.Fatal(err)
-			}
-
 			// Create the Handlers instance with the mock flag manager
 			h := &Handlers{
-				flagManager:   fm.parser,
-				userdataStore: store,
+				flagManager: fm.parser,
 			}
 
 			// Call the method
-			res, err := h.ResetIncorrectPin(ctx, "reset_incorrect_pin", tt.input)
+			res, err := h.ResetIncorrectPin(context.Background(), "reset_incorrect_pin", tt.input)
 			if err != nil {
 				t.Error(err)
 			}
@@ -2239,93 +2190,3 @@ func TestGetVoucherDetails(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, expectedResult, res)
 }
-
-func TestCountIncorrectPINAttempts(t *testing.T) {
-	ctx, store := InitializeTestStore(t)
-	sessionId := "session123"
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	attempts := uint8(2)
-
-	h := &Handlers{
-		userdataStore: store,
-	}
-	err := store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(attempts))))
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	err = h.incrementIncorrectPINAttempts(ctx, sessionId)
-	if err != nil {
-		t.Logf(err.Error())
-	}
-
-	attemptsAfterCount, err := store.ReadEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS)
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	pinAttemptsValue, _ := strconv.ParseUint(string(attemptsAfterCount), 0, 64)
-	pinAttemptsCount := uint8(pinAttemptsValue)
-	expectedAttempts := attempts + 1
-	assert.Equal(t, pinAttemptsCount, expectedAttempts)
-
-}
-
-func TestResetIncorrectPINAttempts(t *testing.T) {
-	ctx, store := InitializeTestStore(t)
-	sessionId := "session123"
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
-
-	err := store.WriteEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS, []byte(string("2")))
-	if err != nil {
-		t.Logf(err.Error())
-	}
-
-	h := &Handlers{
-		userdataStore: store,
-	}
-	h.resetIncorrectPINAttempts(ctx, sessionId)
-	incorrectAttempts, err := store.ReadEntry(ctx, sessionId, common.DATA_INCORRECT_PIN_ATTEMPTS)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	assert.Equal(t, "0", string(incorrectAttempts))
-
-}
-
-func TestPersistLanguageCode(t *testing.T) {
-	ctx, store := InitializeTestStore(t)
-
-	sessionId := "session123"
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore: store,
-	}
-	tests := []struct {
-		name                 string
-		code                 string
-		expectedLanguageCode string
-	}{
-		{
-			name:                 "Set Default Language (English)",
-			code:                 "eng",
-			expectedLanguageCode: "eng",
-		},
-		{
-			name:                 "Set Swahili Language",
-			code:                 "swa",
-			expectedLanguageCode: "swa",
-		},
-	}
-
-	for _, test := range tests {
-		err := h.persistLanguageCode(ctx, test.code)
-		if err != nil {
-			t.Logf(err.Error())
-		}
-		code, err := store.ReadEntry(ctx, sessionId, common.DATA_SELECTED_LANGUAGE_CODE)
-
-		assert.Equal(t, test.expectedLanguageCode, string(code))
-	}
-
-}

internal/ssh/ssh.go

@@ -41,7 +41,6 @@ func NewAuther(ctx context.Context, keyStore *SshKeyStore) *auther {
 }
 
 func(a *auther) Check(conn ssh.ConnMetadata, pubKey ssh.PublicKey) (*ssh.Permissions, error) {
-	logg.TraceCtxf(a.Ctx, "looking for publickey", "pubkey", fmt.Sprintf("%x", pubKey))
 	va, err := a.keyStore.Get(a.Ctx, pubKey)
 	if err != nil {
 		return nil, err
@@ -72,20 +71,6 @@ func(a *auther) Get(k []byte) (string, error) {
 	return v, nil
 }
 
-type SshRunner struct {
-	Ctx context.Context
-	Cfg engine.Config
-	FlagFile string
-	Conn storage.ConnData
-	ResourceDir string
-	Debug bool
-	SrvKeyFile string
-	Host string
-	Port uint
-	wg sync.WaitGroup
-	lst net.Listener
-}
-
 func(s *SshRunner) serve(ctx context.Context, sessionId string, ch ssh.NewChannel, en engine.Engine) error {
 	if ch == nil {
 		return errors.New("nil channel")
@@ -143,13 +128,32 @@ func(s *SshRunner) serve(ctx context.Context, sessionId string, ch ssh.NewChanne
 	return nil
 }
 
+type SshRunner struct {
+	Ctx context.Context
+	Cfg engine.Config
+	FlagFile string
+	DbDir string
+	ResourceDir string
+	Debug bool
+	SrvKeyFile string
+	Host string
+	Port uint
+	wg sync.WaitGroup
+	lst net.Listener
+}
+
 func(s *SshRunner) Stop() error {
 	return s.lst.Close()
 }
 
 func(s *SshRunner) GetEngine(sessionId string) (engine.Engine, func(), error) {
 	ctx := s.Ctx
-	menuStorageService := storage.NewMenuStorageService(s.Conn, s.ResourceDir)
+	menuStorageService := storage.NewMenuStorageService(s.DbDir, s.ResourceDir)
+
+	err := menuStorageService.EnsureDbDir()
+	if err != nil {
+		return nil, nil, err
+	}
 
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
@@ -204,7 +208,6 @@ func(s *SshRunner) GetEngine(sessionId string) (engine.Engine, func(), error) {
 
 // adapted example from crypto/ssh package, NewServerConn doc
 func(s *SshRunner) Run(ctx context.Context, keyStore *SshKeyStore) {
-	s.Ctx = ctx
 	running := true
 
 	// TODO: waitgroup should probably not be global

internal/storage/parse.go

@@ -1,86 +0,0 @@
-package storage
-
-import (
-	"fmt"
-	"net/url"
-	"path"
-)
-
-const (
-	DBTYPE_MEM = iota
-	DBTYPE_GDBM
-	DBTYPE_POSTGRES
-)
-
-type ConnData struct {
-	typ int
-	str string
-	domain string
-}
-
-func (cd *ConnData) DbType() int {
-	return cd.typ
-}
-
-func (cd *ConnData) String() string {
-	return cd.str
-}
-
-func (cd *ConnData) Domain() string {
-	return cd.domain
-}
-
-func (cd *ConnData) Path() string {
-	v, _ := url.Parse(cd.str)
-	v.RawQuery = ""
-	return v.String()
-}
-
-func probePostgres(s string) (string, string, bool) {
-	domain := "public"
-	v, err := url.Parse(s)
-	if err != nil {
-		return "", "", false
-	}
-	if v.Scheme != "postgres" {
-		return "", "", false
-	}
-	vv := v.Query()
-	if vv.Has("search_path") {
-		domain = vv.Get("search_path")
-	}
-	return s, domain, true
-}
-
-func probeGdbm(s string) (string, string, bool) {
-	if !path.IsAbs(s) {
-		return "", "", false
-	}
-	s = path.Clean(s)
-	return s, "", true
-}
-
-func ToConnData(connStr string) (ConnData, error) {
-	var o ConnData
-
-	if connStr == "" {
-		return o, nil
-	}
-
-	v, domain, ok := probePostgres(connStr)
-	if ok {
-		o.typ = DBTYPE_POSTGRES
-		o.str = v
-		o.domain = domain
-		return o, nil
-	}
-
-	v, _, ok = probeGdbm(connStr)
-	if ok {
-		o.typ = DBTYPE_GDBM
-		o.str = v
-		return o, nil
-	}
-
-	return o, fmt.Errorf("invalid connection string: %s", connStr)
-}

internal/storage/parse_test.go

@@ -1,28 +0,0 @@
-package storage
-
-import (
-	"testing"
-)
-
-func TestParseConnStr(t *testing.T) {
-	_, err := ToConnData("postgres://foo:bar@localhost:5432/baz")
-	if err != nil {
-		t.Fatal(err)	
-	}
-	_, err = ToConnData("/foo/bar")
-	if err != nil {
-		t.Fatal(err)	
-	}
-	_, err = ToConnData("/foo/bar/")
-	if err != nil {
-		t.Fatal(err)	
-	}
-	_, err = ToConnData("foo/bar")
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	_, err = ToConnData("http://foo/bar")
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-}

internal/storage/storageservice.go

@@ -13,8 +13,8 @@ import (
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/urdt/ussd/initializers"
 	gdbmstorage "git.grassecon.net/urdt/ussd/internal/storage/db/gdbm"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 var (
@@ -25,10 +25,11 @@ type StorageService interface {
 	GetPersister(ctx context.Context) (*persist.Persister, error)
 	GetUserdataDb(ctx context.Context) db.Db
 	GetResource(ctx context.Context) (resource.Resource, error)
+	EnsureDbDir() error
 }
 
 type MenuStorageService struct {
-	conn ConnData
+	dbDir         string
 	resourceDir   string
 	poResource    resource.Resource
 	resourceStore db.Db
@@ -36,48 +37,27 @@ type MenuStorageService struct {
 	userDataStore db.Db
 }
 
-func NewMenuStorageService(conn ConnData, resourceDir string) *MenuStorageService {
-	return &MenuStorageService{
-		conn: conn,
-		resourceDir: resourceDir,
-	}
+func buildConnStr() string {
+	host := initializers.GetEnv("DB_HOST", "localhost")
+	user := initializers.GetEnv("DB_USER", "postgres")
+	password := initializers.GetEnv("DB_PASSWORD", "")
+	dbName := initializers.GetEnv("DB_NAME", "")
+	port := initializers.GetEnv("DB_PORT", "5432")
+
+	connString := fmt.Sprintf(
+		"postgres://%s:%s@%s:%s/%s",
+		user, password, host, port, dbName,
+	)
+	logg.Debugf("pg conn string", "conn", connString)
+
+	return connString
 }
 
-func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.Db, section string) (db.Db, error) {
-	var newDb db.Db
-	var err error
-
-	if existingDb != nil {
-		return existingDb, nil
+func NewMenuStorageService(dbDir string, resourceDir string) *MenuStorageService {
+	return &MenuStorageService{
+		dbDir:       dbDir,
+		resourceDir: resourceDir,
 	}
-
-
-	connStr := ms.conn.String()
-	dbTyp := ms.conn.DbType()
-	if dbTyp == DBTYPE_POSTGRES {
-		// TODO: move to vise
-		err = ensureSchemaExists(ctx, ms.conn)
-		if err != nil {
-			return nil, err
-		}
-		newDb = postgres.NewPgDb().WithSchema(ms.conn.Domain())
-	} else if dbTyp == DBTYPE_GDBM {
-		err = ms.ensureDbDir()
-		if err != nil {
-			return nil, err
-		}
-		connStr = path.Join(connStr, section)
-		newDb = gdbmstorage.NewThreadGdbmDb()
-	} else {
-		return nil, fmt.Errorf("unsupported connection string: '%s'\n", ms.conn.String())
-	}
-	logg.DebugCtxf(ctx, "connecting to db", "conn", connStr, "conndata", ms.conn)
-	err = newDb.Connect(ctx, connStr)
-	if err != nil {
-		return nil, err
-	}
-
-	return newDb, nil
 }
 
 // WithGettext triggers use of gettext for translation of templates and menus.
@@ -102,21 +82,34 @@ func (ms *MenuStorageService) WithGettext(path string, lns []lang.Language) *Men
 	return ms
 }
 
-// ensureSchemaExists creates a new schema if it does not exist
-func ensureSchemaExists(ctx context.Context, conn ConnData) error {
-	h, err := pgxpool.New(ctx, conn.Path())
-	if err != nil {
-		return fmt.Errorf("failed to connect to the database: %w", err)
-	}
-	defer h.Close()
-
-	query := fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS %s", conn.Domain())
-	_, err = h.Exec(ctx, query)
-	if err != nil {
-		return fmt.Errorf("failed to create schema: %w", err)
+func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.Db, fileName string) (db.Db, error) {
+	database, ok := ctx.Value("Database").(string)
+	if !ok {
+		return nil, fmt.Errorf("failed to select the database")
 	}
 
-	return nil
+	if existingDb != nil {
+		return existingDb, nil
+	}
+
+	var newDb db.Db
+	var err error
+
+	if database == "postgres" {
+		newDb = postgres.NewPgDb()
+		connStr := buildConnStr()
+		err = newDb.Connect(ctx, connStr)
+	} else {
+		newDb = gdbmstorage.NewThreadGdbmDb()
+		storeFile := path.Join(ms.dbDir, fileName)
+		err = newDb.Connect(ctx, storeFile)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return newDb, nil
 }
 
 func (ms *MenuStorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
@@ -173,8 +166,8 @@ func (ms *MenuStorageService) GetStateStore(ctx context.Context) (db.Db, error)
 	return ms.stateStore, nil
 }
 
-func (ms *MenuStorageService) ensureDbDir() error {
-	err := os.MkdirAll(ms.conn.String(), 0700)
+func (ms *MenuStorageService) EnsureDbDir() error {
+	err := os.MkdirAll(ms.dbDir, 0700)
 	if err != nil {
 		return fmt.Errorf("state dir create exited with error: %v\n", err)
 	}

internal/testutil/TestEngine.go

@@ -0,0 +1,124 @@
+package testutil
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path"
+	"time"
+
+	"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/internal/storage"
+	"git.grassecon.net/urdt/ussd/internal/testutil/testservice"
+	"git.grassecon.net/urdt/ussd/internal/testutil/testtag"
+	testdataloader "github.com/peteole/testdata-loader"
+	"git.grassecon.net/urdt/ussd/remote"
+)
+
+var (
+	baseDir   = testdataloader.GetBasePath()
+	logg      = logging.NewVanilla()
+	scriptDir = path.Join(baseDir, "services", "registration")
+)
+
+func TestEngine(sessionId string) (engine.Engine, func(), chan bool) {
+	ctx := context.Background()
+	ctx = context.WithValue(ctx, "SessionId", sessionId)
+	ctx = context.WithValue(ctx, "Database", "gdbm")
+	pfp := path.Join(scriptDir, "pp.csv")
+
+	var eventChannel = make(chan bool)
+
+	cfg := engine.Config{
+		Root:       "root",
+		SessionId:  sessionId,
+		OutputSize: uint32(160),
+		FlagCount:  uint32(128),
+	}
+
+	dbDir := ".test_state"
+	resourceDir := scriptDir
+	menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
+
+	err := menuStorageService.EnsureDbDir()
+	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)
+	}
+
+	pe, err := menuStorageService.GetPersister(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)
+	}
+
+	dbResource, ok := rs.(*resource.DbResource)
+	if !ok {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
+	lhs.SetDataStore(&userDataStore)
+	lhs.SetPersister(pe)
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	if testtag.AccountService == nil {
+		testtag.AccountService = &remote.AccountService{}
+	}
+
+	switch testtag.AccountService.(type) {
+	case *testservice.TestAccountService:
+		go func() {
+			eventChannel <- false
+		}()
+	case *remote.AccountService:
+		go func() {
+			time.Sleep(5 * time.Second) // Wait for 5 seconds
+			eventChannel <- true
+		}()
+	default:
+		panic("Unknown account service type")
+	}
+
+	hl, err := lhs.GetHandler(testtag.AccountService)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	en := lhs.GetEngine()
+	en = en.WithFirst(hl.Init)
+	cleanFn := func() {
+		err := en.Finish()
+		if err != nil {
+			logg.Errorf(err.Error())
+		}
+
+		err = menuStorageService.Close()
+		if err != nil {
+			logg.Errorf(err.Error())
+		}
+		logg.Infof("testengine storage closed")
+	}
+	return en, cleanFn, eventChannel
+}

internal/testutil/engine.go

@@ -1,209 +0,0 @@
-package testutil
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"net/url"
-	"os"
-	"path"
-	"path/filepath"
-	"time"
-
-	"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/storage"
-	"git.grassecon.net/urdt/ussd/internal/testutil/testservice"
-	"git.grassecon.net/urdt/ussd/internal/testutil/testtag"
-	"git.grassecon.net/urdt/ussd/remote"
-	"github.com/jackc/pgx/v5/pgxpool"
-	testdataloader "github.com/peteole/testdata-loader"
-)
-
-var (
-	logg        = logging.NewVanilla()
-	baseDir     = testdataloader.GetBasePath()
-	scriptDir   = path.Join(baseDir, "services", "registration")
-	setDbType   string
-	setConnStr  string
-	setDbSchema string
-)
-
-func init() {
-	initializers.LoadEnvVariablesPath(baseDir)
-	config.LoadConfig()
-}
-
-// SetDatabase updates the database used by TestEngine
-func SetDatabase(database, connStr, dbSchema string) {
-	setDbType = database
-	setConnStr = connStr
-	setDbSchema = dbSchema
-}
-
-// CleanDatabase removes all test data from the database
-func CleanDatabase() {
-	if setDbType == "postgres" {
-		ctx := context.Background()
-		// Update the connection string with the new search path
-		updatedConnStr, err := updateSearchPath(setConnStr, setDbSchema)
-		if err != nil {
-			log.Fatalf("Failed to update search path: %v", err)
-		}
-
-		dbConn, err := pgxpool.New(ctx, updatedConnStr)
-		if err != nil {
-			log.Fatalf("Failed to connect to database for cleanup: %v", err)
-		}
-		defer dbConn.Close()
-
-		query := fmt.Sprintf("DELETE FROM %s.kv_vise;", setDbSchema)
-		_, execErr := dbConn.Exec(ctx, query)
-		if execErr != nil {
-			log.Printf("Failed to cleanup table %s.kv_vise: %v", setDbSchema, execErr)
-		} else {
-			log.Printf("Successfully cleaned up table %s.kv_vise", setDbSchema)
-		}
-	} else {
-		setConnStr, _ := filepath.Abs(setConnStr)
-		if err := os.RemoveAll(setConnStr); err != nil {
-			log.Fatalf("Failed to delete state store %s: %v", setConnStr, err)
-		}
-	}
-}
-
-// updateSearchPath updates the search_path (schema) to be used in the connection
-func updateSearchPath(connStr string, newSearchPath string) (string, error) {
-	u, err := url.Parse(connStr)
-	if err != nil {
-		return "", fmt.Errorf("invalid connection string: %w", err)
-	}
-
-	// Parse the query parameters
-	q := u.Query()
-
-	// Update or add the search_path parameter
-	q.Set("search_path", newSearchPath)
-
-	// Rebuild the connection string with updated parameters
-	u.RawQuery = q.Encode()
-
-	return u.String(), nil
-}
-
-func TestEngine(sessionId string) (engine.Engine, func(), chan bool) {
-	var err error
-	ctx := context.Background()
-	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	pfp := path.Join(scriptDir, "pp.csv")
-
-	var eventChannel = make(chan bool)
-
-	cfg := engine.Config{
-		Root:       "root",
-		SessionId:  sessionId,
-		OutputSize: uint32(160),
-		FlagCount:  uint32(128),
-	}
-
-	if setDbType == "postgres" {
-		setConnStr = config.DbConn
-		setConnStr, err = updateSearchPath(setConnStr, setDbSchema)
-		if err != nil {
-			fmt.Println("Error:", err)
-			os.Exit(1)
-		}
-	} else {
-		setConnStr, err = filepath.Abs(setConnStr)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "connstr err: %v", err)
-			os.Exit(1)
-		}
-	}
-
-	conn, err := storage.ToConnData(setConnStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connstr parse err: %v", err)
-		os.Exit(1)
-	}
-
-	resourceDir := scriptDir
-	menuStorageService := storage.NewMenuStorageService(conn, resourceDir)
-
-	rs, err := menuStorageService.GetResource(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "resource error: %v", err)
-		os.Exit(1)
-	}
-
-	pe, err := menuStorageService.GetPersister(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "persister error: %v", err)
-		os.Exit(1)
-	}
-
-	userDataStore, err := menuStorageService.GetUserdataDb(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "userdb error: %v", err)
-		os.Exit(1)
-	}
-
-	dbResource, ok := rs.(*resource.DbResource)
-	if !ok {
-		fmt.Fprintf(os.Stderr, "dbresource cast error")
-		os.Exit(1)
-	}
-
-	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
-	lhs.SetDataStore(&userDataStore)
-	lhs.SetPersister(pe)
-
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	if testtag.AccountService == nil {
-		testtag.AccountService = &remote.AccountService{}
-	}
-
-	switch testtag.AccountService.(type) {
-	case *testservice.TestAccountService:
-		go func() {
-			eventChannel <- false
-		}()
-	case *remote.AccountService:
-		go func() {
-			time.Sleep(5 * time.Second) // Wait for 5 seconds
-			eventChannel <- true
-		}()
-	default:
-		panic("Unknown account service type")
-	}
-
-	hl, err := lhs.GetHandler(testtag.AccountService)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	en := lhs.GetEngine()
-	en = en.WithFirst(hl.Init)
-	cleanFn := func() {
-		err := en.Finish()
-		if err != nil {
-			logg.Errorf(err.Error())
-		}
-
-		err = menuStorageService.Close()
-		if err != nil {
-			logg.Errorf(err.Error())
-		}
-		logg.Infof("testengine storage closed")
-	}
-	return en, cleanFn, eventChannel
-}

internal/testutil/engine_test.go

@@ -1,15 +0,0 @@
-package testutil
-
-import (
-	"testing"
-)
-
-func TestCreateEngine(t *testing.T) {
-	o, clean, eventC := TestEngine("foo")
-	defer clean()
-	defer func() {
-		<-eventC
-		close(eventC)
-	}()
-	_ = o
-}

menutraversal_test/group_test.json

@@ -54,7 +54,7 @@
                 },
                 {
                     "input": "1235",
-                    "expectedContent": "Incorrect PIN. You have: 2 remaining attempt(s).\n1:Retry\n9:Quit"
+                    "expectedContent": "Incorrect PIN\n1:Retry\n9:Quit"
                 },
                 {
                     "input": "1",
@@ -95,7 +95,7 @@
                 },
                 {
                     "input": "1235",
-                    "expectedContent": "Incorrect PIN. You have: 2 remaining attempt(s).\n1:Retry\n9:Quit"
+                    "expectedContent": "Incorrect PIN\n1:Retry\n9:Quit"
                 },
                 {
                     "input": "1",
@@ -107,7 +107,8 @@
                 },
                 {
                     "input": "0",
-                    "expectedContent": "Balances:\n1:My balance\n2:Community balance\n0:Back"
+                     "expectedContent": "Balances:\n1:My balance\n2:Community balance\n0:Back"
+                    
                 },
                 {
                     "input": "0",
@@ -140,7 +141,7 @@
                 },
                 {
                     "input": "1235",
-                    "expectedContent": "Incorrect PIN. You have: 2 remaining attempt(s).\n1:Retry\n9:Quit"
+                    "expectedContent": "Incorrect PIN\n1:Retry\n9:Quit"
                 },
                 {
                     "input": "1",
@@ -152,7 +153,8 @@
                 },
                 {
                     "input": "0",
-                    "expectedContent": "Balances:\n1:My balance\n2:Community balance\n0:Back"
+                     "expectedContent": "Balances:\n1:My balance\n2:Community balance\n0:Back"
+                    
                 },
                 {
                     "input": "0",
@@ -193,7 +195,7 @@
                 },
                 {
                     "input": "1",
-                    "expectedContent": "Enter your year of birth\n0:Back"
+                    "expectedContent":  "Enter your year of birth\n0:Back"
                 },
                 {
                     "input": "1940",
@@ -256,6 +258,7 @@
                     "input": "0",
                     "expectedContent": "{balance}\n\n1:Send\n2:My Vouchers\n3:My Account\n4:Help\n9:Quit"
                 }
+               
             ]
         },
         {
@@ -440,4 +443,10 @@
             ]
         }
     ]
-}
+}
+      
+        
+       
+        
+    
+

menutraversal_test/menu_traversal_test.go

@@ -6,6 +6,7 @@ import (
 	"flag"
 	"log"
 	"math/rand"
+	"os"
 	"regexp"
 	"testing"
 
@@ -16,15 +17,13 @@ import (
 
 var (
 	testData  = driver.ReadData()
+	testStore = ".test_state"
 	sessionID string
 	src       = rand.NewSource(42)
 	g         = rand.New(src)
 )
 
 var groupTestFile = flag.String("test-file", "group_test.json", "The test file to use for running the group tests")
-var database = flag.String("db", "gdbm", "Specify the database (gdbm or postgres)")
-var connStr = flag.String("conn", ".test_state", "connection string")
-var dbSchema = flag.String("schema", "test", "Specify the database schema (default test)")
 
 func GenerateSessionId() string {
 	uu := uuid.NewGenWithOptions(uuid.WithRandomReader(g))
@@ -80,15 +79,12 @@ func extractSendAmount(response []byte) string {
 }
 
 func TestMain(m *testing.M) {
-	// Parse the flags
-	flag.Parse()
 	sessionID = GenerateSessionId()
-	// set the db
-	testutil.SetDatabase(*database, *connStr, *dbSchema)
-
-	// Cleanup the db after tests
-	defer testutil.CleanDatabase()
-
+	defer func() {
+		if err := os.RemoveAll(testStore); err != nil {
+			log.Fatalf("Failed to delete state store %s: %v", testStore, err)
+		}
+	}()
 	m.Run()
 }
 
@@ -125,6 +121,7 @@ func TestAccountCreationSuccessful(t *testing.T) {
 		}
 	}
 	<-eventChannel
+
 }
 
 func TestAccountRegistrationRejectTerms(t *testing.T) {

services/registration/blocked_account.vis

@@ -1,2 +0,0 @@
-LOAD show_blocked_account 0
-HALT 

services/registration/incorrect_pin

@@ -1 +1 @@
-Incorrect PIN. You have: {{.reset_incorrect}} remaining attempt(s).
+Incorrect PIN

services/registration/incorrect_pin.vis

@@ -1,7 +1,5 @@
 LOAD reset_incorrect 0
 RELOAD reset_incorrect
-MAP reset_incorrect
-CATCH blocked_account flag_account_blocked 1
 MOUT retry 1
 MOUT quit 9
 HALT

services/registration/incorrect_pin_swa

@@ -1 +1 @@
-PIN ulioeka sio sahihi, una majaribio: {{.reset_incorrect}} yaliyobaki
+PIN ulioeka sio sahihi

services/registration/locale/swa/default.po

@@ -7,11 +7,8 @@ msgstr "Ombi lako limetumwa. %s atapokea %s %s kutoka kwa %s."
 msgid "Thank you for using Sarafu. Goodbye!"
 msgstr "Asante kwa kutumia huduma ya Sarafu. Kwaheri!"
 
-msgid "For more help, please call: 0757628885"
-msgstr "Kwa usaidizi zaidi, piga: 0757628885"
-
-msgid "Your account has been locked. For help on how to unblock your account, contact support at: 0757628885"
-msgstr "Akaunti yako imefungwa. Kwa usaidizi wa jinsi ya kufungua akaunti yako, wasiliana na usaidizi kwa: 0757628885"
+msgid "For more help,please call: 0757628885"
+msgstr "Kwa usaidizi zaidi,piga: 0757628885"
 
 msgid "Balance: %s\n"
 msgstr "Salio: %s\n"

services/registration/pp.csv

@@ -28,5 +28,3 @@ flag,flag_gender_set,34,this is set when the gender of the profile is set
 flag,flag_location_set,35,this is set when the location of the profile is set
 flag,flag_offerings_set,36,this is set when the offerings of the profile is set
 flag,flag_back_set,37,this is set when it is a back navigation
-flag,flag_account_blocked,38,this is set when an account has been blocked after the allowed incorrect PIN attempts have been exceeded
-

services/registration/root.vis

@@ -1,4 +1,3 @@
-CATCH blocked_account flag_account_blocked 1
 CATCH select_language flag_language_set 0
 CATCH terms flag_account_created 0
 LOAD check_account_status 0