-
-
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)
-}
-
-
-