diff --git a/cmd/main.go b/cmd/main.go index 3be8980..fc734d4 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -2,170 +2,184 @@ package main import ( "context" - "encoding/csv" "flag" "fmt" - "io" - "log" "os" "path" - "strconv" - "git.defalsify.org/vise.git/cache" + "git.defalsify.org/vise.git/asm" + "git.defalsify.org/vise.git/db" + fsdb "git.defalsify.org/vise.git/db/fs" + gdbmdb "git.defalsify.org/vise.git/db/gdbm" "git.defalsify.org/vise.git/engine" + "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/ussd" ) var ( + logg = logging.NewVanilla() scriptDir = path.Join("services", "registration") ) +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 +} + +func getHandler(appFlags *asm.FlagParser, rs *resource.DbResource, pe *persist.Persister, userdataStore db.Db) (*ussd.Handlers, error) { + + ussdHandlers, err := ussd.NewHandlers(appFlags, pe, userdataStore) + if err != nil { + return nil, err + } + rs.AddLocalFunc("select_language", ussdHandlers.SetLanguage) + rs.AddLocalFunc("create_account", ussdHandlers.CreateAccount) + rs.AddLocalFunc("save_pin", ussdHandlers.SavePin) + rs.AddLocalFunc("verify_pin", ussdHandlers.VerifyPin) + rs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier) + rs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus) + rs.AddLocalFunc("authorize_account", ussdHandlers.Authorize) + rs.AddLocalFunc("quit", ussdHandlers.Quit) + rs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance) + rs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient) + rs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset) + rs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount) + rs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount) + rs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount) + rs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient) + rs.AddLocalFunc("get_sender", ussdHandlers.GetSender) + rs.AddLocalFunc("get_amount", ussdHandlers.GetAmount) + rs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin) + rs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname) + rs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname) + rs.AddLocalFunc("save_gender", ussdHandlers.SaveGender) + rs.AddLocalFunc("save_location", ussdHandlers.SaveLocation) + rs.AddLocalFunc("save_yob", ussdHandlers.SaveYob) + rs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings) + rs.AddLocalFunc("quit_with_balance", ussdHandlers.QuitWithBalance) + rs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized) + rs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate) + rs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo) + rs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob) + rs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob) + rs.AddLocalFunc("set_reset_single_edit", ussdHandlers.SetResetSingleEdit) + rs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction) + + return ussdHandlers, nil +} + +func getPersister(dbDir string, ctx context.Context) (*persist.Persister, error) { + err := os.MkdirAll(dbDir, 0700) + if err != nil { + return nil, fmt.Errorf("state dir create exited with error: %v\n", err) + } + store := gdbmdb.NewGdbmDb() + storeFile := path.Join(dbDir, "state.gdbm") + store.Connect(ctx, storeFile) + pr := persist.NewPersister(store) + return pr, nil +} + +func getUserdataDb(dbDir string, ctx context.Context) db.Db { + store := gdbmdb.NewGdbmDb() + storeFile := path.Join(dbDir, "userdata.gdbm") + store.Connect(ctx, storeFile) + + return store +} + +func getResource(resourceDir string, ctx context.Context) (resource.Resource, error) { + store := fsdb.NewFsDb() + err := store.Connect(ctx, resourceDir) + if err != nil { + return nil, err + } + rfs := resource.NewDbResource(store) + return rfs, nil +} + +func getEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) *engine.DefaultEngine { + en := engine.NewEngine(cfg, rs) + en = en.WithPersister(pr) + return en +} + func main() { - var dir string - var root string + var dbDir string var size uint var sessionId string - flag.StringVar(&dir, "d", ".", "resource dir to read from") - flag.UintVar(&size, "s", 0, "max size of output") - flag.StringVar(&root, "root", "root", "entry point symbol") - flag.StringVar(&sessionId, "session-id", "default", "session id") + var debug bool + flag.StringVar(&sessionId, "session-id", "075xx2123", "session id") + flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from") + flag.BoolVar(&debug, "d", false, "use engine debug output") + flag.UintVar(&size, "s", 160, "max size of output") flag.Parse() - fmt.Fprintf(os.Stderr, "starting session at symbol '%s' using resource dir: %s\n", root, dir) + + logg.Infof("start command", "dbdir", dbDir, "outputsize", size) ctx := context.Background() - st := state.NewState(16) - st.UseDebug() - + ctx = context.WithValue(ctx, "SessionId", sessionId) pfp := path.Join(scriptDir, "pp.csv") - file, err := os.Open(pfp) + flagParser, err := getParser(pfp, true) + if err != nil { - fmt.Fprintf(os.Stderr, "Failed to open CSV file: %v\n", err) os.Exit(1) } - defer file.Close() - reader := csv.NewReader(file) - // Iterate through the CSV records and register the flags - for { - record, err := reader.Read() - if err != nil { - if err == io.EOF { - break - } - fmt.Fprintf(os.Stderr, "Error reading CSV file: %v\n", err) - os.Exit(1) - } - - // Ensure the record starts with "flag" and has at least 3 columns - if len(record) < 3 || record[0] != "flag" { - continue - } - - flagName := record[1] - flagValue, err := strconv.Atoi(record[2]) - if err != nil { - fmt.Fprintf(os.Stderr, "Failed to convert flag value %s to integer: %v\n", record[2], err) - continue - } - - // Register the flag - log.Printf("Registering flagName:%s; flagValue:%v", flagName, flagValue) - state.FlagDebugger.Register(uint32(flagValue), flagName) - } - - rfs := resource.NewFsResource(scriptDir) - ca := cache.NewCache() cfg := engine.Config{ - Root: "root", - SessionId: sessionId, + Root: "root", + SessionId: sessionId, + OutputSize: uint32(size), + FlagCount: uint32(16), } - dp := path.Join(scriptDir, ".state") - err = os.MkdirAll(dp, 0700) + rs, err := getResource(scriptDir, ctx) if err != nil { - fmt.Fprintf(os.Stderr, "state dir create exited with error: %v\n", err) + fmt.Fprintf(os.Stderr, err.Error()) os.Exit(1) } - pr := persist.NewFsPersister(dp) - en, err := engine.NewPersistedEngine(ctx, cfg, pr, rfs) + pr, err := getPersister(dbDir, ctx) if err != nil { - pr = pr.WithContent(&st, ca) - err = pr.Save(cfg.SessionId) - if err != nil { - fmt.Fprintf(os.Stderr, "Failed to save state with error: %v\n", err) - } - en, err = engine.NewPersistedEngine(ctx, cfg, pr, rfs) - if err != nil { - fmt.Fprintf(os.Stderr, "engine create exited with error: %v\n", err) - os.Exit(1) - } + fmt.Fprintf(os.Stderr, err.Error()) + os.Exit(1) } - fp := path.Join(dp, sessionId) - - ussdHandlers, err := ussd.NewHandlers(fp, &st, sessionId) - + store := getUserdataDb(dbDir, ctx) if err != nil { - fmt.Fprintf(os.Stderr, "handler setup failed with error: %v\n", err) + fmt.Fprintf(os.Stderr, err.Error()) + os.Exit(1) } - rfs.AddLocalFunc("select_language", ussdHandlers.SetLanguage) - rfs.AddLocalFunc("create_account", ussdHandlers.CreateAccount) - rfs.AddLocalFunc("save_pin", ussdHandlers.SavePin) - rfs.AddLocalFunc("verify_pin", ussdHandlers.VerifyPin) - rfs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier) - rfs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus) - rfs.AddLocalFunc("authorize_account", ussdHandlers.Authorize) - rfs.AddLocalFunc("quit", ussdHandlers.Quit) - rfs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance) - rfs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient) - rfs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset) - rfs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount) - rfs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount) - rfs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount) - rfs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient) - rfs.AddLocalFunc("get_sender", ussdHandlers.GetSender) - rfs.AddLocalFunc("get_amount", ussdHandlers.GetAmount) - rfs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin) - rfs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname) - rfs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname) - rfs.AddLocalFunc("save_gender", ussdHandlers.SaveGender) - rfs.AddLocalFunc("save_location", ussdHandlers.SaveLocation) - rfs.AddLocalFunc("save_yob", ussdHandlers.SaveYob) - rfs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings) - rfs.AddLocalFunc("quit_with_balance", ussdHandlers.QuitWithBalance) - rfs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized) - rfs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate) - rfs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo) - rfs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob) - rfs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob) - rfs.AddLocalFunc("set_reset_single_edit", ussdHandlers.SetResetSingleEdit) - rfs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction) + dbResource, ok := rs.(*resource.DbResource) + if !ok { + os.Exit(1) + } - cont, err := en.Init(ctx) - en.SetDebugger(engine.NewSimpleDebug(nil)) + hl, err := getHandler(flagParser, dbResource, pr, store) + if err != nil { + fmt.Fprintf(os.Stderr, err.Error()) + os.Exit(1) + } + + en := getEngine(cfg, rs, pr) + en = en.WithFirst(hl.Init) + if debug { + en = en.WithDebug(nil) + } + + _, err = en.Init(ctx) if err != nil { fmt.Fprintf(os.Stderr, "engine init exited with error: %v\n", err) os.Exit(1) } - if !cont { - _, err = en.WriteResult(ctx, os.Stdout) - if err != nil { - fmt.Fprintf(os.Stderr, "dead init write error: %v\n", err) - os.Exit(1) - } - err = en.Finish() - if err != nil { - fmt.Fprintf(os.Stderr, "engine finish error: %v\n", err) - os.Exit(1) - } - os.Stdout.Write([]byte{0x0a}) - os.Exit(0) - } + err = engine.Loop(ctx, en, os.Stdin, os.Stdout) if err != nil { fmt.Fprintf(os.Stderr, "loop exited with error: %v\n", err) diff --git a/go-vise b/go-vise deleted file mode 160000 index 1f47a67..0000000 --- a/go-vise +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 1f47a674d95380be8c387f410f0342eb72357df5 diff --git a/go.mod b/go.mod index de33912..e2aff05 100644 --- a/go.mod +++ b/go.mod @@ -2,4 +2,24 @@ module git.grassecon.net/urdt/ussd go 1.22.6 -require github.com/stretchr/testify v1.9.0 // indirect +require ( + github.com/alecthomas/participle/v2 v2.0.0 // indirect + github.com/alecthomas/repr v0.2.0 // indirect + github.com/barbashov/iso639-3 v0.0.0-20211020172741-1f4ffb2d8d1c // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/fxamacker/cbor/v2 v2.4.0 // indirect + github.com/graygnuorg/go-gdbm v0.0.0-20220711140707-71387d66dce4 // indirect + github.com/hexops/gotextdiff v1.0.3 // indirect + github.com/mattn/kinako v0.0.0-20170717041458-332c0a7e205a // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/testify v1.9.0 + github.com/x448/float16 v0.8.4 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) + +require ( + git.defalsify.org/vise.git v0.1.0-rc.1.0.20240906020635-400f69d01a89 + github.com/alecthomas/assert/v2 v2.2.2 + gopkg.in/leonelquinteros/gotext.v1 v1.3.1 +) diff --git a/go.sum b/go.sum index f203383..2624d07 100644 --- a/go.sum +++ b/go.sum @@ -1,2 +1,36 @@ +git.defalsify.org/vise.git v0.1.0-rc.1.0.20240906020635-400f69d01a89 h1:YyQODhMwSM5YD9yKHM5jCF0HC0RQtE3MkVXcTnOhXJo= +git.defalsify.org/vise.git v0.1.0-rc.1.0.20240906020635-400f69d01a89/go.mod h1:JDguWmcoWBdsnpw7PUjVZAEpdC/ubBmjdUBy3tjP63M= +github.com/alecthomas/assert/v2 v2.2.2 h1:Z/iVC0xZfWTaFNE6bA3z07T86hd45Xe2eLt6WVy2bbk= +github.com/alecthomas/assert/v2 v2.2.2/go.mod h1:pXcQ2Asjp247dahGEmsZ6ru0UVwnkhktn7S0bBDLxvQ= +github.com/alecthomas/participle/v2 v2.0.0 h1:Fgrq+MbuSsJwIkw3fEj9h75vDP0Er5JzepJ0/HNHv0g= +github.com/alecthomas/participle/v2 v2.0.0/go.mod h1:rAKZdJldHu8084ojcWevWAL8KmEU+AT+Olodb+WoN2Y= +github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk= +github.com/alecthomas/repr v0.2.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4= +github.com/barbashov/iso639-3 v0.0.0-20211020172741-1f4ffb2d8d1c h1:H9Nm+I7Cg/YVPpEV1RzU3Wq2pjamPc/UtHDgItcb7lE= +github.com/barbashov/iso639-3 v0.0.0-20211020172741-1f4ffb2d8d1c/go.mod h1:rGod7o6KPeJ+hyBpHfhi4v7blx9sf+QsHsA7KAsdN6U= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fxamacker/cbor/v2 v2.4.0 h1:ri0ArlOR+5XunOP8CRUowT0pSJOwhW098ZCUyskZD88= +github.com/fxamacker/cbor/v2 v2.4.0/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo= +github.com/graygnuorg/go-gdbm v0.0.0-20220711140707-71387d66dce4 h1:U4kkNYryi/qfbBF8gh7Vsbuz+cVmhf5kt6pE9bYYyLo= +github.com/graygnuorg/go-gdbm v0.0.0-20220711140707-71387d66dce4/go.mod h1:zpZDgZFzeq9s0MIeB1P50NIEWDFFHSFBohI/NbaTD/Y= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= +github.com/mattn/kinako v0.0.0-20170717041458-332c0a7e205a h1:0Q3H0YXzMHiciXtRcM+j0jiCe8WKPQHoRgQiRTnfcLY= +github.com/mattn/kinako v0.0.0-20170717041458-332c0a7e205a/go.mod h1:CdTTBOYzS5E4mWS1N8NWP6AHI19MP0A2B18n3hLzRMk= +github.com/peteole/testdata-loader v0.3.0 h1:8jckE9KcyNHgyv/VPoaljvKZE0Rqr8+dPVYH6rfNr9I= +github.com/peteole/testdata-loader v0.3.0/go.mod h1:Mt0ZbRtb56u8SLJpNP+BnQbENljMorYBpqlvt3cS83U= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/leonelquinteros/gotext.v1 v1.3.1 h1:8d9/fdTG0kn/B7NNGV1BsEyvektXFAbkMsTZS2sFSCc= +gopkg.in/leonelquinteros/gotext.v1 v1.3.1/go.mod h1:X1WlGDeAFIYsW6GjgMm4VwUwZ2XjI7Zan2InxSUQWrU= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/handlers/ussd/menuhandler.go b/internal/handlers/ussd/menuhandler.go index c47f2e0..3b441c2 100644 --- a/internal/handlers/ussd/menuhandler.go +++ b/internal/handlers/ussd/menuhandler.go @@ -3,7 +3,6 @@ package ussd import ( "bytes" "context" - "errors" "fmt" "path" "regexp" @@ -11,42 +10,25 @@ import ( "strings" "git.defalsify.org/vise.git/asm" - "git.defalsify.org/vise.git/engine" + + "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" - "github.com/graygnuorg/go-gdbm" "gopkg.in/leonelquinteros/gotext.v1" ) var ( + logg = logging.NewVanilla().WithDomain("ussdmenuhandler") scriptDir = path.Join("services", "registration") translationDir = path.Join(scriptDir, "locale") ) -const ( - TrackingIdKey = "TRACKINGID" - PublicKeyKey = "PUBLICKEY" - CustodialIdKey = "CUSTODIALID" - AccountPin = "ACCOUNTPIN" - AccountStatus = "ACCOUNTSTATUS" - FirstName = "FIRSTNAME" - FamilyName = "FAMILYNAME" - YearOfBirth = "YOB" - Location = "LOCATION" - Gender = "GENDER" - Offerings = "OFFERINGS" - Recipient = "RECIPIENT" - Amount = "AMOUNT" - AccountCreated = "ACCOUNTCREATED" -) - -func toBytes(s string) []byte { - return []byte(s) -} - type FSData struct { Path string St *state.State @@ -76,34 +58,31 @@ func (fm *FlagManager) GetFlag(label string) (uint32, error) { } type Handlers struct { - fs *FSData - db *gdbm.Database - flagManager *FlagManager - accountFileHandler utils.AccountFileHandlerInterface - accountService server.AccountServiceInterface + pe *persist.Persister + st *state.State + ca cache.Memory + userdataStore utils.DataStore + flagManager *asm.FlagParser + accountService server.AccountServiceInterface } -func NewHandlers(dir string, st *state.State, sessionId string) (*Handlers, error) { - filename := path.Join(scriptDir, sessionId+"_userdata.gdbm") - db, err := gdbm.Open(filename, gdbm.ModeWrcreat) - if err != nil { - panic(err) +func NewHandlers(parser *asm.FlagParser, pe *persist.Persister, userdataStore db.Db) (*Handlers, error) { + userDb := utils.UserDataStore{ + Db: userdataStore, } - pfp := path.Join(scriptDir, "pp.csv") - flagManager, err := NewFlagManager(pfp) - if err != nil { - return nil, fmt.Errorf("failed to create flag manager: %v", err) + if pe == nil { + return nil, fmt.Errorf("cannot create handler with nil persister") } - return &Handlers{ - db: db, - fs: &FSData{ - Path: dir, - St: st, - }, - flagManager: flagManager, - accountFileHandler: utils.NewAccountFileHandler(dir + "_data"), - accountService: &server.AccountService{}, - }, nil + if userdataStore == nil { + return nil, fmt.Errorf("cannot create handler with nil userdata store") + } + h := &Handlers{ + pe: pe, + userdataStore: &userDb, + flagManager: parser, + accountService: &server.AccountService{}, + } + return h, nil } // Define the regex pattern as a constant @@ -115,9 +94,30 @@ func isValidPIN(pin string) bool { return match } +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) { - res := resource.Result{} + var res resource.Result + var err error inputStr := string(input) switch inputStr { @@ -139,50 +139,60 @@ func (h *Handlers) SetLanguage(ctx context.Context, sym string, input []byte) (r 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) { - res := resource.Result{} - - _, err := h.db.Fetch([]byte(AccountCreated)) + 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 errors.Is(err, gdbm.ErrItemNotFound) { - accountResp, err := h.accountService.CreateAccount() + 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 { - flag_account_creation_failed, _ := h.flagManager.GetFlag("flag_account_creation_failed") - res.FlagSet = append(res.FlagSet, flag_account_creation_failed) return res, err } - data := map[string]string{ - TrackingIdKey: accountResp.Result.TrackingId, - PublicKeyKey: accountResp.Result.PublicKey, - CustodialIdKey: accountResp.Result.CustodialId.String(), - } - - for key, value := range data { - err := h.db.Store(toBytes(key), toBytes(value), true) - if err != nil { - return res, err - } - } - key := []byte(AccountCreated) - value := []byte("1") - h.db.Store(key, value, true) - flag_account_created, _ := h.flagManager.GetFlag("flag_account_created") - res.FlagSet = append(res.FlagSet, flag_account_created) - return res, err - } else { - return res, err } - } else { - return res, nil } + 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) { - res := resource.Result{} + 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") @@ -194,17 +204,18 @@ func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resou } res.FlagReset = append(res.FlagReset, flag_incorrect_pin) - - key := []byte(AccountPin) - value := []byte(accountPIN) - - h.db.Store(key, value, true) + store := h.userdataStore + err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(accountPIN)) + if err != nil { + return res, err + } return res, nil } // SetResetSingleEdit sets and resets flags to allow gradual editing of profile information. func (h *Handlers) SetResetSingleEdit(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} + var res resource.Result + menuOption := string(input) flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update") @@ -231,16 +242,24 @@ func (h *Handlers) SetResetSingleEdit(ctx context.Context, sym string, input []b // 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) { - res := resource.Result{} + 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") - AccountPin, err := h.db.Fetch([]byte(AccountPin)) + sessionId, ok := ctx.Value("SessionId").(string) + if !ok { + return res, fmt.Errorf("missing session") + } + + //AccountPin, _ := utils.ReadEntry(ctx, h.userdataStore, sessionId, utils.DATA_ACCOUNT_PIN) + 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} @@ -255,7 +274,6 @@ func (h *Handlers) VerifyPin(ctx context.Context, sym string, input []byte) (res // codeFromCtx retrieves language codes from the context that can be used for handling translations func codeFromCtx(ctx context.Context) string { var code string - engine.Logg.DebugCtxf(ctx, "in msg", "ctx", ctx, "val", code) if ctx.Value("Language") != nil { lang := ctx.Value("Language").(lang.Language) code = lang.Code @@ -263,63 +281,104 @@ func codeFromCtx(ctx context.Context) string { return code } -// SaveFirstname updates the first name in a JSON data file with the provided input. -func (h *Handlers) SaveFirstname(cxt context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} +// 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 { - name := string(input) - key := []byte(FirstName) - value := []byte(name) - h.db.Store(key, value, true) + 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 a JSON data file with the provided input. -func (h *Handlers) SaveFamilyname(cxt context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} +// 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 { - secondname := string(input) - key := []byte(FamilyName) - value := []byte(secondname) - h.db.Store(key, value, true) + familyName := string(input) + store := h.userdataStore + err = store.WriteEntry(ctx, sessionId, utils.DATA_FAMILY_NAME, []byte(familyName)) + if err != nil { + return res, err + } + if err != nil { + return res, nil + } + } 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 a JSON data file with the provided input. -func (h *Handlers) SaveYob(cxt context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - yob := string(input) - if len(yob) == 4 { +// 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) - key := []byte(YearOfBirth) - value := []byte(yob) - h.db.Store(key, value, true) + 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 a JSON data file with the provided input. -func (h *Handlers) SaveLocation(cxt context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} +// 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) - key := []byte(Location) - value := []byte(location) - - h.db.Store(key, value, true) + 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 a JSON data file with the provided input. +// 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) { - res := resource.Result{} + 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 { gender := string(input) switch gender { @@ -330,28 +389,40 @@ func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (re case "3": gender = "Unspecified" } - key := []byte(Gender) - value := []byte(gender) - h.db.Store(key, value, true) + 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 a JSON data file with the provided input. +// 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) { - res := resource.Result{} + 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) - key := []byte(Offerings) - value := []byte(offerings) - h.db.Store(key, value, true) + 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) { - res := resource.Result{} + var res resource.Result flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update") @@ -361,7 +432,7 @@ func (h *Handlers) ResetAllowUpdate(ctx context.Context, sym string, input []byt // 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) { - res := resource.Result{} + var res resource.Result flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized") @@ -371,29 +442,46 @@ func (h *Handlers) ResetAccountAuthorized(ctx context.Context, sym string, input // CheckIdentifier retrieves the PublicKey from the JSON data file. func (h *Handlers) CheckIdentifier(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) - if err != nil { - return res, err + 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) { - res := resource.Result{} + 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") - storedpin, err := h.db.Fetch([]byte(AccountPin)) + store := h.userdataStore + AccountPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN) + if err != nil { + return res, err + } + if err == nil { if len(input) == 4 { - if bytes.Equal(input, storedpin) { - if h.fs.St.MatchFlag(flag_account_authorized, false) { + 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 { @@ -406,17 +494,16 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res return res, nil } } - } else if errors.Is(err, gdbm.ErrItemNotFound) { - return res, err } else { - return res, err + 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) { - res := resource.Result{} + var res resource.Result flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin") @@ -427,31 +514,28 @@ func (h *Handlers) ResetIncorrectPin(ctx context.Context, sym string, input []by // 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) { - res := resource.Result{} + var res resource.Result flag_account_success, _ := h.flagManager.GetFlag("flag_account_success") flag_account_pending, _ := h.flagManager.GetFlag("flag_account_pending") - trackingId, err := h.db.Fetch([]byte(TrackingIdKey)) - + 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 } status, err := h.accountService.CheckAccountStatus(string(trackingId)) - if err != nil { fmt.Println("Error checking account status:", err) return res, err - } - err = h.db.Store(toBytes(AccountStatus), toBytes(status), true) - if err != nil { - return res, nil - } - - err = h.db.Store(toBytes(TrackingIdKey), toBytes(status), true) + err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_STATUS, []byte(status)) if err != nil { return res, nil } @@ -468,7 +552,7 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b // Quit displays the Thank you message and exits the menu func (h *Handlers) Quit(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} + var res resource.Result flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized") @@ -483,12 +567,13 @@ func (h *Handlers) Quit(ctx context.Context, sym string, input []byte) (resource // VerifyYob verifies the length of the given input func (h *Handlers) VerifyYob(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} + 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) + _, err = strconv.Atoi(date) if err != nil { // If conversion fails, input is not numeric res.FlagSet = append(res.FlagSet, flag_incorrect_date_format) @@ -506,7 +591,7 @@ func (h *Handlers) VerifyYob(ctx context.Context, sym string, input []byte) (res // 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) { - res := resource.Result{} + var res resource.Result flag_incorrect_date_format, _ := h.flagManager.GetFlag("flag_incorrect_date_format") @@ -517,9 +602,16 @@ func (h *Handlers) ResetIncorrectYob(ctx context.Context, sym string, input []by // 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) { - res := resource.Result{} - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) + 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, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY) if err != nil { return res, err } @@ -535,7 +627,14 @@ func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) ( // 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) { - res := resource.Result{} + 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") @@ -548,12 +647,11 @@ func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []by return res, nil } - - // accountData["Recipient"] = recipient - key := []byte(Recipient) - value := []byte(recipient) - - h.db.Store(key, value, true) + store := h.userdataStore + err = store.WriteEntry(ctx, sessionId, utils.DATA_RECIPIENT, []byte(recipient)) + if err != nil { + return res, nil + } } return res, nil @@ -562,18 +660,25 @@ func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []by // 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) { - res := resource.Result{} + 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") - - err := h.db.Delete([]byte(Amount)) - if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) { - return res, err + store := h.userdataStore + err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte("")) + if err != nil { + return res, nil } - err = h.db.Delete([]byte(Recipient)) - if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) { - return res, err + + 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) @@ -583,13 +688,19 @@ func (h *Handlers) TransactionReset(ctx context.Context, sym string, input []byt // ResetTransactionAmount resets the transaction amount and invalid flag func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} + 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") - - err := h.db.Delete([]byte(Amount)) - if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) { - return res, err + 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) @@ -600,11 +711,15 @@ func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input // 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) { - res := resource.Result{} - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) - if err != nil { - return res, err + 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) balance, err := h.accountService.CheckBalance(string(publicKey)) if err != nil { @@ -619,16 +734,19 @@ func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (res // 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) { - res := resource.Result{} + 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") - amountStr := string(input) - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) + publicKey, _ := utils.ReadEntry(ctx, h.userdataStore, sessionId, utils.DATA_PUBLIC_KEY) - if err != nil { - return res, err - } + amountStr := string(input) balanceStr, err := h.accountService.CheckBalance(string(publicKey)) @@ -670,10 +788,8 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte) } res.Content = fmt.Sprintf("%.3f", inputAmount) // Format to 3 decimal places - key := []byte(Amount) - value := []byte(res.Content) - h.db.Store(key, value, true) - + store := h.userdataStore + err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(amountStr)) if err != nil { return res, err } @@ -681,13 +797,16 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte) return res, nil } -// GetRecipient returns the transaction recipient from a JSON data file. +// GetRecipient returns the transaction recipient from the gdbm. func (h *Handlers) GetRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - recipient, err := h.db.Fetch([]byte(Recipient)) - if err != nil { - return res, err + 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) @@ -696,12 +815,16 @@ func (h *Handlers) GetRecipient(ctx context.Context, sym string, input []byte) ( // GetSender retrieves the public key from the Gdbm Db func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) - if err != nil { - return res, err + 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 @@ -709,11 +832,15 @@ func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (res // GetAmount retrieves the amount from teh Gdbm Db func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - amount, err := h.db.Fetch([]byte(Amount)) - if err != nil { - return res, err + 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 @@ -722,14 +849,21 @@ func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (res // 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) { - res := resource.Result{} + 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") - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) + + store := h.userdataStore + publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY) if err != nil { return res, err } @@ -743,27 +877,26 @@ func (h *Handlers) QuitWithBalance(ctx context.Context, sym string, input []byte } // InitiateTransaction returns a confirmation and resets the transaction data -// on the JSON file. +// on the gdbm store. func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} + 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) - publicKey, err := h.db.Fetch([]byte(PublicKeyKey)) - if err != nil { - return res, err - } - amount, err := h.db.Fetch([]byte(Amount)) - if err != nil { - return res, err - } - recipient, err := h.db.Fetch([]byte(Recipient)) - if err != nil { - return res, err - } + 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)) @@ -778,63 +911,56 @@ func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input [] // GetProfileInfo retrieves and formats the profile information of a user from a Gdbm backed storage. func (h *Handlers) GetProfileInfo(ctx context.Context, sym string, input []byte) (resource.Result, error) { - res := resource.Result{} - - // Define default values - defaultValue := "Not provided" - name := defaultValue - familyName := defaultValue - yob := defaultValue - gender := defaultValue - location := defaultValue - offerings := defaultValue - - // Fetch data using a map for better organization - dataKeys := map[string]*string{ - FirstName: &name, - FamilyName: &familyName, - YearOfBirth: &yob, - Location: &location, - Gender: &gender, - Offerings: &offerings, + var res resource.Result + sessionId, ok := ctx.Value("SessionId").(string) + if !ok { + return res, fmt.Errorf("missing session") } - // Iterate over keys and fetch values - //iter := h.db.Iterator() - next := h.db.Iterator() - //defer iter.Close() // Ensure the iterator is closed - for key, err := next(); err == nil; key, err = next() { - if valuePointer, ok := dataKeys[string(key)]; ok { - value, fetchErr := h.db.Fetch(key) - if fetchErr == nil { - *valuePointer = string(value) - } + // Default value when an entry is not found + 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 name == defaultValue { + if firstName == defaultValue { name = familyName } else { - name = name + " " + familyName + name = firstName + " " + familyName } } // Calculate age from year of birth - var age string + age := defaultValue if yob != defaultValue { - yobInt, err := strconv.Atoi(yob) - if err != nil { + 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) } - age = strconv.Itoa(utils.CalculateAgeWithYOB(yobInt)) - } else { - age = defaultValue } // Format the result - formattedData := fmt.Sprintf("Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n", name, gender, age, location, offerings) - res.Content = formattedData + res.Content = fmt.Sprintf( + "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n", + name, gender, age, location, offerings, + ) + return res, nil } diff --git a/internal/handlers/ussd/menuhandler_test.go b/internal/handlers/ussd/menuhandler_test.go index 5bcf7c1..0a6aedb 100644 --- a/internal/handlers/ussd/menuhandler_test.go +++ b/internal/handlers/ussd/menuhandler_test.go @@ -2,992 +2,319 @@ package ussd import ( "context" - "encoding/json" - "fmt" - "os" - "path/filepath" "testing" "git.defalsify.org/vise.git/resource" "git.grassecon.net/urdt/ussd/internal/handlers/ussd/mocks" - "git.grassecon.net/urdt/ussd/internal/models" "git.grassecon.net/urdt/ussd/internal/utils" "github.com/alecthomas/assert/v2" - "github.com/stretchr/testify/mock" ) -// MockAccountService implements AccountServiceInterface for testing -type MockAccountService struct { - mock.Mock -} +func TestSaveFirstname(t *testing.T) { + // Create a new instance of MockMyDataStore + mockStore := new(mocks.MockUserDataStore) -type MockFlagParser struct { - mock.Mock -} + // Define test data + sessionId := "session123" + firstName := "John" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) -func (m *MockFlagParser) GetFlag(key string) (uint32, error) { - args := m.Called(key) - return args.Get(0).(uint32), args.Error(1) -} + // Set up the expected behavior of the mock + mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_FIRST_NAME, []byte(firstName)).Return(nil) -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) (string, error) { - args := m.Called(publicKey) - return args.String(0), args.Error(1) -} - -func (m *MockAccountService) CheckAccountStatus(trackingId string) (string, error) { - args := m.Called(trackingId) - return args.String(0), args.Error(1) -} - -func TestCreateAccount(t *testing.T) { - // Setup - tempDir, err := os.MkdirTemp("", "test_create_account") - if err != nil { - t.Fatalf("Failed to create temp directory: %v", err) - } - defer os.RemoveAll(tempDir) // Clean up after the test run - - sessionID := "07xxxxxxxx" - - // Set up the data file path using the session ID - accountFilePath := filepath.Join(tempDir, sessionID+"_data") - - // Initialize account file handler - accountFileHandler := utils.NewAccountFileHandler(accountFilePath) - - // Create a mock account service - mockAccountService := &MockAccountService{} - mockAccountResponse := &models.AccountResponse{ - Ok: true, - Result: struct { - CustodialId json.Number `json:"custodialId"` - PublicKey string `json:"publicKey"` - TrackingId string `json:"trackingId"` - }{ - CustodialId: "test-custodial-id", - PublicKey: "test-public-key", - TrackingId: "test-tracking-id", - }, - } - - // Set up expectations for the mock account service - mockAccountService.On("CreateAccount").Return(mockAccountResponse, nil) - - mockParser := new(MockFlagParser) - - flag_account_created := uint32(1) - flag_account_creation_failed := uint32(2) - - mockParser.On("GetFlag", "flag_account_created").Return(flag_account_created, nil) - mockParser.On("GetFlag", "flag_account_creation_failed").Return(flag_account_creation_failed, nil) - - // Initialize Handlers with mock account service + // Create the Handlers instance with the mock store h := &Handlers{ - fs: &FSData{Path: accountFilePath}, - accountFileHandler: accountFileHandler, - accountService: mockAccountService, - parser: mockParser, + userdataStore: mockStore, } - tests := []struct { - name string - existingData map[string]string - expectedResult resource.Result - expectedData map[string]string - }{ - { - name: "New account creation", - existingData: nil, - expectedResult: resource.Result{ - FlagSet: []uint32{flag_account_created}, - }, - expectedData: map[string]string{ - "TrackingId": "test-tracking-id", - "PublicKey": "test-public-key", - "CustodialId": "test-custodial-id", - "Status": "PENDING", - "Gender": "Not provided", - "YOB": "Not provided", - "Location": "Not provided", - "Offerings": "Not provided", - "FirstName": "Not provided", - "FamilyName": "Not provided", - }, - }, - { - name: "Existing account", - existingData: map[string]string{ - "TrackingId": "test-tracking-id", - "PublicKey": "test-public-key", - "CustodialId": "test-custodial-id", - "Status": "PENDING", - "Gender": "Not provided", - "YOB": "Not provided", - "Location": "Not provided", - "Offerings": "Not provided", - "FirstName": "Not provided", - "FamilyName": "Not provided", - }, - expectedResult: resource.Result{}, - expectedData: map[string]string{ - "TrackingId": "test-tracking-id", - "PublicKey": "test-public-key", - "CustodialId": "test-custodial-id", - "Status": "PENDING", - "Gender": "Not provided", - "YOB": "Not provided", - "Location": "Not provided", - "Offerings": "Not provided", - "FirstName": "Not provided", - "FamilyName": "Not provided", - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the data file path using the session ID - accountFilePath := filepath.Join(tempDir, sessionID+"_data") - - // Setup existing data if any - if tt.existingData != nil { - data, _ := json.Marshal(tt.existingData) - err := os.WriteFile(accountFilePath, data, 0644) - if err != nil { - t.Fatalf("Failed to write existing data: %v", err) - } - } - - // Call the function - result, err := h.CreateAccount(context.Background(), "", nil) - - // Check for errors - if err != nil { - t.Fatalf("CreateAccount returned an error: %v", err) - } - - // Check the result - if len(result.FlagSet) != len(tt.expectedResult.FlagSet) { - t.Errorf("Expected %d flags, got %d", len(tt.expectedResult.FlagSet), len(result.FlagSet)) - } - for i, flag := range tt.expectedResult.FlagSet { - if result.FlagSet[i] != flag { - t.Errorf("Expected flag %d, got %d", flag, result.FlagSet[i]) - } - } - - // Check the stored data - data, err := os.ReadFile(accountFilePath) - if err != nil { - t.Fatalf("Failed to read account data file: %v", err) - } - - var storedData map[string]string - err = json.Unmarshal(data, &storedData) - if err != nil { - t.Fatalf("Failed to unmarshal stored data: %v", err) - } - - for key, expectedValue := range tt.expectedData { - if storedValue, ok := storedData[key]; !ok || storedValue != expectedValue { - t.Errorf("Expected %s to be %s, got %s", key, expectedValue, storedValue) - } - } - }) - } -} - -func TestCreateAccount_Success(t *testing.T) { - mockAccountFileHandler := new(mocks.MockAccountFileHandler) - mockCreateAccountService := new(mocks.MockAccountService) - - mockAccountFileHandler.On("EnsureFileExists").Return(nil) - - // Mock that no account data exists - mockAccountFileHandler.On("ReadAccountData").Return(nil, nil) - - // Define expected account response after api call - expectedAccountResp := &models.AccountResponse{ - Ok: true, - Result: struct { - CustodialId json.Number `json:"custodialId"` - PublicKey string `json:"publicKey"` - TrackingId string `json:"trackingId"` - }{ - CustodialId: "12", - PublicKey: "0x8E0XSCSVA", - TrackingId: "d95a7e83-196c-4fd0-866fSGAGA", - }, - } - mockCreateAccountService.On("CreateAccount").Return(expectedAccountResp, nil) - - // Mock WriteAccountData to not error - mockAccountFileHandler.On("WriteAccountData", mock.Anything).Return(nil) - - handlers := &Handlers{ - accountService: mockCreateAccountService, - } - - actualResponse, err := handlers.accountService.CreateAccount() + // Call the method + res, err := h.SaveFirstname(ctx, "save_firstname", []byte(firstName)) // Assert results assert.NoError(t, err) - assert.Equal(t, expectedAccountResp.Ok, true) - assert.Equal(t, expectedAccountResp, actualResponse) + assert.Equal(t, resource.Result{}, res) + + // Assert all expectations were met + mockStore.AssertExpectations(t) } -func TestSavePin(t *testing.T) { - // Setup - tempDir, err := os.MkdirTemp("", "test_save_pin") - if err != nil { - t.Fatalf("Failed to create temp directory: %v", err) - } - defer os.RemoveAll(tempDir) +func TestSaveFamilyname(t *testing.T) { + // Create a new instance of UserDataStore + mockStore := new(mocks.MockUserDataStore) - sessionID := "07xxxxxxxx" + // Define test data + sessionId := "session123" + familyName := "Doeee" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) - // Set up the data file path using the session ID - accountFilePath := filepath.Join(tempDir, sessionID+"_data") - initialAccountData := map[string]string{ - "TrackingId": "test-tracking-id", - "PublicKey": "test-public-key", - } - data, _ := json.Marshal(initialAccountData) - err = os.WriteFile(accountFilePath, data, 0644) - if err != nil { - t.Fatalf("Failed to write initial account data: %v", err) - } + // Set up the expected behavior of the mock + mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_FAMILY_NAME, []byte(familyName)).Return(nil) - // Create a new AccountFileHandler and set it in the Handlers struct - accountFileHandler := utils.NewAccountFileHandler(accountFilePath) - mockParser := new(MockFlagParser) - + // Create the Handlers instance with the mock store h := &Handlers{ - accountFileHandler: accountFileHandler, - parser: mockParser, + userdataStore: mockStore, } - flag_incorrect_pin := uint32(1) - mockParser.On("GetFlag", "flag_incorrect_pin").Return(flag_incorrect_pin, nil) + // Call the method + res, err := h.SaveFamilyname(ctx, "save_familyname", []byte(familyName)) - tests := []struct { - name string - input []byte - expectedFlags []uint32 - expectedData map[string]string - expectedErrors bool - }{ - { - name: "Valid PIN", - input: []byte("1234"), - expectedFlags: []uint32{}, - expectedData: map[string]string{ - "TrackingId": "test-tracking-id", - "PublicKey": "test-public-key", - "AccountPIN": "1234", - }, - }, - { - name: "Invalid PIN - non-numeric", - input: []byte("12ab"), - expectedFlags: []uint32{flag_incorrect_pin}, - expectedData: initialAccountData, // No changes expected - expectedErrors: false, - }, - { - name: "Invalid PIN - less than 4 digits", - input: []byte("123"), - expectedFlags: []uint32{flag_incorrect_pin}, - expectedData: initialAccountData, // No changes expected - expectedErrors: false, - }, - { - name: "Invalid PIN - more than 4 digits", - input: []byte("12345"), - expectedFlags: []uint32{flag_incorrect_pin}, - expectedData: initialAccountData, // No changes expected - expectedErrors: false, - }, + // Assert results + assert.NoError(t, err) + assert.Equal(t, resource.Result{}, res) + + // Assert all expectations were met + mockStore.AssertExpectations(t) +} + +func TestSaveYoB(t *testing.T) { + // Create a new instance of MockMyDataStore + mockStore := new(mocks.MockUserDataStore) + + // Define test data + sessionId := "session123" + yob := "1980" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + + // Set up the expected behavior of the mock + mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_YOB, []byte(yob)).Return(nil) + + // Create the Handlers instance with the mock store + h := &Handlers{ + userdataStore: mockStore, } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - err := accountFileHandler.EnsureFileExists() - if err != nil { - t.Fatalf("Failed to ensure account file exists: %v", err) - } + // Call the method + res, err := h.SaveYob(ctx, "save_yob", []byte(yob)) - result, err := h.SavePin(context.Background(), "", tt.input) - if err != nil && !tt.expectedErrors { - t.Fatalf("SavePin returned an unexpected error: %v", err) - } + // Assert results + assert.NoError(t, err) + assert.Equal(t, resource.Result{}, res) - if len(result.FlagSet) != len(tt.expectedFlags) { - t.Errorf("Expected %d flags, got %d", len(tt.expectedFlags), len(result.FlagSet)) - } - for i, flag := range tt.expectedFlags { - if result.FlagSet[i] != flag { - t.Errorf("Expected flag %d, got %d", flag, result.FlagSet[i]) - } - } - - data, err := os.ReadFile(accountFilePath) - if err != nil { - t.Fatalf("Failed to read account data file: %v", err) - } - - var storedData map[string]string - err = json.Unmarshal(data, &storedData) - if err != nil { - t.Fatalf("Failed to unmarshal stored data: %v", err) - } - - for key, expectedValue := range tt.expectedData { - if storedValue, ok := storedData[key]; !ok || storedValue != expectedValue { - t.Errorf("Expected %s to be %s, got %s", key, expectedValue, storedValue) - } - } - }) - } + // Assert all expectations were met + mockStore.AssertExpectations(t) } func TestSaveLocation(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) + // Create a new instance of MockMyDataStore + mockStore := new(mocks.MockUserDataStore) - // Define test cases - tests := []struct { - name string - input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Successful Save", - input: []byte("Mombasa"), - existingData: map[string]string{"Location": "Mombasa"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, - { - name: "Empty location input", - input: []byte{}, - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, + // Define test data + sessionId := "session123" + yob := "Kilifi" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + + // Set up the expected behavior of the mock + mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_LOCATION, []byte(yob)).Return(nil) + + // Create the Handlers instance with the mock store + h := &Handlers{ + userdataStore: mockStore, } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["Location"] == string(tt.input) - })).Return(tt.writeError) - } else if len(tt.input) == 0 { - // For empty input, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) - return - } + // Call the method + res, err := h.SaveLocation(ctx, "save_location", []byte(yob)) - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } + // Assert results + assert.NoError(t, err) + assert.Equal(t, resource.Result{}, res) - // Call Save Location - result, err := h.SaveLocation(context.Background(), "save_location", tt.input) - - if err != nil { - t.Fatalf("Failed to save location with error: %v", err) - } - - savedData, err := h.accountFileHandler.ReadAccountData() - if err == nil { - //Assert that the input provided is what was saved into the file - assert.Equal(t, string(tt.input), savedData["Location"]) - } - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } -} - -func TestSaveFirstname(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) - - // Define test cases - tests := []struct { - name string - input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Successful Save", - input: []byte("Joe"), - existingData: map[string]string{"Name": "Joe"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, - { - name: "Empty Input", - input: []byte{}, - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedError: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["FirstName"] == string(tt.input) - })).Return(tt.writeError) - } else if len(tt.input) == 0 { - // For empty input, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) - return - } - - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } - - // Call save location - result, err := h.SaveFirstname(context.Background(), "save_location", tt.input) - - if err != nil { - t.Fatalf("Failed to save first name with error: %v", err) - } - savedData, err := h.accountFileHandler.ReadAccountData() - if err == nil { - //Assert that the input provided is what was saved into the file - assert.Equal(t, string(tt.input), savedData["FirstName"]) - } - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } -} - -func TestSaveFamilyName(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) - - // Define test cases - tests := []struct { - name string - input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Successful Save", - input: []byte("Doe"), - existingData: map[string]string{"FamilyName": "Doe"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, - { - name: "Empty Input", - input: []byte{}, - existingData: map[string]string{"FamilyName": "Doe"}, - writeError: nil, - expectedError: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["FamilyName"] == string(tt.input) - })).Return(tt.writeError) - } else if len(tt.input) == 0 { - // For empty input, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) - return - } - - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } - - // Call save familyname - result, err := h.SaveFamilyname(context.Background(), "save_familyname", tt.input) - - if err != nil { - t.Fatalf("Failed to save family name with error: %v", err) - } - savedData, err := h.accountFileHandler.ReadAccountData() - if err == nil { - //Assert that the input provided is what was saved into the file - assert.Equal(t, string(tt.input), savedData["FamilyName"]) - } - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } -} - -func TestSaveYOB(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) - - // Define test cases - tests := []struct { - name string - input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Successful Save", - input: []byte("2006"), - existingData: map[string]string{"": ""}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, - { - name: "YOB less than 4 digits(invalid date entry)", - input: []byte{}, - existingData: map[string]string{"": ""}, - writeError: nil, - expectedError: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["YOB"] == string(tt.input) - })).Return(tt.writeError) - } else if len(tt.input) != 4 { - // For input whose input is not a valid yob, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) - return - } - - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } - - // Call save yob - result, err := h.SaveYob(context.Background(), "save_yob", tt.input) - - if err != nil { - t.Fatalf("Failed to save family name with error: %v", err) - } - savedData, err := h.accountFileHandler.ReadAccountData() - if err == nil { - //Assert that the input provided is what was saved into the file - assert.Equal(t, string(tt.input), savedData["YOB"]) - } - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } -} - -func TestSaveOfferings(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) - - // Define test cases - tests := []struct { - name string - input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Successful Save", - input: []byte("Bananas"), - existingData: map[string]string{"": ""}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, - }, - { - name: "Empty input", - input: []byte{}, - existingData: map[string]string{"": ""}, - writeError: nil, - expectedError: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["Offerings"] == string(tt.input) - })).Return(tt.writeError) - } else if len(tt.input) != 4 { - // For input whose input is not a valid yob, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) - return - } - - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } - - // Call save yob - result, err := h.SaveOfferings(context.Background(), "save_offerings", tt.input) - - if err != nil { - t.Fatalf("Failed to save offerings with error: %v", err) - } - savedData, err := h.accountFileHandler.ReadAccountData() - if err == nil { - //Assert that the input provided is what was saved into the file - assert.Equal(t, string(tt.input), savedData["Offerings"]) - } - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } + // Assert all expectations were met + mockStore.AssertExpectations(t) } func TestSaveGender(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) + // Create a new instance of MockMyDataStore + mockStore := new(mocks.MockUserDataStore) + + // Define the session ID and context + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) // Define test cases tests := []struct { name string input []byte - existingData map[string]string - writeError error - expectedResult resource.Result - expectedError error expectedGender string + expectCall bool }{ { - name: "Successful Save - Male", + name: "Valid Male Input", input: []byte("1"), - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, expectedGender: "Male", + expectCall: true, }, { - name: "Successful Save - Female", + name: "Valid Female Input", input: []byte("2"), - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, expectedGender: "Female", + expectCall: true, }, { - name: "Successful Save - Unspecified", + name: "Valid Unspecified Input", input: []byte("3"), - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, expectedGender: "Unspecified", + expectCall: true, }, - { name: "Empty Input", - input: []byte{}, - existingData: map[string]string{"OtherKey": "OtherValue"}, - writeError: nil, - expectedResult: resource.Result{}, - expectedError: nil, + input: []byte(""), expectedGender: "", + expectCall: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.existingData, tt.expectedError) - if tt.expectedError == nil && len(tt.input) > 0 { - mockFileHandler.On("WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["Gender"] == tt.expectedGender - })).Return(tt.writeError) - } else if len(tt.input) == 0 { - // For empty input, no WriteAccountData call should be made - mockFileHandler.On("WriteAccountData", mock.Anything).Maybe().Return(tt.writeError) + // Set up expectations for the mock database + if tt.expectCall { + expectedKey := utils.DATA_GENDER + mockStore.On("WriteEntry", ctx, sessionId, expectedKey, []byte(tt.expectedGender)).Return(nil) + } else { + mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_GENDER, []byte(tt.expectedGender)).Return(nil) } - // Create the Handlers instance with the mock file handler + // Create the Handlers instance with the mock store h := &Handlers{ - accountFileHandler: mockFileHandler, + userdataStore: mockStore, } // Call the method - result, err := h.SaveGender(context.Background(), "save_gender", tt.input) + _, err := h.SaveGender(ctx, "someSym", tt.input) - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) + // Assert no error + assert.NoError(t, err) - // Verify WriteAccountData was called with the expected data - if len(tt.input) > 0 && tt.expectedError == nil { - mockFileHandler.AssertCalled(t, "WriteAccountData", mock.MatchedBy(func(data map[string]string) bool { - return data["Gender"] == tt.expectedGender - })) + // Verify expectations + if tt.expectCall { + mockStore.AssertCalled(t, "WriteEntry", ctx, sessionId, utils.DATA_GENDER, []byte(tt.expectedGender)) + } else { + mockStore.AssertNotCalled(t, "WriteEntry", ctx, sessionId, utils.DATA_GENDER, []byte(tt.expectedGender)) } - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) }) } } +func TestCheckIdentifier(t *testing.T) { + // Create a new instance of MockMyDataStore + mockStore := new(mocks.MockUserDataStore) + + // Define the session ID and context + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + + // Define test cases + tests := []struct { + name string + mockPublicKey []byte + mockErr error + expectedContent string + expectError bool + }{ + { + name: "Saved public Key", + mockPublicKey: []byte("0xa8363"), + mockErr: nil, + expectedContent: "0xa8363", + expectError: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Set up expectations for the mock database + mockStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return(tt.mockPublicKey, tt.mockErr) + + // Create the Handlers instance with the mock store + h := &Handlers{ + userdataStore: mockStore, + } + + // Call the method + res, err := h.CheckIdentifier(ctx, "check_identifier", nil) + + // Assert results + + assert.NoError(t, err) + assert.Equal(t, tt.expectedContent, res.Content) + + // Verify expectations + mockStore.AssertExpectations(t) + }) + } +} + +func TestMaxAmount(t *testing.T) { + mockStore := new(mocks.MockUserDataStore) + mockCreateAccountService := new(mocks.MockAccountService) + + // Define test data + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + publicKey := "0xcasgatweksalw1018221" + expectedBalance := "0.003CELO" + + // Set up the expected behavior of the mock + mockStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return([]byte(publicKey), nil) + mockCreateAccountService.On("CheckBalance", publicKey).Return(expectedBalance, nil) + + // Create the Handlers instance with the mock store + h := &Handlers{ + userdataStore: mockStore, + accountService: mockCreateAccountService, + } + + // Call the method + res, _ := h.MaxAmount(ctx, "max_amount", []byte("check_balance")) + + //Assert that the balance that was set as the result content is what was returned by Check Balance + assert.Equal(t, expectedBalance, res.Content) + +} + func TestGetSender(t *testing.T) { - mockAccountFileHandler := new(mocks.MockAccountFileHandler) + mockStore := new(mocks.MockUserDataStore) + + // Define test data + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + publicKey := "0xcasgatweksalw1018221" + + // Set up the expected behavior of the mock + mockStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return([]byte(publicKey), nil) + + // Create the Handlers instance with the mock store h := &Handlers{ - accountFileHandler: mockAccountFileHandler, + userdataStore: mockStore, } - tests := []struct { - name string - expectedResult resource.Result - accountData map[string]string - }{ - { - name: "Valid public key", - expectedResult: resource.Result{ - Content: "test-public-key", - }, - accountData: map[string]string{ - "PublicKey": "test-public-key", - }, - }, - { - name: "Missing public key", - expectedResult: resource.Result{ - Content: "", - }, - accountData: map[string]string{}, - }, - } + // Call the method + res, _ := h.GetSender(ctx, "max_amount", []byte("check_balance")) - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Reset the mock state - mockAccountFileHandler.Mock = mock.Mock{} + //Assert that the public key from readentry operation is what was set as the result content. + assert.Equal(t, publicKey, res.Content) - mockAccountFileHandler.On("ReadAccountData").Return(tt.accountData, nil) - - result, err := h.GetSender(context.Background(), "", nil) - - if err != nil { - t.Fatalf("Error occurred: %v", err) - } - - assert.Equal(t, tt.expectedResult.Content, result.Content) - mockAccountFileHandler.AssertCalled(t, "ReadAccountData") - }) - } } func TestGetAmount(t *testing.T) { - mockAccountFileHandler := new(mocks.MockAccountFileHandler) + mockStore := new(mocks.MockUserDataStore) + + // Define test data + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + Amount := "0.03CELO" + + // Set up the expected behavior of the mock + mockStore.On("ReadEntry", ctx, sessionId, utils.DATA_AMOUNT).Return([]byte(Amount), nil) + + // Create the Handlers instance with the mock store h := &Handlers{ - accountFileHandler: mockAccountFileHandler, + userdataStore: mockStore, } - tests := []struct { - name string - expectedResult resource.Result - accountData map[string]string - }{ - { - name: "Valid amount", - expectedResult: resource.Result{ - Content: "0.003", - }, - accountData: map[string]string{ - "Amount": "0.003", - }, - }, - { - name: "Missing amount", - expectedResult: resource.Result{}, - accountData: map[string]string{ - "Amount": "", - }, - }, - } + // Call the method + res, _ := h.GetAmount(ctx, "get_amount", []byte("Getting amount...")) - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Reset the mock state - mockAccountFileHandler.Mock = mock.Mock{} + //Assert that the retrieved amount is what was set as the content + assert.Equal(t, Amount, res.Content) - mockAccountFileHandler.On("ReadAccountData").Return(tt.accountData, nil) - - result, err := h.GetAmount(context.Background(), "", nil) - - assert.NoError(t, err) - assert.Equal(t, tt.expectedResult.Content, result.Content) - - mockAccountFileHandler.AssertCalled(t, "ReadAccountData") - }) - } -} - -func TestGetProfileInfo(t *testing.T) { - tests := []struct { - name string - accountData map[string]string - readError error - expectedResult resource.Result - expectedError error - }{ - { - name: "Complete Profile", - accountData: map[string]string{ - "FirstName": "John", - "FamilyName": "Doe", - "Gender": "Male", - "YOB": "1980", - "Location": "Mombasa", - "Offerings": "Product A", - }, - readError: nil, - expectedResult: resource.Result{ - Content: fmt.Sprintf( - "Name: %s %s\nGender: %s\nAge: %d\nLocation: %s\nYou provide: %s\n", - "John", "Doe", "Male", 44, "Mombasa", "Product A", - ), - }, - expectedError: nil, - }, - { - name: "Profile with Not Provided Fields", - accountData: map[string]string{ - "FirstName": "Not provided", - "FamilyName": "Doe", - "Gender": "Female", - "YOB": "1995", - "Location": "Not provided", - "Offerings": "Service B", - }, - readError: nil, - expectedResult: resource.Result{ - Content: fmt.Sprintf( - "Name: %s\nGender: %s\nAge: %d\nLocation: %s\nYou provide: %s\n", - "Not provided", "Female", 29, "Not provided", "Service B", - ), - }, - expectedError: nil, - }, - { - name: "Profile with YOB as Not provided", - accountData: map[string]string{ - "FirstName": "Not provided", - "FamilyName": "Doe", - "Gender": "Female", - "YOB": "Not provided", - "Location": "Not provided", - "Offerings": "Service B", - }, - readError: nil, - expectedResult: resource.Result{ - Content: fmt.Sprintf( - "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n", - "Not provided", "Female", "Not provided", "Not provided", "Service B", - ), - }, - expectedError: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Create a new instance of MockAccountFileHandler - mockFileHandler := new(mocks.MockAccountFileHandler) - - // Set up the mock expectations - mockFileHandler.On("ReadAccountData").Return(tt.accountData, tt.readError) - - // Create the Handlers instance with the mock file handler - h := &Handlers{ - accountFileHandler: mockFileHandler, - } - - // Call the method - result, err := h.GetProfileInfo(context.Background(), "get_profile_info", nil) - - // Assert the results - assert.Equal(t, tt.expectedResult, result) - assert.Equal(t, tt.expectedError, err) - - // Assert all expectations were met - mockFileHandler.AssertExpectations(t) - }) - } } diff --git a/internal/handlers/ussd/mocks/dbmock.go b/internal/handlers/ussd/mocks/dbmock.go new file mode 100644 index 0000000..0b40eab --- /dev/null +++ b/internal/handlers/ussd/mocks/dbmock.go @@ -0,0 +1,59 @@ +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) +} diff --git a/internal/handlers/ussd/mocks/mocks.go b/internal/handlers/ussd/mocks/mocks.go deleted file mode 100644 index 3c7eb1e..0000000 --- a/internal/handlers/ussd/mocks/mocks.go +++ /dev/null @@ -1,44 +0,0 @@ -package mocks - -import ( - "git.grassecon.net/urdt/ussd/internal/models" - "github.com/stretchr/testify/mock" -) - -type MockAccountFileHandler struct { - mock.Mock -} - -func (m *MockAccountFileHandler) EnsureFileExists() error { - args := m.Called() - return args.Error(0) -} - -func (m *MockAccountFileHandler) ReadAccountData() (map[string]string, error) { - args := m.Called() - return args.Get(0).(map[string]string), args.Error(1) -} - -func (m *MockAccountFileHandler) WriteAccountData(data map[string]string) error { - args := m.Called(data) - return args.Error(0) -} - -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) CheckAccountStatus(TrackingId string) (string, error) { - args := m.Called() - return args.Get(0).(string), args.Error(1) -} - -func (m *MockAccountService) CheckBalance(PublicKey string) (string, error) { - args := m.Called() - return args.Get(0).(string), args.Error(1) -} diff --git a/internal/handlers/ussd/mocks/servicemock.go b/internal/handlers/ussd/mocks/servicemock.go new file mode 100644 index 0000000..9fb6d3e --- /dev/null +++ b/internal/handlers/ussd/mocks/servicemock.go @@ -0,0 +1,26 @@ +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) (string, error) { + args := m.Called(publicKey) + return args.String(0), args.Error(1) +} + +func (m *MockAccountService) CheckAccountStatus(trackingId string) (string, error) { + args := m.Called(trackingId) + return args.String(0), args.Error(1) +} \ No newline at end of file diff --git a/internal/handlers/ussd/mocks/userdbmock.go b/internal/handlers/ussd/mocks/userdbmock.go new file mode 100644 index 0000000..ff3f18d --- /dev/null +++ b/internal/handlers/ussd/mocks/userdbmock.go @@ -0,0 +1,24 @@ +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) +} diff --git a/internal/utils/account_utils.go b/internal/utils/account_utils.go deleted file mode 100644 index 39fb66b..0000000 --- a/internal/utils/account_utils.go +++ /dev/null @@ -1,46 +0,0 @@ -package utils - -import ( - "encoding/json" - "os" -) - -type AccountFileHandler struct { - FilePath string -} - -func NewAccountFileHandler(path string) *AccountFileHandler { - return &AccountFileHandler{FilePath: path} -} - -func (afh *AccountFileHandler) ReadAccountData() (map[string]string, error) { - jsonData, err := os.ReadFile(afh.FilePath) - if err != nil { - return nil, err - } - - var accountData map[string]string - err = json.Unmarshal(jsonData, &accountData) - if err != nil { - return nil, err - } - - return accountData, nil -} - -func (afh *AccountFileHandler) WriteAccountData(accountData map[string]string) error { - jsonData, err := json.Marshal(accountData) - if err != nil { - return err - } - - return os.WriteFile(afh.FilePath, jsonData, 0644) -} - -func (afh *AccountFileHandler) EnsureFileExists() error { - f, err := os.OpenFile(afh.FilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) - if err != nil { - return err - } - return f.Close() -} diff --git a/internal/utils/db.go b/internal/utils/db.go new file mode 100644 index 0000000..5b128f6 --- /dev/null +++ b/internal/utils/db.go @@ -0,0 +1,58 @@ +package utils + +import ( + "context" + "encoding/binary" + + "git.defalsify.org/vise.git/db" +) + +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 +) + +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...) +} + +func ReadEntry(ctx context.Context, store db.Db, sessionId string, typ DataTyp) ([]byte, error) { + + store.SetPrefix(db.DATATYPE_USERDATA) + store.SetSession(sessionId) + k := PackKey(typ, []byte(sessionId)) + b, err := store.Get(ctx, k) + if err != nil { + return nil, err + } + return b, nil +} + +func WriteEntry(ctx context.Context, store db.Db, 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) +} diff --git a/internal/utils/filehandler.go b/internal/utils/filehandler.go deleted file mode 100644 index 8b11e29..0000000 --- a/internal/utils/filehandler.go +++ /dev/null @@ -1,13 +0,0 @@ -package utils - - - - -type AccountFileHandlerInterface interface { - EnsureFileExists() error - ReadAccountData() (map[string]string, error) - WriteAccountData(data map[string]string) error -} - - - diff --git a/internal/utils/userStore.go b/internal/utils/userStore.go new file mode 100644 index 0000000..a1485b1 --- /dev/null +++ b/internal/utils/userStore.go @@ -0,0 +1,32 @@ +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) +} diff --git a/services/registration/Makefile b/services/registration/Makefile index 1863b0b..af8b8c1 100644 --- a/services/registration/Makefile +++ b/services/registration/Makefile @@ -4,7 +4,7 @@ TXTS = $(wildcard ./*.txt.orig) # Rule to build .bin files from .vis files %.vis: - go run ../../go-vise/dev/asm -f pp.csv $(basename $@).vis > $(basename $@).bin + go run ../../go-vise/dev/asm/main.go -f pp.csv $(basename $@).vis > $(basename $@).bin @echo "Built $(basename $@).bin from $(basename $@).vis" # Rule to copy .orig files to .txt