+
+
package main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "net/http"
+ "os"
+ "os/signal"
+ "path"
+ "strconv"
+ "strings"
+ "syscall"
+
+ "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"
+ httpserver "git.grassecon.net/urdt/ussd/internal/http"
+ "git.grassecon.net/urdt/ussd/internal/storage"
+)
+
+var (
+ logg = logging.NewVanilla()
+ scriptDir = path.Join("services", "registration")
+)
+
+type atRequestParser struct{}
+
+func (arp *atRequestParser) GetSessionId(rq any) (string, error) {
+ rqv, ok := rq.(*http.Request)
+ if !ok {
+ return "", handlers.ErrInvalidRequest
+ }
+ if err := rqv.ParseForm(); err != nil {
+ return "", fmt.Errorf("failed to parse form data: %v", err)
+ }
+
+ phoneNumber := rqv.FormValue("phoneNumber")
+ if phoneNumber == "" {
+ return "", fmt.Errorf("no phone number found")
+ }
+
+ return phoneNumber, 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 main() {
+ var dbDir string
+ var resourceDir string
+ var size uint
+ var engineDebug bool
+ var host string
+ var port uint
+ 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.UintVar(&size, "s", 160, "max size of output")
+ flag.StringVar(&host, "h", "127.0.0.1", "http host")
+ flag.UintVar(&port, "p", 7123, "http port")
+ flag.Parse()
+
+ logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)
+
+ ctx := context.Background()
+ pfp := path.Join(scriptDir, "pp.csv")
+
+ cfg := engine.Config{
+ Root: "root",
+ OutputSize: uint32(size),
+ FlagCount: uint32(20),
+ }
+
+ if engineDebug {
+ cfg.EngineDebug = true
+ }
+
+ 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())
+ os.Exit(1)
+ }
+ defer userdataStore.Close()
+
+ dbResource, ok := rs.(*resource.DbResource)
+ if !ok {
+ os.Exit(1)
+ }
+
+ lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
+ lhs.SetDataStore(&userdataStore)
+
+ if err != nil {
+ fmt.Fprintf(os.Stderr, err.Error())
+ os.Exit(1)
+ }
+
+ hl, err := lhs.GetHandler()
+ 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 := &atRequestParser{}
+ bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
+ sh := httpserver.NewATSessionHandler(bsh)
+ s := &http.Server{
+ Addr: fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
+ Handler: sh,
+ }
+ 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)
+ }
+}
+
+
+
package main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "os"
+ "os/signal"
+ "path"
+ "syscall"
+
+ "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"
+)
+
+var (
+ logg = logging.NewVanilla()
+ scriptDir = path.Join("services", "registration")
+)
+
+type asyncRequestParser struct {
+ sessionId string
+ input []byte
+}
+
+func (p *asyncRequestParser) GetSessionId(r any) (string, error) {
+ return p.sessionId, nil
+}
+
+func (p *asyncRequestParser) GetInput(r any) ([]byte, error) {
+ return p.input, nil
+}
+
+func main() {
+ var sessionId string
+ var dbDir string
+ var resourceDir string
+ var size uint
+ var engineDebug bool
+ var host string
+ var port uint
+ 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.BoolVar(&engineDebug, "d", false, "use engine debug output")
+ flag.UintVar(&size, "s", 160, "max size of output")
+ flag.StringVar(&host, "h", "127.0.0.1", "http host")
+ flag.UintVar(&port, "p", 7123, "http port")
+ flag.Parse()
+
+ logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)
+
+ ctx := context.Background()
+ pfp := path.Join(scriptDir, "pp.csv")
+
+ cfg := engine.Config{
+ Root: "root",
+ OutputSize: uint32(size),
+ FlagCount: uint32(16),
+ }
+
+ if engineDebug {
+ cfg.EngineDebug = true
+ }
+
+ 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())
+ os.Exit(1)
+ }
+ defer userdataStore.Close()
+
+ dbResource, ok := rs.(*resource.DbResource)
+ if !ok {
+ os.Exit(1)
+ }
+
+ lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
+ lhs.SetDataStore(&userdataStore)
+
+ hl, err := lhs.GetHandler()
+ 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 := &asyncRequestParser{
+ sessionId: sessionId,
+ }
+ sh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
+ cfg.SessionId = sessionId
+ rqs := handlers.RequestSession{
+ Ctx: ctx,
+ Writer: os.Stdout,
+ Config: cfg,
+ }
+
+ 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:
+ }
+ sh.Shutdown()
+ }()
+
+ for true {
+ rqs, err = sh.Process(rqs)
+ if err != nil {
+ logg.ErrorCtxf(ctx, "error in process: %v", "err", err)
+ fmt.Errorf("error in process: %v", err)
+ os.Exit(1)
+ }
+ rqs, err = sh.Output(rqs)
+ if err != nil {
+ logg.ErrorCtxf(ctx, "error in output: %v", "err", err)
+ fmt.Errorf("error in output: %v", err)
+ os.Exit(1)
+ }
+ rqs, err = sh.Reset(rqs)
+ if err != nil {
+ logg.ErrorCtxf(ctx, "error in reset: %v", "err", err)
+ fmt.Errorf("error in reset: %v", err)
+ os.Exit(1)
+ }
+ fmt.Println("")
+ _, err = fmt.Scanln(&rqs.Input)
+ if err != nil {
+ logg.ErrorCtxf(ctx, "error in input", "err", err)
+ fmt.Errorf("error in input: %v", err)
+ os.Exit(1)
+ }
+ }
+}
+
+
+
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/internal/handlers"
+ httpserver "git.grassecon.net/urdt/ussd/internal/http"
+ "git.grassecon.net/urdt/ussd/internal/storage"
+)
+
+var (
+ logg = logging.NewVanilla()
+ scriptDir = path.Join("services", "registration")
+)
+
+func main() {
+ var dbDir string
+ var resourceDir string
+ var size uint
+ var engineDebug bool
+ var host string
+ var port uint
+ 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.UintVar(&size, "s", 160, "max size of output")
+ flag.StringVar(&host, "h", "127.0.0.1", "http host")
+ flag.UintVar(&port, "p", 7123, "http port")
+ flag.Parse()
+
+ logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)
+
+ ctx := context.Background()
+ pfp := path.Join(scriptDir, "pp.csv")
+
+ cfg := engine.Config{
+ Root: "root",
+ OutputSize: uint32(size),
+ FlagCount: uint32(16),
+ }
+
+ if engineDebug {
+ cfg.EngineDebug = true
+ }
+
+ 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())
+ os.Exit(1)
+ }
+ defer userdataStore.Close()
+
+ dbResource, ok := rs.(*resource.DbResource)
+ if !ok {
+ os.Exit(1)
+ }
+
+ lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
+ lhs.SetDataStore(&userdataStore)
+
+ if err != nil {
+ fmt.Fprintf(os.Stderr, err.Error())
+ os.Exit(1)
+ }
+
+ hl, err := lhs.GetHandler()
+ 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 := &httpserver.DefaultRequestParser{}
+ bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
+ sh := httpserver.ToSessionHandler(bsh)
+ s := &http.Server{
+ Addr: fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
+ Handler: sh,
+ }
+ 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)
+ }
+}
+
+
+
package main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "os"
+ "path"
+
+ "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"
+)
+
+var (
+ logg = logging.NewVanilla()
+ scriptDir = path.Join("services", "registration")
+)
+
+func main() {
+ var dbDir string
+ var size uint
+ var sessionId string
+ var engineDebug bool
+ flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
+ 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.Parse()
+
+ logg.Infof("start command", "dbdir", dbDir, "outputsize", size)
+
+ ctx := context.Background()
+ ctx = context.WithValue(ctx, "SessionId", sessionId)
+ pfp := path.Join(scriptDir, "pp.csv")
+
+ cfg := engine.Config{
+ Root: "root",
+ SessionId: sessionId,
+ OutputSize: uint32(size),
+ FlagCount: uint32(20),
+ }
+
+ 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(pfp, true, dbResource, cfg, rs)
+ lhs.SetDataStore(&userdatastore)
+ lhs.SetPersister(pe)
+
+ if err != nil {
+ fmt.Fprintf(os.Stderr, err.Error())
+ os.Exit(1)
+ }
+
+ hl, err := lhs.GetHandler()
+ if err != nil {
+ fmt.Fprintf(os.Stderr, err.Error())
+ os.Exit(1)
+ }
+
+ en := lhs.GetEngine()
+ en = en.WithFirst(hl.Init)
+ if engineDebug {
+ en = en.WithDebug(nil)
+ }
+
+ err = engine.Loop(ctx, en, os.Stdin, os.Stdout, nil)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "loop exited with error: %v\n", err)
+ os.Exit(1)
+ }
+}
+
+
+
package handlers
+
+import (
+ "git.defalsify.org/vise.git/db"
+ "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/ussd"
+ "git.grassecon.net/urdt/ussd/internal/storage"
+)
+
+type BaseSessionHandler struct {
+ cfgTemplate engine.Config
+ 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 *ussd.Handlers) *BaseSessionHandler {
+ return &BaseSessionHandler{
+ cfgTemplate: cfg,
+ rs: rs,
+ hn: hn,
+ rp: rp,
+ provider: storage.NewSimpleStorageProvider(stateDb, userdataDb),
+ }
+}
+
+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 {
+ en := engine.NewEngine(cfg, rs)
+ en = en.WithPersister(pr)
+ return en
+}
+
+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)
+ if err != nil {
+ logg.ErrorCtxf(rqs.Ctx, "", "storage get error", err)
+ return rqs, ErrStorage
+ }
+
+ f.hn = f.hn.WithPersister(rqs.Storage.Persister)
+ eni := f.GetEngine(rqs.Config, f.rs, rqs.Storage.Persister)
+ en, ok := eni.(*engine.DefaultEngine)
+ if !ok {
+ perr := f.provider.Put(rqs.Config.SessionId, rqs.Storage)
+ rqs.Storage = nil
+ if perr != nil {
+ logg.ErrorCtxf(rqs.Ctx, "", "storage put error", perr)
+ }
+ return rqs, ErrEngineType
+ }
+ en = en.WithFirst(f.hn.Init)
+ if rqs.Config.EngineDebug {
+ en = en.WithDebug(nil)
+ }
+ rqs.Engine = en
+
+ r, err = rqs.Engine.Exec(rqs.Ctx, rqs.Input)
+ if err != nil {
+ perr := f.provider.Put(rqs.Config.SessionId, rqs.Storage)
+ rqs.Storage = nil
+ if perr != nil {
+ logg.ErrorCtxf(rqs.Ctx, "", "storage put error", perr)
+ }
+ return rqs, err
+ }
+
+ rqs.Continue = r
+ return rqs, nil
+}
+
+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) {
+ defer f.provider.Put(rqs.Config.SessionId, rqs.Storage)
+ return rqs, rqs.Engine.Finish()
+}
+
+func(f *BaseSessionHandler) GetConfig() engine.Config {
+ return f.cfgTemplate
+}
+
+func(f *BaseSessionHandler) GetRequestParser() RequestParser {
+ return f.rp
+}
+
+
+
package handlers
+
+import (
+ "git.defalsify.org/vise.git/asm"
+ "git.defalsify.org/vise.git/db"
+ "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/ussd"
+)
+
+type HandlerService interface {
+ GetHandler() (*ussd.Handlers, error)
+}
+
+func getParser(fp string, debug bool) (*asm.FlagParser, error) {
+ flagParser := asm.NewFlagParser().WithDebug()
+ _, err := flagParser.Load(fp)
+ if err != nil {
+ return nil, err
+ }
+ return flagParser, nil
+}
+
+type LocalHandlerService struct {
+ Parser *asm.FlagParser
+ DbRs *resource.DbResource
+ Pe *persist.Persister
+ UserdataStore *db.Db
+ Cfg engine.Config
+ Rs resource.Resource
+}
+
+func NewLocalHandlerService(fp string, debug bool, dbResource *resource.DbResource, cfg engine.Config, rs resource.Resource) (*LocalHandlerService, error) {
+ parser, err := getParser(fp, debug)
+ if err != nil {
+ return nil, err
+ }
+ return &LocalHandlerService{
+ Parser: parser,
+ DbRs: dbResource,
+ Cfg: cfg,
+ Rs: rs,
+ }, nil
+}
+
+func (ls *LocalHandlerService) SetPersister(Pe *persist.Persister) {
+ ls.Pe = Pe
+}
+
+func (ls *LocalHandlerService) SetDataStore(db *db.Db) {
+ ls.UserdataStore = db
+}
+
+func (ls *LocalHandlerService) GetHandler() (*ussd.Handlers, error) {
+ ussdHandlers, err := ussd.NewHandlers(ls.Parser, *ls.UserdataStore)
+ if err != nil {
+ return nil, err
+ }
+ ussdHandlers = ussdHandlers.WithPersister(ls.Pe)
+ ls.DbRs.AddLocalFunc("set_language", ussdHandlers.SetLanguage)
+ ls.DbRs.AddLocalFunc("create_account", ussdHandlers.CreateAccount)
+ ls.DbRs.AddLocalFunc("save_pin", ussdHandlers.SavePin)
+ ls.DbRs.AddLocalFunc("verify_pin", ussdHandlers.VerifyPin)
+ 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("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("quit_with_balance", ussdHandlers.QuitWithBalance)
+ 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("save_temporary_pin", ussdHandlers.SaveTemporaryPin)
+ 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_custodial_balances", ussdHandlers.FetchCustodialBalances)
+
+ return ussdHandlers, nil
+}
+
+// TODO: enable setting of sessionId on engine init time
+func (ls *LocalHandlerService) GetEngine() *engine.DefaultEngine {
+ en := engine.NewEngine(ls.Cfg, ls.Rs)
+ en = en.WithPersister(ls.Pe)
+ return en
+}
+
+
+
package server
+
+import (
+ "encoding/json"
+ "io"
+ "net/http"
+
+ "git.grassecon.net/urdt/ussd/config"
+ "git.grassecon.net/urdt/ussd/internal/models"
+)
+
+type AccountServiceInterface interface {
+ CheckBalance(publicKey string) (*models.BalanceResponse, error)
+ CreateAccount() (*models.AccountResponse, error)
+ CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error)
+}
+
+type AccountService struct {
+}
+
+// CheckAccountStatus retrieves the status of an account transaction based on the provided tracking ID.
+//
+// Parameters:
+// - trackingId: A unique identifier for the account.This should be obtained from a previous call to
+// CreateAccount or a similar function that returns an AccountResponse. The `trackingId` field in the
+// AccountResponse struct can be used here to check the account status during a transaction.
+//
+// Returns:
+// - string: The status of the transaction as a string. If there is an error during the request or processing, this will be an empty string.
+// - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
+// If no error occurs, this will be nil.
+func (as *AccountService) CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error) {
+ resp, err := http.Get(config.TrackStatusURL + trackingId)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ var trackResp models.TrackStatusResponse
+ err = json.Unmarshal(body, &trackResp)
+ if err != nil {
+ return nil, err
+ }
+
+ // status := trackResp.Result.Transaction.Status
+
+ return &trackResp, nil
+}
+
+// CheckBalance retrieves the balance for a given public key from the custodial balance API endpoint.
+// Parameters:
+// - publicKey: The public key associated with the account whose balance needs to be checked.
+func (as *AccountService) CheckBalance(publicKey string) (*models.BalanceResponse, error) {
+
+ resp, err := http.Get(config.BalanceURL + publicKey)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ var balanceResp models.BalanceResponse
+ err = json.Unmarshal(body, &balanceResp)
+ if err != nil {
+ return nil, err
+ }
+
+ //balance := balanceResp.Result.Balance
+ return &balanceResp, nil
+}
+
+// CreateAccount creates a new account in the custodial system.
+// Returns:
+// - *models.AccountResponse: A pointer to an AccountResponse struct containing the details of the created account.
+// If there is an error during the request or processing, this will be nil.
+// - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
+// If no error occurs, this will be nil.
+func (as *AccountService) CreateAccount() (*models.AccountResponse, error) {
+ resp, err := http.Post(config.CreateAccountURL, "application/json", nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ var accountResp models.AccountResponse
+ err = json.Unmarshal(body, &accountResp)
+ if err != nil {
+ return nil, err
+ }
+
+ return &accountResp, nil
+}
+
+
+
package ussd
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "path"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "git.defalsify.org/vise.git/asm"
+
+ "git.defalsify.org/vise.git/cache"
+ "git.defalsify.org/vise.git/db"
+ "git.defalsify.org/vise.git/lang"
+ "git.defalsify.org/vise.git/logging"
+ "git.defalsify.org/vise.git/persist"
+ "git.defalsify.org/vise.git/resource"
+ "git.defalsify.org/vise.git/state"
+ "git.grassecon.net/urdt/ussd/internal/handlers/server"
+ "git.grassecon.net/urdt/ussd/internal/utils"
+ "gopkg.in/leonelquinteros/gotext.v1"
+)
+
+var (
+ logg = logging.NewVanilla().WithDomain("ussdmenuhandler")
+ scriptDir = path.Join("services", "registration")
+ translationDir = path.Join(scriptDir, "locale")
+)
+
+// FlagManager handles centralized flag management
+type FlagManager struct {
+ parser *asm.FlagParser
+}
+
+// NewFlagManager creates a new FlagManager instance
+func NewFlagManager(csvPath string) (*FlagManager, error) {
+ parser := asm.NewFlagParser()
+ _, err := parser.Load(csvPath)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load flag parser: %v", err)
+ }
+
+ return &FlagManager{
+ parser: parser,
+ }, nil
+}
+
+// GetFlag retrieves a flag value by its label
+func (fm *FlagManager) GetFlag(label string) (uint32, error) {
+ return fm.parser.GetFlag(label)
+}
+
+type Handlers struct {
+ pe *persist.Persister
+ st *state.State
+ ca cache.Memory
+ userdataStore utils.DataStore
+ flagManager *asm.FlagParser
+ accountService server.AccountServiceInterface
+}
+
+func NewHandlers(appFlags *asm.FlagParser, userdataStore db.Db) (*Handlers, error) {
+ if userdataStore == nil {
+ return nil, fmt.Errorf("cannot create handler with nil userdata store")
+ }
+ userDb := &utils.UserDataStore{
+ Db: userdataStore,
+ }
+ h := &Handlers{
+ userdataStore: userDb,
+ flagManager: appFlags,
+ accountService: &server.AccountService{},
+ }
+ return h, nil
+}
+
+// Define the regex pattern as a constant
+const pinPattern = `^\d{4}$`
+
+// isValidPIN checks whether the given input is a 4 digit number
+func isValidPIN(pin string) bool {
+ match, _ := regexp.MatchString(pinPattern, pin)
+ return match
+}
+
+func (h *Handlers) WithPersister(pe *persist.Persister) *Handlers {
+ if h.pe != nil {
+ panic("persister already set")
+ }
+ h.pe = pe
+ return h
+}
+
+func (h *Handlers) Init(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var r resource.Result
+
+ if h.pe == nil {
+ logg.WarnCtxf(ctx, "handler init called before it is ready or more than once", "state", h.st, "cache", h.ca)
+ return r, nil
+ }
+ h.st = h.pe.GetState()
+ h.ca = h.pe.GetMemory()
+ if h.st == nil || h.ca == nil {
+ logg.ErrorCtxf(ctx, "perister fail in handler", "state", h.st, "cache", h.ca)
+ return r, fmt.Errorf("cannot get state and memory for handler")
+ }
+ h.pe = nil
+
+ logg.DebugCtxf(ctx, "handler has been initialized", "state", h.st, "cache", h.ca)
+
+ return r, nil
+}
+
+// SetLanguage sets the language across the menu
+func (h *Handlers) SetLanguage(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ symbol, _ := h.st.Where()
+ code := strings.Split(symbol, "_")[1]
+
+ if !utils.IsValidISO639(code) {
+ return res, nil
+ }
+ res.FlagSet = append(res.FlagSet, state.FLAG_LANG)
+ res.Content = code
+
+ languageSetFlag, err := h.flagManager.GetFlag("flag_language_set")
+ if err != nil {
+ return res, err
+ }
+ res.FlagSet = append(res.FlagSet, languageSetFlag)
+
+ return res, nil
+}
+
+func (h *Handlers) createAccountNoExist(ctx context.Context, sessionId string, res *resource.Result) error {
+ accountResp, err := h.accountService.CreateAccount()
+ data := map[utils.DataTyp]string{
+ utils.DATA_TRACKING_ID: accountResp.Result.TrackingId,
+ utils.DATA_PUBLIC_KEY: accountResp.Result.PublicKey,
+ utils.DATA_CUSTODIAL_ID: accountResp.Result.CustodialId.String(),
+ }
+
+ for key, value := range data {
+ store := h.userdataStore
+ err := store.WriteEntry(ctx, sessionId, key, []byte(value))
+ if err != nil {
+ return err
+ }
+ }
+ flag_account_created, _ := h.flagManager.GetFlag("flag_account_created")
+ res.FlagSet = append(res.FlagSet, flag_account_created)
+ return err
+
+}
+
+// CreateAccount checks if any account exists on the JSON data file, and if not
+// creates an account on the API,
+// sets the default values and flags
+func (h *Handlers) CreateAccount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ _, err = store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_CREATED)
+ if err != nil {
+ if db.IsNotFound(err) {
+ logg.Printf(logging.LVL_INFO, "Creating an account because it doesn't exist")
+ err = h.createAccountNoExist(ctx, sessionId, &res)
+ if err != nil {
+ return res, err
+ }
+ }
+ }
+ return res, nil
+}
+
+// SavePin persists the user's PIN choice into the filesystem
+func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
+
+ accountPIN := string(input)
+ // Validate that the PIN is a 4-digit number
+ if !isValidPIN(accountPIN) {
+ res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
+ return res, nil
+ }
+
+ res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(accountPIN))
+ if err != nil {
+ return res, err
+ }
+ return res, nil
+}
+
+func (h *Handlers) VerifyNewPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ res := resource.Result{}
+ _, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
+ pinInput := string(input)
+ // Validate that the PIN is a 4-digit number
+ if isValidPIN(pinInput) {
+ res.FlagSet = append(res.FlagSet, flag_valid_pin)
+ } else {
+ res.FlagReset = append(res.FlagReset, flag_valid_pin)
+ }
+
+ return res, nil
+}
+
+func (h *Handlers) SaveTemporaryPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
+
+ accountPIN := string(input)
+
+ // Validate that the PIN is a 4-digit number
+ if !isValidPIN(accountPIN) {
+ res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
+ return res, nil
+ }
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_TEMPORARY_PIN, []byte(accountPIN))
+ if err != nil {
+ return res, err
+ }
+ return res, nil
+}
+
+func (h *Handlers) ConfirmPinChange(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
+
+ store := h.userdataStore
+ temporaryPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_TEMPORARY_PIN)
+ if err != nil {
+ return res, err
+ }
+ if bytes.Equal(temporaryPin, input) {
+ res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
+ } else {
+ res.FlagSet = append(res.FlagSet, flag_pin_mismatch)
+ }
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(temporaryPin))
+ if err != nil {
+ return res, err
+ }
+ return res, nil
+}
+
+// VerifyPin checks whether the confirmation PIN is similar to the account PIN
+// If similar, it sets the USERFLAG_PIN_SET flag allowing the user
+// to access the main menu
+func (h *Handlers) VerifyPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
+ flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
+ flag_pin_set, _ := h.flagManager.GetFlag("flag_pin_set")
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ AccountPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN)
+ if err != nil {
+ return res, err
+ }
+
+ if bytes.Equal(input, AccountPin) {
+ res.FlagSet = []uint32{flag_valid_pin}
+ res.FlagReset = []uint32{flag_pin_mismatch}
+ res.FlagSet = append(res.FlagSet, flag_pin_set)
+ } else {
+ res.FlagSet = []uint32{flag_pin_mismatch}
+ }
+
+ return res, nil
+}
+
+// codeFromCtx retrieves language codes from the context that can be used for handling translations
+func codeFromCtx(ctx context.Context) string {
+ var code string
+ if ctx.Value("Language") != nil {
+ lang := ctx.Value("Language").(lang.Language)
+ code = lang.Code
+ }
+ return code
+}
+
+// SaveFirstname updates the first name in the gdbm with the provided input.
+func (h *Handlers) SaveFirstname(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ if len(input) > 0 {
+ firstName := string(input)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_FIRST_NAME, []byte(firstName))
+ if err != nil {
+ return res, err
+ }
+ }
+
+ return res, nil
+}
+
+// SaveFamilyname updates the family name in the gdbm with the provided input.
+func (h *Handlers) SaveFamilyname(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ if len(input) > 0 {
+ familyName := string(input)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_FAMILY_NAME, []byte(familyName))
+ if err != nil {
+ return res, err
+ }
+ } else {
+ return res, fmt.Errorf("a family name cannot be less than one character")
+ }
+
+ return res, nil
+}
+
+// SaveYOB updates the Year of Birth(YOB) in the gdbm with the provided input.
+func (h *Handlers) SaveYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ if len(input) == 4 {
+ yob := string(input)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_YOB, []byte(yob))
+ if err != nil {
+ return res, err
+ }
+ }
+
+ return res, nil
+}
+
+// SaveLocation updates the location in the gdbm with the provided input.
+func (h *Handlers) SaveLocation(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ if len(input) > 0 {
+ location := string(input)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_LOCATION, []byte(location))
+ if err != nil {
+ return res, err
+ }
+ }
+
+ return res, nil
+}
+
+// SaveGender updates the gender in the gdbm with the provided input.
+func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ symbol, _ := h.st.Where()
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ gender := strings.Split(symbol, "_")[1]
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_GENDER, []byte(gender))
+ if err != nil {
+ return res, nil
+ }
+
+ return res, nil
+}
+
+// SaveOfferings updates the offerings(goods and services provided by the user) in the gdbm with the provided input.
+func (h *Handlers) SaveOfferings(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ if len(input) > 0 {
+ offerings := string(input)
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_OFFERINGS, []byte(offerings))
+ if err != nil {
+ return res, nil
+ }
+ }
+
+ return res, nil
+}
+
+// ResetAllowUpdate resets the allowupdate flag that allows a user to update profile data.
+func (h *Handlers) ResetAllowUpdate(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
+
+ res.FlagReset = append(res.FlagReset, flag_allow_update)
+ return res, nil
+}
+
+// ResetAccountAuthorized resets the account authorization flag after a successful PIN entry.
+func (h *Handlers) ResetAccountAuthorized(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
+
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ return res, nil
+}
+
+// CheckIdentifier retrieves the PublicKey from the JSON data file.
+func (h *Handlers) CheckIdentifier(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ store := h.userdataStore
+ publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+
+ res.Content = string(publicKey)
+
+ return res, nil
+}
+
+// Authorize attempts to unlock the next sequential nodes by verifying the provided PIN against the already set PIN.
+// It sets the required flags that control the flow.
+func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
+ flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
+ flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
+
+ store := h.userdataStore
+ AccountPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN)
+ if err != nil {
+ return res, err
+ }
+ if len(input) == 4 {
+ if bytes.Equal(input, AccountPin) {
+ 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)
+ } else {
+ res.FlagSet = append(res.FlagSet, flag_allow_update)
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ }
+ } else {
+ res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ return res, nil
+ }
+ } else {
+ return res, nil
+ }
+ return res, nil
+}
+
+// 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
+ flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
+ res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
+ return res, nil
+}
+
+// CheckAccountStatus queries the API using the TrackingId and sets flags
+// based on the account status
+func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_account_success, _ := h.flagManager.GetFlag("flag_account_success")
+ flag_account_pending, _ := h.flagManager.GetFlag("flag_account_pending")
+ flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ trackingId, err := store.ReadEntry(ctx, sessionId, utils.DATA_TRACKING_ID)
+ if err != nil {
+ return res, err
+ }
+
+ accountStatus, err := h.accountService.CheckAccountStatus(string(trackingId))
+ if err != nil {
+ fmt.Println("Error checking account status:", err)
+ return res, err
+ }
+ if !accountStatus.Ok {
+ res.FlagSet = append(res.FlagSet, flag_api_error)
+ return res, err
+ }
+ res.FlagReset = append(res.FlagReset, flag_api_error)
+ status := accountStatus.Result.Transaction.Status
+
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_STATUS, []byte(status))
+ if err != nil {
+ return res, nil
+ }
+ if accountStatus.Result.Transaction.Status == "SUCCESS" {
+ res.FlagSet = append(res.FlagSet, flag_account_success)
+ res.FlagReset = append(res.FlagReset, flag_account_pending)
+ } else {
+ res.FlagReset = append(res.FlagReset, flag_account_success)
+ res.FlagSet = append(res.FlagSet, flag_account_pending)
+ }
+ return res, nil
+}
+
+// Quit displays the Thank you message and exits the menu
+func (h *Handlers) Quit(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
+
+ code := codeFromCtx(ctx)
+ l := gotext.NewLocale(translationDir, code)
+ l.AddDomain("default")
+
+ res.Content = l.Get("Thank you for using Sarafu. Goodbye!")
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ return res, nil
+}
+
+// QuitWithHelp displays helpline information then exits the menu
+func (h *Handlers) QuitWithHelp(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
+
+ code := codeFromCtx(ctx)
+ l := gotext.NewLocale(translationDir, code)
+ l.AddDomain("default")
+
+ res.Content = l.Get("For more help,please call: 0757628885")
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ 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
+ var err error
+
+ flag_incorrect_date_format, _ := h.flagManager.GetFlag("flag_incorrect_date_format")
+
+ date := string(input)
+ _, err = strconv.Atoi(date)
+ if err != nil {
+ // If conversion fails, input is not numeric
+ res.FlagSet = append(res.FlagSet, flag_incorrect_date_format)
+ return res, nil
+ }
+
+ if len(date) == 4 {
+ res.FlagReset = append(res.FlagReset, flag_incorrect_date_format)
+ } else {
+ res.FlagSet = append(res.FlagSet, flag_incorrect_date_format)
+ }
+
+ return res, nil
+}
+
+// ResetIncorrectYob resets the incorrect date format flag after a new attempt
+func (h *Handlers) ResetIncorrectYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ flag_incorrect_date_format, _ := h.flagManager.GetFlag("flag_incorrect_date_format")
+
+ res.FlagReset = append(res.FlagReset, flag_incorrect_date_format)
+ return res, nil
+}
+
+// CheckBalance retrieves the balance from the API using the "PublicKey" and sets
+// the balance as the result content
+func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ store := h.userdataStore
+ publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+ if err != nil {
+ return res, err
+ }
+
+ balanceResponse, err := h.accountService.CheckBalance(string(publicKey))
+ if err != nil {
+ return res, nil
+ }
+ if !balanceResponse.Ok {
+ res.FlagSet = append(res.FlagSet, flag_api_error)
+ return res, nil
+ }
+ res.FlagReset = append(res.FlagReset, flag_api_error)
+ balance := balanceResponse.Result.Balance
+ res.Content = balance
+
+ return res, nil
+}
+
+func (h *Handlers) FetchCustodialBalances(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ symbol, _ := h.st.Where()
+ balanceType := strings.Split(symbol, "_")[0]
+
+ store := h.userdataStore
+ publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+ if err != nil {
+ return res, err
+ }
+
+ balanceResponse, err := h.accountService.CheckBalance(string(publicKey))
+ if err != nil {
+ return res, nil
+ }
+ if !balanceResponse.Ok {
+ res.FlagSet = append(res.FlagSet, flag_api_error)
+ return res, nil
+ }
+ res.FlagReset = append(res.FlagReset, flag_api_error)
+ balance := balanceResponse.Result.Balance
+
+ switch balanceType {
+ case "my":
+ res.Content = fmt.Sprintf("Your balance is %s", balance)
+ case "community":
+ res.Content = fmt.Sprintf("Your community balance is %s", balance)
+ default:
+ break
+ }
+ return res, nil
+}
+
+// ValidateRecipient validates that the given input is a valid phone number.
+func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ recipient := string(input)
+
+ flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
+
+ if recipient != "0" {
+ // mimic invalid number check
+ if recipient == "000" {
+ res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
+ res.Content = recipient
+
+ return res, nil
+ }
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_RECIPIENT, []byte(recipient))
+ if err != nil {
+ return res, nil
+ }
+ }
+
+ return res, nil
+}
+
+// TransactionReset resets the previous transaction data (Recipient and Amount)
+// as well as the invalid flags
+func (h *Handlers) TransactionReset(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
+ flag_invalid_recipient_with_invite, _ := h.flagManager.GetFlag("flag_invalid_recipient_with_invite")
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(""))
+ if err != nil {
+ return res, nil
+ }
+
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_RECIPIENT, []byte(""))
+ if err != nil {
+ return res, nil
+ }
+
+ res.FlagReset = append(res.FlagReset, flag_invalid_recipient, flag_invalid_recipient_with_invite)
+
+ return res, nil
+}
+
+// ResetTransactionAmount resets the transaction amount and invalid flag
+func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_invalid_amount, _ := h.flagManager.GetFlag("flag_invalid_amount")
+ store := h.userdataStore
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(""))
+ if err != nil {
+ return res, nil
+ }
+
+ res.FlagReset = append(res.FlagReset, flag_invalid_amount)
+
+ return res, nil
+}
+
+// MaxAmount gets the current balance from the API and sets it as
+// the result content.
+func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+
+ balanceResp, err := h.accountService.CheckBalance(string(publicKey))
+ if err != nil {
+ return res, nil
+ }
+ balance := balanceResp.Result.Balance
+
+ res.Content = balance
+
+ return res, nil
+}
+
+// ValidateAmount ensures that the given input is a valid amount and that
+// it is not more than the current balance.
+func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_invalid_amount, _ := h.flagManager.GetFlag("flag_invalid_amount")
+
+ store := h.userdataStore
+ publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+
+ amountStr := string(input)
+
+ balanceRes, err := h.accountService.CheckBalance(string(publicKey))
+ balanceStr := balanceRes.Result.Balance
+
+ if err != nil {
+ return res, err
+ }
+ res.Content = balanceStr
+
+ // Parse the balance
+ balanceParts := strings.Split(balanceStr, " ")
+ if len(balanceParts) != 2 {
+ return res, fmt.Errorf("unexpected balance format: %s", balanceStr)
+ }
+ balanceValue, err := strconv.ParseFloat(balanceParts[0], 64)
+ if err != nil {
+ return res, fmt.Errorf("failed to parse balance: %v", err)
+ }
+
+ // Extract numeric part from input
+ re := regexp.MustCompile(`^(\d+(\.\d+)?)\s*(?:CELO)?$`)
+ matches := re.FindStringSubmatch(strings.TrimSpace(amountStr))
+ if len(matches) < 2 {
+ res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+ res.Content = amountStr
+ return res, nil
+ }
+
+ inputAmount, err := strconv.ParseFloat(matches[1], 64)
+ if err != nil {
+ res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+ res.Content = amountStr
+ return res, nil
+ }
+
+ if inputAmount > balanceValue {
+ res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+ res.Content = amountStr
+ return res, nil
+ }
+
+ res.Content = fmt.Sprintf("%.3f", inputAmount) // Format to 3 decimal places
+ err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(amountStr))
+ if err != nil {
+ return res, err
+ }
+
+ return res, nil
+}
+
+// GetRecipient returns the transaction recipient from the gdbm.
+func (h *Handlers) GetRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ recipient, _ := store.ReadEntry(ctx, sessionId, utils.DATA_RECIPIENT)
+
+ res.Content = string(recipient)
+
+ return res, nil
+}
+
+// GetSender retrieves the public key from the Gdbm Db
+func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ store := h.userdataStore
+ publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+
+ res.Content = string(publicKey)
+
+ return res, nil
+}
+
+// GetAmount retrieves the amount from teh Gdbm Db
+func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ store := h.userdataStore
+ amount, _ := store.ReadEntry(ctx, sessionId, utils.DATA_AMOUNT)
+
+ res.Content = string(amount)
+
+ return res, nil
+}
+
+// QuickWithBalance retrieves the balance for a given public key from the custodial balance API endpoint before
+// gracefully exiting the session.
+func (h *Handlers) QuitWithBalance(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
+
+ code := codeFromCtx(ctx)
+ l := gotext.NewLocale(translationDir, code)
+ l.AddDomain("default")
+
+ store := h.userdataStore
+ publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+ if err != nil {
+ return res, err
+ }
+ balance, err := h.accountService.CheckBalance(string(publicKey))
+ if err != nil {
+ return res, nil
+ }
+ res.Content = l.Get("Your account balance is %s", balance)
+ res.FlagReset = append(res.FlagReset, flag_account_authorized)
+ return res, nil
+}
+
+// InitiateTransaction returns a confirmation and resets the transaction data
+// on the gdbm store.
+func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var err error
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+
+ code := codeFromCtx(ctx)
+ l := gotext.NewLocale(translationDir, code)
+ l.AddDomain("default")
+ // TODO
+ // Use the amount, recipient and sender to call the API and initialize the transaction
+ store := h.userdataStore
+ publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
+
+ amount, _ := store.ReadEntry(ctx, sessionId, utils.DATA_AMOUNT)
+
+ recipient, _ := store.ReadEntry(ctx, sessionId, utils.DATA_RECIPIENT)
+
+ res.Content = l.Get("Your request has been sent. %s will receive %s from %s.", string(recipient), string(amount), string(publicKey))
+
+ account_authorized_flag, err := h.flagManager.GetFlag("flag_account_authorized")
+ if err != nil {
+ return res, err
+ }
+
+ res.FlagReset = append(res.FlagReset, account_authorized_flag)
+ return res, nil
+}
+
+func (h *Handlers) GetProfileInfo(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+ var res resource.Result
+ var defaultValue string
+ sessionId, ok := ctx.Value("SessionId").(string)
+ if !ok {
+ return res, fmt.Errorf("missing session")
+ }
+ language, ok := ctx.Value("Language").(lang.Language)
+ if !ok {
+ return res, fmt.Errorf("value for 'Language' is not of type lang.Language")
+ }
+ code := language.Code
+ if code == "swa" {
+ defaultValue = "Haipo"
+ } else {
+ defaultValue = "Not Provided"
+ }
+
+ // Helper function to handle nil byte slices and convert them to string
+ getEntryOrDefault := func(entry []byte, err error) string {
+ if err != nil || entry == nil {
+ return defaultValue
+ }
+ return string(entry)
+ }
+ store := h.userdataStore
+ // Retrieve user data as strings with fallback to defaultValue
+ firstName := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_FIRST_NAME))
+ familyName := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_FAMILY_NAME))
+ yob := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_YOB))
+ gender := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_GENDER))
+ location := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_LOCATION))
+ offerings := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_OFFERINGS))
+
+ // Construct the full name
+ name := defaultValue
+ if familyName != defaultValue {
+ if firstName == defaultValue {
+ name = familyName
+ } else {
+ name = firstName + " " + familyName
+ }
+ }
+
+ // Calculate age from year of birth
+ age := defaultValue
+ if yob != defaultValue {
+ if yobInt, err := strconv.Atoi(yob); err == nil {
+ age = strconv.Itoa(utils.CalculateAgeWithYOB(yobInt))
+ } else {
+ return res, fmt.Errorf("invalid year of birth: %v", err)
+ }
+ }
+ switch language.Code {
+ case "eng":
+ res.Content = fmt.Sprintf(
+ "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
+ name, gender, age, location, offerings,
+ )
+ case "swa":
+ res.Content = fmt.Sprintf(
+ "Jina: %s\nJinsia: %s\nUmri: %s\nEneo: %s\nUnauza: %s\n",
+ name, gender, age, location, offerings,
+ )
+ default:
+ res.Content = fmt.Sprintf(
+ "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
+ name, gender, age, location, offerings,
+ )
+ }
+
+ return res, nil
+}
+
+
+
package http
+
+import (
+ "io"
+ "net/http"
+
+ "git.grassecon.net/urdt/ussd/internal/handlers"
+)
+
+type ATSessionHandler struct {
+ *SessionHandler
+}
+
+func NewATSessionHandler(h handlers.RequestHandler) *ATSessionHandler {
+ return &ATSessionHandler{
+ SessionHandler: 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)
+ 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
+}
+
+
package http
+
+import (
+ "io/ioutil"
+ "net/http"
+ "strconv"
+
+ "git.defalsify.org/vise.git/logging"
+
+ "git.grassecon.net/urdt/ussd/internal/handlers"
+)
+
+var (
+ logg = logging.NewVanilla().WithDomain("httpserver")
+)
+
+type DefaultRequestParser struct {
+}
+
+
+func(rp *DefaultRequestParser) GetSessionId(rq any) (string, error) {
+ rqv, ok := rq.(*http.Request)
+ if !ok {
+ return "", handlers.ErrInvalidRequest
+ }
+ v := rqv.Header.Get("X-Vise-Session")
+ if v == "" {
+ return "", handlers.ErrSessionMissing
+ }
+ return v, nil
+}
+
+func(rp *DefaultRequestParser) GetInput(rq any) ([]byte, error) {
+ rqv, ok := rq.(*http.Request)
+ if !ok {
+ return nil, handlers.ErrInvalidRequest
+ }
+ defer rqv.Body.Close()
+ v, err := ioutil.ReadAll(rqv.Body)
+ if err != nil {
+ return nil, err
+ }
+ return v, nil
+}
+
+type SessionHandler struct {
+ handlers.RequestHandler
+}
+
+func ToSessionHandler(h handlers.RequestHandler) *SessionHandler {
+ return &SessionHandler{
+ RequestHandler: h,
+ }
+}
+
+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{})
+ if err != nil {
+ logg.Errorf("error writing error!!", "err", err, "olderr", s)
+ w.WriteHeader(500)
+ }
+ return
+}
+
+func(f *SessionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ var code int
+ var err error
+ var perr error
+
+ rqs := handlers.RequestSession{
+ Ctx: req.Context(),
+ Writer: w,
+ }
+
+ rp := f.GetRequestParser()
+ cfg := f.GetConfig()
+ cfg.SessionId, err = rp.GetSessionId(req)
+ if err != nil {
+ logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
+ f.writeError(w, 400, err)
+ }
+ rqs.Config = cfg
+ rqs.Input, err = rp.GetInput(req)
+ if err != nil {
+ logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
+ f.writeError(w, 400, err)
+ return
+ }
+
+ rqs, err = f.Process(rqs)
+ switch err {
+ case handlers.ErrStorage:
+ code = 500
+ case handlers.ErrEngineInit:
+ code = 500
+ case handlers.ErrEngineExec:
+ code = 500
+ default:
+ code = 200
+ }
+
+ if code != 200 {
+ f.writeError(w, 500, err)
+ return
+ }
+
+ w.WriteHeader(200)
+ w.Header().Set("Content-Type", "text/plain")
+ rqs, err = f.Output(rqs)
+ rqs, perr = f.Reset(rqs)
+ if err != nil {
+ f.writeError(w, 500, err)
+ return
+ }
+ if perr != nil {
+ f.writeError(w, 500, perr)
+ return
+ }
+}
+
+
+
package mocks
+
+import (
+ "context"
+
+ "git.defalsify.org/vise.git/lang"
+ "github.com/stretchr/testify/mock"
+)
+
+type MockDb struct {
+ mock.Mock
+}
+
+func (m *MockDb) SetPrefix(prefix uint8) {
+ m.Called(prefix)
+}
+
+func (m *MockDb) Prefix() uint8 {
+ args := m.Called()
+ return args.Get(0).(uint8)
+}
+
+func (m *MockDb) Safe() bool {
+ args := m.Called()
+ return args.Get(0).(bool)
+}
+
+func (m *MockDb) SetLanguage(language *lang.Language) {
+ m.Called(language)
+}
+
+func (m *MockDb) SetLock(uint8, bool) error {
+ args := m.Called()
+ return args.Error(0)
+}
+
+func (m *MockDb) Connect(ctx context.Context, connectionStr string) error {
+ args := m.Called(ctx, connectionStr)
+ return args.Error(0)
+}
+
+func (m *MockDb) SetSession(sessionId string) {
+ m.Called(sessionId)
+}
+
+func (m *MockDb) Put(ctx context.Context, key, value []byte) error {
+ args := m.Called(ctx, key, value)
+ return args.Error(0)
+}
+
+func (m *MockDb) Get(ctx context.Context, key []byte) ([]byte, error) {
+ args := m.Called(ctx, key)
+ return nil, args.Error(0)
+}
+
+func (m *MockDb) Close() error {
+ args := m.Called(nil)
+ return args.Error(0)
+}
+
+
+
package httpmocks
+
+import (
+ "context"
+ "io"
+)
+
+// MockEngine implements the engine.Engine interface for testing
+type MockEngine struct {
+ InitFunc func(context.Context) (bool, error)
+ ExecFunc func(context.Context, []byte) (bool, error)
+ FlushFunc func(context.Context, io.Writer) (int, error)
+ FinishFunc func() error
+}
+
+func (m *MockEngine) Init(ctx context.Context) (bool, error) {
+ return m.InitFunc(ctx)
+}
+
+func (m *MockEngine) Exec(ctx context.Context, input []byte) (bool, error) {
+ return m.ExecFunc(ctx, input)
+}
+
+func (m *MockEngine) Flush(ctx context.Context, w io.Writer) (int, error) {
+ return m.FlushFunc(ctx, w)
+}
+
+func (m *MockEngine) Finish() error {
+ return m.FinishFunc()
+}
+
+
+
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()
+}
+
+
+
package httpmocks
+
+// MockRequestParser implements the handlers.RequestParser interface for testing
+type MockRequestParser struct {
+ GetSessionIdFunc func(any) (string, error)
+ GetInputFunc func(any) ([]byte, error)
+}
+
+func (m *MockRequestParser) GetSessionId(rq any) (string, error) {
+ return m.GetSessionIdFunc(rq)
+}
+
+func (m *MockRequestParser) GetInput(rq any) ([]byte, error) {
+ return m.GetInputFunc(rq)
+}
+
+
+
package httpmocks
+
+import "net/http"
+
+// MockWriter implements a mock io.Writer for testing
+type MockWriter struct {
+ WriteStringCalled bool
+ WrittenString string
+}
+
+func (m *MockWriter) Write(p []byte) (n int, err error) {
+ return len(p), nil
+}
+
+func (m *MockWriter) WriteString(s string) (n int, err error) {
+ m.WriteStringCalled = true
+ m.WrittenString = s
+ return len(s), nil
+}
+
+func (m *MockWriter) Header() http.Header {
+ return http.Header{}
+}
+
+func (m *MockWriter) WriteHeader(statusCode int) {}
+
+
package mocks
+
+import (
+ "git.grassecon.net/urdt/ussd/internal/models"
+ "github.com/stretchr/testify/mock"
+)
+
+// MockAccountService implements AccountServiceInterface for testing
+type MockAccountService struct {
+ mock.Mock
+}
+
+func (m *MockAccountService) CreateAccount() (*models.AccountResponse, error) {
+ args := m.Called()
+ return args.Get(0).(*models.AccountResponse), args.Error(1)
+}
+
+func (m *MockAccountService) CheckBalance(publicKey string) (*models.BalanceResponse, error) {
+ args := m.Called(publicKey)
+ return args.Get(0).(*models.BalanceResponse), args.Error(1)
+}
+
+func (m *MockAccountService) CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error) {
+ args := m.Called(trackingId)
+ return args.Get(0).(*models.TrackStatusResponse), args.Error(1)
+}
+
+
package mocks
+
+import (
+ "context"
+
+ "git.defalsify.org/vise.git/db"
+ "git.grassecon.net/urdt/ussd/internal/utils"
+ "github.com/stretchr/testify/mock"
+)
+
+type MockUserDataStore struct {
+ db.Db
+ mock.Mock
+}
+
+func (m *MockUserDataStore) ReadEntry(ctx context.Context, sessionId string, typ utils.DataTyp) ([]byte, error) {
+ args := m.Called(ctx, sessionId, typ)
+ return args.Get(0).([]byte), args.Error(1)
+}
+
+func (m *MockUserDataStore) WriteEntry(ctx context.Context, sessionId string, typ utils.DataTyp, value []byte) error {
+ args := m.Called(ctx, sessionId, typ, value)
+ return args.Error(0)
+}
+
+
+
package storage
+
+import (
+ "context"
+
+ "git.defalsify.org/vise.git/db"
+ "git.defalsify.org/vise.git/lang"
+ gdbmdb "git.defalsify.org/vise.git/db/gdbm"
+)
+
+var (
+ dbC map[string]chan db.Db
+)
+
+type ThreadGdbmDb struct {
+ db db.Db
+ connStr string
+}
+
+func NewThreadGdbmDb() *ThreadGdbmDb {
+ if dbC == nil {
+ dbC = make(map[string]chan db.Db)
+ }
+ return &ThreadGdbmDb{}
+}
+
+func(tdb *ThreadGdbmDb) Connect(ctx context.Context, connStr string) error {
+ var ok bool
+ _, ok = dbC[connStr]
+ if ok {
+ logg.WarnCtxf(ctx, "already registered thread gdbm, skipping", "connStr", connStr)
+ return nil
+ }
+ gdb := gdbmdb.NewGdbmDb()
+ err := gdb.Connect(ctx, connStr)
+ if err != nil {
+ return err
+ }
+ dbC[connStr] = make(chan db.Db, 1)
+ dbC[connStr]<- gdb
+ tdb.connStr = connStr
+ return nil
+}
+
+func(tdb *ThreadGdbmDb) reserve() {
+ if tdb.db == nil {
+ tdb.db = <-dbC[tdb.connStr]
+ }
+}
+
+func(tdb *ThreadGdbmDb) release() {
+ if tdb.db == nil {
+ return
+ }
+ dbC[tdb.connStr] <- tdb.db
+ tdb.db = nil
+}
+
+func(tdb *ThreadGdbmDb) SetPrefix(pfx uint8) {
+ tdb.reserve()
+ tdb.db.SetPrefix(pfx)
+}
+
+func(tdb *ThreadGdbmDb) SetSession(sessionId string) {
+ tdb.reserve()
+ tdb.db.SetSession(sessionId)
+}
+
+func(tdb *ThreadGdbmDb) SetLanguage(lng *lang.Language) {
+ tdb.reserve()
+ tdb.db.SetLanguage(lng)
+}
+
+func(tdb *ThreadGdbmDb) Safe() bool {
+ tdb.reserve()
+ v := tdb.db.Safe()
+ tdb.release()
+ return v
+}
+
+func(tdb *ThreadGdbmDb) Prefix() uint8 {
+ tdb.reserve()
+ v := tdb.db.Prefix()
+ tdb.release()
+ return v
+}
+
+func(tdb *ThreadGdbmDb) SetLock(typ uint8, locked bool) error {
+ tdb.reserve()
+ err := tdb.db.SetLock(typ, locked)
+ tdb.release()
+ return err
+}
+
+func(tdb *ThreadGdbmDb) Put(ctx context.Context, key []byte, val []byte) error {
+ tdb.reserve()
+ err := tdb.db.Put(ctx, key, val)
+ tdb.release()
+ return err
+}
+
+func(tdb *ThreadGdbmDb) Get(ctx context.Context, key []byte) ([]byte, error) {
+ tdb.reserve()
+ v, err := tdb.db.Get(ctx, key)
+ tdb.release()
+ return v, err
+}
+
+func(tdb *ThreadGdbmDb) Close() error {
+ tdb.reserve()
+ close(dbC[tdb.connStr])
+ err := tdb.db.Close()
+ tdb.db = nil
+ return err
+}
+
+
+
package storage
+
+import (
+ "git.defalsify.org/vise.git/db"
+ "git.defalsify.org/vise.git/persist"
+)
+
+const (
+ DATATYPE_CUSTOM = 128
+)
+
+type Storage struct {
+ Persister *persist.Persister
+ UserdataDb db.Db
+}
+
+type StorageProvider interface {
+ Get(sessionId string) (*Storage, error)
+ Put(sessionId string, storage *Storage) error
+ Close() error
+}
+
+type SimpleStorageProvider struct {
+ *Storage
+}
+
+func NewSimpleStorageProvider(stateStore db.Db, userdataStore db.Db) StorageProvider {
+ pe := persist.NewPersister(stateStore)
+ pe = pe.WithFlush()
+ return &SimpleStorageProvider{
+ Storage: &Storage{
+ Persister: pe,
+ UserdataDb: userdataStore,
+ },
+ }
+}
+
+func (p *SimpleStorageProvider) Get(sessionId string) (*Storage, error) {
+ return p.Storage, nil
+}
+
+func (p *SimpleStorageProvider) Put(sessionId string, storage *Storage) error {
+ return nil
+}
+
+func (p *SimpleStorageProvider) Close() error {
+ return p.Storage.UserdataDb.Close()
+}
+
+
+
package storage
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "path"
+
+ "git.defalsify.org/vise.git/db"
+ fsdb "git.defalsify.org/vise.git/db/fs"
+ "git.defalsify.org/vise.git/persist"
+ "git.defalsify.org/vise.git/resource"
+ "git.defalsify.org/vise.git/logging"
+)
+
+var (
+ logg = logging.NewVanilla().WithDomain("storage")
+)
+
+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{
+ dbDir string
+ resourceDir string
+ resourceStore db.Db
+ stateStore db.Db
+ userDataStore db.Db
+}
+
+func NewMenuStorageService(dbDir string, resourceDir string) *MenuStorageService {
+ return &MenuStorageService{
+ dbDir: dbDir,
+ resourceDir: resourceDir,
+ }
+}
+
+func (ms *MenuStorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
+ ms.stateStore = NewThreadGdbmDb()
+ storeFile := path.Join(ms.dbDir, "state.gdbm")
+ err := ms.stateStore.Connect(ctx, storeFile)
+ if err != nil {
+ return nil, err
+ }
+ pr := persist.NewPersister(ms.stateStore)
+ logg.TraceCtxf(ctx, "menu storage service", "persist", pr, "store", ms.stateStore)
+ return pr, nil
+}
+
+func (ms *MenuStorageService) GetUserdataDb(ctx context.Context) (db.Db, error) {
+ ms.userDataStore = NewThreadGdbmDb()
+ storeFile := path.Join(ms.dbDir, "userdata.gdbm")
+ err := ms.userDataStore.Connect(ctx, storeFile)
+ if err != nil {
+ return nil, err
+ }
+ return ms.userDataStore, nil
+}
+
+func (ms *MenuStorageService) GetResource(ctx context.Context) (resource.Resource, error) {
+ ms.resourceStore = fsdb.NewFsDb()
+ err := ms.resourceStore.Connect(ctx, ms.resourceDir)
+ if err != nil {
+ return nil, err
+ }
+ rfs := resource.NewDbResource(ms.resourceStore)
+ return rfs, nil
+}
+
+func (ms *MenuStorageService) GetStateStore(ctx context.Context) (db.Db, error) {
+ if ms.stateStore != nil {
+ panic("set up store when already exists")
+ }
+ ms.stateStore = NewThreadGdbmDb()
+ storeFile := path.Join(ms.dbDir, "state.gdbm")
+ err := ms.stateStore.Connect(ctx, storeFile)
+ if err != nil {
+ return nil, err
+ }
+ return ms.stateStore, nil
+}
+
+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)
+ }
+ return nil
+}
+
+func (ms *MenuStorageService) Close() error {
+ errA := ms.stateStore.Close()
+ errB := ms.userDataStore.Close()
+ errC := ms.resourceStore.Close()
+ if errA != nil || errB != nil || errC != nil {
+ return fmt.Errorf("%v %v %v", errA, errB, errC)
+ }
+ return nil
+}
+
+
+
package utils
+
+import "time"
+
+// CalculateAge calculates the age based on a given birthdate and the current date in the format dd/mm/yy
+// It adjusts for cases where the current date is before the birthday in the current year.
+func CalculateAge(birthdate, today time.Time) int {
+ today = today.In(birthdate.Location())
+ ty, tm, td := today.Date()
+ today = time.Date(ty, tm, td, 0, 0, 0, 0, time.UTC)
+ by, bm, bd := birthdate.Date()
+ birthdate = time.Date(by, bm, bd, 0, 0, 0, 0, time.UTC)
+ if today.Before(birthdate) {
+ return 0
+ }
+ age := ty - by
+ anniversary := birthdate.AddDate(age, 0, 0)
+ if anniversary.After(today) {
+ age--
+ }
+ return age
+}
+
+// CalculateAgeWithYOB calculates the age based on the given year of birth (YOB).
+// It subtracts the YOB from the current year to determine the age.
+//
+// Parameters:
+// yob: The year of birth as an integer.
+//
+// Returns:
+// The calculated age as an integer.
+func CalculateAgeWithYOB(yob int) int {
+ currentYear := time.Now().Year()
+ return currentYear - yob
+}
+
+
package utils
+
+import (
+ "encoding/binary"
+)
+
+type DataTyp uint16
+
+const (
+ DATA_ACCOUNT DataTyp = iota
+ DATA_ACCOUNT_CREATED
+ DATA_TRACKING_ID
+ DATA_PUBLIC_KEY
+ DATA_CUSTODIAL_ID
+ DATA_ACCOUNT_PIN
+ DATA_ACCOUNT_STATUS
+ DATA_FIRST_NAME
+ DATA_FAMILY_NAME
+ DATA_YOB
+ DATA_LOCATION
+ DATA_GENDER
+ DATA_OFFERINGS
+ DATA_RECIPIENT
+ DATA_AMOUNT
+ DATA_TEMPORARY_PIN
+)
+
+func typToBytes(typ DataTyp) []byte {
+ var b [2]byte
+ binary.BigEndian.PutUint16(b[:], uint16(typ))
+ return b[:]
+}
+
+func PackKey(typ DataTyp, data []byte) []byte {
+ v := typToBytes(typ)
+ return append(v, data...)
+}
+
+
+
package utils
+
+var isoCodes = map[string]bool{
+ "eng": true, // English
+ "swa": true, // Swahili
+
+}
+
+func IsValidISO639(code string) bool {
+ return isoCodes[code]
+}
+
+
+
package utils
+
+import (
+ "context"
+
+ "git.defalsify.org/vise.git/db"
+)
+
+type DataStore interface {
+ db.Db
+ ReadEntry(ctx context.Context, sessionId string, typ DataTyp) ([]byte, error)
+ WriteEntry(ctx context.Context, sessionId string, typ DataTyp, value []byte) error
+}
+
+type UserDataStore struct {
+ db.Db
+}
+
+// ReadEntry retrieves an entry from the store based on the provided parameters.
+func (store *UserDataStore) ReadEntry(ctx context.Context, sessionId string, typ DataTyp) ([]byte, error) {
+ store.SetPrefix(db.DATATYPE_USERDATA)
+ store.SetSession(sessionId)
+ k := PackKey(typ, []byte(sessionId))
+ return store.Get(ctx, k)
+}
+
+func (store *UserDataStore) WriteEntry(ctx context.Context, sessionId string, typ DataTyp, value []byte) error {
+ store.SetPrefix(db.DATATYPE_USERDATA)
+ store.SetSession(sessionId)
+ k := PackKey(typ, []byte(sessionId))
+ return store.Put(ctx, k, value)
+}
+
+
+