Refactoring tables

pkg/handlers/handlers.go

@@ -63,7 +63,7 @@ func (h *Handler) Delete(msg *tb.Message) {
 		return
 	}
 
-	err = h.TablesProvider.DeletSecrets(index - 1)
+	err = h.TablesProvider.DeleteSecrets(index - 1)
 
 	if err != nil {
 		h.sendMessage(msg, h.Locales.Get(msg.Sender.LanguageCode, "delete_unable_delete"))
@@ -103,46 +103,40 @@ func (h *Handler) Query(msg *tb.Message) {
 		return
 	}
 
-	rows := h.TablesProvider.GetSecrets()
-
+	secrets := h.TablesProvider.GetSecrets()
 	query := strings.ToLower(msg.Text)
-
 	exists := false
 
-	for index, row := range rows {
-		if len(row) != numbQueryColumns {
+	for index, secret := range secrets {
+		if !strings.Contains(strings.ToLower(secret.Description), query) {
 			continue
 		}
 
-		for _, v := range row[:1] {
-			if strings.Contains(strings.ToLower(v), query) {
-				username, _ := base58.Decode(row[1])
-				password, _ := base58.Decode(row[2])
+		username, _ := base58.Decode(secret.Username)
+		password, _ := base58.Decode(secret.Secret)
 
-				decUsername, err := crypto.DecryptWithPriv(privkey, username)
-				if err != nil {
-					log.Error("Decrypt username with private key: " + err.Error())
+		decUsername, err := crypto.DecryptWithPriv(privkey, username)
+		if err != nil {
+			log.Error("Decrypt username with private key: " + err.Error())
 
-					break
-				}
+			break
+		}
 
-				decPassword, err := crypto.DecryptWithPriv(privkey, password)
-				if err != nil {
-					log.Error("Decrypt password with private key: " + err.Error())
+		decPassword, err := crypto.DecryptWithPriv(privkey, password)
+		if err != nil {
+			log.Error("Decrypt password with private key: " + err.Error())
 
-					break
-				}
+			break
+		}
 
-				row[1] = string(decUsername)
-				row[2] = string(decPassword)
+		secret.Username = string(decUsername)
+		secret.Secret = string(decPassword)
 
-				exists = true
+		exists = true
 
-				h.sendMessage(msg, makeQueryResponse(index+1, row))
+		h.sendMessage(msg, makeQueryResponse(index+1, secret))
 
-				break
-			}
-		}
+		break
 	}
 
 	if !exists {

pkg/handlers/helpers.go

@@ -68,12 +68,9 @@ func (h *Handler) hasAccess(msg *tb.Message) bool {
 }
 
 func getPrivkeyAsBytes(tp *tables.TablesProvider, salt, masterPass string) ([]byte, bool, error) {
-	keys := tp.GetKeys()
-	if len(keys) == 0 {
-		return nil, false, nil
-	}
+	k := tp.GetKey()
 
-	key, err := base58.Decode(keys[0])
+	key, err := base58.Decode(k)
 	if err != nil {
 		return nil, false, errors.Wrap(err, "base58 decode")
 	}
@@ -111,12 +108,12 @@ func getPrivkey(tp *tables.TablesProvider, salt, masterPass string) (*ecdsa.Priv
 	return privkey.(*ecdsa.PrivateKey), nil
 }
 
-func makeQueryResponse(index int, row []string) string {
+func makeQueryResponse(index int, secret tables.SecretsData) string {
 	return fmt.Sprintf("(%d) <b>%s</b>\n<code>%s</code>\n<code>%s</code>",
 		index,
-		html.EscapeString(row[0]),
-		html.EscapeString(row[1]),
-		html.EscapeString(row[2]),
+		html.EscapeString(secret.Description),
+		html.EscapeString(secret.Username),
+		html.EscapeString(secret.Secret),
 	)
 }
 

pkg/handlers/middlewares.go

@@ -18,6 +18,7 @@ import (
 	"crypto/x509"
 	"secretable/pkg/crypto"
 	"secretable/pkg/log"
+	"secretable/pkg/tables"
 	"strings"
 
 	"github.com/mr-tron/base58/base58"
@@ -165,7 +166,11 @@ func (h *Handler) querySetNewSecretsSecret(msg *tb.Message, masterPass string) {
 	arr[1] = base58.Encode(cypher1)
 	arr[2] = base58.Encode(cypher2)
 
-	err = h.TablesProvider.AddSecrets(arr)
+	err = h.TablesProvider.AddSecrets(tables.SecretsData{
+		Description: arr[0],
+		Username:    arr[1],
+		Secret:      arr[2],
+	})
 
 	if err != nil {
 		h.sendMessage(msg, "Error of appending new encrypted")

pkg/providers/storage.go

@@ -0,0 +1,4 @@
+package providers
+
+type StorageProvider interface {
+}

pkg/tables/tables.go

@@ -35,14 +35,21 @@ const (
 	updateTimeout = 10 // in sec
 )
 
+type SecretsData struct {
+	Description string
+	Username    string
+	Secret      string
+}
+
 type TablesProvider struct {
 	service       *sheets.Service
 	spreadsheetID string
 
 	secretsID int64
 	keysID    int64
-	secrets   [][]string
-	keys      []string
+
+	secrets []SecretsData
+	key     string
 
 	mx sync.RWMutex
 }
@@ -101,16 +108,12 @@ func createTable(service *sheets.Service, spreadsheetID, tableTitle string) (err
 	return nil
 }
 
-func (t *TablesProvider) AddSecrets(arr []string) error {
-	row := make([]interface{}, 0)
-
-	for _, v := range arr {
-		row = append(row, v)
-	}
-
+func (t *TablesProvider) AddSecrets(data SecretsData) error {
 	_, err := t.service.Spreadsheets.Values.Append(t.spreadsheetID, secretesRange, &sheets.ValueRange{
 		Values: [][]interface{}{
-			row,
+			{
+				data.Description, data.Username, data.Secret,
+			},
 		},
 		MajorDimension: "ROWS",
 	}).ValueInputOption("RAW").InsertDataOption("INSERT_ROWS").Do()
@@ -147,7 +150,7 @@ func (t *TablesProvider) SetKey(key string) error {
 	return nil
 }
 
-func (t *TablesProvider) DeletSecrets(index int) error {
+func (t *TablesProvider) DeleteSecrets(index int) error {
 	return t.delete(t.secretsID, index)
 }
 
@@ -176,36 +179,45 @@ func (t *TablesProvider) delete(sheetID int64, index int) error {
 }
 
 func (t *TablesProvider) updateSecrets(data []*sheets.GridData) {
-	var newrows [][]string
+	var newrows []SecretsData
 
 	for _, item := range data {
 		for _, row := range item.RowData {
-			var newrowsItem []string
-			for _, cell := range row.Values {
-				newrowsItem = append(newrowsItem, cell.FormattedValue)
+			if len(row.Values) < 3 {
+				continue
 			}
 
-			newrows = append(newrows, newrowsItem)
+			newrows = append(newrows, SecretsData{
+				Description: row.Values[0].FormattedValue,
+				Username:    row.Values[1].FormattedValue,
+				Secret:      row.Values[2].FormattedValue,
+			})
 		}
 	}
 
 	t.setSecrets(newrows)
 }
 
-func (t *TablesProvider) updateKeys(data []*sheets.GridData) {
-	var newrows []string
-
+func (t *TablesProvider) updateKey(data []*sheets.GridData) {
 	for _, item := range data {
-		for _, row := range item.RowData {
-			for _, cell := range row.Values {
-				newrows = append(newrows, cell.FormattedValue)
+		if len(item.RowData) == 0 {
+			continue
+		}
 
-				break
-			}
+		if len(item.RowData) == 0 {
+			continue
 		}
-	}
 
-	t.setKeys(newrows)
+		row := item.RowData[0]
+
+		if len(row.Values) == 0 {
+			continue
+		}
+
+		t.setKey(row.Values[0].FormattedValue)
+
+		break
+	}
 }
 
 func (t *TablesProvider) update() error {
@@ -221,41 +233,39 @@ func (t *TablesProvider) update() error {
 			t.updateSecrets(sheet.Data)
 		case keysTitle:
 			t.keysID = sheet.Properties.SheetId
-			t.updateKeys(sheet.Data)
+			t.updateKey(sheet.Data)
 		}
 	}
 
 	return nil
 }
 
-func (t *TablesProvider) setSecrets(rows [][]string) {
+func (t *TablesProvider) setSecrets(secrets []SecretsData) {
 	t.mx.Lock()
-	t.secrets = make([][]string, len(rows))
-	copy(t.secrets, rows)
+	t.secrets = make([]SecretsData, len(secrets))
+	copy(t.secrets, secrets)
 	t.mx.Unlock()
 }
 
-func (t *TablesProvider) GetSecrets() (rows [][]string) {
+func (t *TablesProvider) GetSecrets() (secrets []SecretsData) {
 	t.mx.RLock()
-	rows = make([][]string, len(t.secrets))
-	copy(rows, t.secrets)
+	secrets = make([]SecretsData, len(t.secrets))
+	copy(secrets, t.secrets)
 	t.mx.RUnlock()
 
-	return rows
+	return secrets
 }
 
-func (t *TablesProvider) setKeys(rows []string) {
+func (t *TablesProvider) setKey(key string) {
 	t.mx.Lock()
-	t.keys = make([]string, len(rows))
-	copy(t.keys, rows)
+	t.key = key
 	t.mx.Unlock()
 }
 
-func (t *TablesProvider) GetKeys() (rows []string) {
+func (t *TablesProvider) GetKey() string {
 	t.mx.RLock()
-	rows = make([]string, len(t.keys))
-	copy(rows, t.keys)
+	key := t.key
 	t.mx.RUnlock()
 
-	return rows
+	return key
 }