replace Id with ID

2025-02-13 08:00:49 -06:00
parent f948a06b66
commit 32facb1767
19 changed files with 172 additions and 169 deletions
--- a/repository/customer_user_repository.go
+++ b/repository/customer_user_repository.go
@@ -5,16 +5,16 @@ import (
 )

 type CustomerUserRepository interface {
-	GetCustomer(entities.CustomerId) (*entities.Customer, error)
-	GetUser(entities.UserEmail, entities.CustomerId) (*entities.User, error)
+	GetCustomer(entities.CustomerID) (*entities.Customer, error)
+	GetUser(entities.UserEmail, entities.CustomerID) (*entities.User, error)
 	CreateCustomer(entities.Customer) error
 	WriteNewUser(entities.User) error
 	UpdateUserNKode(entities.User) error
-	UpdateUserInterface(entities.UserId, entities.UserInterface) error
-	UpdateUserRefreshToken(entities.UserId, string) error
-	Renew(entities.CustomerId) error
+	UpdateUserInterface(entities.UserID, entities.UserInterface) error
+	UpdateUserRefreshToken(entities.UserID, string) error
+	Renew(entities.CustomerID) error
 	RefreshUserPasscode(entities.User, []int, entities.CustomerAttributes) error
 	RandomSvgInterface(entities.KeypadDimension) ([]string, error)
-	RandomSvgIdxInterface(entities.KeypadDimension) (entities.SvgIdInterface, error)
-	GetSvgStringInterface(entities.SvgIdInterface) ([]string, error)
+	RandomSvgIdxInterface(entities.KeypadDimension) (entities.SvgIDInterface, error)
+	GetSvgStringInterface(entities.SvgIDInterface) ([]string, error)
 }
