From 71e1ae6e3c09335ff4b180ce43d473a33395a0bd Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Thu, 19 Sep 2024 15:54:23 +0300 Subject: [PATCH] add function registration service --- cmd/main.go | 132 ++++------------------------ internal/handlers/handlerservice.go | 99 +++++++++++++++++++++ 2 files changed, 115 insertions(+), 116 deletions(-) create mode 100644 internal/handlers/handlerservice.go diff --git a/cmd/main.go b/cmd/main.go index b9ca7aa..7e5bc0d 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -7,15 +7,11 @@ import ( "os" "path" - "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.grassecon.net/urdt/ussd/internal/handlers/ussd" + "git.grassecon.net/urdt/ussd/internal/handlers" + "git.grassecon.net/urdt/ussd/internal/storage" ) var ( @@ -23,106 +19,6 @@ var ( 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, userdataStore) - if err != nil { - return nil, err - } - ussdHandlers = ussdHandlers.WithPersister(pe) - rs.AddLocalFunc("set_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) - rs.AddLocalFunc("save_temporary_pin", ussdHandlers.SaveTemporaryPin) - rs.AddLocalFunc("verify_new_pin", ussdHandlers.VerifyNewPin) - rs.AddLocalFunc("confirm_pin_change", ussdHandlers.ConfirmPinChange) - rs.AddLocalFunc("quit_with_help",ussdHandlers.QuitWithHelp) - - return ussdHandlers, nil -} - -func ensureDbDir(dbDir string) error { - err := os.MkdirAll(dbDir, 0700) - if err != nil { - return fmt.Errorf("state dir create exited with error: %v\n", err) - } - return nil -} - -func getPersister(dbDir string, ctx context.Context) (*persist.Persister, error) { - err := ensureDbDir(dbDir) - if err != nil { - return nil, 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 dbDir string var size uint @@ -139,11 +35,6 @@ func main() { ctx := context.Background() ctx = context.WithValue(ctx, "SessionId", sessionId) pfp := path.Join(scriptDir, "pp.csv") - flagParser, err := getParser(pfp, true) - - if err != nil { - os.Exit(1) - } cfg := engine.Config{ Root: "root", @@ -152,19 +43,21 @@ func main() { FlagCount: uint32(16), } - rs, err := getResource(scriptDir, ctx) + menuStorageService := storage.MenuStorageService{} + + rs, err := menuStorageService.GetResource(scriptDir, ctx) if err != nil { fmt.Fprintf(os.Stderr, err.Error()) os.Exit(1) } - pe, err := getPersister(dbDir, ctx) + pe, err := menuStorageService.GetPersister(dbDir, ctx) if err != nil { fmt.Fprintf(os.Stderr, err.Error()) os.Exit(1) } - store := getUserdataDb(dbDir, ctx) + userdatastore := menuStorageService.GetUserdataDb(dbDir, ctx) if err != nil { fmt.Fprintf(os.Stderr, err.Error()) os.Exit(1) @@ -176,13 +69,20 @@ func main() { os.Exit(1) } - hl, err := getHandler(flagParser, dbResource, pe, store) + lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, pe, userdatastore, cfg, rs) + if err != nil { fmt.Fprintf(os.Stderr, err.Error()) os.Exit(1) } - en := getEngine(cfg, rs, pe) + hl, err := lhs.GetHandler() + if err != nil { + fmt.Fprintf(os.Stderr, err.Error()) + os.Exit(1) + } + + en := lhs.GetEngine() en = en.WithFirst(hl.Init) if debug { en = en.WithDebug(nil) diff --git a/internal/handlers/handlerservice.go b/internal/handlers/handlerservice.go new file mode 100644 index 0000000..e6d4fb6 --- /dev/null +++ b/internal/handlers/handlerservice.go @@ -0,0 +1,99 @@ +package handlers + +import ( + "git.defalsify.org/vise.git/asm" + "git.defalsify.org/vise.git/db" + "git.defalsify.org/vise.git/engine" + "git.defalsify.org/vise.git/persist" + "git.defalsify.org/vise.git/resource" + "git.grassecon.net/urdt/ussd/internal/handlers/ussd" +) + +type HandlerService interface { + GetHandler() (*ussd.Handlers, error) +} + +func getParser(fp string, debug bool) (*asm.FlagParser, error) { + flagParser := asm.NewFlagParser().WithDebug() + _, err := flagParser.Load(fp) + if err != nil { + return nil, err + } + return flagParser, nil +} + +type LocalHandlerService struct { + Parser *asm.FlagParser + DbRs *resource.DbResource + Pe *persist.Persister + UserdataStore db.Db + Cfg engine.Config + Rs resource.Resource +} + +func NewLocalHandlerService(fp string, debug bool, dbResource *resource.DbResource, Pe *persist.Persister, userDataStore db.Db, cfg engine.Config, rs resource.Resource) (*LocalHandlerService, error) { + parser, err := getParser(fp, debug) + if err != nil { + return nil, err + } + return &LocalHandlerService{ + Parser: parser, + DbRs: dbResource, + Pe: Pe, + UserdataStore: userDataStore, + Cfg: cfg, + Rs: rs, + }, nil +} + +func (localHandlerService *LocalHandlerService) GetHandler() (*ussd.Handlers, error) { + ussdHandlers, err := ussd.NewHandlers(localHandlerService.Parser, localHandlerService.UserdataStore) + if err != nil { + return nil, err + } + ussdHandlers = ussdHandlers.WithPersister(localHandlerService.Pe) + localHandlerService.DbRs.AddLocalFunc("set_language", ussdHandlers.SetLanguage) + localHandlerService.DbRs.AddLocalFunc("create_account", ussdHandlers.CreateAccount) + localHandlerService.DbRs.AddLocalFunc("save_pin", ussdHandlers.SavePin) + localHandlerService.DbRs.AddLocalFunc("verify_pin", ussdHandlers.VerifyPin) + localHandlerService.DbRs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier) + localHandlerService.DbRs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus) + localHandlerService.DbRs.AddLocalFunc("authorize_account", ussdHandlers.Authorize) + localHandlerService.DbRs.AddLocalFunc("quit", ussdHandlers.Quit) + localHandlerService.DbRs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance) + localHandlerService.DbRs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient) + localHandlerService.DbRs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset) + localHandlerService.DbRs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount) + localHandlerService.DbRs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount) + localHandlerService.DbRs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount) + localHandlerService.DbRs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient) + localHandlerService.DbRs.AddLocalFunc("get_sender", ussdHandlers.GetSender) + localHandlerService.DbRs.AddLocalFunc("get_amount", ussdHandlers.GetAmount) + localHandlerService.DbRs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin) + localHandlerService.DbRs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname) + localHandlerService.DbRs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname) + localHandlerService.DbRs.AddLocalFunc("save_gender", ussdHandlers.SaveGender) + localHandlerService.DbRs.AddLocalFunc("save_location", ussdHandlers.SaveLocation) + localHandlerService.DbRs.AddLocalFunc("save_yob", ussdHandlers.SaveYob) + localHandlerService.DbRs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings) + localHandlerService.DbRs.AddLocalFunc("quit_with_balance", ussdHandlers.QuitWithBalance) + localHandlerService.DbRs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized) + localHandlerService.DbRs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate) + localHandlerService.DbRs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo) + localHandlerService.DbRs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob) + localHandlerService.DbRs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob) + localHandlerService.DbRs.AddLocalFunc("set_reset_single_edit", ussdHandlers.SetResetSingleEdit) + localHandlerService.DbRs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction) + localHandlerService.DbRs.AddLocalFunc("save_temporary_pin", ussdHandlers.SaveTemporaryPin) + localHandlerService.DbRs.AddLocalFunc("verify_new_pin", ussdHandlers.VerifyNewPin) + localHandlerService.DbRs.AddLocalFunc("confirm_pin_change", ussdHandlers.ConfirmPinChange) + localHandlerService.DbRs.AddLocalFunc("quit_with_help", ussdHandlers.QuitWithHelp) + + return ussdHandlers, nil +} + +func (localHandlerService *LocalHandlerService) GetEngine() *engine.DefaultEngine { + en := engine.NewEngine(localHandlerService.Cfg, localHandlerService.Rs) + en = en.WithPersister(localHandlerService.Pe) + return en +}