--- a/repository/sqlite_nkode_repo.go
+++ b/repository/sqlite_nkode_repo.go
@@ -70,11 +70,11 @@ func (d *SqliteNKodeRepo) WriteNewUser(u entities.User) error {
 	}
 	// Map entities.User to CreateUserParams
 	params := sqlc.CreateUserParams{
-		ID:               uuid.UUID(u.Id).String(),
+		ID:               uuid.UUID(u.ID).String(),
 		Email:            string(u.Email),
 		Renew:            int64(renew),
 		RefreshToken:     sql.NullString{String: u.RefreshToken, Valid: u.RefreshToken != ""},
-		CustomerID:       uuid.UUID(u.CustomerId).String(),
+		CustomerID:       uuid.UUID(u.CustomerID).String(),
 		Code:             u.EncipheredPasscode.Code,
 		Mask:             u.EncipheredPasscode.Mask,
 		AttributesPerKey: int64(u.Kp.AttrsPerKey),
@@ -86,7 +86,7 @@ func (d *SqliteNKodeRepo) WriteNewUser(u entities.User) error {
 		Salt:             u.CipherKeys.Salt,
 		MaxNkodeLen:      int64(u.CipherKeys.MaxNKodeLen),
 		IdxInterface:     security.IntArrToByteArr(u.Interface.IdxInterface),
-		SvgIDInterface:   security.IntArrToByteArr(u.Interface.SvgId),
+		SvgIDInterface:   security.IntArrToByteArr(u.Interface.SvgID),
 		CreatedAt:        sql.NullString{String: utils.TimeStamp(), Valid: true},
 	}
 	return d.Queue.EnqueueWriteTx(queryFunc, params)
@@ -109,7 +109,7 @@ func (d *SqliteNKodeRepo) UpdateUserNKode(u entities.User) error {
 		Email:            string(u.Email),
 		Renew:            int64(renew),
 		RefreshToken:     sql.NullString{String: u.RefreshToken, Valid: u.RefreshToken != ""},
-		CustomerID:       uuid.UUID(u.CustomerId).String(),
+		CustomerID:       uuid.UUID(u.CustomerID).String(),
 		Code:             u.EncipheredPasscode.Code,
 		Mask:             u.EncipheredPasscode.Mask,
 		AttributesPerKey: int64(u.Kp.AttrsPerKey),
@@ -121,12 +121,12 @@ func (d *SqliteNKodeRepo) UpdateUserNKode(u entities.User) error {
 		Salt:             u.CipherKeys.Salt,
 		MaxNkodeLen:      int64(u.CipherKeys.MaxNKodeLen),
 		IdxInterface:     security.IntArrToByteArr(u.Interface.IdxInterface),
-		SvgIDInterface:   security.IntArrToByteArr(u.Interface.SvgId),
+		SvgIDInterface:   security.IntArrToByteArr(u.Interface.SvgID),
 	}
 	return d.Queue.EnqueueWriteTx(queryFunc, params)
 }

-func (d *SqliteNKodeRepo) UpdateUserInterface(id entities.UserId, ui entities.UserInterface) error {
+func (d *SqliteNKodeRepo) UpdateUserInterface(id entities.UserID, ui entities.UserInterface) error {
 	queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
 		params, ok := args.(sqlc.UpdateUserInterfaceParams)
 		if !ok {
@@ -143,7 +143,7 @@ func (d *SqliteNKodeRepo) UpdateUserInterface(id entities.UserId, ui entities.Us
 	return d.Queue.EnqueueWriteTx(queryFunc, params)
 }

-func (d *SqliteNKodeRepo) UpdateUserRefreshToken(id entities.UserId, refreshToken string) error {
+func (d *SqliteNKodeRepo) UpdateUserRefreshToken(id entities.UserID, refreshToken string) error {
 	queryFunc := func(q *sqlc.Queries, ctx context.Context, args any) error {
 		params, ok := args.(sqlc.UpdateUserRefreshTokenParams)
 		if !ok {
@@ -172,7 +172,7 @@ func (d *SqliteNKodeRepo) RenewCustomer(renewParams sqlc.RenewCustomerParams) er
 	return d.Queue.EnqueueWriteTx(queryFunc, renewParams)
 }

-func (d *SqliteNKodeRepo) Renew(id entities.CustomerId) error {
+func (d *SqliteNKodeRepo) Renew(id entities.CustomerID) error {
 	setXor, attrXor, err := d.renewCustomer(id)
 	if err != nil {
 		return err
@@ -192,8 +192,8 @@ func (d *SqliteNKodeRepo) Renew(id entities.CustomerId) error {

 	for _, row := range userRenewRows {
 		user := entities.User{
-			Id:                 entities.UserIdFromString(row.ID),
-			CustomerId:         entities.CustomerId{},
+			ID:                 entities.UserIDFromString(row.ID),
+			CustomerID:         entities.CustomerID{},
 			Email:              "",
 			EncipheredPasscode: entities.EncipheredNKode{},
 			Kp: entities.KeypadDimension{
@@ -215,7 +215,7 @@ func (d *SqliteNKodeRepo) Renew(id entities.CustomerId) error {
 			AlphaKey: security.Uint64ArrToByteArr(user.CipherKeys.AlphaKey),
 			SetKey:   security.Uint64ArrToByteArr(user.CipherKeys.SetKey),
 			Renew:    1,
-			ID:       uuid.UUID(user.Id).String(),
+			ID:       uuid.UUID(user.ID).String(),
 		}
 		if err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
 			return err
@@ -224,7 +224,7 @@ func (d *SqliteNKodeRepo) Renew(id entities.CustomerId) error {
 	return nil
 }

-func (d *SqliteNKodeRepo) renewCustomer(id entities.CustomerId) ([]uint64, []uint64, error) {
+func (d *SqliteNKodeRepo) renewCustomer(id entities.CustomerID) ([]uint64, []uint64, error) {
 	customer, err := d.GetCustomer(id)
 	if err != nil {
 		return nil, nil, err
@@ -244,7 +244,7 @@ func (d *SqliteNKodeRepo) renewCustomer(id entities.CustomerId) ([]uint64, []uin
 	params := sqlc.RenewCustomerParams{
 		AttributeValues: security.Uint64ArrToByteArr(customer.Attributes.AttrVals),
 		SetValues:       security.Uint64ArrToByteArr(customer.Attributes.SetVals),
-		ID:              uuid.UUID(customer.Id).String(),
+		ID:              uuid.UUID(customer.ID).String(),
 	}

 	if err = d.Queue.EnqueueWriteTx(queryFunc, params); err != nil {
@@ -273,7 +273,7 @@ func (d *SqliteNKodeRepo) RefreshUserPasscode(user entities.User, passcodeIdx []
 		PassKey:  security.Uint64ArrToByteArr(user.CipherKeys.PassKey),
 		MaskKey:  security.Uint64ArrToByteArr(user.CipherKeys.MaskKey),
 		Salt:     user.CipherKeys.Salt,
-		ID:       uuid.UUID(user.Id).String(),
+		ID:       uuid.UUID(user.ID).String(),
 	}
 	return d.Queue.EnqueueWriteTx(queryFunc, params)
 }
@@ -289,14 +289,14 @@ func (d *SqliteNKodeRepo) AddSvg(svg string) error {
 	return d.Queue.EnqueueWriteTx(queryFunc, svg)
 }

-func (d *SqliteNKodeRepo) GetCustomer(id entities.CustomerId) (*entities.Customer, error) {
+func (d *SqliteNKodeRepo) GetCustomer(id entities.CustomerID) (*entities.Customer, error) {
 	customer, err := d.Queue.Queries.GetCustomer(d.ctx, uuid.UUID(id).String())
 	if err != nil {
 		return nil, err
 	}

 	return &entities.Customer{
-		Id: id,
+		ID: id,
 		NKodePolicy: entities.NKodePolicy{
 			MaxNkodeLen:        int(customer.MaxNkodeLen),
 			MinNkodeLen:        int(customer.MinNkodeLen),
@@ -309,10 +309,10 @@ func (d *SqliteNKodeRepo) GetCustomer(id entities.CustomerId) (*entities.Custome
 	}, nil
 }

-func (d *SqliteNKodeRepo) GetUser(email entities.UserEmail, customerId entities.CustomerId) (*entities.User, error) {
+func (d *SqliteNKodeRepo) GetUser(email entities.UserEmail, customerID entities.CustomerID) (*entities.User, error) {
 	userRow, err := d.Queue.Queries.GetUser(d.ctx, sqlc.GetUserParams{
 		Email:      string(email),
-		CustomerID: uuid.UUID(customerId).String(),
+		CustomerID: uuid.UUID(customerID).String(),
 	})
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
@@ -331,8 +331,8 @@ func (d *SqliteNKodeRepo) GetUser(email entities.UserEmail, customerId entities.
 		renew = true
 	}
 	user := entities.User{
-		Id:         entities.UserIdFromString(userRow.ID),
-		CustomerId: customerId,
+		ID:         entities.UserIDFromString(userRow.ID),
+		CustomerID: customerID,
 		Email:      email,
 		EncipheredPasscode: entities.EncipheredNKode{
 			Code: userRow.Code,
@@ -350,7 +350,7 @@ func (d *SqliteNKodeRepo) GetUser(email entities.UserEmail, customerId entities.
 		},
 		Interface: entities.UserInterface{
 			IdxInterface: security.ByteArrToIntArr(userRow.IdxInterface),
-			SvgId:        security.ByteArrToIntArr(userRow.SvgIDInterface),
+			SvgID:        security.ByteArrToIntArr(userRow.SvgIDInterface),
 			Kp:           &kp,
 		},
 		Renew:        renew,
@@ -360,24 +360,24 @@ func (d *SqliteNKodeRepo) GetUser(email entities.UserEmail, customerId entities.
 }

 func (d *SqliteNKodeRepo) RandomSvgInterface(kp entities.KeypadDimension) ([]string, error) {
-	ids, err := d.getRandomIds(kp.TotalAttrs())
+	ids, err := d.getRandomIDs(kp.TotalAttrs())
 	if err != nil {
 		return nil, err
 	}
-	return d.getSvgsById(ids)
+	return d.getSvgsByID(ids)
 }

-func (d *SqliteNKodeRepo) RandomSvgIdxInterface(kp entities.KeypadDimension) (entities.SvgIdInterface, error) {
-	return d.getRandomIds(kp.TotalAttrs())
+func (d *SqliteNKodeRepo) RandomSvgIdxInterface(kp entities.KeypadDimension) (entities.SvgIDInterface, error) {
+	return d.getRandomIDs(kp.TotalAttrs())
 }

-func (d *SqliteNKodeRepo) GetSvgStringInterface(idxs entities.SvgIdInterface) ([]string, error) {
-	return d.getSvgsById(idxs)
+func (d *SqliteNKodeRepo) GetSvgStringInterface(idxs entities.SvgIDInterface) ([]string, error) {
+	return d.getSvgsByID(idxs)
 }

 // Is this even useful?
-func (d *SqliteNKodeRepo) AddUserPermission(userEmail entities.UserEmail, customerId entities.CustomerId, permission entities.UserPermission) error {
-	user, err := d.GetUser(userEmail, customerId)
+func (d *SqliteNKodeRepo) AddUserPermission(userEmail entities.UserEmail, customerID entities.CustomerID, permission entities.UserPermission) error {
+	user, err := d.GetUser(userEmail, customerID)
 	if err != nil {
 		return err
 	}
@@ -389,16 +389,16 @@ func (d *SqliteNKodeRepo) AddUserPermission(userEmail entities.UserEmail, custom
 		return q.AddUserPermission(ctx, params)
 	}
 	params := sqlc.AddUserPermissionParams{
-		UserID:     user.Id.String(),
+		UserID:     user.ID.String(),
 		Permission: permission.String(),
 	}
 	return d.Queue.EnqueueWriteTx(queryFunc, params)
 }

-func (d *SqliteNKodeRepo) getSvgsById(ids []int) ([]string, error) {
+func (d *SqliteNKodeRepo) getSvgsByID(ids []int) ([]string, error) {
 	svgs := make([]string, len(ids))
 	for idx, id := range ids {
-		svg, err := d.Queue.Queries.GetSvgId(d.ctx, int64(id))
+		svg, err := d.Queue.Queries.GetSvgID(d.ctx, int64(id))
 		if err != nil {
 			return nil, err
 		}
@@ -407,7 +407,7 @@ func (d *SqliteNKodeRepo) getSvgsById(ids []int) ([]string, error) {
 	return svgs, nil
 }

-func (d *SqliteNKodeRepo) getRandomIds(count int) ([]int, error) {
+func (d *SqliteNKodeRepo) getRandomIDs(count int) ([]int, error) {
 	totalRows, err := d.Queue.Queries.GetSvgCount(d.ctx)
 	if err != nil {
 		log.Print(err)
--- a/repository/sqlite_nkode_repo_test.go
+++ b/repository/sqlite_nkode_repo_test.go
@@ -28,24 +28,24 @@ func testSignupLoginRenew(t *testing.T, db CustomerUserRepository) {
 	assert.NoError(t, err)
 	err = db.CreateCustomer(*customerOrig)
 	assert.NoError(t, err)
-	customer, err := db.GetCustomer(customerOrig.Id)
+	customer, err := db.GetCustomer(customerOrig.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, customerOrig, customer)
 	username := "test_user@example.com"
 	kp := entities.KeypadDefault
 	passcodeIdx := []int{0, 1, 2, 3}
-	mockSvgInterface := make(entities.SvgIdInterface, kp.TotalAttrs())
+	mockSvgInterface := make(entities.SvgIDInterface, kp.TotalAttrs())
 	ui, err := entities.NewUserInterface(&kp, mockSvgInterface)
 	assert.NoError(t, err)
 	userOrig, err := entities.NewUser(*customer, username, passcodeIdx, *ui, kp)
 	assert.NoError(t, err)
 	err = db.WriteNewUser(*userOrig)
 	assert.NoError(t, err)
-	user, err := db.GetUser(entities.UserEmail(username), customer.Id)
+	user, err := db.GetUser(entities.UserEmail(username), customer.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, userOrig, user)

-	err = db.Renew(customer.Id)
+	err = db.Renew(customer.ID)
 	assert.NoError(t, err)

 }